Fixes for old unit tests that broke,and a bug in the making with parseToLines not being wholey tuples, and in index_preserved because the filter function was broken

Author: tngreene

io_xplane2blender/tests/__init__.py

@@ -14,7 +14,12 @@
 from io_xplane2blender.tests import animation_file_mappings, test_creation_helpers
 from io_xplane2blender.xplane_config import getDebug, setDebug
 from io_xplane2blender.xplane_helpers import XPlaneLogger, logger
-from io_xplane2blender.xplane_types import xplane_bone, xplane_file, xplane_primitive
+from io_xplane2blender.xplane_types import (
+    xplane_attribute,
+    xplane_bone,
+    xplane_file,
+    xplane_primitive,
+)
 
 FLOAT_TOLERANCE = 0.0001
 
@@ -188,10 +193,10 @@ def assertFloatVectorsEqual(
         for a_comp, b_comp in zip(a, b):
             self.assertFloatsEqual(a_comp, b_comp, tolerance)
 
-    def parseFileToLines(self, data: str) -> List[Union[float, str]]:
+    def parseFileToLines(self, data: str) -> List[Tuple[Union[float, str]]]:
         """
-        Turns a string of \n seperated lines into a List[Union[float,str]]
-        without comments or 0 length strings. All numeric parts are converted
+        Turns a string of \n seperated lines into a list of lines
+        without comments or 0 length strings with all numeric parts are converted
         """
         lines = []  # type: List[Union[float,str]]
 
@@ -207,7 +212,7 @@ def tryToFloat(part: str) -> Union[float, str]:
             line = line.strip()
             if line:
                 if line.startswith("800"):
-                    lines.append(line.split())
+                    lines.append(tuple(line.split()))
                 else:
                     lines.append(tuple(map(tryToFloat, line.split())))
 
@@ -445,34 +450,35 @@ def assertExportableRootExportEqualsFixture(
     # asserts that an attributes object equals a dict
     def assertAttributesEqualDict(
         self,
-        attrs: List[str],
+        attrs: List[Union[str, xplane_attribute.XPlaneAttribute]],
         d: Dict[str, Any],
         floatTolerance: float = FLOAT_TOLERANCE,
     ):
-        self.assertEquals(len(d), len(attrs), "Attribute lists have different length")
+        self.assertEquals(
+            len(d),
+            len(attrs),
+            f"Attribute lists {list(d.keys())}, {list(attrs.keys())} have different length",
+        )
 
         for name in attrs:
             attr = attrs[name]
             value = attr.getValue()
             expectedValue = d[name]
 
-            if isinstance(expectedValue, list) or isinstance(expectedValue, tuple):
-                self.assertTrue(
-                    isinstance(value, list) or isinstance(value, tuple),
-                    'Attribute value for "%s" is no list or tuple but: %s'
-                    % (name, str(value)),
+            if isinstance(expectedValue, (list, tuple)):
+                self.assertIsInstance(
+                    value,
+                    (list, tuple),
+                    msg='Attribute value for "%s" is no list or tuple but: %s',
                 )
                 self.assertEquals(
                     len(expectedValue),
                     len(value),
                     'Attribute values for "%s" have different length' % name,
                 )
 
-                for i in range(0, len(expectedValue)):
-                    v = value[i]
-                    expectedV = expectedValue[i]
-
-                    if isinstance(expectedV, float) or isinstance(expectedV, int):
+                for i, (v, expectedV) in enumerate(zip(value, expectedValue)):
+                    if isinstance(expectedV, (float, int)):
                         self.assertFloatsEqual(expectedV, v, floatTolerance)
                     else:
                         self.assertEquals(

tests/features/materials.test.py

@@ -1,50 +1,58 @@
-import bpy
 import os
 import sys
+
+import bpy
+
 from io_xplane2blender.tests import *
 from io_xplane2blender.xplane_config import getDebug
 from io_xplane2blender.xplane_types import xplane_file
 
 __dirname__ = os.path.dirname(__file__)
 
+
 class TestMaterials(XPlaneTestCase):
     def test_material_attributes(self):
-        xplaneFile = self.createXPlaneFileFromPotentialRoot(bpy.data.collections["Layer 1"])
-
-        green = xplaneFile._bl_obj_name_to_bone['green'].xplaneObject.material
-        red = xplaneFile._bl_obj_name_to_bone['red'].xplaneObject.material
-        blue = xplaneFile._bl_obj_name_to_bone['blue'].xplaneObject.material
-        emissive = xplaneFile._bl_obj_name_to_bone['emissive'].xplaneObject.material
-        cockpit = xplaneFile._bl_obj_name_to_bone['cockpit'].xplaneObject.material
-        cockpitPanel = xplaneFile._bl_obj_name_to_bone['cockpit_panel'].xplaneObject.material
-        invisible = xplaneFile._bl_obj_name_to_bone['invisible'].xplaneObject.material
-        surface = xplaneFile._bl_obj_name_to_bone['surface'].xplaneObject.material
-        conditions = xplaneFile._bl_obj_name_to_bone['conditions'].xplaneObject.material
-        specular = xplaneFile._bl_obj_name_to_bone['specular'].xplaneObject.material
+        xplaneFile = self.createXPlaneFileFromPotentialRoot(
+            bpy.data.collections["Layer 1"]
+        )
+
+        green = xplaneFile._bl_obj_name_to_bone["green"].xplaneObject.material
+        red = xplaneFile._bl_obj_name_to_bone["red"].xplaneObject.material
+        blue = xplaneFile._bl_obj_name_to_bone["blue"].xplaneObject.material
+        emissive = xplaneFile._bl_obj_name_to_bone["emissive"].xplaneObject.material
+        cockpit = xplaneFile._bl_obj_name_to_bone["cockpit"].xplaneObject.material
+        cockpitPanel = xplaneFile._bl_obj_name_to_bone[
+            "cockpit_panel"
+        ].xplaneObject.material
+        invisible = xplaneFile._bl_obj_name_to_bone["invisible"].xplaneObject.material
+        surface = xplaneFile._bl_obj_name_to_bone["surface"].xplaneObject.material
+        conditions = xplaneFile._bl_obj_name_to_bone["conditions"].xplaneObject.material
+        specular = xplaneFile._bl_obj_name_to_bone["specular"].xplaneObject.material
 
         defaultAttrs = {
-            'ATTR_shiny_rat': 1,
-            'ATTR_hard': None,
-            'ATTR_hard_deck': None,
-            'ATTR_no_hard': True,
-            'ATTR_blend': True,
-            'ATTR_shadow_blend': None,
-            'ATTR_no_blend': None,
-            'ATTR_draw_enable': True,
-            'ATTR_shadow': True,
-            'ATTR_no_shadow': False,
-            'ATTR_draw_disable': None,
-            'ATTR_solid_camera': None,
-            'ATTR_no_solid_camera': True,
-            'ATTR_light_level': None,
-            'ATTR_poly_os': None,
-            'ATTR_draped': None,
-            'ATTR_no_draped': True
+            "ATTR_shiny_rat": 1,
+            "ATTR_hard": None,
+            "ATTR_hard_deck": None,
+            "ATTR_no_hard": True,
+            "ATTR_blend": True,
+            "ATTR_shadow_blend": None,
+            "ATTR_no_blend": None,
+            "ATTR_draw_enable": True,
+            "ATTR_shadow": True,
+            "ATTR_no_shadow": False,
+            "ATTR_draw_disable": None,
+            "ATTR_solid_camera": None,
+            "ATTR_no_solid_camera": True,
+            "ATTR_light_level": None,
+            "ATTR_poly_os": None,
+            "ATTR_draped": None,
+            "ATTR_no_draped": True,
         }
         defaultCockpitAttrs = {
-            'ATTR_cockpit': None,
-            'ATTR_no_cockpit': True,
-            'ATTR_cockpit_region': None
+            "ATTR_cockpit": None,
+            "ATTR_cockpit_lit_only": None,
+            "ATTR_cockpit_region": None,
+            "ATTR_no_cockpit": True,
         }
 
         redAttrs = defaultAttrs.copy()
@@ -56,48 +64,49 @@ def test_material_attributes(self):
         emissiveAttrs = defaultAttrs.copy()
 
         cockpitAttrs = defaultAttrs.copy()
-        cockpitAttrs['ATTR_shiny_rat'] = 1.0
-        cockpitAttrs['ATTR_blend'] = True
-        cockpitAttrs['ATTR_draw_enable'] = True
-        cockpitAttrs['ATTR_solid_camera'] = True
-        cockpitAttrs['ATTR_no_solid_camera'] = False
-        cockpitAttrs['ATTR_light_level'] = [1.0, 2.0, 'light-level-test']
+        cockpitAttrs["ATTR_shiny_rat"] = 1.0
+        cockpitAttrs["ATTR_blend"] = True
+        cockpitAttrs["ATTR_draw_enable"] = True
+        cockpitAttrs["ATTR_solid_camera"] = True
+        cockpitAttrs["ATTR_no_solid_camera"] = False
+        cockpitAttrs["ATTR_light_level"] = [1.0, 2.0, "light-level-test"]
         cockpitCockpitAttrs = defaultCockpitAttrs.copy()
-        cockpitCockpitAttrs['ATTR_cockpit'] = None
-        cockpitCockpitAttrs['ATTR_no_cockpit'] = True
-        cockpitCockpitAttrs['ATTR_cockpit_region'] = None
+        cockpitCockpitAttrs["ATTR_cockpit"] = None
+        cockpitCockpitAttrs["ATTR_no_cockpit"] = True
+        cockpitCockpitAttrs["ATTR_cockpit_region"] = None
 
         cockpitPanelAttrs = defaultAttrs.copy()
-        cockpitPanelAttrs['ATTR_shiny_rat'] = None
-        cockpitPanelAttrs['ATTR_blend'] = None
-        cockpitPanelAttrs['ATTR_draw_enable'] = True
+        cockpitPanelAttrs["ATTR_shiny_rat"] = None
+        cockpitPanelAttrs["ATTR_blend"] = None
+        cockpitPanelAttrs["ATTR_draw_enable"] = True
         cockpitPanelAttrs["ATTR_shadow"] = None
         cockpitPanelAttrs["ATTR_no_shadow"] = None
-        cockpitPanelAttrs['ATTR_solid_camera'] = True
-        cockpitPanelAttrs['ATTR_no_solid_camera'] = False
+        cockpitPanelAttrs["ATTR_solid_camera"] = True
+        cockpitPanelAttrs["ATTR_no_solid_camera"] = False
         cockpitPanelCockpitAttrs = defaultCockpitAttrs.copy()
-        cockpitPanelCockpitAttrs['ATTR_cockpit'] = True
-        cockpitPanelCockpitAttrs['ATTR_no_cockpit'] = None
-        cockpitPanelCockpitAttrs['ATTR_cockpit_region'] = 0
+        cockpitPanelCockpitAttrs["ATTR_cockpit"] = True
+        cockpitPanelCockpitAttrs["ATTR_cockpit_lit_only"] = None
+        cockpitPanelCockpitAttrs["ATTR_cockpit_region"] = 0
+        cockpitPanelCockpitAttrs["ATTR_no_cockpit"] = None
 
         invisibleAttrs = defaultAttrs.copy()
-        invisibleAttrs['ATTR_shiny_rat'] = None
-        invisibleAttrs['ATTR_blend'] = None
-        invisibleAttrs['ATTR_draw_enable'] = None
-        invisibleAttrs['ATTR_draw_disable'] = True
+        invisibleAttrs["ATTR_shiny_rat"] = None
+        invisibleAttrs["ATTR_blend"] = None
+        invisibleAttrs["ATTR_draw_enable"] = None
+        invisibleAttrs["ATTR_draw_disable"] = True
         invisibleAttrs["ATTR_shadow"] = None
         invisibleAttrs["ATTR_no_shadow"] = None
 
         surfaceAttrs = defaultAttrs.copy()
-        surfaceAttrs['ATTR_no_hard'] = None
-        surfaceAttrs['ATTR_hard_deck'] = 'asphalt'
-        surfaceAttrs['ATTR_poly_os'] = 2
+        surfaceAttrs["ATTR_no_hard"] = None
+        surfaceAttrs["ATTR_hard_deck"] = "asphalt"
+        surfaceAttrs["ATTR_poly_os"] = 2
 
         conditionsAttrs = defaultAttrs.copy()
-        conditionsAttrs['custom_prop'] = '10'
+        conditionsAttrs["custom_prop"] = "10"
 
         specularAttrs = defaultAttrs.copy()
-        specularAttrs['ATTR_shiny_rat'] = 0.25
+        specularAttrs["ATTR_shiny_rat"] = 0.25
 
         self.assertAttributesEqualDict(red.attributes, redAttrs)
         self.assertAttributesEqualDict(red.cockpitAttributes, defaultCockpitAttrs)
@@ -115,7 +124,9 @@ def test_material_attributes(self):
         self.assertAttributesEqualDict(cockpit.cockpitAttributes, cockpitCockpitAttrs)
 
         self.assertAttributesEqualDict(cockpitPanel.attributes, cockpitPanelAttrs)
-        self.assertAttributesEqualDict(cockpitPanel.cockpitAttributes, cockpitPanelCockpitAttrs)
+        self.assertAttributesEqualDict(
+            cockpitPanel.cockpitAttributes, cockpitPanelCockpitAttrs
+        )
 
         self.assertAttributesEqualDict(invisible.attributes, invisibleAttrs)
         self.assertAttributesEqualDict(invisible.cockpitAttributes, defaultCockpitAttrs)
@@ -124,20 +135,24 @@ def test_material_attributes(self):
         self.assertAttributesEqualDict(surface.cockpitAttributes, defaultCockpitAttrs)
 
         self.assertAttributesEqualDict(conditions.attributes, conditionsAttrs)
-        self.assertAttributesEqualDict(conditions.cockpitAttributes, defaultCockpitAttrs)
+        self.assertAttributesEqualDict(
+            conditions.cockpitAttributes, defaultCockpitAttrs
+        )
 
         self.assertAttributesEqualDict(specular.attributes, specularAttrs)
         self.assertAttributesEqualDict(specular.cockpitAttributes, defaultCockpitAttrs)
 
     def test_export_materials(self):
         def filterLines(line):
-            return isinstance(line[0], str) and line[0].find('ATTR_') == 0
+            return isinstance(line[0], str) and line[0].find("ATTR_") == 0
 
-        filename = 'test_materials'
+        filename = "test_materials"
         self.assertLayerExportEqualsFixture(
-            0, os.path.join(__dirname__, 'fixtures', filename + '.obj'),
+            0,
+            os.path.join(__dirname__, "fixtures", filename + ".obj"),
             filterLines,
             filename,
         )
 
+
 runTestCases([TestMaterials])