class TestInstance(unittest.TestCase):
    def setUp(self):
        self.instance = ThreeDinstance()
        self.instance.description.setname = "Instance"
        self.instance.description.name = "Test"

    def test_instance_valid(self):
        self.assertTrue(self.instance.IsValid()[0])

    def test_instance_addcontainerkind(self):
        container_kind = ThreeDcontainerkind()
        container_kind.id = 1
        container_kind.quantity = 1
        loadingspace = ThreeDloadingspace()
        loadingspace.id = 1
        loadingspace.boundingBox = [2000, 1000, 1000]
        loadingspace.position = [0, 0, 0]
        container_kind.addLoadingspace(loadingspace)
        self.instance.addContainerkind(container_kind)
        self.assertEqual(len(self.instance.containerkinds), 1)
        self.assertTrue(self.instance.IsValid()[0])

    def test_instance_addpalletkind(self):
        pallet_kind = ThreeDpalletkind()
        pallet_kind.id = 1
        pallet_kind.quantity = 1
        pallet_kind.boundingBox = [750, 750, 10]
        pallet_kind.position = [0, 0, 0]
        pallet_kind.loadingspace = ThreeDloadingspace()
        pallet_kind.loadingspace.id = 1
        pallet_kind.loadingspace.boundingBox = [750, 750, 1500]
        pallet_kind.loadingspace.position = [0, 0, 10]
        pallet_kind.orientations = set(['LWH', 'WLH'])
        self.instance.addPalletkind(pallet_kind)
        self.assertEqual(len(self.instance.palletkinds), 1)
        self.assertTrue(self.instance.IsValid()[0])

    def test_instance_addboxkind(self):
        box_kind = ThreeDboxkind()
        box_kind.id = 1
        box_kind.quantity = 1
        box_kind.boundingBox = [750, 750, 10]
        box_kind.position = [0, 0, 0]
        box_kind.loadingspace = ThreeDloadingspace()
        box_kind.loadingspace.id = 1
        box_kind.loadingspace.boundingBox = [750, 750, 1500]
        box_kind.loadingspace.position = [0, 0, 10]
        box_kind.orientations = set(['LWH', 'WLH'])
        self.instance.addBoxkind(box_kind)
        self.assertEqual(len(self.instance.boxkinds), 1)
        self.assertTrue(self.instance.IsValid()[0])

    def test_instance_additemkind(self):
        item_kind = ThreeDitemkind()
        item_kind.id = 1
        item_kind.quantity = 10
        item_kind.boundingBox = [10, 10, 10]
        item_kind.orientations = set(['LWH', 'WLH'])
        self.instance.addItemkind(item_kind)
        self.assertEqual(len(self.instance.itemkinds), 1)
        self.assertTrue(self.instance.IsValid()[0])

    def test_instance_addconstraint(self):
        constraint = ThreeDconstraint()
        constraint.constraint = MaximumWeightConstraint
        self.instance.addConstraint(constraint)
        self.assertEqual(len(self.instance.constraints), 1)
        self.assertTrue(self.instance.IsValid()[0])

    def test_instance_addobjective(self):
        objective = ThreeDobjective()
        objective.objective = ItemCountObjective
        objective.priority = 1
        objective.weight = 1.0
        self.instance.addObjective(objective)
        self.assertEqual(len(self.instance.objectives), 1)
        self.assertTrue(self.instance.IsValid()[0])

    def test_instance_isdatacomplete1(self):
        pass

    def test_instance_typestring(self):
        self.assertEqual(self.instance.TypeString(), "instance")

    def test_instance_ne(self):
        self.assertNotEqual(self.instance, ThreeDinstance())
