fix tests to be cross-platform

Author: perazz

src/stdlib_system.F90

@@ -13,6 +13,8 @@ module stdlib_system
 public :: is_running
 public :: update
 public :: wait
+public :: elapsed
+public :: has_win32
 
 ! CPU clock ticks storage
 integer, parameter, private :: TICKS = int64
@@ -122,4 +124,11 @@ module subroutine sleep(millisec)
     end subroutine sleep
 end interface sleep        
 
+!! version: experimental
+!!
+interface 
+    module logical function has_win32()
+    end function has_win32
+end interface    
+
 end module stdlib_system

src/stdlib_system_subprocess.F90

@@ -56,6 +56,12 @@ type(c_ptr) function process_null_device(len) bind(C,name='process_null_device')
             implicit none
             integer(c_int), intent(out) :: len
         end function process_null_device
+        
+        ! Utility: check if _WIN32 is defined in the C compiler
+        logical(c_bool) function process_has_win32() bind(C,name='process_has_win32')
+            import c_bool
+            implicit none
+        end function process_has_win32
 
     end interface
 
@@ -455,6 +461,13 @@ function null_device()
 
     end function null_device
 
+    !> Returns the file path of the null device for the current operating system.
+    !>
+    !> Version: Helper function.
+    module logical function has_win32()
+       has_win32 = logical(process_has_win32())
+    end function has_win32
+    
     !> Reads a whole ASCII file and loads its contents into an allocatable character string..
     !> The function handles error states and optionally deletes the file after reading.
     !> Temporarily uses `linalg_state_type` in lieu of the generalized `state_type`.

src/stdlib_system_subprocess.c

@@ -263,3 +263,14 @@ const char* process_null_device(int* len)
         return "/dev/null";
 #endif
 }
+
+// Returns a boolean flag if macro _WIN32 is defined
+bool process_has_win32()
+{
+#ifdef _WIN32
+   return true;
+#else
+   return false;
+#endif // _WIN32
+}
+

test/system/test_subprocess.f90

@@ -1,6 +1,6 @@
 module test_subprocess
     use testdrive, only : new_unittest, unittest_type, error_type, check, skip_test
-    use stdlib_system, only: process_type, run, is_running, wait, update
+    use stdlib_system, only: process_type, run, is_running, wait, update, elapsed, has_win32
 
     implicit none
 
@@ -27,27 +27,36 @@ subroutine test_run_synchronous(error)
         process = run(command, wait=.true., want_stdout=.true.)
         call check(error, process%completed)
         if (allocated(error)) return
-
-        call check(error, trim(process%stdout) == "Hello")
+        
+        call check(error, trim(process%stdout) == "Hello", "stdout=<"//trim(process%stdout)//">, expected <Hello>")
     end subroutine test_run_synchronous
 
     !> Test running an asynchronous process
     subroutine test_run_asynchronous(error)
         type(error_type), allocatable, intent(out) :: error
         type(process_type) :: process
         logical :: running
-        character(len=*), parameter :: command = "sleep 1"
 
-        process = run(command, wait=.false.)
-        call check(error, .not. process%completed)
+        ! The closest possible to a cross-platform command that waits
+        if (has_win32()) then 
+            process = run("ping -n 2 127.0.0.1", wait=.false.)
+        else
+            process = run("ping -c 2 127.0.0.1", wait=.false.)
+        endif
+        ! Should not be immediately completed
+        call check(error, .not. process%completed, "ping process should not complete immediately")
         if (allocated(error)) return
 
         running = is_running(process)
-        call check(error, running)
+        call check(error, running, "ping process should still be running immediately after started")
         if (allocated(error)) return
 
         call wait(process)
-        call check(error, process%completed)
+        call check(error, process%completed, "process should be complete after `call wait`")
+        if (allocated(error)) return
+
+        call check(error, elapsed(process)>1.0e-4, "There should be a non-zero elapsed time")
+        
     end subroutine test_run_asynchronous
 
     !> Test updating and checking process state
@@ -62,10 +71,13 @@ subroutine test_process_state(error)
         call check(error, process%completed)
         if (allocated(error)) return
 
-        call check(error, process%exit_code == 0)
+        call check(error, process%exit_code == 0, "Check zero exit code")
+        if (allocated(error)) return
+        
+        call check(error, len_trim(process%stderr) == 0, "Check no stderr output")
         if (allocated(error)) return
 
-        call check(error, trim(process%stdout) == "Testing")
+        call check(error, trim(process%stdout) == "Testing", "stdout=<"//trim(process%stdout)//">, expected <Testing>")
         if (allocated(error)) return
     end subroutine test_process_state