nanocoat/tests/testDescMethodType.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 <string.h>
  11
  12 #include "mock.h"
  13 #include "proto.h"
  14 #include "sjme/util.h"
  15 #include "test.h"
  16 #include "unit.h"
  17 #include "sjme/nvm/descriptor.h"
  18
  19 /**
  20  * What to test and the expected values for method descriptors.
  21  *
  22  * @since 2024/02/18
  23  */
  24 typedef struct testDescMethodTypeEntry
  25 {
  26         /** The string for the entry. */
  27         sjme_lpcstr string;
  28
  29         /** Return value cells. */
  30         sjme_jint returnCells;
  31
  32         /** Argument cells. */
  33         sjme_jint argCells;
  34
  35         /** The field descriptors used, index zero is the return value. */
  36         sjme_lpcstr fields;
  37 } testDescMethodTypeEntry;
  38
  39 /** Entries for tests. */
  40 static const testDescMethodTypeEntry testEntries[] =
  41 {
  42         /* Void returning void. */
  43         {
  44                 "()V",
  45                 0,
  46                 0,
  47                 "V\0\0"
  48         },
  49
  50         /* Void returning boolean. */
  51         {
  52                 "()Z",
  53                 1,
  54                 0,
  55                 "Z\0\0"
  56         },
  57
  58         /* Void returning byte. */
  59         {
  60                 "()B",
  61                 1,
  62                 0,
  63                 "B\0\0"
  64         },
  65
  66         /* Void returning short. */
  67         {
  68                 "()S",
  69                 1,
  70                 0,
  71                 "S\0\0"
  72         },
  73
  74         /* Void returning char. */
  75         {
  76                 "()C",
  77                 1,
  78                 0,
  79                 "C\0\0"
  80         },
  81
  82         /* Void returning int. */
  83         {
  84                 "()I",
  85                 1,
  86                 0,
  87                 "I\0\0"
  88         },
  89
  90         /* Void returning long. */
  91         {
  92                 "()J",
  93                 2,
  94                 0,
  95                 "J\0\0"
  96         },
  97
  98         /* Void returning float. */
  99         {
 100                 "()F",
 101                 1,
 102                 0,
 103                 "F\0\0"
 104         },
 105
 106         /* Void returning double. */
 107         {
 108                 "()D",
 109                 2,
 110                 0,
 111                 "D\0\0"
 112         },
 113
 114         /* Void returning object. */
 115         {
 116                 "()LSqueak/In/Box;",
 117                 1,
 118                 0,
 119                 "LSqueak/In/Box;\0\0"
 120         },
 121
 122         /* Boolean returning void. */
 123         {
 124                 "(Z)V",
 125                 0,
 126                 1,
 127                 "V\0Z\0\0"
 128         },
 129
 130         /* Byte returning void. */
 131         {
 132                 "(B)V",
 133                 0,
 134                 1,
 135                 "V\0B\0\0"
 136         },
 137
 138         /* Short returning void. */
 139         {
 140                 "(S)V",
 141                 0,
 142                 1,
 143                 "V\0S\0\0"
 144         },
 145
 146         /* Char returning void. */
 147         {
 148                 "(C)V",
 149                 0,
 150                 1,
 151                 "V\0C\0\0"
 152         },
 153
 154         /* Int returning void. */
 155         {
 156                 "(I)V",
 157                 0,
 158                 1,
 159                 "V\0I\0\0"
 160         },
 161
 162         /* Long returning void. */
 163         {
 164                 "(J)V",
 165                 0,
 166                 2,
 167                 "V\0J\0\0"
 168         },
 169
 170         /* Float returning void. */
 171         {
 172                 "(F)V",
 173                 0,
 174                 1,
 175                 "V\0F\0\0"
 176         },
 177
 178         /* Double returning void. */
 179         {
 180                 "(D)V",
 181                 0,
 182                 2,
 183                 "V\0D\0\0"
 184         },
 185
 186         /* Object returning void. */
 187         {
 188                 "(LSqueak/In/Box;)V",
 189                 0,
 190                 1,
 191                 "V\0LSqueak/In/Box;\0\0"
 192         },
 193
 194         /* Long long returning object. */
 195         {
 196                 "(JJ)LSqueak/In/Box;",
 197                 1,
 198                 4,
 199                 "LSqueak/In/Box;\0J\0J\0\0"
 200         },
 201
 202         /* Object returning long. */
 203         {
 204                 "(LSqueak/In/Box;)J",
 205                 2,
 206                 1,
 207                 "J\0LSqueak/In/Box;\0\0"
 208         },
 209
 210         /* Int long returning double. */
 211         {
 212                 "(IJ)D",
 213                 2,
 214                 3,
 215                 "D\0I\0J\0\0"
 216         },
 217
 218         /* Long int returning double. */
 219         {
 220                 "(JI)D",
 221                 2,
 222                 3,
 223                 "D\0J\0I\0\0"
 224         },
 225
 226         /* End. */
 227         {NULL},
 228 };
 229
 230 /** String pair. */
 231 #define pair(s) s, strlen(s)
 232
 233 /**
 234  * Tests parsing of method descriptors.
 235  *
 236  * @since 2024/01/01
 237  */
 238 SJME_TEST_DECLARE(testDescMethodType)
 239 {
 240         const testDescMethodTypeEntry* entry;
 241         sjme_desc_methodType* result;
 242         sjme_desc_fieldType* field;
 243         sjme_list_sjme_lpcstr* fieldStrings;
 244         sjme_lpcstr string, subString;
 245         sjme_jint strLen, subStrLen, strHash, atEntry, i;
 246
 247         /* Go through every entry. */
 248         for (atEntry = 0; testEntries[atEntry].string != NULL;
 249                  atEntry++)
 250         {
 251                 /* Get the entry to test. */
 252                 entry = &testEntries[atEntry];
 253
 254                 /* Load in string details. */
 255                 string = entry->string;
 256                 strLen = strlen(string);
 257                 strHash = sjme_string_hash(string);
 258
 259                 /* Interpret method entry. */
 260                 result = NULL;
 261                 if (sjme_error_is(sjme_desc_interpretMethodType(test->pool,
 262                         &result, string, strLen)) || result == NULL)
 263                         return sjme_unit_fail(test, "Could not interpret %s?", string);
 264
 265                 /* Basic whole value and hash check. */
 266                 sjme_unit_equalI(test, result->hash, strHash,
 267                         "Hash of whole %s incorrect?", string);
 268                 sjme_unit_equalI(test, result->whole.length, strLen,
 269                         "Length of whole %s incorrect?", string);
 270                 sjme_unit_equalP(test, result->whole.pointer, string,
 271                         "Pointer of whole %s incorrect?", string);
 272
 273                 /* Cells should match. */
 274                 sjme_unit_equalI(test, result->returnCells, entry->returnCells,
 275                         "Return cells of %s incorrect?", string);
 276                 sjme_unit_equalI(test, result->argCells, entry->argCells,
 277                         "Argument cells of %s incorrect?", string);
 278
 279                 /* Parse recorded fields. */
 280                 fieldStrings = NULL;
 281                 if (sjme_error_is(sjme_list_flattenArgNul(test->pool,
 282                         &fieldStrings, entry->fields) ||
 283                         fieldStrings == NULL))
 284                         return sjme_unit_fail(test, "Could not parse fields of %s?",
 285                                 string);
 286
 287                 /* Count should match. */
 288                 sjme_unit_equalI(test, fieldStrings->length, result->fields.length,
 289                         "Incorrect field count for %s?", string);
 290
 291                 /* Match each individual field. */
 292                 for (i = 0; i < fieldStrings->length; i++)
 293                 {
 294                         /* Get string information. */
 295                         subString = fieldStrings->elements[i];
 296                         subStrLen = strlen(subString);
 297
 298                         /* Parse */
 299                         field = NULL;
 300                         if (sjme_error_is(sjme_desc_interpretFieldType(
 301                                 test->pool, &field, subString,
 302                                 subStrLen)) || field == NULL)
 303                                 return sjme_unit_fail(test, "Could not parse field %s in %s?",
 304                                         subString, string);
 305
 306                         /* Should be the same field. */
 307                         sjme_unit_equalI(test, 0, sjme_desc_compareFieldC(
 308                                 &result->fields.elements[i], field),
 309                                 "Decoded field %s is incorrect in %s (%.*s == %s)?",
 310                                         subString, string,
 311                                         result->fields.elements[i].fragment.length,
 312                                         result->fields.elements[i].fragment.pointer, field);
 313                 }
 314         }
 315
 316         /* Invalid methods types. */
 317         result = NULL;
 318         sjme_unit_equalI(test, SJME_ERROR_INVALID_METHOD_TYPE,
 319                 sjme_desc_interpretMethodType(test->pool,
 320                         &result, pair("")),
 321                 "Blank is valid?");
 322
 323         result = NULL;
 324         sjme_unit_equalI(test, SJME_ERROR_INVALID_METHOD_TYPE,
 325                 sjme_desc_interpretMethodType(test->pool,
 326                         &result, pair("V")),
 327                 "Return only is valid?");
 328
 329         result = NULL;
 330         sjme_unit_equalI(test, SJME_ERROR_INVALID_METHOD_TYPE,
 331                 sjme_desc_interpretMethodType(test->pool,
 332                         &result, pair("()")),
 333                 "Arguments only is valid?");
 334
 335         result = NULL;
 336         sjme_unit_equalI(test, SJME_ERROR_INVALID_METHOD_TYPE,
 337                 sjme_desc_interpretMethodType(test->pool,
 338                         &result, pair("()II")),
 339                 "Double return type is valid?");
 340
 341         result = NULL;
 342         sjme_unit_equalI(test, SJME_ERROR_INVALID_FIELD_TYPE,
 343                 sjme_desc_interpretMethodType(test->pool,
 344                         &result, pair("()[")),
 345                 "Unspecified array return is valid?");
 346
 347         result = NULL;
 348         sjme_unit_equalI(test, SJME_ERROR_INVALID_BINARY_NAME,
 349                 sjme_desc_interpretMethodType(test->pool,
 350                         &result, pair("()L")),
 351                 "Unspecified object return is valid?");
 352
 353         result = NULL;
 354         sjme_unit_equalI(test, SJME_ERROR_INVALID_FIELD_TYPE,
 355                 sjme_desc_interpretMethodType(test->pool,
 356                         &result, pair("()LOops")),
 357                 "Unclosed object return is valid?");
 358
 359         result = NULL;
 360         sjme_unit_equalI(test, SJME_ERROR_INVALID_FIELD_TYPE,
 361                 sjme_desc_interpretMethodType(test->pool,
 362                         &result, pair("([)V")),
 363                 "Unspecified array is valid?");
 364
 365         result = NULL;
 366         sjme_unit_equalI(test, SJME_ERROR_INVALID_FIELD_TYPE,
 367                 sjme_desc_interpretMethodType(test->pool,
 368                         &result, pair("(L)V")),
 369                 "Unspecified object is valid?");
 370
 371         result = NULL;
 372         sjme_unit_equalI(test, SJME_ERROR_INVALID_FIELD_TYPE,
 373                 sjme_desc_interpretMethodType(test->pool,
 374                         &result, pair("(LOops)V")),
 375                 "Unclosed object is valid?");
 376
 377         result = NULL;
 378         sjme_unit_equalI(test, SJME_ERROR_INVALID_METHOD_TYPE,
 379                 sjme_desc_interpretMethodType(test->pool,
 380                         &result, pair("V()")),
 381                 "Wrong order is valid?");
 382
 383         /* Success! */
 384         return SJME_TEST_RESULT_PASS;
 385 }