test: Smart backend selection

Author: scivision

+stdlib/Backend.m

@@ -26,19 +26,22 @@
   end
 end
 
-if any(strlength(functionName))
+if strlength(functionName)
   self.func = self.getFunc(functionName, backendReq);
 end
 end
 
 
-function m = select(self, functionName, backendReq)
+function backendAvailable = select(self, functionName, backendReq, firstOnly)
 arguments
   self
   functionName (1,1) string
   backendReq (1,:) string = string.empty
+  firstOnly (1,1) logical = false
 end
 
+backendAvailable = string.empty;
+
 if ~any(strlength(backendReq))
   backendReq = self.backends;
 end
@@ -93,13 +96,14 @@
   end
 
   if ~isempty(which(sprintf('%s.%s.%s', self.namespace, m, functionName)))
-    return
+    backendAvailable(end+1) = m; %#ok<AGROW>
+    if firstOnly
+      return
+    end
   end
 
 end
 
-m = string.empty;
-
 end
 
 
@@ -113,7 +117,7 @@
 if isscalar(backendReq)
   self.backend = backendReq;
 else
-  self.backend = self.select(functionName, backendReq);
+  self.backend = self.select(functionName, backendReq, true);
 end
 
 if isempty(self.backend)

test/TestCanonical.m

@@ -1,5 +1,5 @@
 classdef (SharedTestFixtures={ matlab.unittest.fixtures.PathFixture("..")}, ...
-          TestTags = {'R2019b', 'impure'}) ...
+          TestTags = {'impure'}) ...
   TestCanonical < matlab.unittest.TestCase
 
 properties(TestParameter)
@@ -20,8 +20,7 @@ function test_dirs(tc)
 end
 
 
-methods(Test)
-
+methods(Test, TestTags={'R2019b'})
 function test_canonical(tc, p)
 c = stdlib.canonical(p{1}, false);
 tc.verifyEqual(c, p{2})
@@ -31,8 +30,10 @@ function test_legacy_canonical(tc, p)
 c = stdlib.legacy.canonical(p{1}, false);
 tc.verifyEqual(c, p{2})
 end
+end
 
 
+methods (Test, TestTags={'R2024a'})
 function test_canonical_array(tc)
 tc.assumeFalse(stdlib.matlabOlderThan('R2024a'))
 
@@ -42,7 +43,6 @@ function test_canonical_array(tc)
 exp = ["", "hi", filesep + "ok", "not-exist"];
 tc.verifyEqual(c, exp)
 end
-
 end
 
 end

test/TestDisk.m

@@ -1,4 +1,5 @@
-classdef (TestTags = {'R2019b', 'impure'}) ...
+classdef (SharedTestFixtures={ matlab.unittest.fixtures.PathFixture("..")}, ...
+          TestTags = {'R2019b', 'impure'}) ...
   TestDisk < matlab.unittest.TestCase
 
 properties
@@ -8,24 +9,37 @@
 properties (TestParameter)
 Ps = {".", "", "/", getenv("SystemDrive"), "not-exist"}
 Po = {mfilename("fullpath") + ".m", pwd(), ".", "", "not-exist"}
-backend_jps = init_backend({'sys', 'java', 'python'})
-backend_djps = init_backend({'sys', 'dotnet', 'java', 'python'})
-backend_ds = init_backend({'dotnet', 'sys'})
-backend_ps = init_backend({'python', 'sys'})
+B_disk
+B_is_removable
+B_is_mount
+B_hard_link_count
+B_filesystem_type
+B_owner
+B_device
+end
+
+methods (TestParameterDefinition, Static)
+function [B_disk, B_is_removable, B_is_mount, B_hard_link_count, B_filesystem_type, B_owner, B_device] = setupBackends()
+B_disk = init_backend("disk_available");
+B_is_removable = init_backend("is_removable");
+B_is_mount = init_backend("is_mount");
+B_hard_link_count = init_backend("hard_link_count");
+B_filesystem_type = init_backend("filesystem_type");
+B_owner = init_backend("get_owner");
+B_device = init_backend("device");
+end
 end
 
 methods(TestClassSetup)
 function test_dirs(tc)
-  pkg_path(tc)
-
   tc.applyFixture(matlab.unittest.fixtures.WorkingFolderFixture())
 end
 end
 
 methods (Test)
 
-function test_disk_available(tc, Ps, backend_djps)
-r = stdlib.disk_available(Ps, backend_djps);
+function test_disk_available(tc, Ps, B_disk)
+r = stdlib.disk_available(Ps, B_disk);
 
 tc.verifyClass(r, 'uint64')
 
