cleanup of deprecated test methods

PiperOrigin-RevId: 722607226

tensorflow_graphics/geometry/convolution/tests/graph_convolution_test.py

@@ -140,7 +140,7 @@ def test_feature_steered_convolution_exception_raised_types(
     data, neighbors, sizes = _random_data(1, 5, 3, True, False, data_type,
                                           neighbors_type, sizes_type)
     u, v, c, w, b = _random_variables(3, 3, 1, var_type)
-    with self.assertRaisesRegexp(TypeError, err_msg):
+    with self.assertRaisesRegex(TypeError, err_msg):
       _ = gc.feature_steered_convolution(
           data=data,
           neighbors=neighbors,
@@ -178,7 +178,7 @@ def test_feature_steered_convolution_exception_not_raised_types(
 
   def test_feature_steered_convolution_exception_raised_shapes(self):
     """Check that invalid input shapes trigger the right exceptions."""
-    with self.assertRaisesRegexp(ValueError, "must have a rank of 2"):
+    with self.assertRaisesRegex(ValueError, "must have a rank of 2"):
       data, neighbors = _dummy_data(1, 5, 2)
       u, v, c, w, b = _dummy_variables(2, 2, 1)
       data = data[0, :]
@@ -192,7 +192,7 @@ def test_feature_steered_convolution_exception_raised_shapes(self):
           var_w=w,
           var_b=b)
 
-    with self.assertRaisesRegexp(ValueError, "must have a rank greater than 1"):
+    with self.assertRaisesRegex(ValueError, "must have a rank greater than 1"):
       u, v, c, w, b = _dummy_variables(2, 2, 1)
       data = np.ones(shape=(5), dtype=np.float32)
       neighbors = _dense_to_sparse(np.ones(shape=(5), dtype=np.float32))
@@ -206,8 +206,9 @@ def test_feature_steered_convolution_exception_raised_shapes(self):
           var_w=w,
           var_b=b)
 
-    with self.assertRaisesRegexp(ValueError,
-                                 "Not all batch dimensions are identical."):
+    with self.assertRaisesRegex(
+        ValueError, "Not all batch dimensions are identical."
+    ):
       data, neighbors = _dummy_data(1, 5, 2)
       u, v, c, w, b = _dummy_variables(2, 2, 1)
       _ = gc.feature_steered_convolution(
@@ -553,7 +554,7 @@ def test_edge_convolution_template_exception_raised_types(
     """Check the type errors for invalid input types."""
     data, neighbors, sizes = _random_data(1, 5, 3, True, False, data_type,
                                           neighbors_type, sizes_type)
-    with self.assertRaisesRegexp(TypeError, err_msg):
+    with self.assertRaisesRegex(TypeError, err_msg):
       gc.edge_convolution_template(
           data=data,
           neighbors=neighbors,
@@ -590,7 +591,7 @@ def test_edge_convolution_template_exception_not_raised_types(
 
   def test_edge_convolution_template_exception_raised_shapes(self):
     """Check that invalid input shapes trigger the right exceptions."""
-    with self.assertRaisesRegexp(ValueError, "must have a rank of 2"):
+    with self.assertRaisesRegex(ValueError, "must have a rank of 2"):
       data, neighbors = _dummy_data(1, 5, 2)
       data = data[0, :]
       _ = gc.edge_convolution_template(
@@ -601,7 +602,7 @@ def test_edge_convolution_template_exception_raised_shapes(self):
           reduction="weighted",
           edge_function_kwargs=dict())
 
-    with self.assertRaisesRegexp(ValueError, "must have a rank greater than 1"):
+    with self.assertRaisesRegex(ValueError, "must have a rank greater than 1"):
       data = np.ones(shape=(5), dtype=np.float32)
       neighbors = _dense_to_sparse(np.ones(shape=(5), dtype=np.float32))
       _ = gc.edge_convolution_template(
@@ -612,7 +613,7 @@ def test_edge_convolution_template_exception_raised_shapes(self):
           reduction="weighted",
           edge_function_kwargs=dict())
 
-    with self.assertRaisesRegexp(ValueError, "must have a rank of 1"):
+    with self.assertRaisesRegex(ValueError, "must have a rank of 1"):
       data, neighbors = _dummy_data(1, 5, 2)
       _ = gc.edge_convolution_template(
           data=data,
@@ -626,7 +627,7 @@ def test_edge_convolution_template_exception_raised_shapes(self):
   def test_edge_convolution_template_exception_raised_reduction(
       self, reduction):
     """Check that an invalid reduction method triggers the exception."""
-    with self.assertRaisesRegexp(ValueError, "reduction method"):
+    with self.assertRaisesRegex(ValueError, "reduction method"):
       data, neighbors = _dummy_data(1, 5, 2)
       gc.edge_convolution_template(
           data=data,

tensorflow_graphics/geometry/convolution/tests/graph_pooling_test.py

@@ -62,7 +62,7 @@ def test_pool_exception_raised_types(self, err_msg, data_type, pool_map_type,
     pool_map = _dense_to_sparse(np.ones((2, 3, 3), dtype=pool_map_type))
     sizes = np.array(((1, 2), (2, 3)), dtype=sizes_type)
 
-    with self.assertRaisesRegexp(TypeError, err_msg):
+    with self.assertRaisesRegex(TypeError, err_msg):
       gp.pool(data, pool_map, sizes)
 
   @parameterized.parameters(
@@ -80,16 +80,17 @@ def test_pool_exception_raised_shapes(self, err_msg, data_shape,
     else:
       sizes = None
 
-    with self.assertRaisesRegexp(ValueError, err_msg):
+    with self.assertRaisesRegex(ValueError, err_msg):
       gp.pool(data, pool_map, sizes)
 
   def test_pool_exception_raised_algorithm(self):
     """Tests the correct exception is raised for an invalid algorithm."""
     data = np.ones(shape=(2, 2))
     pool_map = _dense_to_sparse(np.ones(shape=(2, 2)))
 
-    with self.assertRaisesRegexp(
-        ValueError, 'The pooling method must be "weighted" or "max"'):
+    with self.assertRaisesRegex(
+        ValueError, 'The pooling method must be "weighted" or "max"'
+    ):
       gp.pool(data, pool_map, sizes=None, algorithm='mean')
 
   @parameterized.parameters(
@@ -201,7 +202,7 @@ def test_unpool_exception_raised_types(self, err_msg, data_type,
     pool_map = _dense_to_sparse(np.ones((2, 3, 3), dtype=pool_map_type))
     sizes = np.array(((1, 2), (2, 3)), dtype=sizes_type)
 
-    with self.assertRaisesRegexp(TypeError, err_msg):
+    with self.assertRaisesRegex(TypeError, err_msg):
       gp.unpool(data, pool_map, sizes)
 
   @parameterized.parameters(
@@ -221,7 +222,7 @@ def test_unpool_exception_raised_shapes(self, err_msg, data_shape,
     else:
       sizes = None
 
-    with self.assertRaisesRegexp(ValueError, err_msg):
+    with self.assertRaisesRegex(ValueError, err_msg):
       gp.unpool(data, pool_map, sizes)
 
   @parameterized.parameters(
@@ -311,7 +312,7 @@ def test_upsample_transposed_convolution_exception_raised_types(
     pool_map = _dense_to_sparse(np.ones((2, 3, 3), dtype=pool_map_type))
     sizes = np.array(((1, 2), (2, 3)), dtype=sizes_type)
 
-    with self.assertRaisesRegexp(TypeError, err_msg):
+    with self.assertRaisesRegex(TypeError, err_msg):
       gp.upsample_transposed_convolution(
           data, pool_map, sizes, kernel_size=1, transposed_convolution_op=None)
 
@@ -332,7 +333,7 @@ def test_upsample_transposed_convolution_exception_raised_shapes(
     else:
       sizes = None
 
-    with self.assertRaisesRegexp(ValueError, err_msg):
+    with self.assertRaisesRegex(ValueError, err_msg):
       gp.upsample_transposed_convolution(
           data, pool_map, sizes, kernel_size=1, transposed_convolution_op=None)
 
@@ -342,7 +343,7 @@ def test_upsample_transposed_convolution_exception_raised_callable(self):
     pool_map = _dense_to_sparse(np.eye(5))
     err_msg = "'transposed_convolution_op' must be callable."
 
-    with self.assertRaisesRegexp(TypeError, err_msg):
+    with self.assertRaisesRegex(TypeError, err_msg):
       gp.upsample_transposed_convolution(
           data,
           pool_map,

tensorflow_graphics/geometry/convolution/tests/utils_test.py

@@ -58,7 +58,7 @@ def test_check_valid_graph_convolution_input_exception_raised_types(
     neighbors = _dense_to_sparse(np.ones(shape=(2, 2, 2), dtype=neighbors_type))
     sizes = tf.convert_to_tensor(value=np.array((2, 2), dtype=sizes_type))
 
-    with self.assertRaisesRegexp(TypeError, err_msg):
+    with self.assertRaisesRegex(TypeError, err_msg):
       utils.check_valid_graph_convolution_input(data, neighbors, sizes)
 
   @parameterized.parameters(
@@ -187,7 +187,7 @@ def test_check_valid_graph_pooling_exception_raised_types(
     sizes = tf.convert_to_tensor(
         value=np.array(((1, 2), (2, 3)), dtype=sizes_type))
 
-    with self.assertRaisesRegexp(TypeError, err_msg):
+    with self.assertRaisesRegex(TypeError, err_msg):
       utils.check_valid_graph_pooling_input(data, pool_map, sizes)
 
   @parameterized.parameters(
@@ -305,8 +305,9 @@ def test_input_rank_exception_raised(self, *shapes):
 
   def test_flatten_batch_to_2d_exception_raised_types(self):
     """Check the exception when input is not an integer."""
-    with self.assertRaisesRegexp(TypeError,
-                                 "'sizes' must have an integer type."):
+    with self.assertRaisesRegex(
+        TypeError, "'sizes' must have an integer type."
+    ):
       utils.flatten_batch_to_2d(np.ones((3, 4, 3)), np.ones((3,)))
 
   @parameterized.parameters(
@@ -433,8 +434,9 @@ def test_input_rank_exception_raised(self, *shapes):
 
   def test_input_type_exception_raised(self):
     """Check that invalid input types trigger the right exception."""
-    with self.assertRaisesRegexp(TypeError,
-                                 "'sizes' must have an integer type."):
+    with self.assertRaisesRegex(
+        TypeError, "'sizes' must have an integer type."
+    ):
       utils.unflatten_2d_to_batch(np.ones((3, 4)), np.ones((3,)))
 
   @parameterized.parameters(
@@ -518,38 +520,40 @@ def _validate_sizes(self, block_diag_tensor, sizes):
 
   def test_convert_to_block_diag_2d_exception_raised_types(self):
     """Check the exception when input is not a SparseTensor."""
-    with self.assertRaisesRegexp(TypeError, "'data' must be a 'SparseTensor'."):
+    with self.assertRaisesRegex(TypeError, "'data' must be a 'SparseTensor'."):
       utils.convert_to_block_diag_2d(np.zeros(shape=(3, 3, 3)))
 
-    with self.assertRaisesRegexp(TypeError,
-                                 "'sizes' must have an integer type."):
+    with self.assertRaisesRegex(
+        TypeError, "'sizes' must have an integer type."
+    ):
       utils.convert_to_block_diag_2d(
           _dense_to_sparse(np.ones(shape=(3, 3, 3))),
           np.ones(shape=(3, 2)),
       )
 
   def test_convert_to_block_diag_2d_exception_raised_ranks(self):
     """Check the exception when input data rank is invalid."""
-    with self.assertRaisesRegexp(ValueError, "must have a rank greater than 2"):
+    with self.assertRaisesRegex(ValueError, "must have a rank greater than 2"):
       utils.convert_to_block_diag_2d(_dense_to_sparse(np.ones(shape=(3, 3))))
 
-    with self.assertRaisesRegexp(ValueError, "must have a rank greater than 2"):
+    with self.assertRaisesRegex(ValueError, "must have a rank greater than 2"):
       utils.convert_to_block_diag_2d(_dense_to_sparse(np.ones(shape=(3,))))
 
   def test_convert_to_block_diag_2d_exception_raised_sizes(self):
     """Check the expetion when the shape of sizes is invalid."""
-    with self.assertRaisesRegexp(ValueError, "must have a rank of 2"):
+    with self.assertRaisesRegex(ValueError, "must have a rank of 2"):
       utils.convert_to_block_diag_2d(
           _dense_to_sparse(np.ones(shape=(3, 3, 3))),
           np.ones(shape=(3,), dtype=np.int32))
 
-    with self.assertRaisesRegexp(ValueError, "must have a rank of 3"):
+    with self.assertRaisesRegex(ValueError, "must have a rank of 3"):
       utils.convert_to_block_diag_2d(
           _dense_to_sparse(np.ones(shape=(4, 3, 3, 3))),
           np.ones(shape=(4, 3), dtype=np.int32))
 
-    with self.assertRaisesRegexp(ValueError,
-                                 "must have exactly 2 dimensions in axis -1"):
+    with self.assertRaisesRegex(
+        ValueError, "must have exactly 2 dimensions in axis -1"
+    ):
       utils.convert_to_block_diag_2d(
           _dense_to_sparse(np.ones(shape=(3, 3, 3))),
           np.ones(shape=(3, 1), dtype=np.int32))

tensorflow_graphics/geometry/representation/mesh/tests/sampler_test.py

@@ -65,7 +65,7 @@ def test_negative_weights_random_face_indices_exception(self):
     face_wts = np.array([0.1, -0.1], dtype=np.float32)
     num_samples = 10
     error_msg = "Condition x >= y did not hold."
-    with self.assertRaisesRegexp(tf.errors.InvalidArgumentError, error_msg):
+    with self.assertRaisesRegex(tf.errors.InvalidArgumentError, error_msg):
       sampler.generate_random_face_indices(num_samples, face_weights=face_wts)
 
   @parameterized.parameters(
@@ -154,7 +154,7 @@ def test_weighted_sampler_negative_weights(self):
     face_wts = np.array([-0.3, 0.1, 0.5, 0.6], dtype=np.float32)
     num_samples = 10
     error_msg = "Condition x >= y did not hold."
-    with self.assertRaisesRegexp(tf.errors.InvalidArgumentError, error_msg):
+    with self.assertRaisesRegex(tf.errors.InvalidArgumentError, error_msg):
       sampler.weighted_random_sample_triangle_mesh(
           vertices, faces, num_samples, face_weights=face_wts)
 

tensorflow_graphics/geometry/representation/mesh/tests/utils_test.py

@@ -65,7 +65,7 @@ def test_extract_directed_edges_from_triangular_mesh_preset(
   def test_extract_edges_from_triangular_mesh_raised(
       self, invalid_input, error_msg):
     """Tests that the shape exceptions are properly raised."""
-    with self.assertRaisesRegexp(ValueError, error_msg):
+    with self.assertRaisesRegex(ValueError, error_msg):
       utils.extract_unique_edges_from_triangular_mesh(invalid_input)
 
   @parameterized.parameters(
@@ -98,7 +98,7 @@ def test_get_degree_based_edge_weights_preset(
   def test_get_degree_based_edge_weights_invalid_edges_raised(
       self, invalid_input, error_msg):
     """Tests that the shape exceptions are properly raised."""
-    with self.assertRaisesRegexp(ValueError, error_msg):
+    with self.assertRaisesRegex(ValueError, error_msg):
       utils.get_degree_based_edge_weights(invalid_input)
 
   @parameterized.parameters(
@@ -111,7 +111,7 @@ def test_get_degree_based_edge_weights_invalid_edges_raised(
   def test_get_degree_based_edge_weights_dtype_raised(
       self, invalid_type, error_msg):
     """Tests that the shape exceptions are properly raised."""
-    with self.assertRaisesRegexp(ValueError, error_msg):
+    with self.assertRaisesRegex(ValueError, error_msg):
       utils.get_degree_based_edge_weights(np.array(((1, 1),)), invalid_type)
 
 if __name__ == "__main__":

tensorflow_graphics/geometry/transformation/tests/quaternion_test.py

@@ -508,13 +508,14 @@ def test_normalized_random_initializer_raised(self):
     tensor_shape = np.random.randint(1, 10, size=(tensor_size)).tolist()
 
     with self.subTest(name="dtype"):
-      with self.assertRaisesRegexp(ValueError, "'dtype' must be tf.float32."):
+      with self.assertRaisesRegex(ValueError, "'dtype' must be tf.float32."):
         quaternion.normalized_random_uniform_initializer()(
             tensor_shape + [4], dtype=tf.uint8)
 
     with self.subTest(name="shape"):
-      with self.assertRaisesRegexp(ValueError,
-                                   "Last dimension of 'shape' must be 4."):
+      with self.assertRaisesRegex(
+          ValueError, "Last dimension of 'shape' must be 4."
+      ):
         quaternion.normalized_random_uniform_initializer()(
             tensor_shape + [3], dtype=tf.float32)
 

tensorflow_graphics/io/tests/exr_test.py

@@ -79,23 +79,24 @@ def test_write_read_roundtrip(self, num_channels, datatype, pass_channels):
   def test_reading_mixed_datatypes_fails(self):
     with tempfile.NamedTemporaryFile() as temp:
       _WriteMixedDatatypesExr(temp.name)
-      with self.assertRaisesRegexp(ValueError, 'Channels have mixed datatypes'):
+      with self.assertRaisesRegex(ValueError, 'Channels have mixed datatypes'):
         _, _ = exr.read_exr(temp.name)
 
   def test_writing_with_array_channel_name_mismatch_fails(self):
     array_three_channels = np.zeros([64, 64, 3], dtype=np.float32)
     names_two_channels = ['A', 'B']
     with tempfile.NamedTemporaryFile() as temp:
-      with self.assertRaisesRegexp(
+      with self.assertRaisesRegex(
           ValueError,
-          'Number of channels in values does not match channel names'):
+          'Number of channels in values does not match channel names',
+      ):
         exr.write_exr(temp.name, array_three_channels, names_two_channels)
 
   def test_writing_unsupported_numpy_type_fails(self):
     uint8_array = np.zeros([64, 64, 3], dtype=np.uint8)
     names = ['R', 'G', 'B']
     with tempfile.NamedTemporaryFile() as temp:
-      with self.assertRaisesRegexp(TypeError, 'Unsupported numpy type'):
+      with self.assertRaisesRegex(TypeError, 'Unsupported numpy type'):
         exr.write_exr(temp.name, uint8_array, names)
 
   def test_reading_unknown_exr_type_fails(self):
@@ -109,7 +110,7 @@ def test_reading_unknown_exr_type_fails(self):
       header_dict['channels']['R'].type.v = -1  # Any bad value will do.
       make_mock_exr = collections.namedtuple('MockExr', ['header', 'channel'])
       mock_broken_exr = make_mock_exr(lambda: header_dict, exr_file.channel)
-      with self.assertRaisesRegexp(RuntimeError, 'Unknown EXR channel type'):
+      with self.assertRaisesRegex(RuntimeError, 'Unknown EXR channel type'):
         _ = exr.channels_to_ndarray(mock_broken_exr, ['R', 'G', 'B'])
 
 

tensorflow_graphics/nn/metric/tests/intersection_over_union_test.py

@@ -69,8 +69,9 @@ def test_evaluate_preset(self, ground_truth, predictions, expected_iou):
   def test_evaluate_invalid_argument_exception_raised(self, error_msg,
                                                       ground_truth, predictions,
                                                       grid_size):
-    with self.assertRaisesRegexp((tf.errors.InvalidArgumentError, ValueError),
-                                 error_msg):
+    with self.assertRaisesRegex(
+        (tf.errors.InvalidArgumentError, ValueError), error_msg
+    ):
       self.evaluate(
           intersection_over_union.evaluate(ground_truth, predictions,
                                            grid_size))

tensorflow_graphics/rendering/opengl/tests/rasterizer_op_test.py

@@ -220,7 +220,7 @@ def test_invalid_variable_inputs(self, error_msg, variable_names,
       error = error_eager
     else:
       error = error_graph_mode
-    with self.assertRaisesRegexp(error, error_msg):
+    with self.assertRaisesRegex(error, error_msg):
       self.evaluate(
           rasterization_backend.render_ops.rasterize(
               num_points=0,

tensorflow_graphics/rendering/tests/rasterization_backend_test_base.py

@@ -97,7 +97,7 @@ def test_rasterizer_return_correct_batch_shapes(self, shapes, dtypes,
   def test_rasterizer_rasterize_exception_raised(self, shapes, dtypes, backend):
     """Tests that unsupported backends raise exceptions."""
     placeholders = self._create_placeholders(shapes, dtypes)
-    with self.assertRaisesRegexp(KeyError, 'Backend is not supported'):
+    with self.assertRaisesRegex(KeyError, 'Backend is not supported'):
       rasterization_backend.rasterize(placeholders[0], placeholders[1],
                                       placeholders[2],
                                       (self.IMAGE_WIDTH, self.IMAGE_HEIGHT),