convert bare assert statements in TestCase methods to self.assertEqual

...where appropriate, and the comparison is simple.

This makes errors report more useful information - particularly helpful
for infrequent or hard-to-reproduce failures.

These changes were automatically generated using a libCST script to
parse source code and make changes in a syntax-safe way.  This is the
exact script used to make these changes:

https://github.com/pmolodo/convert_assert_statements/blob/8a39369a68552787b8fbffabdd6be47c88702985/convert_TestCase_assert_statements_to_assert_methods.py

Author: pmolodo

pxr/usd/plugin/sdrOsl/testenv/testOslParser.py

@@ -55,13 +55,13 @@ def test_Basic(self):
         its job correctly.
         """
         nodeMetadata = self.node.GetMetadata()
-        assert nodeMetadata["extra"] == self.metadata["extra"]
+        self.assertEqual(nodeMetadata["extra"], self.metadata["extra"])
 
         # The primvars value will be overridden by the parser plugin.
         assert nodeMetadata["primvars"] != self.metadata["primvars"]
 
         # Ensure that the source code gets copied.
-        assert self.node.GetSourceCode() == self.sourceCode
+        self.assertEqual(self.node.GetSourceCode(), self.sourceCode)
 
         utils.TestBasicNode(self.node,
                             "OSL",

pxr/usd/sdr/testenv/testSdrFilesystemDiscovery.py

@@ -31,8 +31,8 @@ def test_SdrFilesystemDiscovery(self):
             (result.identifier, result.name, result.family, result.version) 
             for result in discoveryResults]
 
-        assert len(discoveryResults) == 13
-        assert set(discoveredNodeNames) == {
+        self.assertEqual(len(discoveryResults), 13)
+        self.assertEqual(set(discoveredNodeNames), {
             ("TestNodeARGS", "TestNodeARGS", "TestNodeARGS", 
              Sdr.Version()),
             ("TestNodeOSL", "TestNodeOSL", "TestNodeOSL", 
@@ -57,17 +57,17 @@ def test_SdrFilesystemDiscovery(self):
              Sdr.Version(3, 0)),
             ("Primvar_float2_3_4", "Primvar_float2", "Primvar", 
              Sdr.Version(3, 4))
-        }
+        })
 
         # Verify that the discovery files helper returns the same URIs as 
         # full discovery plugin when run on the same search path and allowed
         # extensions.
         discoveryUris = Sdr.FsHelpersDiscoverFiles(
             [os.getcwd()], ["oso","args"], True)
-        assert len(discoveryResults) == 13
+        self.assertEqual(len(discoveryResults), 13)
         for result, uris in zip(discoveryResults, discoveryUris):
-            assert result.uri == uris.uri
-            assert result.resolvedUri == result.resolvedUri
+            self.assertEqual(result.uri, uris.uri)
+            self.assertEqual(result.resolvedUri, result.resolvedUri)
 
     def test_testSplitShaderIdentifier(self):
         self.assertEqual(

pxr/usd/sdr/testenv/testSdrRegistry.py

@@ -90,8 +90,7 @@ def test_Registry(self):
 
         # Test that the registry does not see 'RmanCpp' twice as a source type,
         # and that it finds 'glslfx' as a source type
-        assert sorted(self.reg.GetAllShaderNodeSourceTypes()) == \
-            [self.oslType, self.argsType, self.glslfxType]
+        self.assertEqual(sorted(self.reg.GetAllShaderNodeSourceTypes()), [self.oslType, self.argsType, self.glslfxType])
 
         # Calling SdrRegistry::GetShaderNodesByFamily() will actually parse the
         # discovery results.
@@ -102,15 +101,15 @@ def test_Registry(self):
         # parser plugin to support it
         nodes = self.reg.GetShaderNodesByFamily()
         shaderNodeNames = [node.GetName() for node in nodes]
-        assert set(shaderNodeNames) == {
+        self.assertEqual(set(shaderNodeNames), {
             "TestNodeARGS",
             "TestNodeARGS2",
             "TestNodeOSL",
             "TestNodeSameName",
             "TestNodeSameName"
-        }
+        })
 
-        assert self.reg.GetSearchURIs() == ["/TestSearchPath", "/TestSearchPath2"]
+        self.assertEqual(self.reg.GetSearchURIs(), ["/TestSearchPath", "/TestSearchPath2"])
 
         # Calling SdrRegistry::GetShaderNodeNames only looks at discovery
         # results without parsing them.
@@ -119,53 +118,53 @@ def test_Registry(self):
         # Notice that we see 'TestNodeGLSLFX' because it is in our discovery
         # results even though we do not have a parser plugin that supports its
         # source type.
-        assert set(self.reg.GetShaderNodeNames()) == {
+        self.assertEqual(set(self.reg.GetShaderNodeNames()), {
             "TestNodeARGS",
             "TestNodeARGS2",
             "TestNodeOSL",
             "TestNodeSameName",
             "TestNodeGLSLFX"
-        }
+        })
         # Verify that GetShaderNodeIdentifiers follows the same rules as
         # GetShaderNodeNames.
         # Note that the names and identifiers do happen to be the same in this
         # test case which is common.
-        assert set(self.reg.GetShaderNodeIdentifiers()) == {
+        self.assertEqual(set(self.reg.GetShaderNodeIdentifiers()), {
             "TestNodeARGS",
             "TestNodeARGS2",
             "TestNodeOSL",
             "TestNodeSameName",
             "TestNodeGLSLFX"
-        }
+        })
 
-        assert id(self.reg.GetShaderNodeByName(nodes[0].GetName())) == id(nodes[0])
+        self.assertEqual(id(self.reg.GetShaderNodeByName(nodes[0].GetName())), id(nodes[0]))
 
         nodeName = "TestNodeSameName"
         nodeIdentifier = "TestNodeSameName"
 
         # Ensure that the registry can retrieve two nodes of the same name but
         # different source types
-        assert len(self.reg.GetShaderNodesByName(nodeName)) == 2
+        self.assertEqual(len(self.reg.GetShaderNodesByName(nodeName)), 2)
         node = self.reg.GetShaderNodeByNameAndType(nodeName, self.oslType)
         assert node is not None
         node = self.reg.GetShaderNodeByNameAndType(nodeName, self.argsType)
         assert node is not None
         node = self.reg.GetShaderNodeByName(nodeName, [self.oslType, self.argsType])
-        assert node.GetSourceType() == self.oslType
+        self.assertEqual(node.GetSourceType(), self.oslType)
         node = self.reg.GetShaderNodeByName(nodeName, [self.argsType, self.oslType])
-        assert node.GetSourceType() == self.argsType
+        self.assertEqual(node.GetSourceType(), self.argsType)
 
         # Ensure that the registry can retrieve these same nodes via identifier,
         # which, in these cases, are the same as the node names.
-        assert len(self.reg.GetShaderNodesByIdentifier(nodeIdentifier)) == 2
+        self.assertEqual(len(self.reg.GetShaderNodesByIdentifier(nodeIdentifier)), 2)
         node = self.reg.GetShaderNodeByIdentifierAndType(nodeIdentifier, self.oslType)
         assert node is not None
         node = self.reg.GetShaderNodeByIdentifierAndType(nodeIdentifier, self.argsType)
         assert node is not None
         node = self.reg.GetShaderNodeByIdentifier(nodeIdentifier, [self.oslType, self.argsType])
-        assert node.GetSourceType() == self.oslType
+        self.assertEqual(node.GetSourceType(), self.oslType)
         node = self.reg.GetShaderNodeByIdentifier(nodeIdentifier, [self.argsType, self.oslType])
-        assert node.GetSourceType() == self.argsType
+        self.assertEqual(node.GetSourceType(), self.argsType)
 
         # Test GetShaderNodeFromAsset to check that a subidentifier is part of
         # the node's identifier if one is specified
@@ -174,7 +173,7 @@ def test_Registry(self):
             {},                                         # metadata
             "mySubIdentifier")                          # subIdentifier
         assert node.GetIdentifier().endswith("<mySubIdentifier><>")
-        assert node.GetName() == "TestNodeSourceAsset.oso"
+        self.assertEqual(node.GetName(), "TestNodeSourceAsset.oso")
 
         # Test GetShaderNodeFromAsset to check that a sourceType is part of
         # the node's identifier if one is specified
@@ -194,7 +193,7 @@ def test_UsdEncoding(self):
         assert nodeNew is not None
         nodeOld = self.reg.GetShaderNodeByNameAndType("TestNodeSameName", self.oslType)
         assert nodeOld is not None
-        assert nodeOld.GetMetadata()['sdrUsdEncodingVersion'] == "0"
+        self.assertEqual(nodeOld.GetMetadata()['sdrUsdEncodingVersion'], "0")
 
         def _CheckTypes(node, expectedTypes):
             for inputName in node.GetShaderInputNames():
@@ -249,8 +248,8 @@ def test_ParseValue(self):
         nodeNew = self.reg.GetShaderNodeByNameAndType("TestNodeOSL", self.oslType)
         intProp = nodeNew.GetShaderInput("IntProperty")
         val, err = Sdr.MetadataHelpers.ParseSdfValue("3", intProp)
-        assert val == 3
-        assert err == ""
+        self.assertEqual(val, 3)
+        self.assertEqual(err, "")
 
 if __name__ == '__main__':
     unittest.main()

pxr/usd/sdr/testenv/testSdrShownIfConversion.py

@@ -49,7 +49,7 @@ def test_SdrShownIfConversion(self):
                 print(f'  {inputName}')
                 input = node.GetShaderInput(inputName)
                 assert input is not None
-                assert input.GetShownIf() == expected
+                self.assertEqual(input.GetShownIf(), expected)
 
 if __name__ == '__main__':
     unittest.main()

pxr/usd/usd/testenv/testUsdColorSpaceAPIPy.py

@@ -29,81 +29,81 @@ def test_ColorSpaceAPI(self):
 
         # Fetch the color space in a variety of ways
         assert Gf.ColorSpace.IsValid(rec2020)
-        assert rootCsAttr.Get() == rec2020
-        assert rootCsAPI.GetColorSpaceNameAttr().Get() == rec2020
+        self.assertEqual(rootCsAttr.Get(), rec2020)
+        self.assertEqual(rootCsAPI.GetColorSpaceNameAttr().Get(), rec2020)
 
         # Compute the color space
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(rootPrim, cache) == rec2020
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(rootCsAttr, cache) == rec2020
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(rootPrim, cache), rec2020)
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(rootCsAttr, cache), rec2020)
 
         assert cache.IsCached(Sdf.Path("/rec2020"), rec2020)
 
         # Create a color attribute on rootPrim and verify it inherits the color space from rootPrim
         colorAttr = rootPrim.CreateAttribute("color", Sdf.ValueTypeNames.Color3f)
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(colorAttr, cache) == rec2020
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(colorAttr, cache), rec2020)
 
         # Create a child prim with a different color space, and verify it overrides the parent
         childPrim = stage.OverridePrim("/rec2020/linSRGB")
         childCsAPI = Usd.ColorSpaceAPI.Apply(childPrim)
         childCsAttr = childCsAPI.CreateColorSpaceNameAttr(rec709)
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(childPrim, cache) == rec709
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(childPrim, cache), rec709)
 
         assert cache.IsCached(Sdf.Path("/rec2020/linSRGB"), rec709)
 
         # Create a color attribute on childPrim, and verify it inherits the color space from childPrim
         childColorAttr = childPrim.CreateAttribute("color", Sdf.ValueTypeNames.Color3f)
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(childColorAttr, cache) == rec709
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(childColorAttr, cache), rec709)
 
         # Create a grandchild prim with no color space, and verify it inherits the parent's color space
         grandchildPrim = stage.OverridePrim("/rec2020/linSRGB/noColorSpace")
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(grandchildPrim, cache) == rec709
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(grandchildPrim, cache), rec709)
 
         assert cache.IsCached(Sdf.Path("/rec2020/linSRGB/noColorSpace"), rec709)
 
         # Create a color attribute on grandchildPrim, and verify it inherits the color space from childPrim
         grandchildColorAttr = grandchildPrim.CreateAttribute("color", Sdf.ValueTypeNames.Color3f)
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(grandchildColorAttr, cache) == rec709
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(grandchildColorAttr, cache), rec709)
 
         # Create a root prim without assigning color space, and verify the result is empty
         rootPrim2 = stage.OverridePrim("/noColorSpace")
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(rootPrim2, cache) == ""
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(rootPrim2, cache), "")
 
         assert cache.IsCached(Sdf.Path("/noColorSpace"), "")
 
         # Repeat all of the preceding rootPrim tests on rootPrim2
         colorAttr2 = rootPrim2.CreateAttribute("color", Sdf.ValueTypeNames.Color3f)
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(colorAttr2, cache) == ""
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(colorAttr2, cache), "")
 
         # Create a child prim with a different color space, and verify it overrides the parent
         childPrim2 = stage.OverridePrim("/noColorSpace/linSRGB")
         child2CsAPI = Usd.ColorSpaceAPI.Apply(childPrim2)
         child2CsAttr = child2CsAPI.CreateColorSpaceNameAttr(rec709)
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(childPrim2, cache) == rec709
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(childPrim2, cache), rec709)
 
         assert cache.IsCached(Sdf.Path("/noColorSpace/linSRGB"), rec709)
 
         # Create a color attribute on childPrim2, and verify it inherits the color space from childPrim2
         childColorAttr2 = childPrim2.CreateAttribute("color", Sdf.ValueTypeNames.Color3f)
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(childColorAttr2, cache) == rec709
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(childColorAttr2, cache), rec709)
 
         # Create a grandchild prim with no color space, and verify it inherits the parent's color space
         grandchildPrim2 = stage.OverridePrim("/noColorSpace/linSRGB/noColorSpace")
         grandchild2CsAPI = Usd.ColorSpaceAPI.Apply(grandchildPrim2)
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(grandchildPrim2, cache) == rec709
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(grandchildPrim2, cache), rec709)
 
         assert cache.IsCached(Sdf.Path("/noColorSpace/linSRGB/noColorSpace"), rec709)
 
         # Create a color attribute on grandchildPrim2, and verify it inherits the color space from childPrim2
         grandchildColorAttr2 = grandchildPrim2.CreateAttribute("color", Sdf.ValueTypeNames.Color3f)
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(grandchildColorAttr2, cache) == rec709
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(grandchildColorAttr2, cache), rec709)
 
         # Test the CanApply method
         assert Usd.ColorSpaceAPI.CanApply(rootPrim)
         assert Usd.ColorSpaceAPI.CanApply(childPrim)
         assert Usd.ColorSpaceAPI.CanApply(grandchildPrim)
 
         # Test the Get method
-        assert Usd.ColorSpaceAPI.Get(stage, Sdf.Path("/rec2020")).GetPrim() == rootPrim
+        self.assertEqual(Usd.ColorSpaceAPI.Get(stage, Sdf.Path("/rec2020")).GetPrim(), rootPrim)
 
 
         # Test the UsdColorSpaceDefinitionAPI. It's multipleApply so create two instances.
@@ -129,33 +129,33 @@ def test_ColorSpaceAPI(self):
         # set the color space on the prim itself to be testACEScg
         defColorSpaceAttr = defCsAPI.CreateColorSpaceNameAttr(testACEScg)
 
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(defColorAttr, cache) == testRec2020
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(defColorAttr, cache), testRec2020)
 
         # verify that a prim at /colorSpaceDef/noCS has no color space
         noCSPrim = stage.OverridePrim(Sdf.Path("/colorSpaceDef/noCS"))
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(noCSPrim, cache) == ""
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(noCSPrim, cache), "")
 
         # create a child of defPrim, and verify it inherits the color space from defPrim
         childDefPrim = stage.OverridePrim(Sdf.Path("/colorSpaceDef/noCS/defPrim/childDefPrim"))
 
         # first verify that the prim's color space is inherited from the parent
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(childDefPrim, cache) == testACEScg
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(childDefPrim, cache), testACEScg)
 
         # create a color attribute on childDefPrim, and verify it inherits the color space from defPrim
         childDefColorAttr = childDefPrim.CreateAttribute("color", Sdf.ValueTypeNames.Color3f)
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(childDefColorAttr, cache) == testACEScg
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(childDefColorAttr, cache), testACEScg)
 
         # set the attribute color space to testACEScg, and verify that it overrides the parent
         childDefColorAttr.SetColorSpace(testRec2020)
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(childDefColorAttr, cache) == testRec2020
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(childDefColorAttr, cache), testRec2020)
 
         # reverify that the child prim still inherits the color space from the parent
-        assert Usd.ColorSpaceAPI.ComputeColorSpaceName(childDefPrim, cache) == testACEScg
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpaceName(childDefPrim, cache), testACEScg)
 
         # since we haven't filled any data in for the test cases, if we compute the
         # GfColorSpace, it should be equal to a default constructed GfColorSpace.
         cs = Usd.ColorSpaceAPI.ComputeColorSpace(childDefPrim, cache)
-        assert cs == Gf.ColorSpace(testACEScg)
+        self.assertEqual(cs, Gf.ColorSpace(testACEScg))
 
         # Create a linear aces cg color space
         acesCG = Gf.ColorSpace(Gf.ColorSpaceNames.LinearAP1)
@@ -169,10 +169,10 @@ def test_ColorSpaceAPI(self):
         acesCGWhitePointAttr = testACEScgDefAPI.CreateWhitePointAttr(whitePoint)
 
         # verify that the color space is computed correctly
-        assert testACEScgDefAPI.ComputeColorSpaceFromDefinitionAttributes() == acesCG
+        self.assertEqual(testACEScgDefAPI.ComputeColorSpaceFromDefinitionAttributes(), acesCG)
 
         # verify it again, vs childDefPrim.
-        assert Usd.ColorSpaceAPI.ComputeColorSpace(childDefPrim, cache) == acesCG
+        self.assertEqual(Usd.ColorSpaceAPI.ComputeColorSpace(childDefPrim, cache), acesCG)
 
         print("UsdColorSpaceAPI and UsdColorSpaceDefinitionAPI tests passed")
 

pxr/usd/usd/testenv/testUsdCreateProperties.py

@@ -222,7 +222,7 @@ def test_IsDefined(self):
             assert p.GetAttribute("attr1") and p.GetAttribute("attr1").IsDefined()
             assert p.HasProperty("attr1")
             assert p.GetProperty("attr1") and p.GetProperty("attr1").IsDefined()
-            assert p.GetProperty("attr1") == p.GetAttribute("attr1")
+            self.assertEqual(p.GetProperty("attr1"), p.GetAttribute("attr1"))
 
             stage = Usd.Stage.Open(strongLayer.identifier)
             p = stage.OverridePrim("/Parent")
@@ -300,7 +300,7 @@ def test_GetSetNumpy(self):
 
             extent = prim.GetAttribute('extent')
             assert extent.IsDefined()
-            assert extent.GetTypeName() == 'float3[]'
+            self.assertEqual(extent.GetTypeName(), 'float3[]')
             # Make a VtArray, then convert to numpy.
             a = Vt.Vec3fArray(3, [(1,2,3), (2,3,4)])
             n = numpy.array(a)
@@ -309,7 +309,7 @@ def test_GetSetNumpy(self):
             # Now pull the value back out.
             gn = extent.Get()
             # Assert it matches our original array.
-            assert Vt.Vec3fArray.FromNumpy(gn) == a
+            self.assertEqual(Vt.Vec3fArray.FromNumpy(gn), a)
 
     def test_SetArraysWithLists(self):
         from pxr import Vt, Sdf
@@ -324,11 +324,11 @@ def test_SetArraysWithLists(self):
             assert asst.IsDefined()
             # Set with python list.
             strs.Set(['hello']*3)
-            assert strs.Get() == Vt.StringArray(3, ['hello'])
+            self.assertEqual(strs.Get(), Vt.StringArray(3, ['hello']))
             toks.Set(['bye']*3)
-            assert toks.Get() == Vt.TokenArray(3, ['bye'])
+            self.assertEqual(toks.Get(), Vt.TokenArray(3, ['bye']))
             asst.Set([Sdf.AssetPath('/path')]*3)
-            assert asst.Get() == Sdf.AssetPathArray(3, [Sdf.AssetPath('/path')])
+            self.assertEqual(asst.Get(), Sdf.AssetPathArray(3, [Sdf.AssetPath('/path')]))
             # Should fail with incompatible types.
             with self.assertRaises(Tf.ErrorException):
                 strs.Set([1234]*3)