nanocoat/tests/testDescFieldType.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 /** The max permitted array size. */
  20 #define MAX_ARRAY 8
  21
  22 /**
  23  * Represents a component entry.
  24  *
  25  * @since 2024/02/22
  26  */
  27 typedef struct testDescFieldTypeComponentEntry
  28 {
  29         /** The Java type. */
  30         sjme_javaTypeId javaType;
  31
  32         /** The cell count of this field. */
  33         sjme_jint cells;
  34
  35         /** Is this an array? */
  36         sjme_jboolean isArray;
  37 } testDescFieldTypeComponentEntry;
  38
  39 /**
  40  * A single entry that is compared against for the test, since there are
  41  * many different possible scenarios to be tested, this reduces duplicate
  42  * test code.
  43  *
  44  * @since 2024/02/14
  45  */
  46 typedef struct testDescFieldTypeEntry
  47 {
  48         /** The string for the entry. */
  49         sjme_lpcstr string;
  50
  51         /** Interpretation of object type, if an object. */
  52         sjme_lpcstr objectString;
  53
  54         /** The number of dimensions. */
  55         sjme_jint numDims;
  56
  57         /** Component data. */
  58         testDescFieldTypeComponentEntry components[MAX_ARRAY];
  59 } testDescFieldTypeEntry;
  60
  61 /** Entries for tests. */
  62 static const testDescFieldTypeEntry testEntries[] =
  63 {
  64         /* Non-array. */
  65         {
  66                 "B",
  67                 NULL,
  68                 0,
  69                 {
  70                         {
  71                                 SJME_JAVA_TYPE_ID_BOOLEAN_OR_BYTE,
  72                                 1,
  73                                 SJME_JNI_FALSE
  74                         }
  75                 }
  76         },
  77         {
  78                 "C",
  79                 NULL,
  80                 0,
  81                 {
  82                         {
  83                                 SJME_JAVA_TYPE_ID_SHORT_OR_CHAR,
  84                                 1,
  85                                 SJME_JNI_FALSE,
  86                         }
  87                 }
  88         },
  89         {
  90                 "D",
  91                 NULL,
  92                 0,
  93                 {
  94                         {
  95                                 SJME_JAVA_TYPE_ID_DOUBLE,
  96                                 2,
  97                                 SJME_JNI_FALSE,
  98                         }
  99                 }
 100         },
 101         {
 102                 "F",
 103                 NULL,
 104                 0,
 105                 {
 106                         {
 107                                 SJME_JAVA_TYPE_ID_FLOAT,
 108                                 1,
 109                                 SJME_JNI_FALSE,
 110                         }
 111                 }
 112         },
 113         {
 114                 "I",
 115                 NULL,
 116                 0,
 117                 {
 118                         {
 119                                 SJME_JAVA_TYPE_ID_INTEGER,
 120                                 1,
 121                                 SJME_JNI_FALSE,
 122                         }
 123                 }
 124         },
 125         {
 126                 "J",
 127                 NULL,
 128                 0,
 129                 {
 130                         {
 131                                 SJME_JAVA_TYPE_ID_LONG,
 132                                 2,
 133                                 SJME_JNI_FALSE,
 134                         }
 135                 }
 136         },
 137         {
 138                 "S",
 139                 NULL,
 140                 0,
 141                 {
 142                         {
 143                                 SJME_JAVA_TYPE_ID_SHORT_OR_CHAR,
 144                                 1,
 145                                 SJME_JNI_FALSE,
 146                         }
 147                 }
 148         },
 149         {
 150                 "Z",
 151                 NULL,
 152                 0,
 153                 {
 154                         {
 155                                 SJME_JAVA_TYPE_ID_BOOLEAN_OR_BYTE,
 156                                 1,
 157                                 SJME_JNI_FALSE,
 158                         }
 159                 }
 160         },
 161         {
 162                 "LSqueak/In/Box;",
 163                 "Squeak/In/Box",
 164                 0,
 165                 {
 166                         {
 167                                 SJME_JAVA_TYPE_ID_OBJECT,
 168                                 1,
 169                                 SJME_JNI_FALSE,
 170                         }
 171                 }
 172         },
 173
 174         /* Array. */
 175         {
 176                 "[B",
 177                 NULL,
 178                 1,
 179                 {
 180                         {
 181                                 SJME_JAVA_TYPE_ID_OBJECT,
 182                                 1,
 183                                 SJME_JNI_TRUE,
 184                         },
 185                         {
 186                                 SJME_JAVA_TYPE_ID_BOOLEAN_OR_BYTE,
 187                                 1,
 188                                 SJME_JNI_FALSE,
 189                         }
 190                 }
 191         },
 192         {
 193                 "[C",
 194                 NULL,
 195                 1,
 196                 {
 197                         {
 198                                 SJME_JAVA_TYPE_ID_OBJECT,
 199                                 1,
 200                                 SJME_JNI_TRUE,
 201                         },
 202                         {
 203                                 SJME_JAVA_TYPE_ID_SHORT_OR_CHAR,
 204                                 1,
 205                                 SJME_JNI_FALSE,
 206                         }
 207                 }
 208         },
 209         {
 210                 "[D",
 211                 NULL,
 212                 1,
 213                 {
 214                         {
 215                                 SJME_JAVA_TYPE_ID_OBJECT,
 216                                 1,
 217                                 SJME_JNI_TRUE,
 218                         },
 219                         {
 220                                 SJME_JAVA_TYPE_ID_DOUBLE,
 221                                 2,
 222                                 SJME_JNI_FALSE,
 223                         }
 224                 }
 225         },
 226         {
 227                 "[F",
 228                 NULL,
 229                 1,
 230                 {
 231                         {
 232                                 SJME_JAVA_TYPE_ID_OBJECT,
 233                                 1,
 234                                 SJME_JNI_TRUE,
 235                         },
 236                         {
 237                                 SJME_JAVA_TYPE_ID_FLOAT,
 238                                 1,
 239                                 SJME_JNI_FALSE,
 240                         }
 241                 }
 242         },
 243         {
 244                 "[I",
 245                 NULL,
 246                 1,
 247                 {
 248                         {
 249                                 SJME_JAVA_TYPE_ID_OBJECT,
 250                                 1,
 251                                 SJME_JNI_TRUE,
 252                         },
 253                         {
 254                                 SJME_JAVA_TYPE_ID_INTEGER,
 255                                 1,
 256                                 SJME_JNI_FALSE,
 257                         }
 258                 }
 259         },
 260         {
 261                 "[J",
 262                 NULL,
 263                 1,
 264                 {
 265                         {
 266                                 SJME_JAVA_TYPE_ID_OBJECT,
 267                                 1,
 268                                 SJME_JNI_TRUE,
 269                         },
 270                         {
 271                                 SJME_JAVA_TYPE_ID_LONG,
 272                                 2,
 273                                 SJME_JNI_FALSE,
 274                         }
 275                 }
 276         },
 277         {
 278                 "[S",
 279                 NULL,
 280                 1,
 281                 {
 282                         {
 283                                 SJME_JAVA_TYPE_ID_OBJECT,
 284                                 1,
 285                                 SJME_JNI_TRUE,
 286                         },
 287                         {
 288                                 SJME_JAVA_TYPE_ID_SHORT_OR_CHAR,
 289                                 1,
 290                                 SJME_JNI_FALSE,
 291                         }
 292                 }
 293         },
 294         {
 295                 "[Z",
 296                 NULL,
 297                 1,
 298                 {
 299                         {
 300                                 SJME_JAVA_TYPE_ID_OBJECT,
 301                                 1,
 302                                 SJME_JNI_TRUE,
 303                         },
 304                         {
 305                                 SJME_JAVA_TYPE_ID_BOOLEAN_OR_BYTE,
 306                                 1,
 307                                 SJME_JNI_FALSE,
 308                         }
 309                 }
 310         },
 311         {
 312                 "[LSqueak/In/Box;",
 313                 "Squeak/In/Box",
 314                 1,
 315                 {
 316                         {
 317                                 SJME_JAVA_TYPE_ID_OBJECT,
 318                                 1,
 319                                 SJME_JNI_TRUE,
 320                         },
 321                         {
 322                                 SJME_JAVA_TYPE_ID_OBJECT,
 323                                 1,
 324                                 SJME_JNI_FALSE,
 325                         }
 326                 }
 327         },
 328         {
 329                 "[[I",
 330                 NULL,
 331                 2,
 332                 {
 333                         {
 334                                 SJME_JAVA_TYPE_ID_OBJECT,
 335                                 1,
 336                                 SJME_JNI_TRUE,
 337                         },
 338                         {
 339                                 SJME_JAVA_TYPE_ID_OBJECT,
 340                                 1,
 341                                 SJME_JNI_TRUE,
 342                         },
 343                         {
 344                                 SJME_JAVA_TYPE_ID_INTEGER,
 345                                 1,
 346                                 SJME_JNI_FALSE,
 347                         }
 348                 }
 349         },
 350         {
 351                 "[[LSqueak/In/Box;",
 352                 "Squeak/In/Box",
 353                 2,
 354                 {
 355                         {
 356                                 SJME_JAVA_TYPE_ID_OBJECT,
 357                                 1,
 358                                 SJME_JNI_TRUE,
 359                         },
 360                         {
 361                                 SJME_JAVA_TYPE_ID_OBJECT,
 362                                 1,
 363                                 SJME_JNI_TRUE,
 364                         },
 365                         {
 366                                 SJME_JAVA_TYPE_ID_OBJECT,
 367                                 1,
 368                                 SJME_JNI_FALSE,
 369                         }
 370                 }
 371         },
 372
 373         /* End. */
 374         {NULL}
 375 };
 376
 377 /** String pair. */
 378 #define pair(s) s, strlen(s)
 379
 380 /**
 381  * Tests parsing of class field descriptors.
 382  *
 383  * @since 2024/01/01
 384  */
 385 SJME_TEST_DECLARE(testDescFieldType)
 386 {
 387         const testDescFieldTypeEntry* entry;
 388         sjme_desc_fieldType* result;
 389         sjme_desc_binaryName* objectResult;
 390         sjme_lpcstr string;
 391         sjme_jint strLen, strHash, atEntry, i;
 392         sjme_errorCode error;
 393
 394         /* Go through every entry. */
 395         for (atEntry = 0; testEntries[atEntry].string != NULL;
 396                  atEntry++)
 397         {
 398                 /* Get the entry to test. */
 399                 entry = &testEntries[atEntry];
 400
 401                 /* Load in string details. */
 402                 string = entry->string;
 403                 strLen = strlen(string);
 404                 strHash = sjme_string_hash(string);
 405
 406                 /* Parse the field type. */
 407                 result = NULL;
 408                 if (sjme_error_is(error = sjme_desc_interpretFieldType(
 409                         test->pool, &result, string, strLen)) ||
 410                         result == NULL)
 411                         return sjme_unit_fail(test, "Could not interpret %s (%d)?",
 412                                 string, error);
 413
 414                 /* Basic whole value and hash check. */
 415                 sjme_unit_equalI(test, result->hash, strHash,
 416                         "Hash of whole %s incorrect?", string);
 417                 sjme_unit_equalI(test, result->whole.length, strLen,
 418                         "Length of whole %s incorrect?", string);
 419                 sjme_unit_equalP(test, result->whole.pointer, string,
 420                         "Pointer of whole %s incorrect?", string);
 421
 422                 /* Should have same number of dimensions. */
 423                 sjme_unit_equalI(test, result->numDims, entry->numDims,
 424                         "Field %s has incorrect number of dimensions?", string);
 425
 426                 /* Match all components. */
 427                 for (i = 0; i <= entry->numDims; i++)
 428                 {
 429                         /* Debug. */
 430                         sjme_message("Field %s, fragment %d: %.*s",
 431                                 string, i, result->components[i].fragment.length,
 432                                 (char*)result->components[i].fragment.pointer);
 433
 434                         /* Basic comparison. */
 435                         sjme_unit_equalI(test, result->components[i].javaType,
 436                                 entry->components[i].javaType,
 437                                 "Field %s has incorrect Java type?", string);
 438                         sjme_unit_equalI(test, result->components[i].cells,
 439                                 entry->components[i].cells,
 440                                 "Field %s has incorrect number of cells?", string);
 441                         sjme_unit_equalZ(test, result->components[i].isArray,
 442                                 entry->components[i].isArray,
 443                                 "Field %s has incorrect array state?", string);
 444
 445                         /* The last entry will have the object string, if an object. */
 446                         if (i == entry->numDims && entry->objectString != NULL)
 447                         {
 448                                 /* Should be an object type. */
 449                                 sjme_unit_equalI(test, SJME_JAVA_TYPE_ID_OBJECT,
 450                                         result->components[i].javaType,
 451                                         "Not an object?");
 452
 453                                 /* String comparison should be valid. */
 454                                 sjme_unit_equalI(test, 0, sjme_desc_compareBinaryNamePS(
 455                                         &result->components[i].binaryName,
 456                                         entry->objectString),
 457                                         "Binary name of object is incorrect?");
 458
 459                                 /* Parse it. */
 460                                 objectResult = NULL;
 461                                 if (sjme_error_is(sjme_desc_interpretBinaryName(
 462                                         test->pool,
 463                                         &objectResult, entry->objectString,
 464                                         strlen(entry->objectString))) ||
 465                                         objectResult == NULL)
 466                                         return sjme_unit_fail(test,
 467                                         "Field %s has an invalid object string?", string);
 468
 469                                 /* Should be the same. */
 470                                 sjme_unit_equalI(test, 0, sjme_desc_compareBinaryNameP(
 471                                         &result->components[i].binaryName,
 472                                         objectResult),
 473                                         "Field %s has non-equal object?", string);
 474                         }
 475                 }
 476         }
 477
 478         /* Invalid fields. */
 479         result = NULL;
 480         sjme_unit_equalI(test, SJME_ERROR_INVALID_FIELD_TYPE,
 481                 sjme_desc_interpretFieldType(test->pool,
 482                         &result, pair("")),
 483                 "Blank is valid?");
 484
 485         result = NULL;
 486         sjme_unit_equalI(test, SJME_ERROR_INVALID_FIELD_TYPE,
 487                 sjme_desc_interpretFieldType(test->pool,
 488                         &result, pair("X")),
 489                 "Unknown type specifier is valid?");
 490
 491         result = NULL;
 492         sjme_unit_equalI(test, SJME_ERROR_INVALID_FIELD_TYPE,
 493                 sjme_desc_interpretFieldType(test->pool,
 494                         &result, pair("ZI")),
 495                 "Two primitive types is valid?");
 496
 497         result = NULL;
 498         sjme_unit_equalI(test, SJME_ERROR_INVALID_FIELD_TYPE,
 499                 sjme_desc_interpretFieldType(test->pool,
 500                         &result, pair("[")),
 501                 "Blank array is valid?");
 502
 503         result = NULL;
 504         sjme_unit_equalI(test, SJME_ERROR_INVALID_FIELD_TYPE,
 505                 sjme_desc_interpretFieldType(test->pool,
 506                         &result, pair("[[")),
 507                 "Blank double array is valid?");
 508
 509         result = NULL;
 510         sjme_unit_equalI(test, SJME_ERROR_INVALID_BINARY_NAME,
 511                 sjme_desc_interpretFieldType(test->pool,
 512                         &result, pair("L")),
 513                 "Only starting L is valid?");
 514
 515         result = NULL;
 516         sjme_unit_equalI(test, SJME_ERROR_INVALID_FIELD_TYPE,
 517                 sjme_desc_interpretFieldType(test->pool,
 518                         &result, pair("LOops")),
 519                 "Object missing ending semicolon is valid?");
 520
 521         result = NULL;
 522         sjme_unit_equalI(test, SJME_ERROR_INVALID_BINARY_NAME,
 523                 sjme_desc_interpretFieldType(test->pool,
 524                         &result, pair("L;")),
 525                 "Empty but specified object is valid?");
 526
 527         /* Success! */
 528         return SJME_TEST_RESULT_PASS;
 529 }