@@ -37,8 +51,8 @@ function test_disk_available(tc, Ps, backend_djps)
 end
 
 
-function test_disk_capacity(tc, Ps, backend_djps)
-r = stdlib.disk_capacity(Ps, backend_djps);
+function test_disk_capacity(tc, Ps, B_disk)
+r = stdlib.disk_capacity(Ps, B_disk);
 
 tc.verifyClass(r, 'uint64')
 
@@ -50,46 +64,42 @@ function test_disk_capacity(tc, Ps, backend_djps)
 end
 
 
-function test_is_removable(tc, backend_ds)
-y = stdlib.is_removable(pwd(), backend_ds);
+function test_is_removable(tc, B_is_removable)
+y = stdlib.is_removable(pwd(), B_is_removable);
 tc.verifyClass(y, 'logical')
 end
 
 
-function test_is_mount(tc, backend_ps)
-y = stdlib.is_mount(pwd(), backend_ps);
+function test_is_mount(tc, B_is_mount)
+y = stdlib.is_mount(pwd(), B_is_mount);
 
 tc.verifyClass(y, 'logical')
-tc.verifyTrue(stdlib.is_mount("/", backend_ps))
-tc.verifyEmpty(stdlib.is_mount(tempname(), backend_ps))
+tc.verifyTrue(stdlib.is_mount("/", B_is_mount))
+tc.verifyEmpty(stdlib.is_mount(tempname(), B_is_mount))
 
 if ispc()
   sd = getenv("SystemDrive");
   tc.assertTrue(sd == stdlib.root_name(sd), sd)
