From d8f0b2bbf0150f2a2c0ec346bdaf96a5230b0423 Mon Sep 17 00:00:00 2001 From: Daniel Dresser Date: Mon, 26 Oct 2026 15:03:48 -0700 Subject: [PATCH] Various testCancel's : Replace with simpler test that is more reliable --- .../test/IECoreAlembic/AlembicSceneTest.py | 20 +-------- .../IECoreUSD/test/IECoreUSD/USDSceneTest.py | 20 +-------- .../MeshAlgoDistributePointsTest.py | 25 ++--------- test/IECoreScene/MeshAlgoFaceAreaTest.py | 29 +++---------- test/IECoreScene/MeshAlgoNormalsTest.py | 28 ++----------- test/IECoreScene/MeshAlgoTangentsTest.py | 42 ++++--------------- test/IECoreScene/MeshAlgoTriangulateTest.py | 24 ++--------- test/IECoreScene/PrimitiveTest.py | 21 ++-------- 8 files changed, 31 insertions(+), 178 deletions(-) diff --git a/contrib/IECoreAlembic/test/IECoreAlembic/AlembicSceneTest.py b/contrib/IECoreAlembic/test/IECoreAlembic/AlembicSceneTest.py index 3cc171db12..eb585e8b2a 100644 --- a/contrib/IECoreAlembic/test/IECoreAlembic/AlembicSceneTest.py +++ b/contrib/IECoreAlembic/test/IECoreAlembic/AlembicSceneTest.py @@ -1899,7 +1899,6 @@ def testPointsVaryingInterpolation( self ) : IECoreScene.PrimitiveVariable.Interpolation.Vertex, ) - @unittest.skipIf( ( IECore.TestUtil.inMacCI() or IECore.TestUtil.inWindowsCI() ), "Mac and Windows CI are too slow for reliable timing" ) def testCancel ( self ) : strip = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( 0 ), imath.V2f( 100000, 1 ) ), imath.V2i( 100000, 1 ) ) @@ -1916,25 +1915,10 @@ def testCancel ( self ) : readRoot = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Read ) canceller = IECore.Canceller() - cancelled = [False] - - def backgroundRun(): - try: - readRoot.child( "sphere" ).readObject( 0.0, canceller ) - except IECore.Cancelled: - cancelled[0] = True - - thread = threading.Thread(target=backgroundRun, args=()) - - startTime = time.time() - thread.start() - - time.sleep( 0.01 ) canceller.cancel() - thread.join() - self.assertLess( time.time() - startTime, 0.1 if IECore.isDebug() else 0.06 ) - self.assertTrue( cancelled[0] ) + with self.assertRaisesRegex( IECore.Cancelled, "" ): + readRoot.child( "sphere" ).readObject( 0.0, canceller ) def testIndexedCurveUVs( self ) : diff --git a/contrib/IECoreUSD/test/IECoreUSD/USDSceneTest.py b/contrib/IECoreUSD/test/IECoreUSD/USDSceneTest.py index ebe9b22b60..b833d8d037 100644 --- a/contrib/IECoreUSD/test/IECoreUSD/USDSceneTest.py +++ b/contrib/IECoreUSD/test/IECoreUSD/USDSceneTest.py @@ -2673,7 +2673,6 @@ def testInstancedSkinning( self ) : self.assertEqual( len( unskinnedHashes ), 1 ) - @unittest.skipIf( ( IECore.TestUtil.inMacCI() or IECore.TestUtil.inWindowsCI() ), "Mac and Windows CI are too slow for reliable timing" ) def testCancel ( self ) : strip = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( 0 ), imath.V2f( 100000, 1 ) ), imath.V2i( 100000, 1 ) ) @@ -2690,25 +2689,10 @@ def testCancel ( self ) : readRoot = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Read ) canceller = IECore.Canceller() - cancelled = [False] - - def backgroundRun(): - try: - readRoot.child( "sphere" ).readObject( 0.0, canceller ) - except IECore.Cancelled: - cancelled[0] = True - - thread = threading.Thread(target=backgroundRun, args=()) - - startTime = time.time() - thread.start() - - time.sleep( 0.01 ) canceller.cancel() - thread.join() - self.assertLess( time.time() - startTime, 0.03 ) - self.assertTrue( cancelled[0] ) + with self.assertRaisesRegex( IECore.Cancelled, "" ): + readRoot.child( "sphere" ).readObject( 0.0, canceller ) def testCustomAttributes( self ) : diff --git a/test/IECoreScene/MeshAlgoDistributePointsTest.py b/test/IECoreScene/MeshAlgoDistributePointsTest.py index fdcae2a944..ef8ce25bd5 100644 --- a/test/IECoreScene/MeshAlgoDistributePointsTest.py +++ b/test/IECoreScene/MeshAlgoDistributePointsTest.py @@ -419,37 +419,18 @@ def testZeroAreaPolygons( self ): p = IECoreScene.MeshAlgo.distributePoints( mesh = m, density = 1 ) self.assertEqual( len( p["P"].data ), 0 ) - @unittest.skipIf( ( IECore.TestUtil.inMacCI() or IECore.TestUtil.inWindowsCI() ), "Mac and Windows CI are too slow for reliable timing" ) def testCancel( self ) : # Initializing the points distribution is slow and not cancellable # Pre-initialize it so it doesn't mess with our timing IECore.PointDistribution.defaultInstance() canceller = IECore.Canceller() - cancelled = [False] + canceller.cancel() m = IECore.Reader.create( os.path.join( "test", "IECore", "data", "cobFiles", "pCubeShape1.cob" ) ).read() - def backgroundRun(): - try: - p = IECoreScene.MeshAlgo.distributePoints( mesh = m, density = 10000000, offset = imath.V2f( 0.0001, 0.0001 ), canceller = canceller ) - except IECore.Cancelled: - cancelled[0] = True - - thread = threading.Thread(target=backgroundRun, args=()) - - startTime = time.time() - thread.start() - - time.sleep( 0.1 ) - canceller.cancel() - thread.join() - - # This test should actually produce a time extremely close to the sleep duration ( within - # 0.003 seconds whether the sleep duration is 0.01 seconds or 100 seconds ), but checking - # that it terminates with 0.1 seconds is a minimal performance bar - self.assertLess( time.time() - startTime, 0.2 ) - self.assertTrue( cancelled[0] ) + with self.assertRaisesRegex( IECore.Cancelled, "" ): + p = IECoreScene.MeshAlgo.distributePoints( mesh = m, density = 10000000, offset = imath.V2f( 0.0001, 0.0001 ), canceller = canceller ) @unittest.skipIf( True, "Not running slow perf tests by default" ) def testPerformance( self ) : diff --git a/test/IECoreScene/MeshAlgoFaceAreaTest.py b/test/IECoreScene/MeshAlgoFaceAreaTest.py index 909e414112..a8c59a381e 100644 --- a/test/IECoreScene/MeshAlgoFaceAreaTest.py +++ b/test/IECoreScene/MeshAlgoFaceAreaTest.py @@ -128,36 +128,17 @@ def testTwoFaces( self ) : self.assertEqual( textureAreas[0], 6 ) self.assertEqual( textureAreas[1], 1 ) - @unittest.skipIf( ( IECore.TestUtil.inMacCI() or IECore.TestUtil.inWindowsCI() ), "Mac and Windows CI are too slow for reliable timing" ) def testCancel( self ) : canceller = IECore.Canceller() - cancelled = [False] + canceller.cancel() # Basic large mesh strip = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( 0 ), imath.V2f( 1000000, 1 ) ), imath.V2i( 1000000, 1 ) ) - def backgroundRun( texture ): - try: - if texture: - IECoreScene.MeshAlgo.calculateFaceTextureArea( strip, "uv", "P", canceller ) - else: - IECoreScene.MeshAlgo.calculateFaceArea( strip, "P", canceller ) - except IECore.Cancelled: - cancelled[0] = True - - for texture in [ False, True ]: - cancelled[0] = False - thread = threading.Thread(target=backgroundRun, args=(texture,)) - - startTime = time.time() - thread.start() - - time.sleep( 0.01 ) - canceller.cancel() - thread.join() - - self.assertLess( time.time() - startTime, 0.03 ) - self.assertTrue( cancelled[0] ) + with self.assertRaisesRegex( IECore.Cancelled, "" ): + IECoreScene.MeshAlgo.calculateFaceTextureArea( strip, "uv", "P", canceller ) + with self.assertRaisesRegex( IECore.Cancelled, "" ): + IECoreScene.MeshAlgo.calculateFaceArea( strip, "P", canceller ) if __name__ == "__main__": unittest.main() diff --git a/test/IECoreScene/MeshAlgoNormalsTest.py b/test/IECoreScene/MeshAlgoNormalsTest.py index 0e1987db38..ad86773617 100644 --- a/test/IECoreScene/MeshAlgoNormalsTest.py +++ b/test/IECoreScene/MeshAlgoNormalsTest.py @@ -344,7 +344,7 @@ def testFaceVaryingOnSphere( self ): # averaging in the nearby cone faces that have similar normals and pushing the normal # towards the axis. zComp = -0.8660255 - + planeComp = ( 1 - zComp * zComp ) ** 0.5 angles = [ 2 * math.pi * ( i + 0.5 ) / divs for i in range( divs ) ] self.assertVectorListsAlmostEqual( list( n.data )[0:3 * divs:3], [ imath.V3f( planeComp * math.cos( a ), planeComp * math.sin( a ), zComp ) for a in angles ], absError = 1e-3 if divs == 10000 else 1e-5 ) @@ -394,33 +394,13 @@ def testPerformance( self ) : elapsed = time.time() - startTime print( "Time for 1000000 face sphere with extreme verts, thresholded faceVarying: ", elapsed ) - @unittest.skipIf( ( IECore.TestUtil.inMacCI() or IECore.TestUtil.inWindowsCI() ), "Mac and Windows CI are too slow for reliable timing" ) def testCancel( self ) : canceller = IECore.Canceller() - cancelled = [False] - - strip = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( 0 ), imath.V2f( 3000000, 1 ) ), imath.V2i( 3000000, 1 ) ) - def backgroundRun(): - - try: - IECoreScene.MeshAlgo.calculateVertexNormals( strip, IECoreScene.MeshAlgo.NormalWeighting.Equal, canceller = canceller ) - except IECore.Cancelled: - cancelled[0] = True - - thread = threading.Thread(target=backgroundRun, args=()) - - startTime = time.time() - thread.start() - - time.sleep( 0.05 ) canceller.cancel() - thread.join() - # This test should actually produce a time extremely close to the sleep duration ( within - # 0.003 seconds whether the sleep duration is 0.01 seconds or 100 seconds ), but checking - # that it terminates with 0.1 seconds is a minimal performance bar - self.assertLess( time.time() - startTime, 0.15 ) - self.assertTrue( cancelled[0] ) + strip = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( 0 ), imath.V2f( 3000, 1 ) ), imath.V2i( 3000, 1 ) ) + with self.assertRaisesRegex( IECore.Cancelled, "" ): + IECoreScene.MeshAlgo.calculateVertexNormals( strip, IECoreScene.MeshAlgo.NormalWeighting.Equal, canceller = canceller ) if __name__ == "__main__": unittest.main() diff --git a/test/IECoreScene/MeshAlgoTangentsTest.py b/test/IECoreScene/MeshAlgoTangentsTest.py index 4a3e276abc..23e50498c4 100644 --- a/test/IECoreScene/MeshAlgoTangentsTest.py +++ b/test/IECoreScene/MeshAlgoTangentsTest.py @@ -348,43 +348,19 @@ def testComputeTangentsFromPrimitiveCentroid( self ): self.assertArrayEqual( tRes, tangent.data ) self.assertArrayEqual( btRes, biTangent.data ) - @unittest.skipIf( ( IECore.TestUtil.inMacCI() or IECore.TestUtil.inWindowsCI() ), "Mac and Windows CI are too slow for reliable timing" ) def testCancel( self ) : canceller = IECore.Canceller() + canceller.cancel() strip = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( 0 ), imath.V2f( 3000000, 1 ) ), imath.V2i( 3000000, 1 ) ) - variant = 0 - def backgroundRun(): - - try: - if variant == 0: - IECoreScene.MeshAlgo.calculateTangentsFromUV( strip, canceller = canceller ) - elif variant == 1: - IECoreScene.MeshAlgo.calculateTangentsFromFirstEdge( strip, canceller = canceller ) - elif variant == 2: - IECoreScene.MeshAlgo.calculateTangentsFromTwoEdges( strip, canceller = canceller ) - elif variant == 3: - IECoreScene.MeshAlgo.calculateTangentsFromPrimitiveCentroid( strip, canceller = canceller ) - except IECore.Cancelled: - cancelled[0] = True - - for i in range( 4 ): - cancelled = [False] - variant = i - thread = threading.Thread(target=backgroundRun, args=()) - - startTime = time.time() - thread.start() - - time.sleep( 0.1 ) - canceller.cancel() - thread.join() - - # This test should actually produce a time extremely close to the sleep duration ( within - # 0.003 seconds whether the sleep duration is 0.01 seconds or 100 seconds ), but checking - # that it terminates with 0.1 seconds is a minimal performance bar - self.assertLess( time.time() - startTime, 0.2 ) - self.assertTrue( cancelled[0] ) + with self.assertRaisesRegex( IECore.Cancelled, "" ): + IECoreScene.MeshAlgo.calculateTangentsFromUV( strip, canceller = canceller ) + with self.assertRaisesRegex( IECore.Cancelled, "" ): + IECoreScene.MeshAlgo.calculateTangentsFromFirstEdge( strip, canceller = canceller ) + with self.assertRaisesRegex( IECore.Cancelled, "" ): + IECoreScene.MeshAlgo.calculateTangentsFromTwoEdges( strip, canceller = canceller ) + with self.assertRaisesRegex( IECore.Cancelled, "" ): + IECoreScene.MeshAlgo.calculateTangentsFromPrimitiveCentroid( strip, canceller = canceller ) if __name__ == "__main__": unittest.main() diff --git a/test/IECoreScene/MeshAlgoTriangulateTest.py b/test/IECoreScene/MeshAlgoTriangulateTest.py index c8f7b4c57a..69d9ecc0e2 100644 --- a/test/IECoreScene/MeshAlgoTriangulateTest.py +++ b/test/IECoreScene/MeshAlgoTriangulateTest.py @@ -276,34 +276,16 @@ def testPerformance( self ) : elapsed = time.time() - startTime print( "Time for 16000000 faces with heavy, unindexed, face-varying primvar", elapsed ) - @unittest.skipIf( ( IECore.TestUtil.inMacCI() or IECore.TestUtil.inWindowsCI() ), "Mac and Windows CI are too slow for reliable timing" ) def testCancel( self ) : - canceller = IECore.Canceller() - cancelled = [False] # Basic large mesh strip = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( 0 ), imath.V2f( 3000000, 1 ) ), imath.V2i( 3000000, 1 ) ) - def backgroundRun(): - try: - IECoreScene.MeshAlgo.triangulate( strip, canceller ) - except IECore.Cancelled: - cancelled[0] = True - - thread = threading.Thread(target=backgroundRun, args=()) - - startTime = time.time() - thread.start() - - time.sleep( 0.01 ) + canceller = IECore.Canceller() canceller.cancel() - thread.join() - # This test should actually produce a time extremely close to the sleep duration ( within - # 0.01 seconds whether the sleep duration is 0.01 seconds or 1 seconds ), but checking - # that it terminates with 0.2 seconds is a minimal performance bar - self.assertLess( time.time() - startTime, 0.2 ) - self.assertTrue( cancelled[0] ) + with self.assertRaisesRegex( IECore.Cancelled, "" ): + IECoreScene.MeshAlgo.triangulate( strip, canceller ) if __name__ == "__main__": unittest.main() diff --git a/test/IECoreScene/PrimitiveTest.py b/test/IECoreScene/PrimitiveTest.py index 1f3dafc0ab..8681b8a7d6 100644 --- a/test/IECoreScene/PrimitiveTest.py +++ b/test/IECoreScene/PrimitiveTest.py @@ -174,7 +174,6 @@ def testVariableIndexedView( self ) : IECoreScene.testVariableIndexedView() - @unittest.skipIf( ( IECore.TestUtil.inMacCI() or IECore.TestUtil.inWindowsCI() ), "Mac and Windows CI are too slow for reliable timing" ) def testCancelLoading( self ) : strip = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( 0 ), imath.V2f( 100000, 1 ) ), imath.V2i( 1000000, 1 ) ) @@ -189,25 +188,11 @@ def testCancelLoading( self ) : loadIO = IECore.MemoryIndexedIO( saveIO.buffer(), IECore.IndexedIO.OpenMode.Read ) canceller = IECore.Canceller() - cancelled = [False] - - def backgroundRun(): - try: - IECore.Object.load( loadIO, "test", canceller ) - except IECore.Cancelled: - cancelled[0] = True - - thread = threading.Thread(target=backgroundRun, args=()) - - startTime = time.time() - thread.start() - - time.sleep( 0.01 ) canceller.cancel() - thread.join() - self.assertLess( time.time() - startTime, 0.1 ) - self.assertTrue( cancelled[0] ) + with self.assertRaisesRegex( IECore.Cancelled, "" ): + IECore.Object.load( loadIO, "test", canceller ) + if __name__ == "__main__": unittest.main()