test: be explicit instead of import

Author: scivision

+stdlib/+test/TestFilePure.m

@@ -3,28 +3,24 @@
 methods (Test)
 
 function test_posix(tc)
-import stdlib.posix
 
-tc.verifyEmpty(posix(string.empty))
-tc.verifyEqual(posix(""), "")
+tc.verifyEmpty(stdlib.posix(string.empty))
+tc.verifyEqual(stdlib.posix(""), "")
 
 if ispc
-  tc.verifyFalse(contains(posix("c:\foo"), "\"))
-  tc.verifyFalse(all(contains(posix(["x:\123", "d:\abc"]), "\")))
+  tc.verifyFalse(contains(stdlib.posix("c:\foo"), "\"))
+  tc.verifyFalse(all(contains(stdlib.posix(["x:\123", "d:\abc"]), "\")))
 end
 end
 
 function test_samepath(tc)
-
-import stdlib.samepath
-
 tc.assumeTrue(usejava("jvm"), "Java required for samepath")
 
-tc.verifyEmpty(samepath(string.empty, string.empty))
-tc.verifyTrue(samepath("", ""))
-tc.verifyFalse(samepath("a", "b"))
-tc.verifyTrue(samepath("a/b/..", "a/c/.."))
-tc.verifyTrue(samepath(".", "a/.."))
+tc.verifyEmpty(stdlib.samepath(string.empty, string.empty))
+tc.verifyTrue(stdlib.samepath("", ""))
+tc.verifyFalse(stdlib.samepath("a", "b"))
+tc.verifyTrue(stdlib.samepath("a/b/..", "a/c/.."))
+tc.verifyTrue(stdlib.samepath(".", "a/.."))
 
 end
 

+stdlib/+test/TestHDF5.m

@@ -12,8 +12,6 @@
 methods (TestMethodSetup)
 
 function setup_file(tc)
-import stdlib.h5save
-import matlab.unittest.constraints.IsFile
 
 A0 = 42.;
 A1 = [42.; 43.];
@@ -36,20 +34,20 @@ function setup_file(tc)
 tc.TestData.basic = basic;
 
 % create test data first, so that parallel tests works
-h5save(basic, '/A0', A0)
-h5save(basic, '/A1', A1)
-h5save(basic, '/A2', A2)
-h5save(basic, '/A3', A3, "size", size(A3))
-h5save(basic, '/A4', A4)
+stdlib.h5save(basic, '/A0', A0)
+stdlib.h5save(basic, '/A1', A1)
+stdlib.h5save(basic, '/A2', A2)
+stdlib.h5save(basic, '/A3', A3, "size", size(A3))
+stdlib.h5save(basic, '/A4', A4)
 
-h5save(basic, "/utf", utf)
-h5save(basic, "/utf2", utf2)
+stdlib.h5save(basic, "/utf", utf)
+stdlib.h5save(basic, "/utf2", utf2)
 
-h5save(basic, '/t/x', 12)
-h5save(basic, '/t/y', 13)
-h5save(basic, '/j/a/b', 6)
+stdlib.h5save(basic, '/t/x', 12)
+stdlib.h5save(basic, '/t/y', 13)
+stdlib.h5save(basic, '/j/a/b', 6)
 
-tc.assumeThat(basic, IsFile)
+tc.assumeTrue(isfile(basic))
 end
 end
 
@@ -73,93 +71,89 @@ function test_auto_chunk_size(tc)
 
 
 function test_get_variables(tc)
-import stdlib.h5variables
 
 basic = tc.TestData.basic;
 
-v = h5variables(basic);
+v = stdlib.h5variables(basic);
 k = ["A0", "A1", "A2", "A3", "A4", "utf", "utf2"];
 tc.verifyEqual(sort(v), k)
 
 % 1-level group
-v = h5variables(basic, "/t");
+v = stdlib.h5variables(basic, "/t");
 tc.verifyEqual(sort(v), ["x", "y"])
 
 % traversal
-tc.verifyEmpty( h5variables(basic, "/j") )
+tc.verifyEmpty(stdlib.h5variables(basic, "/j") )
 
-tc.verifyEqual( h5variables(basic, "/j/a") , "b")
+tc.verifyEqual(stdlib.h5variables(basic, "/j/a") , "b")
 
 end
 
 
 function test_exists(tc)
-import stdlib.h5exists
 basic = tc.TestData.basic;
 
-tc.verifyEmpty(h5exists(basic, string.empty))
+tc.verifyEmpty(stdlib.h5exists(basic, string.empty))
 
-e = h5exists(basic, "");
+e = stdlib.h5exists(basic, "");
 
 tc.verifyTrue(isscalar(e))
 tc.verifyFalse(e)
 
 vars = {'A0', 'A1', 'A2', 'A3', 'A4', '/A0'};
 
-e = h5exists(basic, vars);
+e = stdlib.h5exists(basic, vars);
 tc.verifyTrue(isvector(e))
 tc.verifyTrue(all(e))
 
 % vector
-e = h5exists(basic, ["/A1", "oops"]);
+e = stdlib.h5exists(basic, ["/A1", "oops"]);
 tc.verifyTrue(isrow(e))
 tc.verifyEqual(e, [true, false])
 end
 
 
 function test_size(tc)
-
-import stdlib.h5ndims
 basic = tc.TestData.basic;
 
-tc.verifyEmpty(h5ndims(basic, string.empty))
-tc.verifyEmpty(h5ndims(basic, ""))
+tc.verifyEmpty(stdlib.h5ndims(basic, string.empty))
+tc.verifyEmpty(stdlib.h5ndims(basic, ""))
 
-r = h5ndims(basic, '/A0');
+r = stdlib.h5ndims(basic, '/A0');
 s = stdlib.h5size(basic, '/A0');
 tc.verifyEmpty(s)
 tc.verifyEqual(r, 0)
 
-r = h5ndims(basic, '/A1');
+r = stdlib.h5ndims(basic, '/A1');
 s = stdlib.h5size(basic, '/A1');
 tc.verifyTrue(isscalar(s))
 tc.verifyEqual(s, 2)
 tc.verifyEqual(r, 1)
 
-r = h5ndims(basic, '/A2');
+r = stdlib.h5ndims(basic, '/A2');
 s = stdlib.h5size(basic, '/A2');
 tc.verifyTrue(isvector(s))
 tc.verifyEqual(s, [4,4])
 tc.verifyEqual(r, 2)
 
-r = h5ndims(basic, '/A3');
+r = stdlib.h5ndims(basic, '/A3');
 s = stdlib.h5size(basic, '/A3');
 tc.verifyTrue(isvector(s))
 tc.verifyEqual(s, [4,3,2])
 tc.verifyEqual(r, 3)
 
-r = h5ndims(basic, '/A4');
+r = stdlib.h5ndims(basic, '/A4');
 s = stdlib.h5size(basic, '/A4');
 tc.verifyTrue(isvector(s))
 tc.verifyEqual(s, [4,3,2,5])
 tc.verifyEqual(r, 4)
 
-r = h5ndims(basic, '/utf');
+r = stdlib.h5ndims(basic, '/utf');
 s = stdlib.h5size(basic, '/utf');
 tc.verifyEmpty(s)
 tc.verifyEqual(r, 0)
 
-r = h5ndims(basic, '/utf2');
+r = stdlib.h5ndims(basic, '/utf2');
 s = stdlib.h5size(basic, '/utf2');
 tc.verifyEqual(s, 2)
 tc.verifyEqual(r, 1)
@@ -216,7 +210,6 @@ function test_shape(tc)
 
 
 function test_coerce(tc)
-import matlab.unittest.constraints.IsFile
 basic = tc.TestData.basic;
 
 for type = ["single", "double", ...
@@ -232,32 +225,30 @@ function test_coerce(tc)
 
 
 function test_rewrite(tc)
-import matlab.unittest.constraints.IsFile
 basic = tc.TestData.basic;
 
 stdlib.h5save(basic, '/A2', 3*magic(4))
 
-tc.assumeThat(basic, IsFile)
+tc.assumeTrue(isfile(basic))
 tc.verifyEqual(h5read(basic, '/A2'), 3*magic(4))
 end
 
 function test_int8(tc)
-import stdlib.h5save
 basic = tc.TestData.basic;
 
-h5save(basic, "/i1", int8(127))
+stdlib.h5save(basic, "/i1", int8(127))
 
 a = h5read(basic, "/i1");
 tc.verifyEqual(a, int8(127))
 
 % test rewrite
-h5save(basic, "/i1", int8(-128))
+stdlib.h5save(basic, "/i1", int8(-128))
 
 a = h5read(basic, "/i1");
 tc.verifyEqual(a, int8(-128))
 
 % test int8 array
-h5save(basic, "/Ai1", int8([1, 2]))
+stdlib.h5save(basic, "/Ai1", int8([1, 2]))
 a = h5read(basic, "/Ai1");
 tc.verifyEqual(a, int8([1;2]))
 end