From 557061ea9a067b762c95a156017d41e229cb5b73 Mon Sep 17 00:00:00 2001 From: Yen-Chen Chen Date: Mon, 18 Dec 2023 11:22:43 +0100 Subject: [PATCH 01/13] Change variable kinds to selected kind --- src/assertions.f90 | 192 +++++++++++++++++++++++---------------------- 1 file changed, 100 insertions(+), 92 deletions(-) diff --git a/src/assertions.f90 b/src/assertions.f90 index 5f73ca9..0cf51e8 100644 --- a/src/assertions.f90 +++ b/src/assertions.f90 @@ -5,6 +5,14 @@ MODULE FUTF_ASSERTIONS IMPLICIT NONE + INTEGER, PARAMETER :: INT_KIND_1BYTE = SELECTED_INT_KIND(2) + INTEGER, PARAMETER :: INT_KIND_2BYTE = SELECTED_INT_KIND(4) + INTEGER, PARAMETER :: INT_KIND_4BYTE = SELECTED_INT_KIND(9) + INTEGER, PARAMETER :: INT_KIND_8BYTE = SELECTED_INT_KIND(18) + + INTEGER, PARAMETER :: REAL_KIND_4BYTE = SELECTED_REAL_KIND(6, 37) + INTEGER, PARAMETER :: REAL_KIND_8BYTE = SELECTED_REAL_KIND(15, 307) + CHARACTER(LEN=300), PRIVATE :: INFO INTERFACE ASSERT_EQUAL @@ -152,7 +160,7 @@ MODULE FUTF_ASSERTIONS ! - INTEGER(1) SINGLE SUBROUTINE ASSERT_EQUAL_INT_1BYTE(INT_1, INT_2) - INTEGER(1), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_1BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 == INT_2) THEN CALL REGISTER_PASSED WRITE(INFO, '(A, I0, A, I0)') "ASSERT_EQUAL: ", INT_1, " == ", INT_2 @@ -165,7 +173,7 @@ END SUBROUTINE ASSERT_EQUAL_INT_1BYTE ! - INTEGER(2) SINGLE SUBROUTINE ASSERT_EQUAL_INT_2BYTE(INT_1, INT_2) - INTEGER(2), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_2BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 == INT_2) THEN CALL REGISTER_PASSED @@ -179,7 +187,7 @@ END SUBROUTINE ASSERT_EQUAL_INT_2BYTE ! - INTEGER(4) SINGLE SUBROUTINE ASSERT_EQUAL_INT_4BYTE(INT_1, INT_2) - INTEGER(4), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_4BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 == INT_2) THEN CALL REGISTER_PASSED @@ -193,7 +201,7 @@ END SUBROUTINE ASSERT_EQUAL_INT_4BYTE ! - INTEGER(8) SINGLE SUBROUTINE ASSERT_EQUAL_INT_8BYTE(INT_1, INT_2) - INTEGER(8), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_8BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 == INT_2) THEN CALL REGISTER_PASSED @@ -209,7 +217,7 @@ END SUBROUTINE ASSERT_EQUAL_INT_8BYTE ! - INTEGER(1) ARRAY SUBROUTINE ASSERT_EQUAL_INT_1BYTE_ARR(INT_1, INT_2) - INTEGER(1), DIMENSION(:), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_1BYTE), DIMENSION(:), INTENT(IN) :: INT_1, INT_2 INTEGER :: I LOGICAL :: COMPARE @@ -240,7 +248,7 @@ END SUBROUTINE ASSERT_EQUAL_INT_1BYTE_ARR ! - INTEGER(2) ARRAY SUBROUTINE ASSERT_EQUAL_INT_2BYTE_ARR(INT_1, INT_2) - INTEGER(2), DIMENSION(:), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_2BYTE), DIMENSION(:), INTENT(IN) :: INT_1, INT_2 INTEGER :: I LOGICAL :: COMPARE @@ -272,7 +280,7 @@ END SUBROUTINE ASSERT_EQUAL_INT_2BYTE_ARR ! - INTEGER(4) ARRAY SUBROUTINE ASSERT_EQUAL_INT_4BYTE_ARR(INT_1, INT_2) - INTEGER(4), DIMENSION(:), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_4BYTE), DIMENSION(:), INTENT(IN) :: INT_1, INT_2 INTEGER :: I LOGICAL :: COMPARE @@ -304,7 +312,7 @@ END SUBROUTINE ASSERT_EQUAL_INT_4BYTE_ARR ! - INTEGER(8) ARRAY SUBROUTINE ASSERT_EQUAL_INT_8BYTE_ARR(INT_1, INT_2) - INTEGER(8), DIMENSION(:), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_8BYTE), DIMENSION(:), INTENT(IN) :: INT_1, INT_2 INTEGER :: I LOGICAL :: COMPARE @@ -338,7 +346,7 @@ END SUBROUTINE ASSERT_EQUAL_INT_8BYTE_ARR ! ****************************** SINGLE ********************************* ! ! - REAL(8) SUBROUTINE ASSERT_EQUAL_REAL_8BYTE(REAL_1, REAL_2) - REAL(8), INTENT(IN) :: REAL_1, REAL_2 + REAL(REAL_KIND_8BYTE), INTENT(IN) :: REAL_1, REAL_2 IF(REAL_1 == REAL_2) THEN CALL REGISTER_PASSED @@ -352,7 +360,7 @@ END SUBROUTINE ASSERT_EQUAL_REAL_8BYTE ! - REAL(4) SUBROUTINE ASSERT_EQUAL_REAL_4BYTE(REAL_1, REAL_2) - REAL(4), INTENT(IN) :: REAL_1, REAL_2 + REAL(REAL_KIND_4BYTE), INTENT(IN) :: REAL_1, REAL_2 IF(REAL_1 == REAL_2) THEN CALL REGISTER_PASSED @@ -367,7 +375,7 @@ END SUBROUTINE ASSERT_EQUAL_REAL_4BYTE ! ******************************* ARRAY ********************************* ! SUBROUTINE ASSERT_EQUAL_REAL_4BYTE_ARR(REAL_1, REAL_2) - REAL(4), DIMENSION(:), INTENT(IN) :: REAL_1, REAL_2 + REAL(REAL_KIND_4BYTE), DIMENSION(:), INTENT(IN) :: REAL_1, REAL_2 INTEGER :: I LOGICAL :: COMPARE @@ -401,7 +409,7 @@ SUBROUTINE ASSERT_EQUAL_REAL_4BYTE_ARR(REAL_1, REAL_2) END SUBROUTINE ASSERT_EQUAL_REAL_4BYTE_ARR SUBROUTINE ASSERT_EQUAL_REAL_8BYTE_ARR(REAL_1, REAL_2) - REAL(8), DIMENSION(:), INTENT(IN) :: REAL_1, REAL_2 + REAL(REAL_KIND_8BYTE), DIMENSION(:), INTENT(IN) :: REAL_1, REAL_2 INTEGER :: I LOGICAL :: COMPARE @@ -480,10 +488,10 @@ SUBROUTINE ASSERT_EQUAL_CHAR(CHAR_1, CHAR_2) END SUBROUTINE ASSERT_EQUAL_CHAR SUBROUTINE ASSERT_ALMOST_EQUAL_INT_1BYTE(INT_1, INT_2, REL_TOL) - INTEGER(1), INTENT(IN) :: INT_1, INT_2 - REAL(8), OPTIONAL :: REL_TOL + INTEGER(INT_KIND_1BYTE), INTENT(IN) :: INT_1, INT_2 + REAL(REAL_KIND_8BYTE), OPTIONAL :: REL_TOL - REAL(8) :: TOLERANCE + REAL(REAL_KIND_8BYTE) :: TOLERANCE LOGICAL PASSES IF(PRESENT(REL_TOL)) THEN @@ -511,10 +519,10 @@ SUBROUTINE ASSERT_ALMOST_EQUAL_INT_1BYTE(INT_1, INT_2, REL_TOL) END SUBROUTINE ASSERT_ALMOST_EQUAL_INT_1BYTE SUBROUTINE ASSERT_ALMOST_EQUAL_INT_2BYTE(INT_1, INT_2, REL_TOL) - INTEGER(2), INTENT(IN) :: INT_1, INT_2 - REAL(8), OPTIONAL :: REL_TOL + INTEGER(INT_KIND_2BYTE), INTENT(IN) :: INT_1, INT_2 + REAL(REAL_KIND_8BYTE), OPTIONAL :: REL_TOL - REAL(8) :: TOLERANCE + REAL(REAL_KIND_8BYTE) :: TOLERANCE LOGICAL PASSES IF(PRESENT(REL_TOL)) THEN @@ -542,10 +550,10 @@ SUBROUTINE ASSERT_ALMOST_EQUAL_INT_2BYTE(INT_1, INT_2, REL_TOL) END SUBROUTINE ASSERT_ALMOST_EQUAL_INT_2BYTE SUBROUTINE ASSERT_ALMOST_EQUAL_INT_4BYTE(INT_1, INT_2, REL_TOL) - INTEGER(4), INTENT(IN) :: INT_1, INT_2 - REAL(8), OPTIONAL :: REL_TOL + INTEGER(INT_KIND_4BYTE), INTENT(IN) :: INT_1, INT_2 + REAL(REAL_KIND_8BYTE), OPTIONAL :: REL_TOL - REAL(8) :: TOLERANCE + REAL(REAL_KIND_8BYTE) :: TOLERANCE LOGICAL PASSES IF(PRESENT(REL_TOL)) THEN @@ -573,10 +581,10 @@ SUBROUTINE ASSERT_ALMOST_EQUAL_INT_4BYTE(INT_1, INT_2, REL_TOL) END SUBROUTINE ASSERT_ALMOST_EQUAL_INT_4BYTE SUBROUTINE ASSERT_ALMOST_EQUAL_INT_8BYTE(INT_1, INT_2, REL_TOL) - INTEGER(8), INTENT(IN) :: INT_1, INT_2 - REAL(8), OPTIONAL :: REL_TOL + INTEGER(INT_KIND_8BYTE), INTENT(IN) :: INT_1, INT_2 + REAL(REAL_KIND_8BYTE), OPTIONAL :: REL_TOL - REAL(8) :: TOLERANCE + REAL(REAL_KIND_8BYTE) :: TOLERANCE LOGICAL PASSES IF(PRESENT(REL_TOL)) THEN @@ -604,10 +612,10 @@ SUBROUTINE ASSERT_ALMOST_EQUAL_INT_8BYTE(INT_1, INT_2, REL_TOL) END SUBROUTINE ASSERT_ALMOST_EQUAL_INT_8BYTE SUBROUTINE ASSERT_ALMOST_EQUAL_REAL_8BYTE(REAL_1, REAL_2, REL_TOL) - REAL(8), INTENT(IN) :: REAL_1, REAL_2 - REAL(8), OPTIONAL :: REL_TOL + REAL(REAL_KIND_8BYTE), INTENT(IN) :: REAL_1, REAL_2 + REAL(REAL_KIND_8BYTE), OPTIONAL :: REL_TOL - REAL(8) :: TOLERANCE + REAL(REAL_KIND_8BYTE) :: TOLERANCE LOGICAL PASSES IF(PRESENT(REL_TOL)) THEN @@ -635,10 +643,10 @@ SUBROUTINE ASSERT_ALMOST_EQUAL_REAL_8BYTE(REAL_1, REAL_2, REL_TOL) END SUBROUTINE ASSERT_ALMOST_EQUAL_REAL_8BYTE SUBROUTINE ASSERT_ALMOST_EQUAL_REAL_4BYTE(REAL_1, REAL_2, REL_TOL) - REAL(4), INTENT(IN) :: REAL_1, REAL_2 - REAL(4), OPTIONAL :: REL_TOL + REAL(REAL_KIND_4BYTE), INTENT(IN) :: REAL_1, REAL_2 + REAL(REAL_KIND_4BYTE), OPTIONAL :: REL_TOL - REAL(4) :: TOLERANCE + REAL(REAL_KIND_4BYTE) :: TOLERANCE LOGICAL PASSES IF(PRESENT(REL_TOL)) THEN @@ -692,7 +700,7 @@ SUBROUTINE ASSERT_FALSE(STATEMENT) END SUBROUTINE ASSERT_FALSE SUBROUTINE ASSERT_NOT_EQUAL_INT_1BYTE(INT_1, INT_2) - INTEGER(1), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_1BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 /= INT_2) THEN CALL REGISTER_PASSED @@ -705,7 +713,7 @@ SUBROUTINE ASSERT_NOT_EQUAL_INT_1BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_NOT_EQUAL_INT_1BYTE SUBROUTINE ASSERT_NOT_EQUAL_INT_2BYTE(INT_1, INT_2) - INTEGER(2), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_2BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 /= INT_2) THEN CALL REGISTER_PASSED @@ -718,7 +726,7 @@ SUBROUTINE ASSERT_NOT_EQUAL_INT_2BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_NOT_EQUAL_INT_2BYTE SUBROUTINE ASSERT_NOT_EQUAL_INT_4BYTE(INT_1, INT_2) - INTEGER(4), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_4BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 /= INT_2) THEN CALL REGISTER_PASSED @@ -731,7 +739,7 @@ SUBROUTINE ASSERT_NOT_EQUAL_INT_4BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_NOT_EQUAL_INT_4BYTE SUBROUTINE ASSERT_NOT_EQUAL_INT_8BYTE(INT_1, INT_2) - INTEGER(8), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_8BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 /= INT_2) THEN CALL REGISTER_PASSED @@ -744,7 +752,7 @@ SUBROUTINE ASSERT_NOT_EQUAL_INT_8BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_NOT_EQUAL_INT_8BYTE SUBROUTINE ASSERT_NOT_EQUAL_REAL_8BYTE(REAL_1, REAL_2) - REAL(8), INTENT(IN) :: REAL_1, REAL_2 + REAL(REAL_KIND_8BYTE), INTENT(IN) :: REAL_1, REAL_2 IF(REAL_1 /= REAL_2) THEN CALL REGISTER_PASSED @@ -757,7 +765,7 @@ SUBROUTINE ASSERT_NOT_EQUAL_REAL_8BYTE(REAL_1, REAL_2) END SUBROUTINE ASSERT_NOT_EQUAL_REAL_8BYTE SUBROUTINE ASSERT_NOT_EQUAL_REAL_4BYTE(REAL_1, REAL_2) - REAL(4), INTENT(IN) :: REAL_1, REAL_2 + REAL(REAL_KIND_4BYTE), INTENT(IN) :: REAL_1, REAL_2 IF(REAL_1 /= REAL_2) THEN CALL REGISTER_PASSED @@ -811,7 +819,7 @@ SUBROUTINE ASSERT_NOT_EQUAL_COMPLEX(COMP_1, COMP_2) END SUBROUTINE ASSERT_NOT_EQUAL_COMPLEX SUBROUTINE ASSERT_GREATER_THAN_INT_1BYTE(INT_1, INT_2) - INTEGER(1), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_1BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 > INT_2) THEN CALL REGISTER_PASSED @@ -824,7 +832,7 @@ SUBROUTINE ASSERT_GREATER_THAN_INT_1BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_GREATER_THAN_INT_1BYTE SUBROUTINE ASSERT_GREATER_THAN_INT_2BYTE(INT_1, INT_2) - INTEGER(2), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_2BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 > INT_2) THEN CALL REGISTER_PASSED @@ -837,7 +845,7 @@ SUBROUTINE ASSERT_GREATER_THAN_INT_2BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_GREATER_THAN_INT_2BYTE SUBROUTINE ASSERT_GREATER_THAN_INT_4BYTE(INT_1, INT_2) - INTEGER(4), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_4BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 > INT_2) THEN CALL REGISTER_PASSED @@ -850,7 +858,7 @@ SUBROUTINE ASSERT_GREATER_THAN_INT_4BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_GREATER_THAN_INT_4BYTE SUBROUTINE ASSERT_GREATER_THAN_INT_8BYTE(INT_1, INT_2) - INTEGER(8), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_8BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 > INT_2) THEN CALL REGISTER_PASSED @@ -863,7 +871,7 @@ SUBROUTINE ASSERT_GREATER_THAN_INT_8BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_GREATER_THAN_INT_8BYTE SUBROUTINE ASSERT_GREATER_THAN_REAL_4BYTE(REAL_1, REAL_2) - REAL(4), INTENT(IN) :: REAL_1, REAL_2 + REAL(REAL_KIND_4BYTE), INTENT(IN) :: REAL_1, REAL_2 IF(REAL_1 > REAL_2) THEN CALL REGISTER_PASSED @@ -876,7 +884,7 @@ SUBROUTINE ASSERT_GREATER_THAN_REAL_4BYTE(REAL_1, REAL_2) END SUBROUTINE ASSERT_GREATER_THAN_REAL_4BYTE SUBROUTINE ASSERT_GREATER_THAN_REAL_8BYTE(REAL_1, REAL_2) - REAL(8), INTENT(IN) :: REAL_1, REAL_2 + REAL(REAL_KIND_8BYTE), INTENT(IN) :: REAL_1, REAL_2 IF(REAL_1 > REAL_2) THEN CALL REGISTER_PASSED @@ -889,7 +897,7 @@ SUBROUTINE ASSERT_GREATER_THAN_REAL_8BYTE(REAL_1, REAL_2) END SUBROUTINE ASSERT_GREATER_THAN_REAL_8BYTE SUBROUTINE ASSERT_LESS_THAN_INT_1BYTE(INT_1, INT_2) - INTEGER(1), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_1BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 < INT_2) THEN CALL REGISTER_PASSED @@ -902,7 +910,7 @@ SUBROUTINE ASSERT_LESS_THAN_INT_1BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_LESS_THAN_INT_1BYTE SUBROUTINE ASSERT_LESS_THAN_INT_2BYTE(INT_1, INT_2) - INTEGER(2), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_2BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 < INT_2) THEN CALL REGISTER_PASSED @@ -915,7 +923,7 @@ SUBROUTINE ASSERT_LESS_THAN_INT_2BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_LESS_THAN_INT_2BYTE SUBROUTINE ASSERT_LESS_THAN_INT_4BYTE(INT_1, INT_2) - INTEGER(4), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_4BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 < INT_2) THEN CALL REGISTER_PASSED @@ -928,7 +936,7 @@ SUBROUTINE ASSERT_LESS_THAN_INT_4BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_LESS_THAN_INT_4BYTE SUBROUTINE ASSERT_LESS_THAN_INT_8BYTE(INT_1, INT_2) - INTEGER(8), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_8BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 < INT_2) THEN CALL REGISTER_PASSED @@ -941,7 +949,7 @@ SUBROUTINE ASSERT_LESS_THAN_INT_8BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_LESS_THAN_INT_8BYTE SUBROUTINE ASSERT_LESS_THAN_REAL_8BYTE(REAL_1, REAL_2) - REAL(8), INTENT(IN) :: REAL_1, REAL_2 + REAL(REAL_KIND_8BYTE), INTENT(IN) :: REAL_1, REAL_2 IF(REAL_1 < REAL_2) THEN CALL REGISTER_PASSED @@ -954,7 +962,7 @@ SUBROUTINE ASSERT_LESS_THAN_REAL_8BYTE(REAL_1, REAL_2) END SUBROUTINE ASSERT_LESS_THAN_REAL_8BYTE SUBROUTINE ASSERT_LESS_THAN_REAL_4BYTE(REAL_1, REAL_2) - REAL(4), INTENT(IN) :: REAL_1, REAL_2 + REAL(REAL_KIND_4BYTE), INTENT(IN) :: REAL_1, REAL_2 IF(REAL_1 < REAL_2) THEN CALL REGISTER_PASSED @@ -967,7 +975,7 @@ SUBROUTINE ASSERT_LESS_THAN_REAL_4BYTE(REAL_1, REAL_2) END SUBROUTINE ASSERT_LESS_THAN_REAL_4BYTE SUBROUTINE ASSERT_GREATER_THAN_EQUAL_INT_1BYTE(INT_1, INT_2) - INTEGER(1), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_1BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 >= INT_2) THEN CALL REGISTER_PASSED @@ -980,7 +988,7 @@ SUBROUTINE ASSERT_GREATER_THAN_EQUAL_INT_1BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_GREATER_THAN_EQUAL_INT_1BYTE SUBROUTINE ASSERT_GREATER_THAN_EQUAL_INT_2BYTE(INT_1, INT_2) - INTEGER(2), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_2BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 >= INT_2) THEN CALL REGISTER_PASSED @@ -993,7 +1001,7 @@ SUBROUTINE ASSERT_GREATER_THAN_EQUAL_INT_2BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_GREATER_THAN_EQUAL_INT_2BYTE SUBROUTINE ASSERT_GREATER_THAN_EQUAL_INT_4BYTE(INT_1, INT_2) - INTEGER(4), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_4BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 >= INT_2) THEN CALL REGISTER_PASSED @@ -1006,7 +1014,7 @@ SUBROUTINE ASSERT_GREATER_THAN_EQUAL_INT_4BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_GREATER_THAN_EQUAL_INT_4BYTE SUBROUTINE ASSERT_GREATER_THAN_EQUAL_INT_8BYTE(INT_1, INT_2) - INTEGER(8), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_8BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 >= INT_2) THEN CALL REGISTER_PASSED @@ -1019,7 +1027,7 @@ SUBROUTINE ASSERT_GREATER_THAN_EQUAL_INT_8BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_GREATER_THAN_EQUAL_INT_8BYTE SUBROUTINE ASSERT_GREATER_THAN_EQUAL_REAL_8BYTE(REAL_1, REAL_2) - REAL(8), INTENT(IN) :: REAL_1, REAL_2 + REAL(REAL_KIND_8BYTE), INTENT(IN) :: REAL_1, REAL_2 IF(REAL_1 >= REAL_2) THEN CALL REGISTER_PASSED @@ -1032,7 +1040,7 @@ SUBROUTINE ASSERT_GREATER_THAN_EQUAL_REAL_8BYTE(REAL_1, REAL_2) END SUBROUTINE ASSERT_GREATER_THAN_EQUAL_REAL_8BYTE SUBROUTINE ASSERT_GREATER_THAN_EQUAL_REAL_4BYTE(REAL_1, REAL_2) - REAL(4), INTENT(IN) :: REAL_1, REAL_2 + REAL(REAL_KIND_4BYTE), INTENT(IN) :: REAL_1, REAL_2 IF(REAL_1 >= REAL_2) THEN CALL REGISTER_PASSED @@ -1045,7 +1053,7 @@ SUBROUTINE ASSERT_GREATER_THAN_EQUAL_REAL_4BYTE(REAL_1, REAL_2) END SUBROUTINE ASSERT_GREATER_THAN_EQUAL_REAL_4BYTE SUBROUTINE ASSERT_LESS_THAN_EQUAL_INT_1BYTE(INT_1, INT_2) - INTEGER(1), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_1BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 <= INT_2) THEN CALL REGISTER_PASSED @@ -1058,7 +1066,7 @@ SUBROUTINE ASSERT_LESS_THAN_EQUAL_INT_1BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_LESS_THAN_EQUAL_INT_1BYTE SUBROUTINE ASSERT_LESS_THAN_EQUAL_INT_2BYTE(INT_1, INT_2) - INTEGER(2), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_2BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 <= INT_2) THEN CALL REGISTER_PASSED @@ -1071,7 +1079,7 @@ SUBROUTINE ASSERT_LESS_THAN_EQUAL_INT_2BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_LESS_THAN_EQUAL_INT_2BYTE SUBROUTINE ASSERT_LESS_THAN_EQUAL_INT_4BYTE(INT_1, INT_2) - INTEGER(4), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_4BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 <= INT_2) THEN CALL REGISTER_PASSED @@ -1084,7 +1092,7 @@ SUBROUTINE ASSERT_LESS_THAN_EQUAL_INT_4BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_LESS_THAN_EQUAL_INT_4BYTE SUBROUTINE ASSERT_LESS_THAN_EQUAL_INT_8BYTE(INT_1, INT_2) - INTEGER(8), INTENT(IN) :: INT_1, INT_2 + INTEGER(INT_KIND_8BYTE), INTENT(IN) :: INT_1, INT_2 IF(INT_1 <= INT_2) THEN CALL REGISTER_PASSED @@ -1097,7 +1105,7 @@ SUBROUTINE ASSERT_LESS_THAN_EQUAL_INT_8BYTE(INT_1, INT_2) END SUBROUTINE ASSERT_LESS_THAN_EQUAL_INT_8BYTE SUBROUTINE ASSERT_LESS_THAN_EQUAL_REAL_4BYTE(REAL_1, REAL_2) - REAL(4), INTENT(IN) :: REAL_1, REAL_2 + REAL(REAL_KIND_4BYTE), INTENT(IN) :: REAL_1, REAL_2 IF(REAL_1 <= REAL_2) THEN CALL REGISTER_PASSED @@ -1110,7 +1118,7 @@ SUBROUTINE ASSERT_LESS_THAN_EQUAL_REAL_4BYTE(REAL_1, REAL_2) END SUBROUTINE ASSERT_LESS_THAN_EQUAL_REAL_4BYTE SUBROUTINE ASSERT_LESS_THAN_EQUAL_REAL_8BYTE(REAL_1, REAL_2) - REAL(8), INTENT(IN) :: REAL_1, REAL_2 + REAL(REAL_KIND_8BYTE), INTENT(IN) :: REAL_1, REAL_2 IF(REAL_1 <= REAL_2) THEN CALL REGISTER_PASSED @@ -1123,42 +1131,42 @@ SUBROUTINE ASSERT_LESS_THAN_EQUAL_REAL_8BYTE(REAL_1, REAL_2) END SUBROUTINE ASSERT_LESS_THAN_EQUAL_REAL_8BYTE SUBROUTINE ASSERT_IS_REAL_REAL_4BYTE(REAL_VAR) - REAL(4), INTENT(IN) :: REAL_VAR + REAL(REAL_KIND_4BYTE), INTENT(IN) :: REAL_VAR CALL REGISTER_PASSED WRITE(INFO, '(A, F0.5, A)') "ASSERT_IS_REAL: ", REAL_VAR, " (REAL)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_REAL_REAL_4BYTE SUBROUTINE ASSERT_IS_REAL_REAL_8BYTE(REAL_VAR) - REAL(8), INTENT(IN) :: REAL_VAR + REAL(REAL_KIND_8BYTE), INTENT(IN) :: REAL_VAR CALL REGISTER_PASSED WRITE(INFO, '(A, F0.5, A)') "ASSERT_IS_REAL: ", REAL_VAR, " (REAL)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_REAL_REAL_8BYTE SUBROUTINE ASSERT_IS_REAL_INT_1BYTE(INT_VAR) - INTEGER(1), INTENT(IN) :: INT_VAR + INTEGER(INT_KIND_1BYTE), INTENT(IN) :: INT_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, I0, A)') "ASSERT_IS_REAL: ", INT_VAR, " (INT)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_REAL_INT_1BYTE SUBROUTINE ASSERT_IS_REAL_INT_2BYTE(INT_VAR) - INTEGER(2), INTENT(IN) :: INT_VAR + INTEGER(INT_KIND_2BYTE), INTENT(IN) :: INT_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, I0, A)') "ASSERT_IS_REAL: ", INT_VAR, " (INT)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_REAL_INT_2BYTE SUBROUTINE ASSERT_IS_REAL_INT_4BYTE(INT_VAR) - INTEGER(4), INTENT(IN) :: INT_VAR + INTEGER(INT_KIND_4BYTE), INTENT(IN) :: INT_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, I0, A)') "ASSERT_IS_REAL: ", INT_VAR, " (INT)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_REAL_INT_4BYTE SUBROUTINE ASSERT_IS_REAL_INT_8BYTE(INT_VAR) - INTEGER(8), INTENT(IN) :: INT_VAR + INTEGER(INT_KIND_8BYTE), INTENT(IN) :: INT_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, I0, A)') "ASSERT_IS_REAL: ", INT_VAR, " (INT)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) @@ -1187,42 +1195,42 @@ SUBROUTINE ASSERT_IS_REAL_COMPLEX(COMP_VAR) END SUBROUTINE ASSERT_IS_REAL_COMPLEX SUBROUTINE ASSERT_IS_INT_REAL_4BYTE(REAL_VAR) - REAL(4), INTENT(IN) :: REAL_VAR + REAL(REAL_KIND_4BYTE), INTENT(IN) :: REAL_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, F0.5, A)') "ASSERT_IS_INT: ", REAL_VAR, " (REAL)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_INT_REAL_4BYTE SUBROUTINE ASSERT_IS_INT_REAL_8BYTE(REAL_VAR) - REAL(8), INTENT(IN) :: REAL_VAR + REAL(REAL_KIND_8BYTE), INTENT(IN) :: REAL_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, F0.5, A)') "ASSERT_IS_INT: ", REAL_VAR, " (REAL)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_INT_REAL_8BYTE SUBROUTINE ASSERT_IS_INT_INT_1BYTE(INT_VAR) - INTEGER(1), INTENT(IN) :: INT_VAR + INTEGER(INT_KIND_1BYTE), INTENT(IN) :: INT_VAR CALL REGISTER_PASSED WRITE(INFO, '(A, I0, A)') "ASSERT_IS_INT: ", INT_VAR, " (INT)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_INT_INT_1BYTE SUBROUTINE ASSERT_IS_INT_INT_2BYTE(INT_VAR) - INTEGER(2), INTENT(IN) :: INT_VAR + INTEGER(INT_KIND_2BYTE), INTENT(IN) :: INT_VAR CALL REGISTER_PASSED WRITE(INFO, '(A, I0, A)') "ASSERT_IS_INT: ", INT_VAR, " (INT)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_INT_INT_2BYTE SUBROUTINE ASSERT_IS_INT_INT_4BYTE(INT_VAR) - INTEGER(4), INTENT(IN) :: INT_VAR + INTEGER(INT_KIND_4BYTE), INTENT(IN) :: INT_VAR CALL REGISTER_PASSED WRITE(INFO, '(A, I0, A)') "ASSERT_IS_INT: ", INT_VAR, " (INT)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_INT_INT_4BYTE SUBROUTINE ASSERT_IS_INT_INT_8BYTE(INT_VAR) - INTEGER(8), INTENT(IN) :: INT_VAR + INTEGER(INT_KIND_8BYTE), INTENT(IN) :: INT_VAR CALL REGISTER_PASSED WRITE(INFO, '(A, I0, A)') "ASSERT_IS_INT: ", INT_VAR, " (INT)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) @@ -1251,42 +1259,42 @@ SUBROUTINE ASSERT_IS_INT_COMPLEX(COMP_VAR) END SUBROUTINE ASSERT_IS_INT_COMPLEX SUBROUTINE ASSERT_IS_CHARACTER_REAL_4BYTE(REAL_VAR) - REAL(4), INTENT(IN) :: REAL_VAR + REAL(REAL_KIND_4BYTE), INTENT(IN) :: REAL_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, F0.5, A)') "ASSERT_IS_CHARACTER: ", REAL_VAR, " (REAL)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_CHARACTER_REAL_4BYTE SUBROUTINE ASSERT_IS_CHARACTER_REAL_8BYTE(REAL_VAR) - REAL(8), INTENT(IN) :: REAL_VAR + REAL(REAL_KIND_8BYTE), INTENT(IN) :: REAL_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, F0.5, A)') "ASSERT_IS_CHARACTER: ", REAL_VAR, " (REAL)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_CHARACTER_REAL_8BYTE SUBROUTINE ASSERT_IS_CHARACTER_INT_1BYTE(INT_VAR) - INTEGER(1), INTENT(IN) :: INT_VAR + INTEGER(INT_KIND_1BYTE), INTENT(IN) :: INT_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, I0, A)') "ASSERT_IS_CHARACTER: ", INT_VAR, " (INT)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_CHARACTER_INT_1BYTE SUBROUTINE ASSERT_IS_CHARACTER_INT_2BYTE(INT_VAR) - INTEGER(2), INTENT(IN) :: INT_VAR + INTEGER(INT_KIND_2BYTE), INTENT(IN) :: INT_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, I0, A)') "ASSERT_IS_CHARACTER: ", INT_VAR, " (INT)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_CHARACTER_INT_2BYTE SUBROUTINE ASSERT_IS_CHARACTER_INT_4BYTE(INT_VAR) - INTEGER(4), INTENT(IN) :: INT_VAR + INTEGER(INT_KIND_4BYTE), INTENT(IN) :: INT_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, I0, A)') "ASSERT_IS_CHARACTER: ", INT_VAR, " (INT)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_CHARACTER_INT_4BYTE SUBROUTINE ASSERT_IS_CHARACTER_INT_8BYTE(INT_VAR) - INTEGER(8), INTENT(IN) :: INT_VAR + INTEGER(INT_KIND_8BYTE), INTENT(IN) :: INT_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, I0, A)') "ASSERT_IS_CHARACTER: ", INT_VAR, " (INT)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) @@ -1315,42 +1323,42 @@ SUBROUTINE ASSERT_IS_CHARACTER_COMPLEX(COMP_VAR) END SUBROUTINE ASSERT_IS_CHARACTER_COMPLEX SUBROUTINE ASSERT_IS_COMPLEX_REAL_4BYTE(REAL_VAR) - REAL(4), INTENT(IN) :: REAL_VAR + REAL(REAL_KIND_4BYTE), INTENT(IN) :: REAL_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, F0.5, A)') "ASSERT_IS_COMPLEX: ", REAL_VAR, " (REAL)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_COMPLEX_REAL_4BYTE SUBROUTINE ASSERT_IS_COMPLEX_REAL_8BYTE(REAL_VAR) - REAL(8), INTENT(IN) :: REAL_VAR + REAL(REAL_KIND_8BYTE), INTENT(IN) :: REAL_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, F0.5, A)') "ASSERT_IS_COMPLEX: ", REAL_VAR, " (REAL)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_COMPLEX_REAL_8BYTE SUBROUTINE ASSERT_IS_COMPLEX_INT_1BYTE(INT_VAR) - INTEGER(1), INTENT(IN) :: INT_VAR + INTEGER(INT_KIND_1BYTE), INTENT(IN) :: INT_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, I0, A)') "ASSERT_IS_COMPLEX: ", INT_VAR, " (INT)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_COMPLEX_INT_1BYTE SUBROUTINE ASSERT_IS_COMPLEX_INT_2BYTE(INT_VAR) - INTEGER(2), INTENT(IN) :: INT_VAR + INTEGER(INT_KIND_2BYTE), INTENT(IN) :: INT_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, I0, A)') "ASSERT_IS_COMPLEX: ", INT_VAR, " (INT)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_COMPLEX_INT_2BYTE SUBROUTINE ASSERT_IS_COMPLEX_INT_4BYTE(INT_VAR) - INTEGER(4), INTENT(IN) :: INT_VAR + INTEGER(INT_KIND_4BYTE), INTENT(IN) :: INT_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, I0, A)') "ASSERT_IS_COMPLEX: ", INT_VAR, " (INT)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_COMPLEX_INT_4BYTE SUBROUTINE ASSERT_IS_COMPLEX_INT_8BYTE(INT_VAR) - INTEGER(8), INTENT(IN) :: INT_VAR + INTEGER(INT_KIND_8BYTE), INTENT(IN) :: INT_VAR CALL REGISTER_FAILED WRITE(INFO, '(A, I0, A)') "ASSERT_IS_COMPLEX: ", INT_VAR, " (INT)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) @@ -1384,8 +1392,8 @@ END SUBROUTINE ASSERT_IS_COMPLEX_COMPLEX ! ! !-------------------------------------------------------------------------! SUBROUTINE VAL_IN_ARR_INT_1BYTE(ARRAY, VAL) - INTEGER(1), INTENT(IN) :: VAL - INTEGER(1), DIMENSION(:), INTENT(IN) :: ARRAY + INTEGER(INT_KIND_1BYTE), INTENT(IN) :: VAL + INTEGER(INT_KIND_1BYTE), DIMENSION(:), INTENT(IN) :: ARRAY IF( ANY(ARRAY == VAL) ) THEN CALL REGISTER_PASSED @@ -1397,8 +1405,8 @@ SUBROUTINE VAL_IN_ARR_INT_1BYTE(ARRAY, VAL) END SUBROUTINE VAL_IN_ARR_INT_1BYTE SUBROUTINE VAL_IN_ARR_INT_2BYTE(ARRAY, VAL) - INTEGER(2), INTENT(IN) :: VAL - INTEGER(2), DIMENSION(:), INTENT(IN) :: ARRAY + INTEGER(INT_KIND_2BYTE), INTENT(IN) :: VAL + INTEGER(INT_KIND_2BYTE), DIMENSION(:), INTENT(IN) :: ARRAY IF( ANY(ARRAY == VAL) ) THEN CALL REGISTER_PASSED @@ -1410,8 +1418,8 @@ SUBROUTINE VAL_IN_ARR_INT_2BYTE(ARRAY, VAL) END SUBROUTINE VAL_IN_ARR_INT_2BYTE SUBROUTINE VAL_IN_ARR_INT_4BYTE(ARRAY, VAL) - INTEGER(4), INTENT(IN) :: VAL - INTEGER(4), DIMENSION(:), INTENT(IN) :: ARRAY + INTEGER(INT_KIND_4BYTE), INTENT(IN) :: VAL + INTEGER(INT_KIND_4BYTE), DIMENSION(:), INTENT(IN) :: ARRAY IF( ANY(ARRAY == VAL) ) THEN CALL REGISTER_PASSED @@ -1423,8 +1431,8 @@ SUBROUTINE VAL_IN_ARR_INT_4BYTE(ARRAY, VAL) END SUBROUTINE VAL_IN_ARR_INT_4BYTE SUBROUTINE VAL_IN_ARR_INT_8BYTE(ARRAY, VAL) - INTEGER(8), INTENT(IN) :: VAL - INTEGER(8), DIMENSION(:), INTENT(IN) :: ARRAY + INTEGER(INT_KIND_8BYTE), INTENT(IN) :: VAL + INTEGER(INT_KIND_8BYTE), DIMENSION(:), INTENT(IN) :: ARRAY IF( ANY(ARRAY == VAL) ) THEN CALL REGISTER_PASSED From fd6afff8816a0a7a0b233c8029c9804c6a610faa Mon Sep 17 00:00:00 2001 From: Yen-Chen Chen Date: Mon, 18 Dec 2023 11:23:30 +0100 Subject: [PATCH 02/13] Fix field width errors for edit descriptors for some compilers --- src/assertions.f90 | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/src/assertions.f90 b/src/assertions.f90 index 0cf51e8..07bf17e 100644 --- a/src/assertions.f90 +++ b/src/assertions.f90 @@ -465,10 +465,10 @@ SUBROUTINE ASSERT_EQUAL_LOGICAL(BOOL_1, BOOL_2) IF(BOOL_1 .EQV. BOOL_2) THEN CALL REGISTER_PASSED - WRITE(INFO, '(A, L, A, L)') "ASSERT_EQUAL: ", BOOL_1, " == ", BOOL_2 + WRITE(INFO, '(A, L1, A, L1)') "ASSERT_EQUAL: ", BOOL_1, " == ", BOOL_2 ELSE CALL REGISTER_FAILED - WRITE(INFO, '(A, L, A, L)') "ASSERT_EQUAL: ", BOOL_1, " != ", BOOL_2 + WRITE(INFO, '(A, L1, A, L1)') "ASSERT_EQUAL: ", BOOL_1, " != ", BOOL_2 END IF INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_EQUAL_LOGICAL @@ -510,10 +510,10 @@ SUBROUTINE ASSERT_ALMOST_EQUAL_INT_1BYTE(INT_1, INT_2, REL_TOL) IF(PASSES) THEN CALL REGISTER_PASSED - WRITE(INFO, '(A, I0, A, I0, A, E0.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") < ", TOLERANCE + WRITE(INFO, '(A, I0, A, I0, A, E10.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") < ", TOLERANCE ELSE CALL REGISTER_FAILED - WRITE(INFO, '(A, I0, A, I0, A, E0.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") > ", TOLERANCE + WRITE(INFO, '(A, I0, A, I0, A, E10.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") > ", TOLERANCE ENDIF INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_ALMOST_EQUAL_INT_1BYTE @@ -541,10 +541,10 @@ SUBROUTINE ASSERT_ALMOST_EQUAL_INT_2BYTE(INT_1, INT_2, REL_TOL) IF(PASSES) THEN CALL REGISTER_PASSED - WRITE(INFO, '(A, I0, A, I0, A, E0.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") < ", TOLERANCE + WRITE(INFO, '(A, I0, A, I0, A, E10.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") < ", TOLERANCE ELSE CALL REGISTER_FAILED - WRITE(INFO, '(A, I0, A, I0, A, E0.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") > ", TOLERANCE + WRITE(INFO, '(A, I0, A, I0, A, E10.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") > ", TOLERANCE ENDIF INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_ALMOST_EQUAL_INT_2BYTE @@ -572,10 +572,10 @@ SUBROUTINE ASSERT_ALMOST_EQUAL_INT_4BYTE(INT_1, INT_2, REL_TOL) IF(PASSES) THEN CALL REGISTER_PASSED - WRITE(INFO, '(A, I0, A, I0, A, E0.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") < ", TOLERANCE + WRITE(INFO, '(A, I0, A, I0, A, E10.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") < ", TOLERANCE ELSE CALL REGISTER_FAILED - WRITE(INFO, '(A, I0, A, I0, A, E0.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") > ", TOLERANCE + WRITE(INFO, '(A, I0, A, I0, A, E10.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") > ", TOLERANCE ENDIF INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_ALMOST_EQUAL_INT_4BYTE @@ -603,10 +603,10 @@ SUBROUTINE ASSERT_ALMOST_EQUAL_INT_8BYTE(INT_1, INT_2, REL_TOL) IF(PASSES) THEN CALL REGISTER_PASSED - WRITE(INFO, '(A, I0, A, I0, A, E0.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") < ", TOLERANCE + WRITE(INFO, '(A, I0, A, I0, A, E10.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") < ", TOLERANCE ELSE CALL REGISTER_FAILED - WRITE(INFO, '(A, I0, A, I0, A, E0.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") > ", TOLERANCE + WRITE(INFO, '(A, I0, A, I0, A, E10.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") > ", TOLERANCE ENDIF INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_ALMOST_EQUAL_INT_8BYTE @@ -782,10 +782,10 @@ SUBROUTINE ASSERT_NOT_EQUAL_LOGICAL(BOOL_1, BOOL_2) IF(BOOL_1 .NEQV. BOOL_2) THEN CALL REGISTER_PASSED - WRITE(INFO, '(A, L, A, L)') "ASSERT_NOT_EQUAL: ", BOOL_1, " != ", BOOL_2 + WRITE(INFO, '(A, L1, A, L1)') "ASSERT_NOT_EQUAL: ", BOOL_1, " != ", BOOL_2 ELSE CALL REGISTER_FAILED - WRITE(INFO, '(A, L, A, L)') "ASSERT_NOT_EQUAL: ", BOOL_1, " == ", BOOL_2 + WRITE(INFO, '(A, L1, A, L1)') "ASSERT_NOT_EQUAL: ", BOOL_1, " == ", BOOL_2 END IF INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_NOT_EQUAL_LOGICAL @@ -1182,7 +1182,7 @@ END SUBROUTINE ASSERT_IS_REAL_CHAR SUBROUTINE ASSERT_IS_REAL_BOOL(BOOL_VAR) LOGICAL, INTENT(IN) :: BOOL_VAR CALL REGISTER_FAILED - WRITE(INFO, '(A, L, A)') "ASSERT_IS_REAL: ", BOOL_VAR, " (LOGICAL)" + WRITE(INFO, '(A, L1, A)') "ASSERT_IS_REAL: ", BOOL_VAR, " (LOGICAL)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_REAL_BOOL @@ -1246,7 +1246,7 @@ END SUBROUTINE ASSERT_IS_INT_CHAR SUBROUTINE ASSERT_IS_INT_BOOL(BOOL_VAR) LOGICAL, INTENT(IN) :: BOOL_VAR CALL REGISTER_FAILED - WRITE(INFO, '(A, L, A)') "ASSERT_IS_INT: ", BOOL_VAR, " (LOGICAL)" + WRITE(INFO, '(A, L1, A)') "ASSERT_IS_INT: ", BOOL_VAR, " (LOGICAL)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_INT_BOOL @@ -1310,7 +1310,7 @@ END SUBROUTINE ASSERT_IS_CHARACTER_CHAR SUBROUTINE ASSERT_IS_CHARACTER_BOOL(BOOL_VAR) LOGICAL, INTENT(IN) :: BOOL_VAR CALL REGISTER_FAILED - WRITE(INFO, '(A, L, A)') "ASSERT_IS_CHARACTER: ", BOOL_VAR, " (LOGICAL)" + WRITE(INFO, '(A, L1, A)') "ASSERT_IS_CHARACTER: ", BOOL_VAR, " (LOGICAL)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_CHARACTER_BOOL @@ -1374,7 +1374,7 @@ END SUBROUTINE ASSERT_IS_COMPLEX_CHAR SUBROUTINE ASSERT_IS_COMPLEX_BOOL(BOOL_VAR) LOGICAL, INTENT(IN) :: BOOL_VAR CALL REGISTER_FAILED - WRITE(INFO, '(A, L, A)') "ASSERT_IS_COMPLEX: ", BOOL_VAR, " (LOGICAL)" + WRITE(INFO, '(A, L1, A)') "ASSERT_IS_COMPLEX: ", BOOL_VAR, " (LOGICAL)" INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_IS_COMPLEX_BOOL From 0229f19ae1ce08d2df6098a4d1bf634bab997adc Mon Sep 17 00:00:00 2001 From: Yen-Chen Chen Date: Mon, 18 Dec 2023 13:52:58 +0100 Subject: [PATCH 03/13] Fix exit code --- src/suite.f90 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/suite.f90 b/src/suite.f90 index 3bff758..ee7711b 100644 --- a/src/suite.f90 +++ b/src/suite.f90 @@ -112,7 +112,7 @@ SUBROUTINE TEST_SUMMARY(QUIET) ENDIF IF(.NOT. PRESENT(QUIET)) THEN - CALL EXIT(FUTF_EXIT_CODE) + ERROR STOP FUTF_EXIT_CODE ENDIF END SUBROUTINE From 5288efe42941bfcd85404da63ff56bac0963680c Mon Sep 17 00:00:00 2001 From: Yen-Chen Chen Date: Mon, 18 Dec 2023 13:54:02 +0100 Subject: [PATCH 04/13] Change kind to selected kind for tests and for the demo project --- examples/demo_project/src/demo_functions.f90 | 6 ++-- src/assertions.f90 | 8 ++--- src/utilities.f90 | 4 +-- tests/test_assertions/test_aequal_int.f90 | 32 ++++++++++---------- tests/test_assertions/test_aequal_real.f90 | 16 +++++----- tests/test_assertions/test_equal_int.f90 | 32 ++++++++++---------- tests/test_assertions/test_equal_real.f90 | 16 +++++----- tests/test_assertions/test_gt_int.f90 | 16 +++++----- tests/test_assertions/test_gt_real.f90 | 8 ++--- tests/test_assertions/test_gteq_int.f90 | 16 +++++----- tests/test_assertions/test_gteq_real.f90 | 8 ++--- tests/test_assertions/test_ischar.f90 | 16 +++++----- tests/test_assertions/test_iscomplex.f90 | 16 +++++----- tests/test_assertions/test_isint.f90 | 12 ++++---- tests/test_assertions/test_isreal.f90 | 12 ++++---- tests/test_assertions/test_lt_int.f90 | 16 +++++----- tests/test_assertions/test_lt_real.f90 | 8 ++--- tests/test_assertions/test_lteq_int.f90 | 16 +++++----- tests/test_assertions/test_lteq_real.f90 | 8 ++--- tests/test_assertions/test_nequal_int.f90 | 16 +++++----- tests/test_assertions/test_nequal_real.f90 | 8 ++--- tests/test_assertions/test_val_in_arr.f90 | 32 ++++++++++---------- 22 files changed, 162 insertions(+), 160 deletions(-) diff --git a/examples/demo_project/src/demo_functions.f90 b/examples/demo_project/src/demo_functions.f90 index e799bd4..5a7ad53 100644 --- a/examples/demo_project/src/demo_functions.f90 +++ b/examples/demo_project/src/demo_functions.f90 @@ -1,6 +1,8 @@ MODULE DEMO_FUNCTIONS IMPLICIT NONE + INTEGER, PARAMETER :: REAL_KIND_8BYTE = SELECTED_REAL_KIND(15, 307) + CONTAINS INTEGER FUNCTION DEMO_FUNC_1(N) @@ -8,8 +10,8 @@ INTEGER FUNCTION DEMO_FUNC_1(N) DEMO_FUNC_1 = N**2-5 END FUNCTION - REAL(8) FUNCTION DEMO_FUNC_2(VAR) - REAL(8), INTENT(IN) :: VAR + REAL(REAL_KIND_8BYTE) FUNCTION DEMO_FUNC_2(VAR) + REAL(REAL_KIND_8BYTE), INTENT(IN) :: VAR DEMO_FUNC_2 = (VAR-4)**2 END FUNCTION diff --git a/src/assertions.f90 b/src/assertions.f90 index 07bf17e..dcceebf 100644 --- a/src/assertions.f90 +++ b/src/assertions.f90 @@ -398,11 +398,11 @@ SUBROUTINE ASSERT_EQUAL_REAL_4BYTE_ARR(REAL_1, REAL_2) IF(COMPARE) THEN CALL REGISTER_PASSED - WRITE(FORMAT_STR, '("(''ASSERT_EQUAL:'', ", I4, "(X, F0.5), '' =='', ", I4, "(X, F0.5))")') SIZE(REAL_1), SIZE(REAL_2) + WRITE(FORMAT_STR, '("(''ASSERT_EQUAL:'', ", I4, "(1X, F0.5), '' =='', ", I4, "(1X, F0.5))")') SIZE(REAL_1), SIZE(REAL_2) WRITE(INFO, FORMAT_STR) REAL_1, REAL_2 ELSE CALL REGISTER_FAILED - WRITE(FORMAT_STR, '("(''ASSERT_EQUAL:'', ", I4, "(X, F0.5), '' !='', ", I4, "(X, F0.5))")') SIZE(REAL_1), SIZE(REAL_2) + WRITE(FORMAT_STR, '("(''ASSERT_EQUAL:'', ", I4, "(1X, F0.5), '' !='', ", I4, "(1X, F0.5))")') SIZE(REAL_1), SIZE(REAL_2) WRITE(INFO, FORMAT_STR) REAL_1, REAL_2 END IF INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) @@ -433,11 +433,11 @@ SUBROUTINE ASSERT_EQUAL_REAL_8BYTE_ARR(REAL_1, REAL_2) IF(COMPARE) THEN CALL REGISTER_PASSED - WRITE(FORMAT_STR, '("(''ASSERT_EQUAL:'', ", I4, "(X, F0.5), '' =='', ", I4, "(X, F0.5))")') SIZE(REAL_1), SIZE(REAL_2) + WRITE(FORMAT_STR, '("(''ASSERT_EQUAL:'', ", I4, "(1X, F0.5), '' =='', ", I4, "(1X, F0.5))")') SIZE(REAL_1), SIZE(REAL_2) WRITE(INFO, FORMAT_STR) REAL_1, REAL_2 ELSE CALL REGISTER_FAILED - WRITE(FORMAT_STR, '("(''ASSERT_EQUAL:'', ", I4, "(X, F0.5), '' !='', ", I4, "(X, F0.5))")') SIZE(REAL_1), SIZE(REAL_2) + WRITE(FORMAT_STR, '("(''ASSERT_EQUAL:'', ", I4, "(1X, F0.5), '' !='', ", I4, "(1X, F0.5))")') SIZE(REAL_1), SIZE(REAL_2) WRITE(INFO, FORMAT_STR) REAL_1, REAL_2 END IF INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) diff --git a/src/utilities.f90 b/src/utilities.f90 index 5dd895d..5b4ac78 100644 --- a/src/utilities.f90 +++ b/src/utilities.f90 @@ -4,8 +4,8 @@ MODULE FUTF_UTILITIES FUNCTION APPEND_CHAR(INPUT_ARRAY, ELEMENT, INT_LEN) RESULT(OUTPUT_ARRAY) INTEGER, INTENT(IN) :: INT_LEN INTEGER :: I, ISIZE - CHARACTER(LEN=INT_LEN), DIMENSION(:), ALLOCATABLE, INTENT(IN) :: INPUT_ARRAY - CHARACTER(LEN=INT_LEN), DIMENSION(:), ALLOCATABLE :: OUTPUT_ARRAY + CHARACTER(LEN=*), DIMENSION(:), ALLOCATABLE, INTENT(IN) :: INPUT_ARRAY + CHARACTER(LEN=*), DIMENSION(:), ALLOCATABLE :: OUTPUT_ARRAY CHARACTER(LEN=INT_LEN), INTENT(IN) :: ELEMENT IF(.NOT. ALLOCATED(INPUT_ARRAY)) THEN diff --git a/tests/test_assertions/test_aequal_int.f90 b/tests/test_assertions/test_aequal_int.f90 index 934031a..48666e0 100644 --- a/tests/test_assertions/test_aequal_int.f90 +++ b/tests/test_assertions/test_aequal_int.f90 @@ -1,7 +1,7 @@ SUBROUTINE TEST_ALMOST_EQUAL_INT_1BYTE USE FORTUTF - INTEGER(1) :: X, Y - REAL(8) :: TOLERANCE + INTEGER(INT_KIND_1BYTE) :: X, Y + REAL(REAL_KIND_8BYTE) :: TOLERANCE X = 2 Y = 3 @@ -15,8 +15,8 @@ END SUBROUTINE TEST_ALMOST_EQUAL_INT_1BYTE SUBROUTINE TEST_FAIL_ALMOST_EQUAL_INT_1BYTE USE FORTUTF - INTEGER(1) :: X, Y - REAL(8) :: TOLERANCE + INTEGER(INT_KIND_1BYTE) :: X, Y + REAL(REAL_KIND_8BYTE) :: TOLERANCE X = 2 Y = 10 @@ -32,8 +32,8 @@ END SUBROUTINE TEST_FAIL_ALMOST_EQUAL_INT_1BYTE SUBROUTINE TEST_ALMOST_EQUAL_INT_2BYTE USE FORTUTF - INTEGER(2) :: X, Y - REAL(8) :: TOLERANCE + INTEGER(INT_KIND_2BYTE) :: X, Y + REAL(REAL_KIND_8BYTE) :: TOLERANCE X = 2 Y = 3 @@ -47,8 +47,8 @@ END SUBROUTINE TEST_ALMOST_EQUAL_INT_2BYTE SUBROUTINE TEST_FAIL_ALMOST_EQUAL_INT_2BYTE USE FORTUTF - INTEGER(2) :: X, Y - REAL(8) :: TOLERANCE + INTEGER(INT_KIND_2BYTE) :: X, Y + REAL(REAL_KIND_8BYTE) :: TOLERANCE X = 2 Y = 20 @@ -64,8 +64,8 @@ END SUBROUTINE TEST_FAIL_ALMOST_EQUAL_INT_2BYTE SUBROUTINE TEST_ALMOST_EQUAL_INT_4BYTE USE FORTUTF - INTEGER(4) :: X, Y - REAL(8) :: TOLERANCE + INTEGER(INT_KIND_4BYTE) :: X, Y + REAL(REAL_KIND_8BYTE) :: TOLERANCE X = 2 Y = 3 @@ -79,8 +79,8 @@ END SUBROUTINE TEST_ALMOST_EQUAL_INT_4BYTE SUBROUTINE TEST_FAIL_ALMOST_EQUAL_INT_4BYTE USE FORTUTF - INTEGER(4) :: X, Y - REAL(8) :: TOLERANCE + INTEGER(INT_KIND_4BYTE) :: X, Y + REAL(REAL_KIND_8BYTE) :: TOLERANCE X = 2 Y = 40 @@ -96,8 +96,8 @@ END SUBROUTINE TEST_FAIL_ALMOST_EQUAL_INT_4BYTE SUBROUTINE TEST_ALMOST_EQUAL_INT_8BYTE USE FORTUTF - INTEGER(8) :: X, Y - REAL(8) :: TOLERANCE + INTEGER(INT_KIND_8BYTE) :: X, Y + REAL(REAL_KIND_8BYTE) :: TOLERANCE X = 2 Y = 3 @@ -111,8 +111,8 @@ END SUBROUTINE TEST_ALMOST_EQUAL_INT_8BYTE SUBROUTINE TEST_FAIL_ALMOST_EQUAL_INT_8BYTE USE FORTUTF - INTEGER(8) :: X, Y - REAL(8) :: TOLERANCE + INTEGER(INT_KIND_8BYTE) :: X, Y + REAL(REAL_KIND_8BYTE) :: TOLERANCE X = 2 Y = 80 diff --git a/tests/test_assertions/test_aequal_real.f90 b/tests/test_assertions/test_aequal_real.f90 index 49a1293..e1f7692 100644 --- a/tests/test_assertions/test_aequal_real.f90 +++ b/tests/test_assertions/test_aequal_real.f90 @@ -1,7 +1,7 @@ SUBROUTINE TEST_ALMOST_EQUAL_REAL_4BYTE USE FORTUTF - REAL(4) :: X, Y - REAL(4) :: TOLERANCE + REAL(REAL_KIND_4BYTE) :: X, Y + REAL(REAL_KIND_4BYTE) :: TOLERANCE X = 2 Y = 3 @@ -15,8 +15,8 @@ END SUBROUTINE TEST_ALMOST_EQUAL_REAL_4BYTE SUBROUTINE TEST_FAIL_ALMOST_EQUAL_REAL_4BYTE USE FORTUTF - REAL(4) :: X, Y - REAL(4) :: TOLERANCE + REAL(REAL_KIND_4BYTE) :: X, Y + REAL(REAL_KIND_4BYTE) :: TOLERANCE X = 2 Y = 4 @@ -32,8 +32,8 @@ END SUBROUTINE TEST_FAIL_ALMOST_EQUAL_REAL_4BYTE SUBROUTINE TEST_ALMOST_EQUAL_REAL_8BYTE USE FORTUTF - REAL(8) :: X, Y - REAL(8) :: TOLERANCE + REAL(REAL_KIND_8BYTE) :: X, Y + REAL(REAL_KIND_8BYTE) :: TOLERANCE X = 2.0 Y = 3.0 @@ -47,8 +47,8 @@ END SUBROUTINE TEST_ALMOST_EQUAL_REAL_8BYTE SUBROUTINE TEST_FAIL_ALMOST_EQUAL_REAL_8BYTE USE FORTUTF - REAL(8) :: X, Y - REAL(8) :: TOLERANCE + REAL(REAL_KIND_8BYTE) :: X, Y + REAL(REAL_KIND_8BYTE) :: TOLERANCE X = 2.0 Y = 80.0 diff --git a/tests/test_assertions/test_equal_int.f90 b/tests/test_assertions/test_equal_int.f90 index 279d4e7..af3afa3 100644 --- a/tests/test_assertions/test_equal_int.f90 +++ b/tests/test_assertions/test_equal_int.f90 @@ -1,6 +1,6 @@ SUBROUTINE TEST_ASSERT_EQ_PASS_INT_1BYTE USE FORTUTF - INTEGER(1) :: X, Y + INTEGER(INT_KIND_1BYTE) :: X, Y X = 4 Y = 4 @@ -16,7 +16,7 @@ END SUBROUTINE TEST_ASSERT_EQ_PASS_INT_1BYTE SUBROUTINE TEST_ASSERT_EQ_PASS_INT_2BYTE USE FORTUTF - INTEGER(2) :: X, Y + INTEGER(INT_KIND_2BYTE) :: X, Y X = 4 Y = 4 @@ -32,7 +32,7 @@ END SUBROUTINE TEST_ASSERT_EQ_PASS_INT_2BYTE SUBROUTINE TEST_ASSERT_EQ_PASS_INT_4BYTE USE FORTUTF - INTEGER(4) :: X, Y + INTEGER(INT_KIND_4BYTE) :: X, Y X = 4 Y = 4 @@ -48,7 +48,7 @@ END SUBROUTINE TEST_ASSERT_EQ_PASS_INT_4BYTE SUBROUTINE TEST_ASSERT_EQ_PASS_INT_8BYTE USE FORTUTF - INTEGER(8) :: X, Y + INTEGER(INT_KIND_8BYTE) :: X, Y X = 4 Y = 4 @@ -63,7 +63,7 @@ END SUBROUTINE TEST_ASSERT_EQ_PASS_INT_8BYTE SUBROUTINE TEST_ASSERT_EQ_FAIL_INT_1BYTE USE FORTUTF - INTEGER(1) :: X, Y + INTEGER(INT_KIND_1BYTE) :: X, Y X = 2 Y = 4 @@ -77,7 +77,7 @@ END SUBROUTINE TEST_ASSERT_EQ_FAIL_INT_1BYTE SUBROUTINE TEST_ASSERT_EQ_FAIL_INT_2BYTE USE FORTUTF - INTEGER(2) :: X, Y + INTEGER(INT_KIND_2BYTE) :: X, Y X = 2 Y = 4 @@ -91,7 +91,7 @@ END SUBROUTINE TEST_ASSERT_EQ_FAIL_INT_2BYTE SUBROUTINE TEST_ASSERT_EQ_FAIL_INT_4BYTE USE FORTUTF - INTEGER(4) :: X, Y + INTEGER(INT_KIND_4BYTE) :: X, Y X = 2 Y = 4 @@ -105,7 +105,7 @@ END SUBROUTINE TEST_ASSERT_EQ_FAIL_INT_4BYTE SUBROUTINE TEST_ASSERT_EQ_FAIL_INT_8BYTE USE FORTUTF - INTEGER(1) :: X, Y + INTEGER(INT_KIND_1BYTE) :: X, Y X = 2 Y = 4 @@ -119,7 +119,7 @@ END SUBROUTINE TEST_ASSERT_EQ_FAIL_INT_8BYTE SUBROUTINE TEST_ASSERT_EQ_PASS_INT_ARR_1BYTE USE FORTUTF - INTEGER(1), DIMENSION(4) :: X, Y + INTEGER(INT_KIND_1BYTE), DIMENSION(4) :: X, Y X = (/1, 2, 3, 4/) Y = (/1, 2, 3, 4/) @@ -134,7 +134,7 @@ END SUBROUTINE TEST_ASSERT_EQ_PASS_INT_ARR_1BYTE SUBROUTINE TEST_ASSERT_EQ_PASS_INT_ARR_2BYTE USE FORTUTF - INTEGER(2), DIMENSION(4) :: X, Y + INTEGER(INT_KIND_2BYTE), DIMENSION(4) :: X, Y X = (/1, 2, 3, 4/) Y = (/1, 2, 3, 4/) @@ -149,7 +149,7 @@ END SUBROUTINE TEST_ASSERT_EQ_PASS_INT_ARR_2BYTE SUBROUTINE TEST_ASSERT_EQ_PASS_INT_ARR_4BYTE USE FORTUTF - INTEGER(4), DIMENSION(4) :: X, Y + INTEGER(INT_KIND_4BYTE), DIMENSION(4) :: X, Y X = (/1, 2, 3, 4/) Y = (/1, 2, 3, 4/) @@ -164,7 +164,7 @@ END SUBROUTINE TEST_ASSERT_EQ_PASS_INT_ARR_4BYTE SUBROUTINE TEST_ASSERT_EQ_PASS_INT_ARR_8BYTE USE FORTUTF - INTEGER(8), DIMENSION(4) :: X, Y + INTEGER(INT_KIND_8BYTE), DIMENSION(4) :: X, Y X = (/1, 2, 3, 4/) Y = (/1, 2, 3, 4/) @@ -179,7 +179,7 @@ END SUBROUTINE TEST_ASSERT_EQ_PASS_INT_ARR_8BYTE SUBROUTINE TEST_ASSERT_EQ_FAIL_INT_ARR_1BYTE USE FORTUTF - INTEGER(1), DIMENSION(4) :: X, Y + INTEGER(INT_KIND_1BYTE), DIMENSION(4) :: X, Y X = (/1, 2, 3, 4/) Y = (/2, 4, 5, 8/) @@ -193,7 +193,7 @@ END SUBROUTINE TEST_ASSERT_EQ_FAIL_INT_ARR_1BYTE SUBROUTINE TEST_ASSERT_EQ_FAIL_INT_ARR_2BYTE USE FORTUTF - INTEGER(2), DIMENSION(4) :: X, Y + INTEGER(INT_KIND_2BYTE), DIMENSION(4) :: X, Y X = (/1, 2, 3, 4/) Y = (/2, 4, 5, 8/) @@ -207,7 +207,7 @@ END SUBROUTINE TEST_ASSERT_EQ_FAIL_INT_ARR_2BYTE SUBROUTINE TEST_ASSERT_EQ_FAIL_INT_ARR_4BYTE USE FORTUTF - INTEGER(4), DIMENSION(4) :: X, Y + INTEGER(INT_KIND_4BYTE), DIMENSION(4) :: X, Y X = (/1, 2, 3, 4/) Y = (/2, 4, 5, 8/) @@ -221,7 +221,7 @@ END SUBROUTINE TEST_ASSERT_EQ_FAIL_INT_ARR_4BYTE SUBROUTINE TEST_ASSERT_EQ_FAIL_INT_ARR_8BYTE USE FORTUTF - INTEGER(8), DIMENSION(4) :: X, Y + INTEGER(INT_KIND_8BYTE), DIMENSION(4) :: X, Y X = (/1, 2, 3, 4/) Y = (/2, 4, 5, 8/) diff --git a/tests/test_assertions/test_equal_real.f90 b/tests/test_assertions/test_equal_real.f90 index 536fb3d..077e8ce 100644 --- a/tests/test_assertions/test_equal_real.f90 +++ b/tests/test_assertions/test_equal_real.f90 @@ -1,6 +1,6 @@ SUBROUTINE TEST_ASSERT_EQ_PASS_REAL_4BYTE USE FORTUTF - REAL(4) :: X, Y + REAL(REAL_KIND_4BYTE) :: X, Y X = 4 Y = 4 @@ -15,7 +15,7 @@ END SUBROUTINE TEST_ASSERT_EQ_PASS_REAL_4BYTE SUBROUTINE TEST_ASSERT_EQ_PASS_REAL_8BYTE USE FORTUTF - REAL(8) :: X, Y + REAL(REAL_KIND_8BYTE) :: X, Y X = 4 Y = 4 @@ -30,7 +30,7 @@ END SUBROUTINE TEST_ASSERT_EQ_PASS_REAL_8BYTE SUBROUTINE TEST_ASSERT_EQ_FAIL_REAL_4BYTE USE FORTUTF - REAL(4) :: X, Y + REAL(REAL_KIND_4BYTE) :: X, Y X = 4 Y = 3 @@ -44,7 +44,7 @@ END SUBROUTINE TEST_ASSERT_EQ_FAIL_REAL_4BYTE SUBROUTINE TEST_ASSERT_EQ_FAIL_REAL_8BYTE USE FORTUTF - REAL(8) :: X, Y + REAL(REAL_KIND_8BYTE) :: X, Y X = 4 Y = 3 @@ -58,7 +58,7 @@ END SUBROUTINE TEST_ASSERT_EQ_FAIL_REAL_8BYTE SUBROUTINE TEST_ASSERT_EQ_PASS_REAL_ARR_4BYTE USE FORTUTF - REAL(4), DIMENSION(4) :: X, Y + REAL(REAL_KIND_4BYTE), DIMENSION(4) :: X, Y X = (/1, 2, 3, 4/) Y = (/1, 2, 3, 4/) @@ -73,7 +73,7 @@ END SUBROUTINE TEST_ASSERT_EQ_PASS_REAL_ARR_4BYTE SUBROUTINE TEST_ASSERT_EQ_PASS_REAL_ARR_8BYTE USE FORTUTF - REAL(8), DIMENSION(4) :: X, Y + REAL(REAL_KIND_8BYTE), DIMENSION(4) :: X, Y X = (/1, 2, 3, 4/) Y = (/1, 2, 3, 4/) @@ -88,7 +88,7 @@ END SUBROUTINE TEST_ASSERT_EQ_PASS_REAL_ARR_8BYTE SUBROUTINE TEST_ASSERT_EQ_FAIL_REAL_ARR_4BYTE USE FORTUTF - REAL(4), DIMENSION(4) :: X, Y + REAL(REAL_KIND_4BYTE), DIMENSION(4) :: X, Y X = (/1, 2, 3, 4/) Y = (/2, 3, 6, 8/) @@ -102,7 +102,7 @@ END SUBROUTINE TEST_ASSERT_EQ_FAIL_REAL_ARR_4BYTE SUBROUTINE TEST_ASSERT_EQ_FAIL_REAL_ARR_8BYTE USE FORTUTF - REAL(8), DIMENSION(4) :: X, Y + REAL(REAL_KIND_8BYTE), DIMENSION(4) :: X, Y X = (/1, 2, 3, 4/) Y = (/2, 4, 6, 8/) diff --git a/tests/test_assertions/test_gt_int.f90 b/tests/test_assertions/test_gt_int.f90 index fb2c0f2..0d8272d 100644 --- a/tests/test_assertions/test_gt_int.f90 +++ b/tests/test_assertions/test_gt_int.f90 @@ -1,6 +1,6 @@ SUBROUTINE TEST_ASSERT_GT_PASS_INT_1BYTE USE FORTUTF - INTEGER(1) :: X, Y + INTEGER(INT_KIND_1BYTE) :: X, Y X = 10 Y = 4 @@ -16,7 +16,7 @@ END SUBROUTINE TEST_ASSERT_GT_PASS_INT_1BYTE SUBROUTINE TEST_ASSERT_GT_PASS_INT_2BYTE USE FORTUTF - INTEGER(2) :: X, Y + INTEGER(INT_KIND_2BYTE) :: X, Y X = 10 Y = 4 @@ -32,7 +32,7 @@ END SUBROUTINE TEST_ASSERT_GT_PASS_INT_2BYTE SUBROUTINE TEST_ASSERT_GT_PASS_INT_4BYTE USE FORTUTF - INTEGER(4) :: X, Y + INTEGER(INT_KIND_4BYTE) :: X, Y X = 10 Y = 4 @@ -48,7 +48,7 @@ END SUBROUTINE TEST_ASSERT_GT_PASS_INT_4BYTE SUBROUTINE TEST_ASSERT_GT_PASS_INT_8BYTE USE FORTUTF - INTEGER(8) :: X, Y + INTEGER(INT_KIND_8BYTE) :: X, Y X = 10 Y = 4 @@ -63,7 +63,7 @@ END SUBROUTINE TEST_ASSERT_GT_PASS_INT_8BYTE SUBROUTINE TEST_ASSERT_GT_FAIL_INT_1BYTE USE FORTUTF - INTEGER(1) :: X, Y + INTEGER(INT_KIND_1BYTE) :: X, Y X = 1 Y = 4 @@ -78,7 +78,7 @@ END SUBROUTINE TEST_ASSERT_GT_FAIL_INT_1BYTE SUBROUTINE TEST_ASSERT_GT_FAIL_INT_2BYTE USE FORTUTF - INTEGER(2) :: X, Y + INTEGER(INT_KIND_2BYTE) :: X, Y X = 1 Y = 4 @@ -93,7 +93,7 @@ END SUBROUTINE TEST_ASSERT_GT_FAIL_INT_2BYTE SUBROUTINE TEST_ASSERT_GT_FAIL_INT_4BYTE USE FORTUTF - INTEGER(4) :: X, Y + INTEGER(INT_KIND_4BYTE) :: X, Y X = 1 Y = 4 @@ -108,7 +108,7 @@ END SUBROUTINE TEST_ASSERT_GT_FAIL_INT_4BYTE SUBROUTINE TEST_ASSERT_GT_FAIL_INT_8BYTE USE FORTUTF - INTEGER(8) :: X, Y + INTEGER(INT_KIND_8BYTE) :: X, Y X = 1 Y = 4 diff --git a/tests/test_assertions/test_gt_real.f90 b/tests/test_assertions/test_gt_real.f90 index 032954e..7a17379 100644 --- a/tests/test_assertions/test_gt_real.f90 +++ b/tests/test_assertions/test_gt_real.f90 @@ -1,6 +1,6 @@ SUBROUTINE TEST_ASSERT_GT_PASS_REAL_4BYTE USE FORTUTF - REAL(4) :: X, Y + REAL(REAL_KIND_4BYTE) :: X, Y X = 10 Y = 4 @@ -15,7 +15,7 @@ END SUBROUTINE TEST_ASSERT_GT_PASS_REAL_4BYTE SUBROUTINE TEST_ASSERT_GT_PASS_REAL_8BYTE USE FORTUTF - REAL(8) :: X, Y + REAL(REAL_KIND_8BYTE) :: X, Y X = 10 Y = 4 @@ -30,7 +30,7 @@ END SUBROUTINE TEST_ASSERT_GT_PASS_REAL_8BYTE SUBROUTINE TEST_ASSERT_GT_FAIL_REAL_4BYTE USE FORTUTF - REAL(4) :: X, Y + REAL(REAL_KIND_4BYTE) :: X, Y X = 1 Y = 4 @@ -44,7 +44,7 @@ END SUBROUTINE TEST_ASSERT_GT_FAIL_REAL_4BYTE SUBROUTINE TEST_ASSERT_GT_FAIL_REAL_8BYTE USE FORTUTF - REAL(8) :: X, Y + REAL(REAL_KIND_8BYTE) :: X, Y X = 1 Y = 4 diff --git a/tests/test_assertions/test_gteq_int.f90 b/tests/test_assertions/test_gteq_int.f90 index d02e288..1023f61 100644 --- a/tests/test_assertions/test_gteq_int.f90 +++ b/tests/test_assertions/test_gteq_int.f90 @@ -1,6 +1,6 @@ SUBROUTINE TEST_ASSERT_GTEQ_PASS_INT_1BYTE USE FORTUTF - INTEGER(1) :: X, Y + INTEGER(INT_KIND_1BYTE) :: X, Y X = 10 Y = 4 @@ -16,7 +16,7 @@ END SUBROUTINE TEST_ASSERT_GTEQ_PASS_INT_1BYTE SUBROUTINE TEST_ASSERT_GTEQ_PASS_INT_2BYTE USE FORTUTF - INTEGER(2) :: X, Y + INTEGER(INT_KIND_2BYTE) :: X, Y X = 10 Y = 4 @@ -32,7 +32,7 @@ END SUBROUTINE TEST_ASSERT_GTEQ_PASS_INT_2BYTE SUBROUTINE TEST_ASSERT_GTEQ_PASS_INT_4BYTE USE FORTUTF - INTEGER(4) :: X, Y + INTEGER(INT_KIND_4BYTE) :: X, Y X = 10 Y = 4 @@ -48,7 +48,7 @@ END SUBROUTINE TEST_ASSERT_GTEQ_PASS_INT_4BYTE SUBROUTINE TEST_ASSERT_GTEQ_PASS_INT_8BYTE USE FORTUTF - INTEGER(8) :: X, Y + INTEGER(INT_KIND_8BYTE) :: X, Y X = 10 Y = 4 @@ -63,7 +63,7 @@ END SUBROUTINE TEST_ASSERT_GTEQ_PASS_INT_8BYTE SUBROUTINE TEST_ASSERT_GTEQ_FAIL_INT_1BYTE USE FORTUTF - INTEGER(1) :: X, Y + INTEGER(INT_KIND_1BYTE) :: X, Y X = 10 Y = 4 @@ -77,7 +77,7 @@ END SUBROUTINE TEST_ASSERT_GTEQ_FAIL_INT_1BYTE SUBROUTINE TEST_ASSERT_GTEQ_FAIL_INT_2BYTE USE FORTUTF - INTEGER(2) :: X, Y + INTEGER(INT_KIND_2BYTE) :: X, Y X = 1 Y = 4 @@ -91,7 +91,7 @@ END SUBROUTINE TEST_ASSERT_GTEQ_FAIL_INT_2BYTE SUBROUTINE TEST_ASSERT_GTEQ_FAIL_INT_4BYTE USE FORTUTF - INTEGER(4) :: X, Y + INTEGER(INT_KIND_4BYTE) :: X, Y X = 1 Y = 4 @@ -105,7 +105,7 @@ END SUBROUTINE TEST_ASSERT_GTEQ_FAIL_INT_4BYTE SUBROUTINE TEST_ASSERT_GTEQ_FAIL_INT_8BYTE USE FORTUTF - INTEGER(8) :: X, Y + INTEGER(INT_KIND_8BYTE) :: X, Y X = 1 Y = 4 diff --git a/tests/test_assertions/test_gteq_real.f90 b/tests/test_assertions/test_gteq_real.f90 index 7e345f2..58a1798 100644 --- a/tests/test_assertions/test_gteq_real.f90 +++ b/tests/test_assertions/test_gteq_real.f90 @@ -1,6 +1,6 @@ SUBROUTINE TEST_ASSERT_GTEQ_PASS_REAL_4BYTE USE FORTUTF - REAL(4) :: X, Y + REAL(REAL_KIND_4BYTE) :: X, Y X = 10 Y = 4 @@ -15,7 +15,7 @@ END SUBROUTINE TEST_ASSERT_GTEQ_PASS_REAL_4BYTE SUBROUTINE TEST_ASSERT_GTEQ_PASS_REAL_8BYTE USE FORTUTF - REAL(8) :: X, Y + REAL(REAL_KIND_8BYTE) :: X, Y X = 10 Y = 4 @@ -30,7 +30,7 @@ END SUBROUTINE TEST_ASSERT_GTEQ_PASS_REAL_8BYTE SUBROUTINE TEST_ASSERT_GTEQ_FAIL_REAL_4BYTE USE FORTUTF - REAL(4) :: X, Y + REAL(REAL_KIND_4BYTE) :: X, Y X = 1 Y = 4 @@ -44,7 +44,7 @@ END SUBROUTINE TEST_ASSERT_GTEQ_FAIL_REAL_4BYTE SUBROUTINE TEST_ASSERT_GTEQ_FAIL_REAL_8BYTE USE FORTUTF - REAL(8) :: X, Y + REAL(REAL_KIND_8BYTE) :: X, Y X = 1 Y = 4 diff --git a/tests/test_assertions/test_ischar.f90 b/tests/test_assertions/test_ischar.f90 index 9a3fd52..7ab3256 100644 --- a/tests/test_assertions/test_ischar.f90 +++ b/tests/test_assertions/test_ischar.f90 @@ -1,6 +1,6 @@ SUBROUTINE TEST_ASSERT_FAIL_INT_IS_CHAR_1BYTE USE FORTUTF - INTEGER(1) :: X + INTEGER(INT_KIND_1BYTE) :: X X = 4 @@ -14,7 +14,7 @@ END SUBROUTINE TEST_ASSERT_FAIL_INT_IS_CHAR_1BYTE SUBROUTINE TEST_ASSERT_FAIL_INT_IS_CHAR_2BYTE USE FORTUTF - INTEGER(2) :: X + INTEGER(INT_KIND_2BYTE) :: X X = 4 @@ -28,7 +28,7 @@ END SUBROUTINE TEST_ASSERT_FAIL_INT_IS_CHAR_2BYTE SUBROUTINE TEST_ASSERT_FAIL_INT_IS_CHAR_4BYTE USE FORTUTF - INTEGER(4) :: X + INTEGER(INT_KIND_4BYTE) :: X X = 4 @@ -42,7 +42,7 @@ END SUBROUTINE TEST_ASSERT_FAIL_INT_IS_CHAR_4BYTE SUBROUTINE TEST_ASSERT_FAIL_INT_IS_CHAR_8BYTE USE FORTUTF - INTEGER(8) :: X + INTEGER(INT_KIND_8BYTE) :: X X = 4 @@ -56,7 +56,7 @@ END SUBROUTINE TEST_ASSERT_FAIL_INT_IS_CHAR_8BYTE SUBROUTINE TEST_FAIL_ASSERT_REAL_IS_CHAR_4BYTE USE FORTUTF - REAL(4) :: X + REAL(REAL_KIND_4BYTE) :: X X = 4 @@ -70,7 +70,7 @@ END SUBROUTINE TEST_FAIL_ASSERT_REAL_IS_CHAR_4BYTE SUBROUTINE TEST_FAIL_ASSERT_REAL_IS_CHAR_8BYTE USE FORTUTF - REAL(8) :: X + REAL(REAL_KIND_8BYTE) :: X X = 4 @@ -84,7 +84,7 @@ END SUBROUTINE TEST_FAIL_ASSERT_REAL_IS_CHAR_8BYTE SUBROUTINE TEST_FAIL_ASSERT_INT_IS_CHAR_4BYTE USE FORTUTF - INTEGER(4) :: X + INTEGER(INT_KIND_4BYTE) :: X X = 4 @@ -98,7 +98,7 @@ END SUBROUTINE TEST_FAIL_ASSERT_INT_IS_CHAR_4BYTE SUBROUTINE TEST_FAIL_ASSERT_INT_IS_CHAR_8BYTE USE FORTUTF - INTEGER(8) :: X + INTEGER(INT_KIND_8BYTE) :: X X = 4 diff --git a/tests/test_assertions/test_iscomplex.f90 b/tests/test_assertions/test_iscomplex.f90 index 8793520..7045bd2 100644 --- a/tests/test_assertions/test_iscomplex.f90 +++ b/tests/test_assertions/test_iscomplex.f90 @@ -1,6 +1,6 @@ SUBROUTINE TEST_FAIL_ASSERT_INT_IS_COMPLEX_1BYTE USE FORTUTF - INTEGER(1) :: X + INTEGER(INT_KIND_1BYTE) :: X X = 4 @@ -14,7 +14,7 @@ END SUBROUTINE TEST_FAIL_ASSERT_INT_IS_COMPLEX_1BYTE SUBROUTINE TEST_FAIL_ASSERT_INT_IS_COMPLEX_2BYTE USE FORTUTF - INTEGER(2) :: X + INTEGER(INT_KIND_2BYTE) :: X X = 4 @@ -28,7 +28,7 @@ END SUBROUTINE TEST_FAIL_ASSERT_INT_IS_COMPLEX_2BYTE SUBROUTINE TEST_ASSERT_INT_IS_COMPLEX_4BYTE USE FORTUTF - INTEGER(4) :: X + INTEGER(INT_KIND_4BYTE) :: X X = 4 @@ -42,7 +42,7 @@ END SUBROUTINE TEST_ASSERT_INT_IS_COMPLEX_4BYTE SUBROUTINE TEST_ASSERT_INT_IS_COMPLEX_8BYTE USE FORTUTF - INTEGER(8) :: X + INTEGER(INT_KIND_8BYTE) :: X X = 4 @@ -56,7 +56,7 @@ END SUBROUTINE TEST_ASSERT_INT_IS_COMPLEX_8BYTE SUBROUTINE TEST_FAIL_ASSERT_REAL_IS_COMPLEX_4BYTE USE FORTUTF - REAL(4) :: X + REAL(REAL_KIND_4BYTE) :: X X = 4 @@ -70,7 +70,7 @@ END SUBROUTINE TEST_FAIL_ASSERT_REAL_IS_COMPLEX_4BYTE SUBROUTINE TEST_FAIL_ASSERT_REAL_IS_COMPLEX_8BYTE USE FORTUTF - REAL(8) :: X + REAL(REAL_KIND_8BYTE) :: X X = 4 @@ -84,7 +84,7 @@ END SUBROUTINE TEST_FAIL_ASSERT_REAL_IS_COMPLEX_8BYTE SUBROUTINE TEST_FAIL_ASSERT_INT_IS_COMPLEX_4BYTE USE FORTUTF - INTEGER(4) :: X + INTEGER(INT_KIND_4BYTE) :: X X = 4 @@ -98,7 +98,7 @@ END SUBROUTINE TEST_FAIL_ASSERT_INT_IS_COMPLEX_4BYTE SUBROUTINE TEST_FAIL_ASSERT_INT_IS_COMPLEX_8BYTE USE FORTUTF - INTEGER(8) :: X + INTEGER(INT_KIND_8BYTE) :: X X = 4 diff --git a/tests/test_assertions/test_isint.f90 b/tests/test_assertions/test_isint.f90 index d7a5cc0..9aef53c 100644 --- a/tests/test_assertions/test_isint.f90 +++ b/tests/test_assertions/test_isint.f90 @@ -1,6 +1,6 @@ SUBROUTINE TEST_ASSERT_INT_IS_INT_1BYTE USE FORTUTF - INTEGER(1) :: X + INTEGER(INT_KIND_1BYTE) :: X X = 4 @@ -14,7 +14,7 @@ END SUBROUTINE TEST_ASSERT_INT_IS_INT_1BYTE SUBROUTINE TEST_ASSERT_INT_IS_INT_2BYTE USE FORTUTF - INTEGER(2) :: X + INTEGER(INT_KIND_2BYTE) :: X X = 4 @@ -26,7 +26,7 @@ END SUBROUTINE TEST_ASSERT_INT_IS_INT_2BYTE SUBROUTINE TEST_ASSERT_INT_IS_INT_4BYTE USE FORTUTF - INTEGER(4) :: X + INTEGER(INT_KIND_4BYTE) :: X X = 4 @@ -36,7 +36,7 @@ END SUBROUTINE TEST_ASSERT_INT_IS_INT_4BYTE SUBROUTINE TEST_ASSERT_INT_IS_INT_8BYTE USE FORTUTF - INTEGER(8) :: X + INTEGER(INT_KIND_8BYTE) :: X X = 4 @@ -46,7 +46,7 @@ END SUBROUTINE TEST_ASSERT_INT_IS_INT_8BYTE SUBROUTINE TEST_FAIL_ASSERT_REAL_IS_INT_4BYTE USE FORTUTF - REAL(4) :: X + REAL(REAL_KIND_4BYTE) :: X X = 4 @@ -60,7 +60,7 @@ END SUBROUTINE TEST_FAIL_ASSERT_REAL_IS_INT_4BYTE SUBROUTINE TEST_FAIL_ASSERT_REAL_IS_INT_8BYTE USE FORTUTF - REAL(8) :: X + REAL(REAL_KIND_8BYTE) :: X X = 4 diff --git a/tests/test_assertions/test_isreal.f90 b/tests/test_assertions/test_isreal.f90 index 55da237..6c063bc 100644 --- a/tests/test_assertions/test_isreal.f90 +++ b/tests/test_assertions/test_isreal.f90 @@ -1,6 +1,6 @@ SUBROUTINE TEST_ASSERT_REAL_IS_REAL_4BYTE USE FORTUTF - REAL(4) :: X + REAL(REAL_KIND_4BYTE) :: X X = 4 @@ -12,7 +12,7 @@ END SUBROUTINE TEST_ASSERT_REAL_IS_REAL_4BYTE SUBROUTINE TEST_ASSERT_REAL_IS_REAL_8BYTE USE FORTUTF - REAL(8) :: X + REAL(REAL_KIND_8BYTE) :: X X = 4 @@ -24,7 +24,7 @@ END SUBROUTINE TEST_ASSERT_REAL_IS_REAL_8BYTE SUBROUTINE TEST_FAIL_ASSERT_INT_IS_REAL_1BYTE USE FORTUTF - INTEGER(1) :: X + INTEGER(INT_KIND_1BYTE) :: X X = 4 @@ -38,7 +38,7 @@ END SUBROUTINE TEST_FAIL_ASSERT_INT_IS_REAL_1BYTE SUBROUTINE TEST_FAIL_ASSERT_INT_IS_REAL_2BYTE USE FORTUTF - INTEGER(2) :: X + INTEGER(INT_KIND_2BYTE) :: X X = 4 @@ -52,7 +52,7 @@ END SUBROUTINE TEST_FAIL_ASSERT_INT_IS_REAL_2BYTE SUBROUTINE TEST_FAIL_ASSERT_INT_IS_REAL_4BYTE USE FORTUTF - INTEGER(4) :: X + INTEGER(INT_KIND_4BYTE) :: X X = 4 @@ -66,7 +66,7 @@ END SUBROUTINE TEST_FAIL_ASSERT_INT_IS_REAL_4BYTE SUBROUTINE TEST_FAIL_ASSERT_INT_IS_REAL_8BYTE USE FORTUTF - INTEGER(8) :: X + INTEGER(INT_KIND_8BYTE) :: X X = 4 diff --git a/tests/test_assertions/test_lt_int.f90 b/tests/test_assertions/test_lt_int.f90 index 0fb4e14..0fcf9b7 100644 --- a/tests/test_assertions/test_lt_int.f90 +++ b/tests/test_assertions/test_lt_int.f90 @@ -1,6 +1,6 @@ SUBROUTINE TEST_ASSERT_LT_PASS_INT_1BYTE USE FORTUTF - INTEGER(1) :: Y, X + INTEGER(INT_KIND_1BYTE) :: Y, X X = 10 Y = 4 @@ -15,7 +15,7 @@ END SUBROUTINE TEST_ASSERT_LT_PASS_INT_1BYTE SUBROUTINE TEST_ASSERT_LT_PASS_INT_2BYTE USE FORTUTF - INTEGER(2) :: Y, X + INTEGER(INT_KIND_2BYTE) :: Y, X X = 10 Y = 4 @@ -30,7 +30,7 @@ END SUBROUTINE TEST_ASSERT_LT_PASS_INT_2BYTE SUBROUTINE TEST_ASSERT_LT_PASS_INT_4BYTE USE FORTUTF - INTEGER(4) :: Y, X + INTEGER(INT_KIND_4BYTE) :: Y, X X = 10 Y = 4 @@ -45,7 +45,7 @@ END SUBROUTINE TEST_ASSERT_LT_PASS_INT_4BYTE SUBROUTINE TEST_ASSERT_LT_PASS_INT_8BYTE USE FORTUTF - INTEGER(8) :: Y, X + INTEGER(INT_KIND_8BYTE) :: Y, X X = 10 Y = 4 @@ -60,7 +60,7 @@ END SUBROUTINE TEST_ASSERT_LT_PASS_INT_8BYTE SUBROUTINE TEST_ASSERT_LT_FAIL_INT_1BYTE USE FORTUTF - INTEGER(1) :: Y, X + INTEGER(INT_KIND_1BYTE) :: Y, X X = 1 Y = 4 @@ -74,7 +74,7 @@ END SUBROUTINE TEST_ASSERT_LT_FAIL_INT_1BYTE SUBROUTINE TEST_ASSERT_LT_FAIL_INT_2BYTE USE FORTUTF - INTEGER(2) :: Y, X + INTEGER(INT_KIND_2BYTE) :: Y, X X = 1 Y = 4 @@ -88,7 +88,7 @@ END SUBROUTINE TEST_ASSERT_LT_FAIL_INT_2BYTE SUBROUTINE TEST_ASSERT_LT_FAIL_INT_4BYTE USE FORTUTF - INTEGER(4) :: Y, X + INTEGER(INT_KIND_4BYTE) :: Y, X X = 1 Y = 4 @@ -102,7 +102,7 @@ END SUBROUTINE TEST_ASSERT_LT_FAIL_INT_4BYTE SUBROUTINE TEST_ASSERT_LT_FAIL_INT_8BYTE USE FORTUTF - INTEGER(8) :: Y, X + INTEGER(INT_KIND_8BYTE) :: Y, X X = 1 Y = 4 diff --git a/tests/test_assertions/test_lt_real.f90 b/tests/test_assertions/test_lt_real.f90 index 02c949b..58e9c23 100644 --- a/tests/test_assertions/test_lt_real.f90 +++ b/tests/test_assertions/test_lt_real.f90 @@ -1,6 +1,6 @@ SUBROUTINE TEST_ASSERT_LT_PASS_REAL_4BYTE USE FORTUTF - REAL(4) :: Y, X + REAL(REAL_KIND_4BYTE) :: Y, X X = 10 Y = 4 @@ -15,7 +15,7 @@ END SUBROUTINE TEST_ASSERT_LT_PASS_REAL_4BYTE SUBROUTINE TEST_ASSERT_LT_PASS_REAL_8BYTE USE FORTUTF - REAL(8) :: Y, X + REAL(REAL_KIND_8BYTE) :: Y, X X = 10 Y = 4 @@ -30,7 +30,7 @@ END SUBROUTINE TEST_ASSERT_LT_PASS_REAL_8BYTE SUBROUTINE TEST_ASSERT_LT_FAIL_REAL_4BYTE USE FORTUTF - REAL(4) :: Y, X + REAL(REAL_KIND_4BYTE) :: Y, X X = 1 Y = 4 @@ -44,7 +44,7 @@ END SUBROUTINE TEST_ASSERT_LT_FAIL_REAL_4BYTE SUBROUTINE TEST_ASSERT_LT_FAIL_REAL_8BYTE USE FORTUTF - REAL(8) :: Y, X + REAL(REAL_KIND_8BYTE) :: Y, X X = 1 Y = 4 diff --git a/tests/test_assertions/test_lteq_int.f90 b/tests/test_assertions/test_lteq_int.f90 index 86cebf3..caf0dc4 100644 --- a/tests/test_assertions/test_lteq_int.f90 +++ b/tests/test_assertions/test_lteq_int.f90 @@ -1,6 +1,6 @@ SUBROUTINE TEST_ASSERT_LTEQ_PASS_INT_1BYTE USE FORTUTF - INTEGER(1) :: Y, X + INTEGER(INT_KIND_1BYTE) :: Y, X X = 10 Y = 4 @@ -16,7 +16,7 @@ END SUBROUTINE TEST_ASSERT_LTEQ_PASS_INT_1BYTE SUBROUTINE TEST_ASSERT_LTEQ_PASS_INT_2BYTE USE FORTUTF - INTEGER(2) :: Y, X + INTEGER(INT_KIND_2BYTE) :: Y, X X = 10 Y = 4 @@ -32,7 +32,7 @@ END SUBROUTINE TEST_ASSERT_LTEQ_PASS_INT_2BYTE SUBROUTINE TEST_ASSERT_LTEQ_PASS_INT_4BYTE USE FORTUTF - INTEGER(4) :: Y, X + INTEGER(INT_KIND_4BYTE) :: Y, X X = 10 Y = 4 @@ -48,7 +48,7 @@ END SUBROUTINE TEST_ASSERT_LTEQ_PASS_INT_4BYTE SUBROUTINE TEST_ASSERT_LTEQ_PASS_INT_8BYTE USE FORTUTF - INTEGER(8) :: Y, X + INTEGER(INT_KIND_8BYTE) :: Y, X X = 10 Y = 4 @@ -63,7 +63,7 @@ END SUBROUTINE TEST_ASSERT_LTEQ_PASS_INT_8BYTE SUBROUTINE TEST_ASSERT_LTEQ_FAIL_INT_1BYTE USE FORTUTF - INTEGER(1) :: Y, X + INTEGER(INT_KIND_1BYTE) :: Y, X X = 1 Y = 4 @@ -78,7 +78,7 @@ END SUBROUTINE TEST_ASSERT_LTEQ_FAIL_INT_1BYTE SUBROUTINE TEST_ASSERT_LTEQ_FAIL_INT_2BYTE USE FORTUTF - INTEGER(2) :: Y, X + INTEGER(INT_KIND_2BYTE) :: Y, X X = 1 Y = 4 @@ -93,7 +93,7 @@ END SUBROUTINE TEST_ASSERT_LTEQ_FAIL_INT_2BYTE SUBROUTINE TEST_ASSERT_LTEQ_FAIL_INT_4BYTE USE FORTUTF - INTEGER(4) :: Y, X + INTEGER(INT_KIND_4BYTE) :: Y, X X = 1 Y = 4 @@ -108,7 +108,7 @@ END SUBROUTINE TEST_ASSERT_LTEQ_FAIL_INT_4BYTE SUBROUTINE TEST_ASSERT_LTEQ_FAIL_INT_8BYTE USE FORTUTF - INTEGER(8) :: Y, X + INTEGER(INT_KIND_8BYTE) :: Y, X X = 1 Y = 4 diff --git a/tests/test_assertions/test_lteq_real.f90 b/tests/test_assertions/test_lteq_real.f90 index 85fcde0..cf80a84 100644 --- a/tests/test_assertions/test_lteq_real.f90 +++ b/tests/test_assertions/test_lteq_real.f90 @@ -1,6 +1,6 @@ SUBROUTINE TEST_ASSERT_LTEQ_PASS_REAL_4BYTE USE FORTUTF - REAL(4) :: Y, X + REAL(REAL_KIND_4BYTE) :: Y, X X = 10 Y = 4 @@ -15,7 +15,7 @@ END SUBROUTINE TEST_ASSERT_LTEQ_PASS_REAL_4BYTE SUBROUTINE TEST_ASSERT_LTEQ_PASS_REAL_8BYTE USE FORTUTF - REAL(8) :: Y, X + REAL(REAL_KIND_8BYTE) :: Y, X X = 10 Y = 4 @@ -30,7 +30,7 @@ END SUBROUTINE TEST_ASSERT_LTEQ_PASS_REAL_8BYTE SUBROUTINE TEST_ASSERT_LTEQ_FAIL_REAL_4BYTE USE FORTUTF - REAL(4) :: Y, X + REAL(REAL_KIND_4BYTE) :: Y, X X = 1 Y = 4 @@ -44,7 +44,7 @@ END SUBROUTINE TEST_ASSERT_LTEQ_FAIL_REAL_4BYTE SUBROUTINE TEST_ASSERT_LTEQ_FAIL_REAL_8BYTE USE FORTUTF - REAL(8) :: Y, X + REAL(REAL_KIND_8BYTE) :: Y, X X = 1 Y = 4 diff --git a/tests/test_assertions/test_nequal_int.f90 b/tests/test_assertions/test_nequal_int.f90 index 394926e..deddb17 100644 --- a/tests/test_assertions/test_nequal_int.f90 +++ b/tests/test_assertions/test_nequal_int.f90 @@ -1,6 +1,6 @@ SUBROUTINE TEST_ASSERT_NEQ_PASS_INT_1BYTE USE FORTUTF - INTEGER(1) :: X, Y + INTEGER(INT_KIND_1BYTE) :: X, Y X = 2 Y = 4 @@ -15,7 +15,7 @@ END SUBROUTINE TEST_ASSERT_NEQ_PASS_INT_1BYTE SUBROUTINE TEST_ASSERT_NEQ_PASS_INT_2BYTE USE FORTUTF - INTEGER(2) :: X, Y + INTEGER(INT_KIND_2BYTE) :: X, Y X = 2 Y = 4 @@ -30,7 +30,7 @@ END SUBROUTINE TEST_ASSERT_NEQ_PASS_INT_2BYTE SUBROUTINE TEST_ASSERT_NEQ_PASS_INT_4BYTE USE FORTUTF - INTEGER(4) :: X, Y + INTEGER(INT_KIND_4BYTE) :: X, Y X = 2 Y = 4 @@ -45,7 +45,7 @@ END SUBROUTINE TEST_ASSERT_NEQ_PASS_INT_4BYTE SUBROUTINE TEST_ASSERT_NEQ_PASS_INT_8BYTE USE FORTUTF - INTEGER(8) :: X, Y + INTEGER(INT_KIND_8BYTE) :: X, Y X = 2 Y = 4 @@ -60,7 +60,7 @@ END SUBROUTINE TEST_ASSERT_NEQ_PASS_INT_8BYTE SUBROUTINE TEST_ASSERT_NEQ_FAIL_INT_1BYTE USE FORTUTF - INTEGER(1) :: X, Y + INTEGER(INT_KIND_1BYTE) :: X, Y X = 4 Y = 4 @@ -74,7 +74,7 @@ END SUBROUTINE TEST_ASSERT_NEQ_FAIL_INT_1BYTE SUBROUTINE TEST_ASSERT_NEQ_FAIL_INT_2BYTE USE FORTUTF - INTEGER(2) :: X, Y + INTEGER(INT_KIND_2BYTE) :: X, Y X = 4 Y = 4 @@ -88,7 +88,7 @@ END SUBROUTINE TEST_ASSERT_NEQ_FAIL_INT_2BYTE SUBROUTINE TEST_ASSERT_NEQ_FAIL_INT_4BYTE USE FORTUTF - INTEGER(4) :: X, Y + INTEGER(INT_KIND_4BYTE) :: X, Y X = 4 Y = 4 @@ -102,7 +102,7 @@ END SUBROUTINE TEST_ASSERT_NEQ_FAIL_INT_4BYTE SUBROUTINE TEST_ASSERT_NEQ_FAIL_INT_8BYTE USE FORTUTF - INTEGER(8) :: X, Y + INTEGER(INT_KIND_8BYTE) :: X, Y X = 4 Y = 4 diff --git a/tests/test_assertions/test_nequal_real.f90 b/tests/test_assertions/test_nequal_real.f90 index ce3f327..2341213 100644 --- a/tests/test_assertions/test_nequal_real.f90 +++ b/tests/test_assertions/test_nequal_real.f90 @@ -1,7 +1,7 @@ SUBROUTINE TEST_ASSERT_NEQ_PASS_REAL_4BYTE USE FORTUTF - REAL(4) :: X, Y + REAL(REAL_KIND_4BYTE) :: X, Y X = 2 Y = 4 @@ -17,7 +17,7 @@ END SUBROUTINE TEST_ASSERT_NEQ_PASS_REAL_4BYTE SUBROUTINE TEST_ASSERT_NEQ_PASS_REAL_8BYTE USE FORTUTF - REAL(8) :: X, Y + REAL(REAL_KIND_8BYTE) :: X, Y X = 2 Y = 4 @@ -33,7 +33,7 @@ END SUBROUTINE TEST_ASSERT_NEQ_PASS_REAL_8BYTE SUBROUTINE TEST_ASSERT_NEQ_FAIL_REAL_4BYTE USE FORTUTF - REAL(4) :: X, Y + REAL(REAL_KIND_4BYTE) :: X, Y X = 4 Y = 4 @@ -48,7 +48,7 @@ END SUBROUTINE TEST_ASSERT_NEQ_FAIL_REAL_4BYTE SUBROUTINE TEST_ASSERT_NEQ_FAIL_REAL_8BYTE USE FORTUTF - REAL(8) :: X, Y + REAL(REAL_KIND_8BYTE) :: X, Y X = 4 Y = 4 diff --git a/tests/test_assertions/test_val_in_arr.f90 b/tests/test_assertions/test_val_in_arr.f90 index 323970b..aa9c599 100644 --- a/tests/test_assertions/test_val_in_arr.f90 +++ b/tests/test_assertions/test_val_in_arr.f90 @@ -1,8 +1,8 @@ SUBROUTINE TEST_ASSERT_INT_IN_ARR_1BYTE USE FORTUTF - INTEGER(1), DIMENSION(5) :: ARRAY - INTEGER(1) :: VAL = 2 + INTEGER(INT_KIND_1BYTE), DIMENSION(5) :: ARRAY + INTEGER(INT_KIND_1BYTE) :: VAL = 2 ARRAY = (/1, 2, 3, 4, 5/) @@ -15,8 +15,8 @@ END SUBROUTINE TEST_ASSERT_INT_IN_ARR_1BYTE SUBROUTINE TEST_ASSERT_INT_IN_ARR_2BYTE USE FORTUTF - INTEGER(2), DIMENSION(5) :: ARRAY - INTEGER(2) :: VAL = 2 + INTEGER(INT_KIND_2BYTE), DIMENSION(5) :: ARRAY + INTEGER(INT_KIND_2BYTE) :: VAL = 2 ARRAY = (/1, 2, 3, 4, 5/) @@ -29,8 +29,8 @@ END SUBROUTINE TEST_ASSERT_INT_IN_ARR_2BYTE SUBROUTINE TEST_ASSERT_INT_IN_ARR_4BYTE USE FORTUTF - INTEGER(4), DIMENSION(5) :: ARRAY - INTEGER(4) :: VAL = 2 + INTEGER(INT_KIND_4BYTE), DIMENSION(5) :: ARRAY + INTEGER(INT_KIND_4BYTE) :: VAL = 2 ARRAY = (/1, 2, 3, 4, 5/) @@ -43,8 +43,8 @@ END SUBROUTINE TEST_ASSERT_INT_IN_ARR_4BYTE SUBROUTINE TEST_ASSERT_INT_IN_ARR_8BYTE USE FORTUTF - INTEGER(8), DIMENSION(5) :: ARRAY - INTEGER(8) :: VAL = 2 + INTEGER(INT_KIND_8BYTE), DIMENSION(5) :: ARRAY + INTEGER(INT_KIND_8BYTE) :: VAL = 2 ARRAY = (/1, 2, 3, 4, 5/) @@ -57,8 +57,8 @@ END SUBROUTINE TEST_ASSERT_INT_IN_ARR_8BYTE SUBROUTINE TEST_FAIL_ASSERT_INT_IN_ARR_1BYTE USE FORTUTF - INTEGER(1), DIMENSION(5) :: ARRAY - INTEGER(1) :: VAL = 12 + INTEGER(INT_KIND_1BYTE), DIMENSION(5) :: ARRAY + INTEGER(INT_KIND_1BYTE) :: VAL = 12 ARRAY = (/1, 2, 3, 4, 5/) @@ -73,8 +73,8 @@ END SUBROUTINE TEST_FAIL_ASSERT_INT_IN_ARR_1BYTE SUBROUTINE TEST_FAIL_ASSERT_INT_IN_ARR_2BYTE USE FORTUTF - INTEGER(2), DIMENSION(5) :: ARRAY - INTEGER(2) :: VAL = 12 + INTEGER(INT_KIND_2BYTE), DIMENSION(5) :: ARRAY + INTEGER(INT_KIND_2BYTE) :: VAL = 12 ARRAY = (/1, 2, 3, 4, 5/) @@ -89,8 +89,8 @@ END SUBROUTINE TEST_FAIL_ASSERT_INT_IN_ARR_2BYTE SUBROUTINE TEST_FAIL_ASSERT_INT_IN_ARR_4BYTE USE FORTUTF - INTEGER(4), DIMENSION(5) :: ARRAY - INTEGER(4) :: VAL = 12 + INTEGER(INT_KIND_4BYTE), DIMENSION(5) :: ARRAY + INTEGER(INT_KIND_4BYTE) :: VAL = 12 ARRAY = (/1, 2, 3, 4, 5/) @@ -105,8 +105,8 @@ END SUBROUTINE TEST_FAIL_ASSERT_INT_IN_ARR_4BYTE SUBROUTINE TEST_FAIL_ASSERT_INT_IN_ARR_8BYTE USE FORTUTF - INTEGER(8), DIMENSION(5) :: ARRAY - INTEGER(8) :: VAL = 12 + INTEGER(INT_KIND_8BYTE), DIMENSION(5) :: ARRAY + INTEGER(INT_KIND_8BYTE) :: VAL = 12 ARRAY = (/1, 2, 3, 4, 5/) From 3a4cff4854106500124b54e8181fc069cc01edba Mon Sep 17 00:00:00 2001 From: Yen-Chen Chen Date: Mon, 18 Dec 2023 14:39:13 +0100 Subject: [PATCH 05/13] Fix exit again --- src/suite.f90 | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/suite.f90 b/src/suite.f90 index ee7711b..ed000ac 100644 --- a/src/suite.f90 +++ b/src/suite.f90 @@ -112,7 +112,9 @@ SUBROUTINE TEST_SUMMARY(QUIET) ENDIF IF(.NOT. PRESENT(QUIET)) THEN - ERROR STOP FUTF_EXIT_CODE + IF(FUTF_EXIT_CODE == 1) THEN + STOP + ENDIF ENDIF END SUBROUTINE From 790763c7331fa76dead8ac68a4066bfc7ddfc08b Mon Sep 17 00:00:00 2001 From: Yen-Chen Chen Date: Mon, 18 Dec 2023 14:39:53 +0100 Subject: [PATCH 06/13] Fix INFO length is wrong bug --- src/specials.f90 | 4 ++-- src/utilities.f90 | 4 ++-- tests/test_suite/test_failing.f90 | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/specials.f90 b/src/specials.f90 index 40ab9e7..872e6d9 100644 --- a/src/specials.f90 +++ b/src/specials.f90 @@ -7,14 +7,14 @@ MODULE FUTF_SPECIALS CONTAINS SUBROUTINE FAIL - CHARACTER(LEN=100) :: INFO + CHARACTER(LEN=300) :: INFO WRITE(INFO, *) "RETURN FAIL" CALL REGISTER_FAILED INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE FAIL SUBROUTINE SUCCEED - CHARACTER(LEN=100) :: INFO + CHARACTER(LEN=300) :: INFO WRITE(INFO, *) "RETURN SUCCEED" CALL REGISTER_PASSED INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) diff --git a/src/utilities.f90 b/src/utilities.f90 index 5b4ac78..5dd895d 100644 --- a/src/utilities.f90 +++ b/src/utilities.f90 @@ -4,8 +4,8 @@ MODULE FUTF_UTILITIES FUNCTION APPEND_CHAR(INPUT_ARRAY, ELEMENT, INT_LEN) RESULT(OUTPUT_ARRAY) INTEGER, INTENT(IN) :: INT_LEN INTEGER :: I, ISIZE - CHARACTER(LEN=*), DIMENSION(:), ALLOCATABLE, INTENT(IN) :: INPUT_ARRAY - CHARACTER(LEN=*), DIMENSION(:), ALLOCATABLE :: OUTPUT_ARRAY + CHARACTER(LEN=INT_LEN), DIMENSION(:), ALLOCATABLE, INTENT(IN) :: INPUT_ARRAY + CHARACTER(LEN=INT_LEN), DIMENSION(:), ALLOCATABLE :: OUTPUT_ARRAY CHARACTER(LEN=INT_LEN), INTENT(IN) :: ELEMENT IF(.NOT. ALLOCATED(INPUT_ARRAY)) THEN diff --git a/tests/test_suite/test_failing.f90 b/tests/test_suite/test_failing.f90 index 873352b..00fef06 100644 --- a/tests/test_suite/test_failing.f90 +++ b/tests/test_suite/test_failing.f90 @@ -1,7 +1,7 @@ SUBROUTINE TEST_FAIL_METHOD USE FORTUTF CHARACTER(LEN=1) :: PASS - CHARACTER(LEN=100) :: INFO + CHARACTER(LEN=300) :: INFO CALL TAG_TEST("TEST_FAILS_CORRECTLY") @@ -23,7 +23,7 @@ END SUBROUTINE TEST_FAIL_METHOD SUBROUTINE TEST_REGISTER_FAILED USE FORTUTF CHARACTER(LEN=1) :: PASS - CHARACTER(LEN=100) :: INFO + CHARACTER(LEN=300) :: INFO CALL TAG_TEST("TEST_REGISTER_FAILED") From 8cc36d727768307d83ad7ed2e65e5959e5186a78 Mon Sep 17 00:00:00 2001 From: Yen-Chen Chen Date: Mon, 18 Dec 2023 14:45:41 +0100 Subject: [PATCH 07/13] Work around GNU specific flags --- CMakeLists.txt | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index d6d0cd2..6e02efd 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -33,7 +33,11 @@ if(NOT BUILD_TESTS) endif() if(BUILD_TESTS) - set(CMAKE_Fortran_FLAGS "-Wall -Wextra -Wno-compare-reals -Wno-maybe-uninitialized -Wno-uninitialized -O3 -g -fprofile-arcs -ftest-coverage") + if(CMAKE_Fortran_COMPILER_ID STREQUAL "GNU") + set(CMAKE_Fortran_FLAGS "-Wall -Wextra -Wno-compare-reals -Wno-maybe-uninitialized -Wno-uninitialized -O3 -g -fprofile-arcs -ftest-coverage") + else() + set(CMAKE_Fortran_FLAGS "-O3") + endif() include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/fortutf.cmake) set(FORTUTF_PROJECT_TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR}/tests) set(FORTUTF_PROJECT_TEST_FILES ${CMAKE_SOURCE_DIR}/tests/test_suite/unfinished_test_check.f90) From f41ce007988cf04e2e3f614d1d20d7ff6b8728a1 Mon Sep 17 00:00:00 2001 From: Yen-Chen Chen Date: Thu, 28 Dec 2023 20:37:33 +0100 Subject: [PATCH 08/13] Set 'W>=D+7' to avoid intel warning --- src/assertions.f90 | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/assertions.f90 b/src/assertions.f90 index dcceebf..3f1b9e1 100644 --- a/src/assertions.f90 +++ b/src/assertions.f90 @@ -510,10 +510,10 @@ SUBROUTINE ASSERT_ALMOST_EQUAL_INT_1BYTE(INT_1, INT_2, REL_TOL) IF(PASSES) THEN CALL REGISTER_PASSED - WRITE(INFO, '(A, I0, A, I0, A, E10.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") < ", TOLERANCE + WRITE(INFO, '(A, I0, A, I0, A, E12.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") < ", TOLERANCE ELSE CALL REGISTER_FAILED - WRITE(INFO, '(A, I0, A, I0, A, E10.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") > ", TOLERANCE + WRITE(INFO, '(A, I0, A, I0, A, E12.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") > ", TOLERANCE ENDIF INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_ALMOST_EQUAL_INT_1BYTE @@ -541,10 +541,10 @@ SUBROUTINE ASSERT_ALMOST_EQUAL_INT_2BYTE(INT_1, INT_2, REL_TOL) IF(PASSES) THEN CALL REGISTER_PASSED - WRITE(INFO, '(A, I0, A, I0, A, E10.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") < ", TOLERANCE + WRITE(INFO, '(A, I0, A, I0, A, E12.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") < ", TOLERANCE ELSE CALL REGISTER_FAILED - WRITE(INFO, '(A, I0, A, I0, A, E10.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") > ", TOLERANCE + WRITE(INFO, '(A, I0, A, I0, A, E12.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") > ", TOLERANCE ENDIF INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_ALMOST_EQUAL_INT_2BYTE @@ -572,10 +572,10 @@ SUBROUTINE ASSERT_ALMOST_EQUAL_INT_4BYTE(INT_1, INT_2, REL_TOL) IF(PASSES) THEN CALL REGISTER_PASSED - WRITE(INFO, '(A, I0, A, I0, A, E10.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") < ", TOLERANCE + WRITE(INFO, '(A, I0, A, I0, A, E12.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") < ", TOLERANCE ELSE CALL REGISTER_FAILED - WRITE(INFO, '(A, I0, A, I0, A, E10.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") > ", TOLERANCE + WRITE(INFO, '(A, I0, A, I0, A, E12.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") > ", TOLERANCE ENDIF INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_ALMOST_EQUAL_INT_4BYTE @@ -603,10 +603,10 @@ SUBROUTINE ASSERT_ALMOST_EQUAL_INT_8BYTE(INT_1, INT_2, REL_TOL) IF(PASSES) THEN CALL REGISTER_PASSED - WRITE(INFO, '(A, I0, A, I0, A, E10.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") < ", TOLERANCE + WRITE(INFO, '(A, I0, A, I0, A, E12.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") < ", TOLERANCE ELSE CALL REGISTER_FAILED - WRITE(INFO, '(A, I0, A, I0, A, E10.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") > ", TOLERANCE + WRITE(INFO, '(A, I0, A, I0, A, E12.5)') "ASSERT_ALMOST_EQUAL: ABS(", INT_1, " - ", INT_2, ") > ", TOLERANCE ENDIF INFO_STRINGS = APPEND_CHAR(INFO_STRINGS, INFO, LEN(INFO)) END SUBROUTINE ASSERT_ALMOST_EQUAL_INT_8BYTE From 212291bc644e55aae083647d4c0908fea1cffc1a Mon Sep 17 00:00:00 2001 From: Yen-Chen Chen Date: Thu, 28 Dec 2023 20:37:48 +0100 Subject: [PATCH 09/13] Add missing assertions --- tests/test_assertions/test_isint.f90 | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tests/test_assertions/test_isint.f90 b/tests/test_assertions/test_isint.f90 index 9aef53c..2bf8121 100644 --- a/tests/test_assertions/test_isint.f90 +++ b/tests/test_assertions/test_isint.f90 @@ -32,6 +32,8 @@ SUBROUTINE TEST_ASSERT_INT_IS_INT_4BYTE CALL TAG_TEST("TEST_ASSERT_INT_IS_INT_4BYTE") + CALL ASSERT_IS_INT(X) + END SUBROUTINE TEST_ASSERT_INT_IS_INT_4BYTE SUBROUTINE TEST_ASSERT_INT_IS_INT_8BYTE @@ -42,6 +44,8 @@ SUBROUTINE TEST_ASSERT_INT_IS_INT_8BYTE CALL TAG_TEST("TEST_ASSERT_INT_IS_INT_8BYTE") + CALL ASSERT_IS_INT(X) + END SUBROUTINE TEST_ASSERT_INT_IS_INT_8BYTE SUBROUTINE TEST_FAIL_ASSERT_REAL_IS_INT_4BYTE From b1a6a030e4d249d9676f905b359df4601586f8c1 Mon Sep 17 00:00:00 2001 From: Yen-Chen Chen Date: Thu, 28 Dec 2023 20:58:07 +0100 Subject: [PATCH 10/13] Add workflow CI for intel compiler --- .github/workflows/futs_intel.yml | 45 ++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 .github/workflows/futs_intel.yml diff --git a/.github/workflows/futs_intel.yml b/.github/workflows/futs_intel.yml new file mode 100644 index 0000000..6399d0b --- /dev/null +++ b/.github/workflows/futs_intel.yml @@ -0,0 +1,45 @@ +name: FortUTF Ubuntu Intel 22 + +on: [push] + +jobs: + build: + name: Intel Latest Tests + runs-on: 'ubuntu-22.04' + steps: + - uses: actions/checkout@v3 + - name: Setup cmake + uses: jwlawson/actions-setup-cmake@v1.14 + with: + cmake-version: '3.27.x' + - name: Install Intel ifort compiler + run: | + curl -Lo- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | sudo gpg --dearmor -o /usr/share/keyrings/oneapi-archive-keyring.gpg + sudo tee /etc/apt/sources.list.d/oneAPI.list <<< "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" + sudo apt update + sudo apt install intel-oneapi-compiler-fortran + - name: Build Tests + run: | + ifort --version + cmake -H. -Bbuild -DBUILD_TESTS=ON -DCMAKE_Fortran_COMPILER=ifort + cmake --build build + - name: Run Tests + run: | + ./build/FortUTF_Tests + if [ $? -eq 0 ]; then + echo "Unit Tests completed successfully" + exit 0 + else + echo "Unit Tests failed" + exit 1 + fi + - name: Run Test List + run: | + ./build/FortUTF_Tests TEST_FAIL_EQUAL_CHAR TEST_EQUAL_CHAR + if [ $? -eq 0 ]; then + echo "Unit Tests completed succesfully" + exit 0 + else + echo "Unit Tests failed" + exit 1 + fi From 6d996d70e25926580deb8c27f25b0564dea5c839 Mon Sep 17 00:00:00 2001 From: Yen-Chen Chen Date: Thu, 28 Dec 2023 21:07:40 +0100 Subject: [PATCH 11/13] Update futs_intel.yml --- .github/workflows/futs_intel.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/futs_intel.yml b/.github/workflows/futs_intel.yml index 6399d0b..699fa6f 100644 --- a/.github/workflows/futs_intel.yml +++ b/.github/workflows/futs_intel.yml @@ -1,4 +1,4 @@ -name: FortUTF Ubuntu Intel 22 +name: FortUTF Ubuntu Intel on: [push] @@ -18,6 +18,7 @@ jobs: sudo tee /etc/apt/sources.list.d/oneAPI.list <<< "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" sudo apt update sudo apt install intel-oneapi-compiler-fortran + source /opt/intel/oneapi/setvars.sh - name: Build Tests run: | ifort --version From e1bd3f02e6c679a7b108450a972291c67e94a4cf Mon Sep 17 00:00:00 2001 From: Yen-Chen Chen Date: Thu, 28 Dec 2023 21:15:19 +0100 Subject: [PATCH 12/13] Update futs_intel.yml --- .github/workflows/futs_intel.yml | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/.github/workflows/futs_intel.yml b/.github/workflows/futs_intel.yml index 699fa6f..68b2ed9 100644 --- a/.github/workflows/futs_intel.yml +++ b/.github/workflows/futs_intel.yml @@ -12,13 +12,12 @@ jobs: uses: jwlawson/actions-setup-cmake@v1.14 with: cmake-version: '3.27.x' - - name: Install Intel ifort compiler - run: | - curl -Lo- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | sudo gpg --dearmor -o /usr/share/keyrings/oneapi-archive-keyring.gpg - sudo tee /etc/apt/sources.list.d/oneAPI.list <<< "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" - sudo apt update - sudo apt install intel-oneapi-compiler-fortran - source /opt/intel/oneapi/setvars.sh + - name: Setup Intel ifort compiler + uses: fortran-lang/setup-fortran@v1 + id: setup-fortran + with: + compiler: intel + version: '2023.2' - name: Build Tests run: | ifort --version From 322e139cf7a80b96cca2392b8a4cf47c2943e3e6 Mon Sep 17 00:00:00 2001 From: Yen-Chen Chen Date: Thu, 28 Dec 2023 21:19:27 +0100 Subject: [PATCH 13/13] Add intel version to name --- .github/workflows/futs_intel.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/futs_intel.yml b/.github/workflows/futs_intel.yml index 68b2ed9..9d98fc1 100644 --- a/.github/workflows/futs_intel.yml +++ b/.github/workflows/futs_intel.yml @@ -1,4 +1,4 @@ -name: FortUTF Ubuntu Intel +name: FortUTF Ubuntu Intel 2023 on: [push]