test: use assume and verify instead of assert

Author: scivision

+hdf5nc/private/expanduser.m

@@ -19,7 +19,7 @@
 %
 %   See also absolute_path
 arguments
-  p (1,1) string
+  p string
 end
 
 expanded = p;

+hdf5nc/test_hdf5.m

@@ -20,6 +20,7 @@ function setupOnce(tc)
 
 basic = tempname + ".h5";
 tc.TestData.basic = basic;
+
 % create test data first, so that parallel tests works
 h5save(basic, '/A0', A0)
 h5save(basic, '/A1', A1)
@@ -34,31 +35,30 @@ function teardownOnce(tc)
 
 
 function test_auto_chunk_size(tc)
-tc.assertEqual(auto_chunk_size([1500,2500,1000,500,100]), [12,20,8,8,2], '5D chunk fail')
-tc.assertEqual(auto_chunk_size([15,250,100]), [2,32,25], '3D chunk fail')
-tc.assertEqual(auto_chunk_size([15,250]), [15,250], '2D small chunk fail')
-
+tc.verifyEqual(auto_chunk_size([1500,2500,1000,500,100]), [12,20,8,8,2])
+tc.verifyEqual(auto_chunk_size([15,250,100]), [2,32,25])
+tc.verifyEqual(auto_chunk_size([15,250]), [15,250])
 end
 
 
 function test_get_variables(tc)
 import hdf5nc.h5variables
 vars = h5variables(tc.TestData.basic);
-tc.assertEqual(sort(vars), ["A0", "A1", "A2", "A3", "A4"], 'missing variables')
+tc.verifyEqual(sort(vars), ["A0", "A1", "A2", "A3", "A4"])
 end
 
 
 function test_exists(tc)
 import hdf5nc.h5exists
 e0 = h5exists(tc.TestData.basic, '/A3');
-tc.assertTrue(isscalar(e0))
-tc.assertTrue(e0, 'A3 exists')
+tc.verifyTrue(isscalar(e0))
+tc.verifyTrue(e0)
 
-tc.assertFalse(h5exists(tc.TestData.basic, '/oops'), 'oops not exist')
+tc.verifyFalse(h5exists(tc.TestData.basic, '/oops'))
 
 e1 = h5exists(tc.TestData.basic, ["A3", "oops"]);
-tc.assertTrue(isrow(e1))
-tc.assertEqual(e1, [true, false])
+tc.verifyTrue(isrow(e1))
+tc.verifyEqual(e1, [true, false])
 end
 
 
@@ -67,48 +67,48 @@ function test_size(tc)
 basic = tc.TestData.basic;
 
 s = h5size(basic, '/A0');
-tc.assertTrue(isscalar(s))
-tc.assertEqual(s, 1, 'A0 shape')
+tc.verifyTrue(isscalar(s))
+tc.verifyEqual(s, 1)
 
 s = h5size(basic, '/A1');
-tc.assertTrue(isscalar(s))
-tc.assertEqual(s, 2, 'A1 shape')
+tc.verifyTrue(isscalar(s))
+tc.verifyEqual(s, 2)
 
 s = h5size(basic, '/A2');
-tc.assertTrue(isvector(s))
-tc.assertEqual(s, [4,4], 'A2 shape')
+tc.verifyTrue(isvector(s))
+tc.verifyEqual(s, [4,4])
 
 s = h5size(basic, '/A3');
-tc.assertTrue(isvector(s))
-tc.assertEqual(s, [4,3,2], 'A3 shape')
+tc.verifyTrue(isvector(s))
+tc.verifyEqual(s, [4,3,2])
 
 s = h5size(basic, '/A4');
-tc.assertTrue(isvector(s))
-tc.assertEqual(s, [4,3,2,5], 'A4 shape')
+tc.verifyTrue(isvector(s))
+tc.verifyEqual(s, [4,3,2,5])
 end
 
 
 function test_read(tc)
 basic = tc.TestData.basic;
 s = h5read(basic, '/A0');
-tc.assertTrue(isscalar(s))
-tc.assertEqual(s, 42, 'A0 read')
+tc.verifyTrue(isscalar(s))
+tc.verifyEqual(s, 42)
 
 s = h5read(basic, '/A1');
-tc.assertTrue(isvector(s))
-tc.assertEqual(s, tc.TestData.A1, 'A1 read')
+tc.verifyTrue(isvector(s))
+tc.verifyEqual(s, tc.TestData.A1)
 
 s = h5read(basic, '/A2');
