nanocoat/tests/src/unit.c

   1 /* -*- Mode: C; indent-tabs-mode: t; tab-width: 4 -*-
   2 // ---------------------------------------------------------------------------
   3 // SquirrelJME
   4 //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
   5 // ---------------------------------------------------------------------------
   6 // SquirrelJME is under the Mozilla Public License Version 2.0.
   7 // See license.mkd for licensing and copyright information.
   8 // -------------------------------------------------------------------------*/
   9
  10 #include <stdarg.h>
  11 #include <string.h>
  12
  13 #include "unit.h"
  14
  15 /** Variable list declarations. */
  16 #define SJME_VA_DEF va_list inputVa; \
  17         va_list copyVa
  18
  19 /**
  20  * Performs a short with the given type.
  21  *
  22  * @param type The type of return value.
  23  * @since 2023/11/11
  24  */
  25 #define SJME_VA_SHORT(type) do {\
  26         va_start(inputVa, format); \
  27     sjme_unitShortingEmit(file, line, func, test, (type), format, inputVa); \
  28     va_end(inputVa); \
  29         } while(SJME_JNI_FALSE)
  30
  31 /**
  32  * Operator comparison function.
  33  *
  34  * @param size The size of the values.
  35  * @param a The first value.
  36  * @param b The second value.
  37  * @return Returns what the comparison is.
  38  * @since 2023/11/20
  39  */
  40 typedef sjme_jboolean (*sjme_unitOperatorFunc)(size_t size, void* a, void* b);
  41
  42 /**
  43  * Operator comparison information.
  44  *
  45  * @since 2023/11/20
  46  */
  47 typedef struct sjme_unitOperatorInfo
  48 {
  49         /** The operator symbol. */
  50         const char* symbol;
  51
  52         /** The function for comparison. */
  53         sjme_unitOperatorFunc function;
  54 } sjme_unitOperatorInfo;
  55
  56 static sjme_jboolean sjme_unitOperatorEqual(size_t size, void* a, void* b)
  57 {
  58         return memcmp(a, b, size) == 0;
  59 }
  60
  61 static sjme_jboolean sjme_unitOperatorNotEqual(size_t size, void* a, void* b)
  62 {
  63         return memcmp(a, b, size) != 0;
  64 }
  65
  66 static sjme_jboolean sjme_unitOperatorLessThan(size_t size, void* a, void* b)
  67 {
  68         sjme_jlong *ja;
  69         sjme_jlong *jb;
  70
  71         if (size == sizeof(sjme_jint))
  72                 return *((sjme_jint*)a) < *((sjme_jint*)b);
  73
  74         ja = a;
  75         jb = b;
  76         if (ja->hi <= jb->hi)
  77                 return ja->lo < jb->lo;
  78         return SJME_JNI_FALSE;
  79 }
  80
  81 static sjme_jboolean sjme_unitOperatorLessEqual(size_t size, void* a, void* b)
  82 {
  83         sjme_jlong *ja;
  84         sjme_jlong *jb;
  85
  86         if (size == sizeof(sjme_jint))
  87                 return *((sjme_jint*)a) <= *((sjme_jint*)b);
  88
  89         ja = a;
  90         jb = b;
  91         if (ja->hi <= jb->hi)
  92                 return ja->lo <= jb->lo;
  93         return SJME_JNI_FALSE;
  94 }
  95
  96 static sjme_jboolean sjme_unitOperatorGreaterThan(size_t size, void* a, void* b)
  97 {
  98         sjme_jlong *ja;
  99         sjme_jlong *jb;
 100
 101         if (size == sizeof(sjme_jint))
 102                 return *((sjme_jint*)a) > *((sjme_jint*)b);
 103
 104         ja = a;
 105         jb = b;
 106         if (ja->hi >= jb->hi)
 107                 return ja->lo > jb->lo;
 108         return SJME_JNI_FALSE;
 109 }
 110
 111 static sjme_jboolean sjme_unitOperatorGreaterEqual(size_t size, void* a, void* b)
 112 {
 113         sjme_jlong *ja;
 114         sjme_jlong *jb;
 115
 116         if (size == sizeof(sjme_jint))
 117                 return *((sjme_jint*)a) >= *((sjme_jint*)b);
 118
 119         ja = a;
 120         jb = b;
 121         if (ja->hi >= jb->hi)
 122                 return ja->lo >= jb->lo;
 123         return SJME_JNI_FALSE;
 124 }
 125
 126 /** Operator information. */
 127 const sjme_unitOperatorInfo sjme_unitOperatorInfos[SJME_NUM_UNIT_OPERATORS] =
 128 {
 129         /* SJME_UNIT_OPERATOR_EQUAL. */
 130         {
 131                 "==",
 132                 sjme_unitOperatorEqual
 133         },
 134
 135         /* SJME_UNIT_OPERATOR_NOT_EQUAL. */
 136         {
 137                 "!=",
 138                 sjme_unitOperatorNotEqual
 139         },
 140
 141         /* SJME_UNIT_OPERATOR_LESS_THAN. */
 142         {
 143                 "<",
 144                 sjme_unitOperatorLessThan
 145         },
 146
 147         /* SJME_UNIT_OPERATOR_LESS_EQUAL. */
 148         {
 149                 "<=",
 150                 sjme_unitOperatorLessEqual
 151         },
 152
 153         /* SJME_UNIT_OPERATOR_GREATER_THAN. */
 154         {
 155                 ">",
 156                 sjme_unitOperatorGreaterThan
 157         },
 158
 159         /* SJME_UNIT_OPERATOR_GREATER_EQUAL. */
 160         {
 161                 ">=",
 162                 sjme_unitOperatorGreaterEqual
 163         },
 164 };
 165
 166 static sjme_jboolean sjme_unitShortingEmit(SJME_DEBUG_DECL_FILE_LINE_FUNC,
 167         sjme_attrInNotNull sjme_test* test,
 168         sjme_attrInRange(SJME_TEST_RESULT_PASS, SJME_TEST_RESULT_FAIL)
 169                 sjme_testResult type,
 170         sjme_attrInNullable const char* format, va_list vaArgs)
 171 {
 172         if (test == NULL)
 173                 return sjme_die("No test structure?");
 174
 175         /* Emit message. */
 176         sjme_messageV(file, line, func, format, vaArgs);
 177
 178         /* Hit abort for debugging. */
 179         abort();
 180
 181         /* Jump back to the outer code. */
 182         longjmp(test->jumpPoint, type);
 183
 184         /* Ignored. */
 185         return (type == SJME_TEST_RESULT_PASS);
 186 }
 187
 188 sjme_testResult sjme_unitOperatorIR(SJME_DEBUG_DECL_FILE_LINE_FUNC,
 189         sjme_attrInValue sjme_unitOperator operator,
 190         sjme_attrInNotNull sjme_test* test,
 191         sjme_attrInValue sjme_jint a,
 192         sjme_attrInValue sjme_jint b,
 193         sjme_attrInNullable sjme_attrFormatArg const char* format, ...)
 194 {
 195         SJME_VA_DEF;
 196         const sjme_unitOperatorInfo* opInfo;
 197
 198         if (operator < 0 || operator >= SJME_NUM_UNIT_OPERATORS)
 199                 SJME_VA_SHORT(SJME_TEST_RESULT_FAIL);
 200         opInfo = &sjme_unitOperatorInfos[operator];
 201
 202         if (!opInfo->function(sizeof(sjme_jint), &a, &b))
 203         {
 204                 sjme_messageR(file, line, func, "ASSERT: %d %s %d",
 205                         a, opInfo->symbol, b);
 206                 SJME_VA_SHORT(SJME_TEST_RESULT_FAIL);
 207         }
 208
 209         return SJME_TEST_RESULT_PASS;
 210 }
 211
 212 sjme_testResult sjme_unitOperatorLR(SJME_DEBUG_DECL_FILE_LINE_FUNC,
 213         sjme_attrInValue sjme_unitOperator operator,
 214         sjme_attrInNotNull sjme_test* test,
 215         sjme_attrInNullable sjme_jobject a,
 216         sjme_attrInNullable sjme_jobject b,
 217         sjme_attrInNullable sjme_attrFormatArg const char* format, ...)
 218 {
 219         SJME_VA_DEF;
 220         const sjme_unitOperatorInfo* opInfo;
 221
 222         if (operator < 0 || operator >= SJME_NUM_UNIT_OPERATORS)
 223                 SJME_VA_SHORT(SJME_TEST_RESULT_FAIL);
 224         opInfo = &sjme_unitOperatorInfos[operator];
 225
 226         if (!opInfo->function(sizeof(sjme_jobject), &a, &b))
 227         {
 228                 sjme_messageR(file, line, func, "ASSERT: %p %s %p",
 229                         a, opInfo->symbol, b);
 230                 SJME_VA_SHORT(SJME_TEST_RESULT_FAIL);
 231         }
 232
 233         return SJME_TEST_RESULT_PASS;
 234 }
 235
 236 sjme_testResult sjme_unitOperatorPR(SJME_DEBUG_DECL_FILE_LINE_FUNC,
 237         sjme_attrInValue sjme_unitOperator operator,
 238         sjme_attrInNotNull sjme_test* test,
 239         sjme_attrInNullable void* a,
 240         sjme_attrInNullable void* b,
 241         sjme_attrInNullable sjme_attrFormatArg const char* format, ...)
 242 {
 243         SJME_VA_DEF;
 244         const sjme_unitOperatorInfo* opInfo;
 245
 246         if (operator < 0 || operator >= SJME_NUM_UNIT_OPERATORS)
 247                 SJME_VA_SHORT(SJME_TEST_RESULT_FAIL);
 248         opInfo = &sjme_unitOperatorInfos[operator];
 249
 250         if (!opInfo->function(sizeof(void*), &a, &b))
 251         {
 252                 sjme_messageR(file, line, func, "ASSERT: %p %s %p",
 253                         a, opInfo->symbol, b);
 254                 SJME_VA_SHORT(SJME_TEST_RESULT_FAIL);
 255         }
 256
 257         return SJME_TEST_RESULT_PASS;
 258 }
 259
 260 sjme_testResult sjme_unitFailR(SJME_DEBUG_DECL_FILE_LINE_FUNC,
 261         sjme_attrInNotNull sjme_test* test,
 262         sjme_attrInNullable sjme_attrFormatArg const char* format, ...)
 263 {
 264         SJME_VA_DEF;
 265
 266         /* Test always fails. */
 267         sjme_messageR(file, line, func, "ASSERT: Fail");
 268         SJME_VA_SHORT(SJME_TEST_RESULT_FAIL);
 269         return SJME_TEST_RESULT_FAIL;
 270 }
 271
 272 sjme_testResult sjme_unitSkipR(SJME_DEBUG_DECL_FILE_LINE_FUNC,
 273         sjme_attrInNotNull sjme_test* test,
 274         sjme_attrInNullable sjme_attrFormatArg const char* format, ...)
 275 {
 276         SJME_VA_DEF;
 277
 278         /* Test always fails. */
 279         sjme_messageR(file, line, func, "Skipped test.");
 280         SJME_VA_SHORT(SJME_TEST_RESULT_SKIP);
 281         return SJME_TEST_RESULT_SKIP;
 282 }