Use Julienne .expectEquals. support for 64-bit integers

Prefer 64-bit comparison for any use case where a truncating conversion
could plausibly mask a defect.

Also, use native kind real comparison whenever possible.

Author: bonachea

test/prif_co_max_test.F90

@@ -128,7 +128,7 @@ function check_64_bit_integer() result(diag)
         call prif_co_max(my_val)
 
         expected = maxval(reshape([(values(:, mod(i-1,size(values,2))+1), i = 1, ni)], [size(values,1),ni]), dim=2)
-        diag = .all. (int(my_val) .equalsExpected. int(expected))
+        diag = .all. (my_val .equalsExpected. expected)
     end function
 
     function check_32_bit_real() result(diag)

test/prif_co_min_test.F90

@@ -126,14 +126,14 @@ function check_64_bit_integer() result(diag)
       call prif_co_min(my_val)
 
       expected = minval(reshape([(values(:, mod(i-1,size(values,2))+1), i = 1, ni)], [size(values,1),ni]), dim=2)
-      diag = .all. (int(my_val) .equalsExpected. int(expected))
+      diag = .all. (my_val .equalsExpected. expected)
   end function
 
   function check_32_bit_real() result(diag)
       type(test_diagnosis_t) :: diag
 
       real(c_float), parameter :: values(*,*,*) = reshape([1, 19, 5, 13, 11, 7, 17, 3], [2,2,2])
-      real(c_double), parameter :: tolerance = 0_c_double
+      real(c_float), parameter :: tolerance = 0_c_double
       integer :: me, ni, i
       real(c_float), dimension(size(values,1), size(values,2)) :: my_val, expected
 
@@ -144,7 +144,7 @@ function check_32_bit_real() result(diag)
       call prif_co_min(my_val)
 
       expected = minval(reshape([(values(:,:,mod(i-1,size(values,3))+1), i = 1, ni)], [size(values,1), size(values,2), ni]), dim=3)
-      diag = .all. (real(expected,kind=c_double) .approximates. real(my_val,kind=c_double) .within. tolerance)
+      diag = .all. (expected .approximates. my_val .within. tolerance)
   end function
 
   function check_64_bit_real() result(diag)

test/prif_co_reduce_test.F90

@@ -112,7 +112,7 @@ function check_derived_type_reduction() result(diag)
     type(pair), dimension(size(values,1)) :: my_val, expected
     type(pair), dimension(:,:), allocatable :: tmp
     procedure(prif_operation_wrapper_interface), pointer :: op
-    double precision, parameter :: tolerance = 0D0
+    real, parameter :: tolerance = 0D0
 
     op => pair_adder
     call prif_this_image_no_coarray(this_image=me)
@@ -138,7 +138,7 @@ function check_derived_type_reduction() result(diag)
     expected = reduce(tmp, add_pair, dim=2)
 #endif
     diag = .all. (my_val%fst .equalsExpected. expected%fst) &
-      .also. (.all. ( real(my_val%snd, kind=kind(0.d0)) .approximates. real(expected%snd, kind=kind(0.d0)) .within. tolerance))
+      .also. (.all. ( my_val%snd .approximates. expected%snd .within. tolerance))
   end function
 
   pure function add_pair(lhs, rhs) result(total)

test/prif_co_sum_test.F90

@@ -129,7 +129,7 @@ function check_64_bit_integer() result(diag)
       call prif_co_sum(my_val)
 
       expected = sum(reshape([(values(:, mod(i-1,size(values,2))+1), i = 1, ni)], [size(values,1),ni]), dim=2)
-      diag = .all. (int(my_val) .equalsExpected. int(expected))
+      diag = .all. (my_val .equalsExpected. expected)
   end function
 
   function check_32_bit_real() result(diag)