-tc.assertTrue(ismatrix(s))
-tc.assertEqual(s, tc.TestData.A2, 'A2 read')
+tc.verifyTrue(ismatrix(s))
+tc.verifyEqual(s, tc.TestData.A2)
 
-s = h5read(tc.TestData.basic, '/A3');
-tc.assertEqual(ndims(s), 3)
-tc.assertEqual(s, tc.TestData.A3, 'A3 read')
+s = h5read(basic, '/A3');
+tc.verifyEqual(ndims(s), 3)
+tc.verifyEqual(s, tc.TestData.A3)
 
-s = h5read(tc.TestData.basic, '/A4');
-tc.assertEqual(ndims(s), 4)
-tc.assertEqual(s, tc.TestData.A4, 'A4 read')
+s = h5read(basic, '/A4');
+tc.verifyEqual(ndims(s), 4)
+tc.verifyEqual(s, tc.TestData.A4)
 end
 
 
@@ -120,16 +120,20 @@ function test_coerce(tc)
 h5save(basic, '/int64', 0, "type", 'int64')
 h5save(basic, '/float32', 0, "type", 'float32')
 
-tc.assertClass(h5read(basic, '/int32'), 'int32', 'int32')
-tc.assertClass(h5read(basic, '/int64'), 'int64', 'int64')
-tc.assertClass(h5read(basic, '/float32'), 'single', 'float32')
+tc.assumeTrue(isfile(basic))
+
+tc.verifyClass(h5read(basic, '/int32'), 'int32')
+tc.verifyClass(h5read(basic, '/int64'), 'int64')
+tc.verifyClass(h5read(basic, '/float32'), 'single')
 end
 
 
 function test_rewrite(tc)
 import hdf5nc.h5save
-h5save(tc.TestData.basic, '/A2', 3*magic(4))
-tc.assertEqual(h5read(tc.TestData.basic, '/A2'), 3*magic(4), 'rewrite 2D fail')
+basic = tc.TestData.basic;
+h5save(basic, '/A2', 3*magic(4))
+tc.assumeTrue(isfile(basic))
+tc.verifyEqual(h5read(basic, '/A2'), 3*magic(4))
 end
 
 function test_string(tc)
@@ -139,13 +143,13 @@ function test_string(tc)
 
 astr = h5read(tc.TestData.basic, "/a_string");
 achar = h5read(tc.TestData.basic, "/a_char");
-tc.assertEqual(astr, "hello")
-tc.assertEqual(achar, "there")
-tc.assertClass(astr, "string")
-tc.assertClass(achar, "string")
+tc.verifyEqual(astr, "hello")
+tc.verifyEqual(achar, "there")
+tc.verifyClass(astr, "string")
+tc.verifyClass(achar, "string")
 end
 
 function test_real_only(tc)
 import hdf5nc.h5save
-tc.assertError(@() h5save(tc.TestData.basic, "/bad_imag", 1j), 'MATLAB:validators:mustBeReal')
+tc.verifyError(@() h5save(tc.TestData.basic, "/bad_imag", 1j), 'MATLAB:validators:mustBeReal')
 end

+hdf5nc/test_netcdf.m

@@ -38,71 +38,72 @@ function teardownOnce(tc)
 function test_get_variables(tc)
 import hdf5nc.ncvariables
 vars = ncvariables(tc.TestData.basic);
-tc.assertEqual(sort(vars), ["A0", "A1", "A2", "A3", "A4"], 'missing variables')
+tc.verifyEqual(sort(vars), ["A0", "A1", "A2", "A3", "A4"])
 end
 
 
 function test_exists(tc)
 import hdf5nc.ncexists
 e0 = ncexists(tc.TestData.basic, 'A3');
-tc.assertTrue(isscalar(e0))
-tc.assertTrue(e0, 'A3 exists')
+tc.verifyTrue(isscalar(e0))
+tc.verifyTrue(e0)
 
-assertFalse(tc, ncexists(tc.TestData.basic, '/oops'), 'oops not exist')
+tc.verifyFalse(ncexists(tc.TestData.basic, '/oops'))
 
 e1 = ncexists(tc.TestData.basic, ["A3", "oops"]);
-tc.assertTrue(isrow(e1))
-tc.assertEqual(e1, [true, false])
+tc.verifyTrue(isrow(e1))
+tc.verifyEqual(e1, [true, false])
 end
 
+
 function test_size(tc)
 import hdf5nc.ncsize
 basic = tc.TestData.basic;
 
 s = ncsize(basic, 'A0');
