tests: Add more attribute tests to try to make coverage deterministic

tests/pgraph/test_cullfaceattrib.py

@@ -0,0 +1,18 @@
+from panda3d.core import CullFaceAttrib
+
+
+def test_cullfaceattrib_compare():
+    clockwise1 = CullFaceAttrib.make()
+    clockwise2 = CullFaceAttrib.make()
+    reverse1 = CullFaceAttrib.make_reverse()
+    reverse2 = CullFaceAttrib.make_reverse()
+
+    assert clockwise1.compare_to(clockwise2) == 0
+    assert clockwise2.compare_to(clockwise1) == 0
+
+    assert reverse1.compare_to(reverse2) == 0
+    assert reverse2.compare_to(reverse1) == 0
+
+    assert reverse1.compare_to(clockwise1) != 0
+    assert clockwise1.compare_to(reverse1) != 0
+    assert reverse1.compare_to(clockwise1) == -clockwise1.compare_to(reverse1)

tests/pgraph/test_lightattrib.py

@@ -72,3 +72,72 @@ def test_lightattrib_compose_alloff():
     assert lattr3.get_num_on_lights() == 0
     assert lattr3.get_num_off_lights() == 0
     assert lattr3.has_all_off()
+
+
+def test_lightattrib_compare():
+    lattr1 = core.LightAttrib.make()
+    lattr2 = core.LightAttrib.make()
+    assert lattr1.compare_to(lattr2) == 0
+
+    # All-off should not compare equal to empty
+    lattr2 = core.LightAttrib.make_all_off()
+    assert lattr1.compare_to(lattr2) != 0
+    assert lattr2.compare_to(lattr1) != 0
+    assert lattr2.compare_to(lattr1) == -lattr1.compare_to(lattr2)
+
+    # If both have the same light, they are equal
+    lattr1 = core.LightAttrib.make()
+    lattr1 = lattr1.add_on_light(spot)
+    lattr2 = core.LightAttrib.make()
+    lattr2 = lattr2.add_on_light(spot)
+    assert lattr1.compare_to(lattr2) == 0
+    assert lattr2.compare_to(lattr1) == 0
+
+    # Adding an extra light makes it unequal
+    lattr2 = lattr2.add_on_light(point)
+    assert lattr1.compare_to(lattr2) != 0
+    assert lattr2.compare_to(lattr1) != 0
+    assert lattr2.compare_to(lattr1) == -lattr1.compare_to(lattr2)
+
+    # Different lights altogether is of course unequal
+    lattr1 = core.LightAttrib.make()
+    lattr1 = lattr1.add_on_light(point)
+    lattr2 = core.LightAttrib.make()
+    lattr2 = lattr2.add_on_light(spot)
+    assert lattr1.compare_to(lattr2) != 0
+    assert lattr2.compare_to(lattr1) != 0
+    assert lattr2.compare_to(lattr1) == -lattr1.compare_to(lattr2)
+
+    # An on light is not the same as an off light
+    lattr1 = core.LightAttrib.make().add_on_light(spot)
+    lattr2 = core.LightAttrib.make().add_off_light(spot)
+    assert lattr1.compare_to(lattr2) != 0
+    assert lattr2.compare_to(lattr1) != 0
+    assert lattr2.compare_to(lattr1) == -lattr1.compare_to(lattr2)
+
+    # If both have the same off light, they are equal
+    lattr1 = core.LightAttrib.make().add_off_light(spot)
+    lattr2 = core.LightAttrib.make().add_off_light(spot)
+    assert lattr1.compare_to(lattr2) == 0
+    assert lattr2.compare_to(lattr1) == 0
+
+    # Off light should not be equal to empty
+    lattr1 = core.LightAttrib.make().add_off_light(spot)
+    lattr2 = core.LightAttrib.make_all_off()
+    assert lattr1.compare_to(lattr2) != 0
+    assert lattr2.compare_to(lattr1) != 0
+    assert lattr2.compare_to(lattr1) == -lattr1.compare_to(lattr2)
+
+    # Off light should not be equal to all-off
+    lattr1 = core.LightAttrib.make().add_off_light(spot)
+    lattr2 = core.LightAttrib.make_all_off()
+    assert lattr1.compare_to(lattr2) != 0
+    assert lattr2.compare_to(lattr1) != 0
+    assert lattr2.compare_to(lattr1) == -lattr1.compare_to(lattr2)
+
+    # Different off lights shouldn't be equal either, of course
+    lattr1 = core.LightAttrib.make().add_off_light(spot)
+    lattr2 = core.LightAttrib.make().add_off_light(point)
+    assert lattr1.compare_to(lattr2) != 0
+    assert lattr2.compare_to(lattr1) != 0
+    assert lattr2.compare_to(lattr1) == -lattr1.compare_to(lattr2)

tests/pgraph/test_shaderattrib.py