예제 #2
0
class TestReadPalletkind(unittest.TestCase):
    def setUp(self):
        self.test_instance = ThreeDinstance()
        self.test_instance.description.setname = "Palletkind"
        self.test_instance.description.name = "Test"
        pallet_kind = ThreeDpalletkind()
        pallet_kind.id = 1
        pallet_kind.quantity = 1
        pallet_kind.boundingBox = [1000, 1000, 10]
        pallet_kind.position = [0, 0, 0]
        pallet_kind.orientations = set(['LWH', 'WLH'])
        self.test_instance.addPalletkind(pallet_kind)
        loadingspace = ThreeDloadingspace()
        loadingspace.id = 1
        loadingspace.boundingBox = [1000, 1000, 1500]
        loadingspace.position = [0, 0, 10]
        pallet_kind.loadingspace = loadingspace
        pallet_kind = ThreeDpalletkind()
        pallet_kind.id = 2
        pallet_kind.quantity = 9999
        pallet_kind.boundingBox = [1000, 1000, 100]
        pallet_kind.position = [0, 0, 0]
        pallet_kind.orientations = set(['LWH', 'WLH'])
        self.test_instance.addPalletkind(pallet_kind)
        loadingspace = ThreeDloadingspace()
        loadingspace.id = 1
        loadingspace.boundingBox = [1000, 1000, 1000]
        loadingspace.position = [0, 0, 100]
        pallet_kind.loadingspace = loadingspace

    def performTest1(self, instance):
        self.assertEqual(instance, self.test_instance)
        self.assertTrue(instance.IsValid()[0])

    def test_palletkind_read_JSON01(self):
        self.performTest1(loadJSON("tests/read/palletkind/test1.json"))

    def test_palletkind_read_XML01(self):
        self.performTest1(loadXML("tests/read/palletkind/test1.xml"))

    def test_palletkind_read_YAML01(self):
        self.performTest1(loadYAML("tests/read/palletkind/test1.yaml"))

    def performTest2(self, instance):
        self.test_instance.palletkinds[0].id = None
        self.assertEqual(instance, self.test_instance)
        self.assertFalse(instance.IsValid()[0])

    def test_palletkind_read_JSON02(self):
        self.performTest2(loadJSON("tests/read/palletkind/test2.json"))

    def test_palletkind_read_XML02(self):
        self.performTest2(loadXML("tests/read/palletkind/test2.xml"))

    def test_palletkind_read_YAML02(self):
        self.performTest2(loadYAML("tests/read/palletkind/test2.yaml"))

    def performTest3(self, instance):
        self.test_instance.palletkinds[0].quantity = None
        self.assertEqual(instance, self.test_instance)
        self.assertFalse(instance.IsValid()[0])

    def test_palletkind_read_JSON03(self):
        self.performTest3(loadJSON("tests/read/palletkind/test3.json"))

    def test_palletkind_read_XML03(self):
        self.performTest3(loadXML("tests/read/palletkind/test3.xml"))

    def test_palletkind_read_YAML03(self):
        self.performTest3(loadYAML("tests/read/palletkind/test3.yaml"))

    def performTest4(self, instance):
        self.test_instance.palletkinds[0].position = None
        self.assertEqual(instance, self.test_instance)
        self.assertFalse(instance.IsValid()[0])

    def test_palletkind_read_JSON04(self):
        self.performTest4(loadJSON("tests/read/palletkind/test4.json"))

    def test_palletkind_read_XML04(self):
        self.performTest4(loadXML("tests/read/palletkind/test4.xml"))

    def test_palletkind_read_YAML04(self):
        self.performTest4(loadYAML("tests/read/palletkind/test4.yaml"))

    def performTest5(self, instance):
        self.test_instance.palletkinds[0].boundingBox = [None, None, None]
        self.assertEqual(instance, self.test_instance)
        self.assertFalse(instance.IsValid()[0])

    def test_palletkind_read_JSON05(self):
        self.performTest5(loadJSON("tests/read/palletkind/test5.json"))

    def test_palletkind_read_XML05(self):
        self.performTest5(loadXML("tests/read/palletkind/test5.xml"))

    def test_palletkind_read_YAML05(self):
        self.performTest5(loadYAML("tests/read/palletkind/test5.yaml"))

    def performTest6(self, instance):
        self.test_instance.palletkinds[0].boundingBox = [None, 1000, 10]
        self.assertEqual(instance, self.test_instance)
        self.assertFalse(instance.IsValid()[0])

    def test_palletkind_read_JSON06(self):
        self.performTest6(loadJSON("tests/read/palletkind/test6.json"))

    def test_palletkind_read_XML06(self):
        self.performTest6(loadXML("tests/read/palletkind/test6.xml"))

    def test_palletkind_read_YAML06(self):
        self.performTest6(loadYAML("tests/read/palletkind/test6.yaml"))

    def performTest7(self, instance):
        self.test_instance.palletkinds[0].boundingBox = [1000, None, 10]
        self.assertEqual(instance, self.test_instance)
        self.assertFalse(instance.IsValid()[0])

    def test_palletkind_read_JSON07(self):
        self.performTest7(loadJSON("tests/read/palletkind/test7.json"))

    def test_palletkind_read_XML07(self):
        self.performTest7(loadXML("tests/read/palletkind/test7.xml"))

    def test_palletkind_read_YAML07(self):
        self.performTest7(loadYAML("tests/read/palletkind/test7.yaml"))

    def performTest8(self, instance):
        self.test_instance.palletkinds[0].boundingBox = [1000, 1000, None]
        self.assertEqual(instance, self.test_instance)
        self.assertFalse(instance.IsValid()[0])

    def test_palletkind_read_JSON08(self):
        self.performTest8(loadJSON("tests/read/palletkind/test8.json"))

    def test_palletkind_read_XML08(self):
        self.performTest8(loadXML("tests/read/palletkind/test8.xml"))

    def test_palletkind_read_YAML08(self):
        self.performTest8(loadYAML("tests/read/palletkind/test8.yaml"))

    def performTest9(self, instance):
        self.test_instance.palletkinds[0].orientations = None
        self.assertEqual(instance, self.test_instance)
        self.assertFalse(instance.IsValid()[0])

    def test_palletkind_read_JSON09(self):
        self.performTest9(loadJSON("tests/read/palletkind/test9.json"))

    def test_palletkind_read_XML09(self):
        self.performTest9(loadXML("tests/read/palletkind/test9.xml"))

    def test_palletkind_read_YAML09(self):
        self.performTest9(loadYAML("tests/read/palletkind/test9.yaml"))