-tc.assertTrue(isscalar(s))
-tc.assertEqual(s, 1, 'A0 shape')
+tc.verifyTrue(isscalar(s))
+tc.verifyEqual(s, 1)
 
 s = ncsize(basic, 'A1');
-tc.assertTrue(isscalar(s))
-tc.assertEqual(s, 2, 'A1 shape')
+tc.verifyTrue(isscalar(s))
+tc.verifyEqual(s, 2)
 
 s = ncsize(basic, 'A2');
-tc.assertTrue(isvector(s))
-tc.assertEqual(s, [4,4], 'A2 shape')
+tc.verifyTrue(isvector(s))
+tc.verifyEqual(s, [4,4])
 
 s = ncsize(basic, 'A3');
-tc.assertTrue(isvector(s))
-tc.assertEqual(s, [4,3,2], 'A3 shape')
+tc.verifyTrue(isvector(s))
+tc.verifyEqual(s, [4,3,2])
 
 s = ncsize(basic, 'A4');
-tc.assertTrue(isvector(s))
-tc.assertEqual(s, [4,3,2,5], 'A4 shape')
+tc.verifyTrue(isvector(s))
+tc.verifyEqual(s, [4,3,2,5])
 end
 
 
 function test_read(tc)
 basic = tc.TestData.basic;
 
 s = ncread(basic, '/A0');
-tc.assertTrue(isscalar(s))
-tc.assertEqual(s, 42, 'A0 read')
+tc.verifyTrue(isscalar(s))
+tc.verifyEqual(s, 42)
 
 s = ncread(basic, '/A1');
-tc.assertTrue(isvector(s))
-tc.assertEqual(s, tc.TestData.A1, 'A1 read')
+tc.verifyTrue(isvector(s))
+tc.verifyEqual(s, tc.TestData.A1)
 
 s = ncread(basic, '/A2');
-tc.assertTrue(ismatrix(s))
-tc.assertEqual(s, tc.TestData.A2, 'A2 read')
+tc.verifyTrue(ismatrix(s))
+tc.verifyEqual(s, tc.TestData.A2)
 
 s = ncread(basic, '/A3');
-tc.assertEqual(ndims(s), 3)
-tc.assertEqual(s, tc.TestData.A3, 'A3 read')
+tc.verifyEqual(ndims(s), 3)
+tc.verifyEqual(s, tc.TestData.A3)
 
 s = ncread(basic, '/A4');
-tc.assertEqual(ndims(s), 4)
-tc.assertEqual(s, tc.TestData.A4, 'A4 read')
+tc.verifyEqual(ndims(s), 4)
+tc.verifyEqual(s, tc.TestData.A4)
 end
 
 
@@ -115,24 +116,29 @@ function test_coerce(tc)
 ncsave(basic, 'int64', 0, "type", 'int64')
 ncsave(basic, 'float32', 0, "type", 'float32')
 
-tc.assertClass(h5read(basic, '/int32'), 'int32', 'int32')
-tc.assertClass(h5read(basic, '/int64'), 'int64', 'int64')
-tc.assertClass(h5read(basic, '/float32'), 'single', 'float32')
+tc.assumeTrue(isfile(basic))
+
+tc.verifyClass(h5read(basic, '/int32'), 'int32')
+tc.verifyClass(h5read(basic, '/int64'), 'int64')
+tc.verifyClass(h5read(basic, '/float32'), 'single')
 end
 
+
 function test_rewrite(tc)
 import hdf5nc.ncsave
-ncsave(tc.TestData.basic, 'A2', 3*magic(4))
-tc.assertEqual(ncread(tc.TestData.basic, 'A2'), 3*magic(4), 'rewrite 2D fail')
+basic = tc.TestData.basic;
+ncsave(basic, 'A2', 3*magic(4))
+tc.assumeTrue(isfile(basic))
+tc.verifyEqual(ncread(basic, 'A2'), 3*magic(4))
 end
 
 function test_no_char_string(tc)
 import hdf5nc.ncsave
-tc.assertError(@() ncsave(tc.TestData.basic, "/a_string", "hello"), 'MATLAB:validators:mustBeNumeric')
+tc.verifyError(@() ncsave(tc.TestData.basic, "/a_string", "hello"), 'MATLAB:validators:mustBeNumeric')
 
 end
 
 function test_real_only(tc)
 import hdf5nc.ncsave
-tc.assertError(@() ncsave(tc.TestData.basic, "/bad_imag", 1j), 'MATLAB:validators:mustBeReal')
+tc.verifyError(@() ncsave(tc.TestData.basic, "/bad_imag", 1j), 'MATLAB:validators:mustBeReal')
 end