-  tc.verifyFalse(stdlib.is_mount(sd, backend_ps), sd)
-  tc.verifyTrue(stdlib.is_mount(sd + "/", backend_ps), sd)
-  tc.verifyTrue(stdlib.is_mount(sd + "\", backend_ps), sd)
+  tc.verifyFalse(stdlib.is_mount(sd, B_is_mount), sd)
+  tc.verifyTrue(stdlib.is_mount(sd + "/", B_is_mount), sd)
+  tc.verifyTrue(stdlib.is_mount(sd + "\", B_is_mount), sd)
 end
 end
 
 
-function test_hard_link_count(tc, backend_jps)
+function test_hard_link_count(tc, B_hard_link_count)
 P = mfilename("fullpath") + ".m";
 
-r = stdlib.hard_link_count(P, backend_jps);
-if ispc() && backend_jps == "java"
-  tc.verifyEmpty(r)
-else
-  tc.verifyGreaterThanOrEqual(r, 1)
-end
+r = stdlib.hard_link_count(P, B_hard_link_count);
+tc.verifyGreaterThanOrEqual(r, 1)
 end
 
 
-function test_filesystem_type(tc, Ps, backend_djps)
-t = stdlib.filesystem_type(Ps, backend_djps);
+function test_filesystem_type(tc, Ps, B_filesystem_type)
+t = stdlib.filesystem_type(Ps, B_filesystem_type);
 tc.verifyClass(t, 'char')
 
-if ~stdlib.exists(Ps) || (backend_djps == "python" && ~stdlib.python.has_psutil())
+if ~stdlib.exists(Ps)
   tc.verifyEmpty(t)
 else
   tc.assumeFalse(isempty(t) && tc.CI, "Some CI block viewing their filesystem type")
@@ -112,12 +122,11 @@ function test_remove_file(tc)
 end
 
 
-function test_device(tc, Po, backend_jps)
-
-i = stdlib.device(Po, backend_jps);
+function test_device(tc, Po, B_device)
+i = stdlib.device(Po, B_device);
 tc.verifyClass(i, 'uint64')
 
-if ispc() && backend_jps == "java" || ~stdlib.exists(Po)
+if ~stdlib.exists(Po)
   tc.verifyEmpty(i)
 else
   tc.assertNotEmpty(i)
@@ -126,12 +135,12 @@ function test_device(tc, Po, backend_jps)
 end
 
 
-function test_inode(tc, Po, backend_jps)
+function test_inode(tc, Po, B_device)
 
-i = stdlib.inode(Po, backend_jps);
+i = stdlib.inode(Po, B_device);
 tc.verifyClass(i, 'uint64')
 
-if ispc() && backend_jps == "java" || ~stdlib.exists(Po)
+if ~stdlib.exists(Po)
   tc.verifyEmpty(i)
 else
   tc.assertNotEmpty(i)
@@ -140,13 +149,10 @@ function test_inode(tc, Po, backend_jps)
 end
 
 
-function test_owner(tc, Po, backend_djps)
-
-o = stdlib.get_owner(Po, backend_djps);
+function test_owner(tc, Po, B_owner)
+o = stdlib.get_owner(Po, B_owner);
 
-if ~stdlib.exists(Po) || ...
-    (backend_djps == "dotnet" && isunix()) || ...
-    (backend_djps == "python" && ispc())
+if ~stdlib.exists(Po)
   tc.verifyEqual(o, "")
 else
   tc.verifyGreaterThan(strlength(o), 0)
@@ -155,19 +161,14 @@ function test_owner(tc, Po, backend_djps)
 end
 
 
-function test_owner_array(tc, backend_djps)
+function test_owner_array(tc, B_owner)
 
-o = stdlib.get_owner([".", pwd(), "not-exist", ""], backend_djps);
+o = stdlib.get_owner([".", pwd(), "not-exist", ""], B_owner);
 L = strlength(o);
 
 tc.verifyEqual(L(3:4), [0, 0])
 
-if (backend_djps == "dotnet" && isunix()) || ...
-   (backend_djps == "python" && ispc())
-  tc.verifyEqual(L(1:2), [0, 0])
-else
-  tc.verifyGreaterThan(L(1:2), 0);
-end
+tc.verifyGreaterThan(L(1:2), 0);
 
 end
 

test/TestExists.m

@@ -1,21 +1,46 @@
-classdef (TestTags = {'R2019b', 'impure'}) ...
+classdef (SharedTestFixtures={ matlab.unittest.fixtures.PathFixture("..")}, ...
+          TestTags = {'impure'}) ...
     TestExists < matlab.unittest.TestCase
 
 properties(TestParameter)
-Ps = init_val()
-% on CI matlabroot can be writable!
-backend = init_backend({'python', 'sys'})
+Ps
+B_is_char_device
 end
 
+
+methods (TestParameterDefinition, Static)
+function Ps = init_val()
+Ps = {
+  {pwd(), true}, ...
+  {mfilename("fullpath") + ".m", true}, ...
+  {fileparts(mfilename("fullpath")) + "/../Readme.md", true}, ...
+  {tempname(), false}, ...
+  {'', false}, ...
+  {"", false}
+};
+if ispc()
+  % On Windows, the root of the system drive is considered to exist
+  systemDrive = getenv("SystemDrive");
+  if ~isempty(systemDrive)
+    Ps{end+1} = {systemDrive, true};
+  end
+end
+end
+
+function B_is_char_device = setupBackends()
+B_is_char_device = init_backend("is_char_device");
+end
+end
+
+
 methods(TestClassSetup)
 function test_dirs(tc)
-pkg_path(tc)
-
 tc.applyFixture(matlab.unittest.fixtures.WorkingFolderFixture())
 end
 end
 
-methods (Test)
+
+methods (Test, TestTags={'R2019b'})
 
 function test_exists(tc, Ps)
 ok = stdlib.exists(Ps{1});
@@ -34,6 +59,18 @@ function test_is_writable(tc, Ps)
 end
 
 
+function test_is_char_device(tc, B_is_char_device)
+% /dev/stdin may not be available on CI systems
+n = stdlib.null_file();
+
+tc.verifyTrue(stdlib.is_char_device(n, B_is_char_device), n)
+end
+
+end
+
+
+methods (Test, TestTags={'R2025a'})
+
 function test_is_readable_array(tc)
 tc.assumeFalse(stdlib.matlabOlderThan('R2025a'))
 in =  [".",  tempname(), mfilename('fullpath') + ".m"];
@@ -53,32 +90,6 @@ function test_is_writable_array(tc)
 tc.verifyEqual(r, out)
 end
 
-
-function test_is_char_device(tc, backend)
-% /dev/stdin may not be available on CI systems
-n = stdlib.null_file();
-
-tc.verifyTrue(stdlib.is_char_device(n, backend), n)
-end
-
-end
 end
 
-
-function Ps = init_val()
-Ps = {
-  {pwd(), true}, ...
-  {mfilename("fullpath") + ".m", true}, ...
-  {fileparts(mfilename("fullpath")) + "/../Readme.md", true}, ...
-  {tempname(), false}, ...
-  {'', false}, ...
-  {"", false}
-};
-if ispc()
-  % On Windows, the root of the system drive is considered to exist
-  systemDrive = getenv("SystemDrive");
-  if ~isempty(systemDrive)
-    Ps{end+1} = {systemDrive, true};
-  end
-end
 end