def test_rotation(self):
        # Test rotation is enabled by default
        s = skyline.SkylineBl(100, 10)
        rect1 = s.add_rect(10, 100)
        self.assertEqual(rect1, Rectangle(0, 0, 100, 10))

        # Test rotation can be disabled
        s = skyline.SkylineBl(100, 10, rot=False)
        rect1 = s.add_rect(10, 100)
        self.assertEqual(rect1, None)
    def test_fitness(self):
        """Test lower is better"""
        p = skyline.SkylineBl(100, 100, rot=False)
        self.assertEqual(p.fitness(100, 20), p.fitness(10, 20))
        self.assertTrue(p.fitness(100, 10) < p.fitness(100, 11))

        # The same but with wasted space
        p = skyline.SkylineBl(100, 100, rot=False)
        p.add_rect(80, 50)
        self.assertEqual(p.fitness(100, 10), p.fitness(80, 10))
        self.assertTrue(p.fitness(100, 10) < p.fitness(40, 20))
  def test_skyline2(self):
      """
      +---------------------------+
      |                           |
      |                           |
      |                           |
      +--------------------+      |
      |                    |      |
      |         4          +------+
      |                    |  5   |
      |                    |      |
      +----------------+---+------+
      |                |     3    |
      |                |          |
      |       1        +-----+----+
      |                |  2  |    |
      |                |     |    |
      +----------------+-----+----+
      """
      s = skyline.SkylineBl(100, 100, rot=False)
      rect1 = s.add_rect(50, 40)
      rect2 = s.add_rect(30, 20)
      rect3 = s.add_rect(50, 20)
      rect4 = s.add_rect(70, 30)
      rect5 = s.add_rect(20, 20)
 
      self.assertEqual(rect1, Rectangle(0, 0, 50, 40))
      self.assertEqual(rect2, Rectangle(50, 0, 30, 20))
      self.assertEqual(rect3, Rectangle(50, 20, 50, 20))
      self.assertEqual(rect4, Rectangle(0, 40, 70, 30))
      self.assertEqual(rect5, Rectangle(70, 40, 20, 20))
    def test_skyline1(self):
        """
        +---------------------------+
        |                           |
        |                           |
        |                           |
        |                           |
        |                           |
        |                           |
        +-------------+-------------+
        |      4      |             |
        |             |             |
        +---------+---+             |
        |         |   |      3      |
        |         |   |             |
        |    1    +---+             |
        |         | 2 |             |
        |         |   |             |
        +---------+---+-------------+
        
        Test lower positions is better than one not losing space
        """
        s = skyline.SkylineBl(100, 100, rot=False)
        rect1 = s.add_rect(40, 30)
        rect2 = s.add_rect(10, 20)
        rect3 = s.add_rect(50, 50)
        rect4 = s.add_rect(50, 20)

        self.assertEqual(rect1, Rectangle(0, 0, 40, 30))
        self.assertEqual(rect2, Rectangle(40, 0, 10, 20))
        self.assertEqual(rect3, Rectangle(50, 0, 50, 50))
        self.assertEqual(rect4, Rectangle(0, 30, 50, 20))
    def test_waste_management(self):
        # Generate one wasted section
        s = skyline.SkylineBlWm(100, 100, rot=False)
        rect1 = s.add_rect(30, 30)
        rect2 = s.add_rect(100, 70)
        self.assertEqual(rect1, Rectangle(0, 0, 30, 30))
        self.assertEqual(rect2, Rectangle(0, 30, 100, 70))
        self.assertEqual(len(s), 2)
        
        # Add rectangle that only fits into wasted section
        self.assertEqual(s.add_rect(71, 30), None)
        self.assertEqual(s.add_rect(70, 31), None) 
        rect3 = s.add_rect(70, 30)
        self.assertEqual(rect3, Rectangle(30, 0, 70, 30))
        self.assertEqual(len(s), 3)
        
        rect4 = s.add_rect(70, 30)
        self.assertEqual(rect4, None)

        # Test the same without waste management
        s = skyline.SkylineBl(100, 100)
        rect1 = s.add_rect(30, 30)
        rect2 = s.add_rect(100, 70)
        self.assertEqual(rect1, Rectangle(0, 0, 30, 30))
        self.assertEqual(rect2, Rectangle(0, 30, 100, 70))
        
        self.assertEqual(s.add_rect(70, 30), None)
        self.assertEqual(len(s), 2)

        # Test waste supports rectangle rotation
        s  = skyline.SkylineBlWm(100, 100, rot=False)
        sr = skyline.SkylineBlWm(100, 100, rot=True)
        self.assertEqual(s.add_rect(30, 30), Rectangle(0, 0, 30, 30))
        self.assertEqual(s.add_rect(100, 70), Rectangle(0, 30, 100, 70))
        self.assertEqual(sr.add_rect(30, 30), Rectangle(0, 0, 30, 30))
        self.assertEqual(sr.add_rect(100, 70), Rectangle(0, 30, 100, 70))
        
        self.assertEqual(s.add_rect(30, 70), None)
        self.assertEqual(sr.add_rect(30, 70), Rectangle(30, 0, 70, 30))
        
        # Try with more than one wasted section
        s = skyline.SkylineBlWm(100, 100, rot=False)
        self.assertEqual(s.add_rect(40, 50), Rectangle(0, 0, 40, 50))
        self.assertEqual(s.add_rect(20, 30), Rectangle(40, 0, 20, 30))
        self.assertEqual(s.add_rect(20, 10), Rectangle(60, 0, 20, 10))
        self.assertEqual(s.add_rect(100, 50), Rectangle(0, 50, 100, 50))

        # Next ones only fit if waste is working
        self.assertEqual(s.add_rect(20, 20), Rectangle(40, 30, 20, 20))
        self.assertEqual(s.add_rect(20, 30), Rectangle(60, 10, 20, 30))
        self.assertEqual(s.add_rect(20, 50), Rectangle(80, 0, 20, 50))
        self.assertEqual(s.add_rect(20, 5), Rectangle(60, 40, 20, 5))
        self.assertEqual(s.add_rect(20, 5), Rectangle(60, 45, 20, 5))
        self.assertEqual(s.add_rect(1, 1), None)
 def test_init(self):
     """Test Waste management is disabled"""
     p = skyline.SkylineBl(100, 100)
     self.assertFalse(p._waste_management)
 def test_init(self):
     s = skyline.SkylineBl(100, 100, rot=False)
     rect1 = s.add_rect(30, 30)
     rect2 = s.add_rect(100, 70)
     self.assertEqual(rect1, Rectangle(0, 0, 30, 30))
     self.assertEqual(rect2, Rectangle(0, 30, 100, 70))