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