@@ -0,0 +1,20 @@
+from panda3d import core
+
+
+def test_shaderattrib_compare():
+    shattr1 = core.ShaderAttrib.make()
+    shattr2 = core.ShaderAttrib.make()
+    assert shattr1.compare_to(shattr2) == 0
+    assert shattr2.compare_to(shattr1) == 0
+
+    shattr2 = core.ShaderAttrib.make().set_flag(core.ShaderAttrib.F_subsume_alpha_test, False)
+    assert shattr1.compare_to(shattr2) != 0
+    assert shattr2.compare_to(shattr1) != 0
+
+    shattr1 = core.ShaderAttrib.make().set_flag(core.ShaderAttrib.F_subsume_alpha_test, False)
+    assert shattr1.compare_to(shattr2) == 0
+    assert shattr2.compare_to(shattr1) == 0
+
+    shattr2 = core.ShaderAttrib.make().set_flag(core.ShaderAttrib.F_subsume_alpha_test, True)
+    assert shattr1.compare_to(shattr2) != 0
+    assert shattr2.compare_to(shattr1) != 0

tests/pgraph/test_textureattrib.py

@@ -0,0 +1,202 @@
+from panda3d import core
+
+# Some dummy textures we can use for our texture attributes.
+stage1 = core.TextureStage("stage1")
+stage2 = core.TextureStage("stage2")
+stage3 = core.TextureStage("stage3")
+tex1 = core.Texture("tex1")
+tex2 = core.Texture("tex2")
+tex3 = core.Texture("tex3")
+
+
+def test_textureattrib_compose_empty():
+    # Tests a case in which a child node does not alter the original.
+    tattr1 = core.TextureAttrib.make()
+    tattr1 = tattr1.add_on_stage(stage1, tex1)
+
+    tattr2 = core.TextureAttrib.make()
+
+    tattr3 = tattr1.compose(tattr2)
+    assert tattr3.get_num_on_stages() == 1
+
+    assert stage1 in tattr3.on_stages
+
+
+def test_textureattrib_compose_add():
+    # Tests a case in which a child node adds another texture.
+    tattr1 = core.TextureAttrib.make()
+    tattr1 = tattr1.add_on_stage(stage1, tex1)
+
+    tattr2 = core.TextureAttrib.make()
+    tattr2 = tattr2.add_on_stage(stage2, tex2)
+
+    tattr3 = tattr1.compose(tattr2)
+    assert tattr3.get_num_on_stages() == 2
+
+    assert stage1 in tattr3.on_stages
+    assert stage2 in tattr3.on_stages
+
+
+def test_textureattrib_compose_override():
+    # Tests a case in which a child node overrides a texture.
+    tattr1 = core.TextureAttrib.make()
+    tattr1 = tattr1.add_on_stage(stage1, tex1)
+
+    tattr2 = core.TextureAttrib.make()
+    tattr2 = tattr2.add_on_stage(stage1, tex2)
+
+    tattr3 = tattr1.compose(tattr2)
+    assert tattr3.get_num_on_stages() == 1
+
+    assert stage1 in tattr3.on_stages
+    assert tattr3.get_on_texture(stage1) == tex2
+
+
+def test_textureattrib_compose_subtract():
+    # Tests a case in which a child node disables a texture.
+    tattr1 = core.TextureAttrib.make()
+    tattr1 = tattr1.add_on_stage(stage1, tex1)
+    tattr1 = tattr1.add_on_stage(stage2, tex2)
+
+    tattr2 = core.TextureAttrib.make()
+    tattr2 = tattr2.add_off_stage(stage3)
+    tattr2 = tattr2.add_off_stage(stage2)
+
+    tattr3 = tattr1.compose(tattr2)
+    assert tattr3.get_num_on_stages() == 1
+
+    assert stage1 in tattr3.on_stages
+    assert stage2 not in tattr3.on_stages
+    assert stage3 not in tattr3.on_stages
+
+
+def test_textureattrib_compose_both():
+    # Tests a case in which a child node both enables and disables a texture.
+    tattr1 = core.TextureAttrib.make()
+    tattr1 = tattr1.add_on_stage(stage1, tex1)
+    tattr1 = tattr1.add_on_stage(stage2, tex2)
+
+    tattr2 = core.TextureAttrib.make()
+    tattr2 = tattr2.add_on_stage(stage3, tex3)
+    tattr2 = tattr2.add_on_stage(stage1, tex1)
+    tattr2 = tattr2.add_off_stage(stage2)
+
+    tattr3 = tattr1.compose(tattr2)
+    assert tattr3.get_num_on_stages() == 2
+
+    assert stage1 in tattr3.on_stages
+    assert stage2 not in tattr3.on_stages
+    assert stage3 in tattr3.on_stages
+
+
+def test_textureattrib_implicit_sort():
+    # Tests that two TextureStages with same sort retain insertion order.
+    tattr1 = core.TextureAttrib.make()
+    tattr1 = tattr1.add_on_stage(stage1, tex1)
+    tattr1 = tattr1.add_on_stage(stage2, tex2)
+
+    assert tattr1.get_on_stage(0) == stage1
+    assert tattr1.get_on_stage(1) == stage2
+
+    tattr2 = core.TextureAttrib.make()
+    tattr2 = tattr1.add_on_stage(stage2, tex2)
+    tattr2 = tattr1.add_on_stage(stage1, tex1)
+
+    assert tattr2.get_on_stage(0) == stage2
+    assert tattr2.get_on_stage(1) == stage1
+
+    assert tattr1.compare_to(tattr2) == -tattr2.compare_to(tattr1)
+
+
+def test_textureattrib_compose_alloff():
+    # Tests a case in which a child node disables all textures.
+    tattr1 = core.TextureAttrib.make()
+    tattr1 = tattr1.add_on_stage(stage1, tex1)
+    tattr1 = tattr1.add_on_stage(stage2, tex2)
+    assert tattr1.get_num_on_stages() == 2
+
+    tattr2 = core.TextureAttrib.make_all_off()
+    assert tattr2.has_all_off()
+
+    tattr3 = tattr1.compose(tattr2)
+    assert tattr3.get_num_on_stages() == 0
+    assert tattr3.get_num_off_stages() == 0
+    assert tattr3.has_all_off()
+
+
+def test_textureattrib_compare():
+    tattr1 = core.TextureAttrib.make()
+    tattr2 = core.TextureAttrib.make()
+    assert tattr1.compare_to(tattr2) == 0
+
+    # All-off should not compare equal to empty
+    tattr2 = core.TextureAttrib.make_all_off()
+    assert tattr1.compare_to(tattr2) != 0
+    assert tattr2.compare_to(tattr1) != 0
+    assert tattr2.compare_to(tattr1) == -tattr1.compare_to(tattr2)
+
+    # Empty stage is not the same as a single off stage
+    tattr1 = core.TextureAttrib.make()
+    tattr2 = core.TextureAttrib.make()
+    tattr2 = tattr2.add_off_stage(stage1)
+    assert tattr1.compare_to(tattr2) != 0
+    assert tattr2.compare_to(tattr1) != 0
+    assert tattr2.compare_to(tattr1) == -tattr1.compare_to(tattr2)
+
+    # All-off stage is not the same as a single off stage
+    tattr1 = core.TextureAttrib.make_all_off()
+    tattr2 = core.TextureAttrib.make()
+    tattr2 = tattr2.add_off_stage(stage1)
+    assert tattr1.compare_to(tattr2) != 0
+    assert tattr2.compare_to(tattr1) != 0
+    assert tattr2.compare_to(tattr1) == -tattr1.compare_to(tattr2)
+
+    # Different off stages are non-equal
+    tattr1 = core.TextureAttrib.make_all_off()
+    tattr1 = tattr2.add_off_stage(stage1)
+    tattr2 = core.TextureAttrib.make()
+    tattr2 = tattr2.add_off_stage(stage2)
+    assert tattr1.compare_to(tattr2) != 0
+    assert tattr2.compare_to(tattr1) != 0
+    assert tattr2.compare_to(tattr1) == -tattr1.compare_to(tattr2)
+
+    # If both have a different texture, but same stage, they are not equal
+    tattr1 = core.TextureAttrib.make()
+    tattr1 = tattr1.add_on_stage(stage1, tex1)
+    tattr2 = core.TextureAttrib.make()
+    tattr2 = tattr2.add_on_stage(stage1, tex2)
+    assert tattr1.compare_to(tattr2) != 0
+    assert tattr2.compare_to(tattr1) != 0
+    assert tattr2.compare_to(tattr1) == -tattr1.compare_to(tattr2)
+
+    # If both have the same texture, but different stage, they are not equal
+    tattr1 = core.TextureAttrib.make()
+    tattr1 = tattr1.add_on_stage(stage1, tex1)
+    tattr2 = core.TextureAttrib.make()
+    tattr2 = tattr2.add_on_stage(stage2, tex2)
+    assert tattr1.compare_to(tattr2) != 0
+    assert tattr2.compare_to(tattr1) != 0
+    assert tattr2.compare_to(tattr1) == -tattr1.compare_to(tattr2)
+
+    # If both have the same texture and stage, they are equal
+    tattr1 = core.TextureAttrib.make()
+    tattr1 = tattr1.add_on_stage(stage1, tex1)
+    tattr2 = core.TextureAttrib.make()
+    tattr2 = tattr2.add_on_stage(stage1, tex1)
+    assert tattr1.compare_to(tattr2) == 0
+    assert tattr2.compare_to(tattr1) == 0
+
+    # Adding an extra texture makes it unequal
+    tattr2 = tattr2.add_on_stage(stage2, tex2)
+    assert tattr1.compare_to(tattr2) != 0
+    assert tattr2.compare_to(tattr1) != 0
+    assert tattr2.compare_to(tattr1) == -tattr1.compare_to(tattr2)
+
+    # Different textures altogether is of course unequal
+    tattr1 = core.TextureAttrib.make()
+    tattr1 = tattr1.add_on_stage(stage2, tex2)
+    tattr2 = core.TextureAttrib.make()
+    tattr2 = tattr2.add_on_stage(stage1, tex1)
+    assert tattr1.compare_to(tattr2) != 0
+    assert tattr2.compare_to(tattr1) != 0
+    assert tattr2.compare_to(tattr1) == -tattr1.compare_to(tattr2)