API/tests/testapi.c

   1 /*
   2  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "JavaScriptCore.h"
  27 #include "JSBasePrivate.h"
  28 #include "JSContextRefPrivate.h"
  29 #include "JSObjectRefPrivate.h"
  30 #include <math.h>
  31 #define ASSERT_DISABLED 0
  32 #include <wtf/Assertions.h>
  33 #include <wtf/UnusedParam.h>
  34
  35 #if COMPILER(MSVC)
  36
  37 #include <wtf/MathExtras.h>
  38
  39 static double nan(const char*)
  40 {
  41     return std::numeric_limits<double>::quiet_NaN();
  42 }
  43
  44 #endif
  45
  46 static JSGlobalContextRef context;
  47 static int failed;
  48 static void assertEqualsAsBoolean(JSValueRef value, bool expectedValue)
  49 {
  50     if (JSValueToBoolean(context, value) != expectedValue) {
  51         fprintf(stderr, "assertEqualsAsBoolean failed: %p, %d\n", value, expectedValue);
  52         failed = 1;
  53     }
  54 }
  55
  56 static void assertEqualsAsNumber(JSValueRef value, double expectedValue)
  57 {
  58     double number = JSValueToNumber(context, value, NULL);
  59
  60     // FIXME <rdar://4668451> - On i386 the isnan(double) macro tries to map to the isnan(float) function,
  61     // causing a build break with -Wshorten-64-to-32 enabled.  The issue is known by the appropriate team.
  62     // After that's resolved, we can remove these casts
  63     if (number != expectedValue && !(isnan((float)number) && isnan((float)expectedValue))) {
  64         fprintf(stderr, "assertEqualsAsNumber failed: %p, %lf\n", value, expectedValue);
  65         failed = 1;
  66     }
  67 }
  68
  69 static void assertEqualsAsUTF8String(JSValueRef value, const char* expectedValue)
  70 {
  71     JSStringRef valueAsString = JSValueToStringCopy(context, value, NULL);
  72
  73     size_t jsSize = JSStringGetMaximumUTF8CStringSize(valueAsString);
  74     char* jsBuffer = (char*)malloc(jsSize);
  75     JSStringGetUTF8CString(valueAsString, jsBuffer, jsSize);
  76
  77     unsigned i;
  78     for (i = 0; jsBuffer[i]; i++) {
  79         if (jsBuffer[i] != expectedValue[i]) {
  80             fprintf(stderr, "assertEqualsAsUTF8String failed at character %d: %c(%d) != %c(%d)\n", i, jsBuffer[i], jsBuffer[i], expectedValue[i], expectedValue[i]);
  81             failed = 1;
  82         }
  83     }
  84
  85     if (jsSize < strlen(jsBuffer) + 1) {
  86         fprintf(stderr, "assertEqualsAsUTF8String failed: jsSize was too small\n");
  87         failed = 1;
  88     }
  89
  90     free(jsBuffer);
  91     JSStringRelease(valueAsString);
  92 }
  93
  94 static void assertEqualsAsCharactersPtr(JSValueRef value, const char* expectedValue)
  95 {
  96     JSStringRef valueAsString = JSValueToStringCopy(context, value, NULL);
  97
  98     size_t jsLength = JSStringGetLength(valueAsString);
  99     const JSChar* jsBuffer = JSStringGetCharactersPtr(valueAsString);
 100
 101     CFStringRef expectedValueAsCFString = CFStringCreateWithCString(kCFAllocatorDefault,
 102                                                                     expectedValue,
 103                                                                     kCFStringEncodingUTF8);
 104     CFIndex cfLength = CFStringGetLength(expectedValueAsCFString);
 105     UniChar* cfBuffer = (UniChar*)malloc(cfLength * sizeof(UniChar));
 106     CFStringGetCharacters(expectedValueAsCFString, CFRangeMake(0, cfLength), cfBuffer);
 107     CFRelease(expectedValueAsCFString);
 108
 109     if (memcmp(jsBuffer, cfBuffer, cfLength * sizeof(UniChar)) != 0) {
 110         fprintf(stderr, "assertEqualsAsCharactersPtr failed: jsBuffer != cfBuffer\n");
 111         failed = 1;
 112     }
 113
 114     if (jsLength != (size_t)cfLength) {
 115         fprintf(stderr, "assertEqualsAsCharactersPtr failed: jsLength(%ld) != cfLength(%ld)\n", jsLength, cfLength);
 116         failed = 1;
 117     }
 118
 119     free(cfBuffer);
 120     JSStringRelease(valueAsString);
 121 }
 122
 123 static bool timeZoneIsPST()
 124 {
 125     char timeZoneName[70];
 126     struct tm gtm;
 127     memset(&gtm, 0, sizeof(gtm));
 128     strftime(timeZoneName, sizeof(timeZoneName), "%Z", &gtm);
 129
 130     return 0 == strcmp("PST", timeZoneName);
 131 }
 132
 133 static JSValueRef jsGlobalValue; // non-stack value for testing JSValueProtect()
 134
 135 /* MyObject pseudo-class */
 136
 137 static bool MyObject_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName)
 138 {
 139     UNUSED_PARAM(context);
 140     UNUSED_PARAM(object);
 141
 142     if (JSStringIsEqualToUTF8CString(propertyName, "alwaysOne")
 143         || JSStringIsEqualToUTF8CString(propertyName, "cantFind")
 144         || JSStringIsEqualToUTF8CString(propertyName, "throwOnGet")
 145         || JSStringIsEqualToUTF8CString(propertyName, "myPropertyName")
 146         || JSStringIsEqualToUTF8CString(propertyName, "hasPropertyLie")
 147         || JSStringIsEqualToUTF8CString(propertyName, "0")) {
 148         return true;
 149     }
 150
 151     return false;
 152 }
 153
 154 static JSValueRef MyObject_getProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
 155 {
 156     UNUSED_PARAM(context);
 157     UNUSED_PARAM(object);
 158
 159     if (JSStringIsEqualToUTF8CString(propertyName, "alwaysOne")) {
 160         return JSValueMakeNumber(context, 1);
 161     }
 162
 163     if (JSStringIsEqualToUTF8CString(propertyName, "myPropertyName")) {
 164         return JSValueMakeNumber(context, 1);
 165     }
 166
 167     if (JSStringIsEqualToUTF8CString(propertyName, "cantFind")) {
 168         return JSValueMakeUndefined(context);
 169     }
 170
 171     if (JSStringIsEqualToUTF8CString(propertyName, "hasPropertyLie")) {
 172         return 0;
 173     }
 174
 175     if (JSStringIsEqualToUTF8CString(propertyName, "throwOnGet")) {
 176         return JSEvaluateScript(context, JSStringCreateWithUTF8CString("throw 'an exception'"), object, JSStringCreateWithUTF8CString("test script"), 1, exception);
 177     }
 178
 179     if (JSStringIsEqualToUTF8CString(propertyName, "0")) {
 180         *exception = JSValueMakeNumber(context, 1);
 181         return JSValueMakeNumber(context, 1);
 182     }
 183
 184     return JSValueMakeNull(context);
 185 }
 186
 187 static bool MyObject_setProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)
 188 {
 189     UNUSED_PARAM(context);
 190     UNUSED_PARAM(object);
 191     UNUSED_PARAM(value);
 192     UNUSED_PARAM(exception);
 193
 194     if (JSStringIsEqualToUTF8CString(propertyName, "cantSet"))
 195         return true; // pretend we set the property in order to swallow it
 196
 197     if (JSStringIsEqualToUTF8CString(propertyName, "throwOnSet")) {
 198         JSEvaluateScript(context, JSStringCreateWithUTF8CString("throw 'an exception'"), object, JSStringCreateWithUTF8CString("test script"), 1, exception);
 199     }
 200
 201     return false;
 202 }
 203
 204 static bool MyObject_deleteProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
 205 {
 206     UNUSED_PARAM(context);
 207     UNUSED_PARAM(object);
 208
 209     if (JSStringIsEqualToUTF8CString(propertyName, "cantDelete"))
 210         return true;
 211
 212     if (JSStringIsEqualToUTF8CString(propertyName, "throwOnDelete")) {
 213         JSEvaluateScript(context, JSStringCreateWithUTF8CString("throw 'an exception'"), object, JSStringCreateWithUTF8CString("test script"), 1, exception);
 214         return false;
 215     }
 216
 217     return false;
 218 }
 219
 220 static void MyObject_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef propertyNames)
 221 {
 222     UNUSED_PARAM(context);
 223     UNUSED_PARAM(object);
 224
 225     JSStringRef propertyName;
 226
 227     propertyName = JSStringCreateWithUTF8CString("alwaysOne");
 228     JSPropertyNameAccumulatorAddName(propertyNames, propertyName);
 229     JSStringRelease(propertyName);
 230
 231     propertyName = JSStringCreateWithUTF8CString("myPropertyName");
 232     JSPropertyNameAccumulatorAddName(propertyNames, propertyName);
 233     JSStringRelease(propertyName);
 234 }
 235
 236 static JSValueRef MyObject_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
 237 {
 238     UNUSED_PARAM(context);
 239     UNUSED_PARAM(object);
 240     UNUSED_PARAM(thisObject);
 241     UNUSED_PARAM(exception);
 242
 243     if (argumentCount > 0 && JSValueIsString(context, arguments[0]) && JSStringIsEqualToUTF8CString(JSValueToStringCopy(context, arguments[0], 0), "throwOnCall")) {
 244         JSEvaluateScript(context, JSStringCreateWithUTF8CString("throw 'an exception'"), object, JSStringCreateWithUTF8CString("test script"), 1, exception);
 245         return JSValueMakeUndefined(context);
 246     }
 247
 248     if (argumentCount > 0 && JSValueIsStrictEqual(context, arguments[0], JSValueMakeNumber(context, 0)))
 249         return JSValueMakeNumber(context, 1);
 250
 251     return JSValueMakeUndefined(context);
 252 }
 253
 254 static JSObjectRef MyObject_callAsConstructor(JSContextRef context, JSObjectRef object, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
 255 {
 256     UNUSED_PARAM(context);
 257     UNUSED_PARAM(object);
 258
 259     if (argumentCount > 0 && JSValueIsString(context, arguments[0]) && JSStringIsEqualToUTF8CString(JSValueToStringCopy(context, arguments[0], 0), "throwOnConstruct")) {
 260         JSEvaluateScript(context, JSStringCreateWithUTF8CString("throw 'an exception'"), object, JSStringCreateWithUTF8CString("test script"), 1, exception);
 261         return object;
 262     }
 263
 264     if (argumentCount > 0 && JSValueIsStrictEqual(context, arguments[0], JSValueMakeNumber(context, 0)))
 265         return JSValueToObject(context, JSValueMakeNumber(context, 1), exception);
 266
 267     return JSValueToObject(context, JSValueMakeNumber(context, 0), exception);
 268 }
 269
 270 static bool MyObject_hasInstance(JSContextRef context, JSObjectRef constructor, JSValueRef possibleValue, JSValueRef* exception)
 271 {
 272     UNUSED_PARAM(context);
 273     UNUSED_PARAM(constructor);
 274
 275     if (JSValueIsString(context, possibleValue) && JSStringIsEqualToUTF8CString(JSValueToStringCopy(context, possibleValue, 0), "throwOnHasInstance")) {
 276         JSEvaluateScript(context, JSStringCreateWithUTF8CString("throw 'an exception'"), constructor, JSStringCreateWithUTF8CString("test script"), 1, exception);
 277         return false;
 278     }
 279
 280     JSStringRef numberString = JSStringCreateWithUTF8CString("Number");
 281     JSObjectRef numberConstructor = JSValueToObject(context, JSObjectGetProperty(context, JSContextGetGlobalObject(context), numberString, exception), exception);
 282     JSStringRelease(numberString);
 283
 284     return JSValueIsInstanceOfConstructor(context, possibleValue, numberConstructor, exception);
 285 }
 286
 287 static JSValueRef MyObject_convertToType(JSContextRef context, JSObjectRef object, JSType type, JSValueRef* exception)
 288 {
 289     UNUSED_PARAM(object);
 290     UNUSED_PARAM(exception);
 291
 292     switch (type) {
 293     case kJSTypeNumber:
 294         return JSValueMakeNumber(context, 1);
 295     case kJSTypeString:
 296         {
 297             JSStringRef string = JSStringCreateWithUTF8CString("MyObjectAsString");
 298             JSValueRef result = JSValueMakeString(context, string);
 299             JSStringRelease(string);
 300             return result;
 301         }
 302     default:
 303         break;
 304     }
 305
 306     // string conversion -- forward to default object class
 307     return JSValueMakeNull(context);
 308 }
 309
 310 static JSStaticValue evilStaticValues[] = {
 311     { "nullGetSet", 0, 0, kJSPropertyAttributeNone },
 312     { 0, 0, 0, 0 }
 313 };
 314
 315 static JSStaticFunction evilStaticFunctions[] = {
 316     { "nullCall", 0, kJSPropertyAttributeNone },
 317     { 0, 0, 0 }
 318 };
 319
 320 JSClassDefinition MyObject_definition = {
 321     0,
 322     kJSClassAttributeNone,
 323
 324     "MyObject",
 325     NULL,
 326
 327     evilStaticValues,
 328     evilStaticFunctions,
 329
 330     NULL,
 331     NULL,
 332     MyObject_hasProperty,
 333     MyObject_getProperty,
 334     MyObject_setProperty,
 335     MyObject_deleteProperty,
 336     MyObject_getPropertyNames,
 337     MyObject_callAsFunction,
 338     MyObject_callAsConstructor,
 339     MyObject_hasInstance,
 340     MyObject_convertToType,
 341 };
 342
 343 static JSClassRef MyObject_class(JSContextRef context)
 344 {
 345     UNUSED_PARAM(context);
 346
 347     static JSClassRef jsClass;
 348     if (!jsClass)
 349         jsClass = JSClassCreate(&MyObject_definition);
 350
 351     return jsClass;
 352 }
 353
 354 static bool EvilExceptionObject_hasInstance(JSContextRef context, JSObjectRef constructor, JSValueRef possibleValue, JSValueRef* exception)
 355 {
 356     UNUSED_PARAM(context);
 357     UNUSED_PARAM(constructor);
 358
 359     JSStringRef hasInstanceName = JSStringCreateWithUTF8CString("hasInstance");
 360     JSValueRef hasInstance = JSObjectGetProperty(context, constructor, hasInstanceName, exception);
 361     JSStringRelease(hasInstanceName);
 362     if (!hasInstance)
 363         return false;
 364     JSObjectRef function = JSValueToObject(context, hasInstance, exception);
 365     JSValueRef result = JSObjectCallAsFunction(context, function, constructor, 1, &possibleValue, exception);
 366     return result && JSValueToBoolean(context, result);
 367 }
 368
 369 static JSValueRef EvilExceptionObject_convertToType(JSContextRef context, JSObjectRef object, JSType type, JSValueRef* exception)
 370 {
 371     UNUSED_PARAM(object);
 372     UNUSED_PARAM(exception);
 373     JSStringRef funcName;
 374     switch (type) {
 375     case kJSTypeNumber:
 376         funcName = JSStringCreateWithUTF8CString("toNumber");
 377         break;
 378     case kJSTypeString:
 379         funcName = JSStringCreateWithUTF8CString("toStringExplicit");
 380         break;
 381     default:
 382         return JSValueMakeNull(context);
 383         break;
 384     }
 385
 386     JSValueRef func = JSObjectGetProperty(context, object, funcName, exception);
 387     JSStringRelease(funcName);
 388     JSObjectRef function = JSValueToObject(context, func, exception);
 389     if (!function)
 390         return JSValueMakeNull(context);
 391     JSValueRef value = JSObjectCallAsFunction(context, function, object, 0, NULL, exception);
 392     if (!value) {
 393         JSStringRef errorString = JSStringCreateWithUTF8CString("convertToType failed");
 394         JSValueRef errorStringRef = JSValueMakeString(context, errorString);
 395         JSStringRelease(errorString);
 396         return errorStringRef;
 397     }
 398     return value;
 399 }
 400
 401 JSClassDefinition EvilExceptionObject_definition = {
 402     0,
 403     kJSClassAttributeNone,
 404
 405     "EvilExceptionObject",
 406     NULL,
 407
 408     NULL,
 409     NULL,
 410
 411     NULL,
 412     NULL,
 413     NULL,
 414     NULL,
 415     NULL,
 416     NULL,
 417     NULL,
 418     NULL,
 419     NULL,
 420     EvilExceptionObject_hasInstance,
 421     EvilExceptionObject_convertToType,
 422 };
 423
 424 static JSClassRef EvilExceptionObject_class(JSContextRef context)
 425 {
 426     UNUSED_PARAM(context);
 427
 428     static JSClassRef jsClass;
 429     if (!jsClass)
 430         jsClass = JSClassCreate(&EvilExceptionObject_definition);
 431
 432     return jsClass;
 433 }
 434
 435 JSClassDefinition EmptyObject_definition = {
 436     0,
 437     kJSClassAttributeNone,
 438
 439     NULL,
 440     NULL,
 441
 442     NULL,
 443     NULL,
 444
 445     NULL,
 446     NULL,
 447     NULL,
 448     NULL,
 449     NULL,
 450     NULL,
 451     NULL,
 452     NULL,
 453     NULL,
 454     NULL,
 455     NULL,
 456 };
 457
 458 static JSClassRef EmptyObject_class(JSContextRef context)
 459 {
 460     UNUSED_PARAM(context);
 461
 462     static JSClassRef jsClass;
 463     if (!jsClass)
 464         jsClass = JSClassCreate(&EmptyObject_definition);
 465
 466     return jsClass;
 467 }
 468
 469
 470 static JSValueRef Base_get(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
 471 {
 472     UNUSED_PARAM(object);
 473     UNUSED_PARAM(propertyName);
 474     UNUSED_PARAM(exception);
 475
 476     return JSValueMakeNumber(ctx, 1); // distinguish base get form derived get
 477 }
 478
 479 static bool Base_set(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)
 480 {
 481     UNUSED_PARAM(object);
 482     UNUSED_PARAM(propertyName);
 483     UNUSED_PARAM(value);
 484
 485     *exception = JSValueMakeNumber(ctx, 1); // distinguish base set from derived set
 486     return true;
 487 }
 488
 489 static JSValueRef Base_callAsFunction(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
 490 {
 491     UNUSED_PARAM(function);
 492     UNUSED_PARAM(thisObject);
 493     UNUSED_PARAM(argumentCount);
 494     UNUSED_PARAM(arguments);
 495     UNUSED_PARAM(exception);
 496
 497     return JSValueMakeNumber(ctx, 1); // distinguish base call from derived call
 498 }
 499
 500 static JSStaticFunction Base_staticFunctions[] = {
 501     { "baseProtoDup", NULL, kJSPropertyAttributeNone },
 502     { "baseProto", Base_callAsFunction, kJSPropertyAttributeNone },
 503     { 0, 0, 0 }
 504 };
 505
 506 static JSStaticValue Base_staticValues[] = {
 507     { "baseDup", Base_get, Base_set, kJSPropertyAttributeNone },
 508     { "baseOnly", Base_get, Base_set, kJSPropertyAttributeNone },
 509     { 0, 0, 0, 0 }
 510 };
 511
 512 static bool TestInitializeFinalize;
 513 static void Base_initialize(JSContextRef context, JSObjectRef object)
 514 {
 515     UNUSED_PARAM(context);
 516
 517     if (TestInitializeFinalize) {
 518         ASSERT((void*)1 == JSObjectGetPrivate(object));
 519         JSObjectSetPrivate(object, (void*)2);
 520     }
 521 }
 522
 523 static unsigned Base_didFinalize;
 524 static void Base_finalize(JSObjectRef object)
 525 {
 526     UNUSED_PARAM(object);
 527     if (TestInitializeFinalize) {
 528         ASSERT((void*)4 == JSObjectGetPrivate(object));
 529         Base_didFinalize = true;
 530     }
 531 }
 532
 533 static JSClassRef Base_class(JSContextRef context)
 534 {
 535     UNUSED_PARAM(context);
 536
 537     static JSClassRef jsClass;
 538     if (!jsClass) {
 539         JSClassDefinition definition = kJSClassDefinitionEmpty;
 540         definition.staticValues = Base_staticValues;
 541         definition.staticFunctions = Base_staticFunctions;
 542         definition.initialize = Base_initialize;
 543         definition.finalize = Base_finalize;
 544         jsClass = JSClassCreate(&definition);
 545     }
 546     return jsClass;
 547 }
 548
 549 static JSValueRef Derived_get(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
 550 {
 551     UNUSED_PARAM(object);
 552     UNUSED_PARAM(propertyName);
 553     UNUSED_PARAM(exception);
 554
 555     return JSValueMakeNumber(ctx, 2); // distinguish base get form derived get
 556 }
 557
 558 static bool Derived_set(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)
 559 {
 560     UNUSED_PARAM(ctx);
 561     UNUSED_PARAM(object);
 562     UNUSED_PARAM(propertyName);
 563     UNUSED_PARAM(value);
 564
 565     *exception = JSValueMakeNumber(ctx, 2); // distinguish base set from derived set
 566     return true;
 567 }
 568
 569 static JSValueRef Derived_callAsFunction(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
 570 {
 571     UNUSED_PARAM(function);
 572     UNUSED_PARAM(thisObject);
 573     UNUSED_PARAM(argumentCount);
 574     UNUSED_PARAM(arguments);
 575     UNUSED_PARAM(exception);
 576
 577     return JSValueMakeNumber(ctx, 2); // distinguish base call from derived call
 578 }
 579
 580 static JSStaticFunction Derived_staticFunctions[] = {
 581     { "protoOnly", Derived_callAsFunction, kJSPropertyAttributeNone },
 582     { "protoDup", NULL, kJSPropertyAttributeNone },
 583     { "baseProtoDup", Derived_callAsFunction, kJSPropertyAttributeNone },
 584     { 0, 0, 0 }
 585 };
 586
 587 static JSStaticValue Derived_staticValues[] = {
 588     { "derivedOnly", Derived_get, Derived_set, kJSPropertyAttributeNone },
 589     { "protoDup", Derived_get, Derived_set, kJSPropertyAttributeNone },
 590     { "baseDup", Derived_get, Derived_set, kJSPropertyAttributeNone },
 591     { 0, 0, 0, 0 }
 592 };
 593
 594 static void Derived_initialize(JSContextRef context, JSObjectRef object)
 595 {
 596     UNUSED_PARAM(context);
 597
 598     if (TestInitializeFinalize) {
 599         ASSERT((void*)2 == JSObjectGetPrivate(object));
 600         JSObjectSetPrivate(object, (void*)3);
 601     }
 602 }
 603
 604 static void Derived_finalize(JSObjectRef object)
 605 {
 606     if (TestInitializeFinalize) {
 607         ASSERT((void*)3 == JSObjectGetPrivate(object));
 608         JSObjectSetPrivate(object, (void*)4);
 609     }
 610 }
 611
 612 static JSClassRef Derived_class(JSContextRef context)
 613 {
 614     static JSClassRef jsClass;
 615     if (!jsClass) {
 616         JSClassDefinition definition = kJSClassDefinitionEmpty;
 617         definition.parentClass = Base_class(context);
 618         definition.staticValues = Derived_staticValues;
 619         definition.staticFunctions = Derived_staticFunctions;
 620         definition.initialize = Derived_initialize;
 621         definition.finalize = Derived_finalize;
 622         jsClass = JSClassCreate(&definition);
 623     }
 624     return jsClass;
 625 }
 626
 627 static JSClassRef Derived2_class(JSContextRef context)
 628 {
 629     static JSClassRef jsClass;
 630     if (!jsClass) {
 631         JSClassDefinition definition = kJSClassDefinitionEmpty;
 632         definition.parentClass = Derived_class(context);
 633         jsClass = JSClassCreate(&definition);
 634     }
 635     return jsClass;
 636 }
 637
 638 static JSValueRef print_callAsFunction(JSContextRef ctx, JSObjectRef functionObject, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
 639 {
 640     UNUSED_PARAM(functionObject);
 641     UNUSED_PARAM(thisObject);
 642     UNUSED_PARAM(exception);
 643
 644     ASSERT(JSContextGetGlobalContext(ctx) == context);
 645
 646     if (argumentCount > 0) {
 647         JSStringRef string = JSValueToStringCopy(ctx, arguments[0], NULL);
 648         size_t sizeUTF8 = JSStringGetMaximumUTF8CStringSize(string);
 649         char* stringUTF8 = (char*)malloc(sizeUTF8);
 650         JSStringGetUTF8CString(string, stringUTF8, sizeUTF8);
 651         printf("%s\n", stringUTF8);
 652         free(stringUTF8);
 653         JSStringRelease(string);
 654     }
 655
 656     return JSValueMakeUndefined(ctx);
 657 }
 658
 659 static JSObjectRef myConstructor_callAsConstructor(JSContextRef context, JSObjectRef constructorObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
 660 {
 661     UNUSED_PARAM(constructorObject);
 662     UNUSED_PARAM(exception);
 663
 664     JSObjectRef result = JSObjectMake(context, NULL, NULL);
 665     if (argumentCount > 0) {
 666         JSStringRef value = JSStringCreateWithUTF8CString("value");
 667         JSObjectSetProperty(context, result, value, arguments[0], kJSPropertyAttributeNone, NULL);
 668         JSStringRelease(value);
 669     }
 670
 671     return result;
 672 }
 673
 674
 675 static void globalObject_initialize(JSContextRef context, JSObjectRef object)
 676 {
 677     UNUSED_PARAM(object);
 678     // Ensure that an execution context is passed in
 679     ASSERT(context);
 680
 681     // Ensure that the global object is set to the object that we were passed
 682     JSObjectRef globalObject = JSContextGetGlobalObject(context);
 683     ASSERT(globalObject);
 684     ASSERT(object == globalObject);
 685
 686     // Ensure that the standard global properties have been set on the global object
 687     JSStringRef array = JSStringCreateWithUTF8CString("Array");
 688     JSObjectRef arrayConstructor = JSValueToObject(context, JSObjectGetProperty(context, globalObject, array, NULL), NULL);
 689     JSStringRelease(array);
 690
 691     UNUSED_PARAM(arrayConstructor);
 692     ASSERT(arrayConstructor);
 693 }
 694
 695 static JSValueRef globalObject_get(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
 696 {
 697     UNUSED_PARAM(object);
 698     UNUSED_PARAM(propertyName);
 699     UNUSED_PARAM(exception);
 700
 701     return JSValueMakeNumber(ctx, 3);
 702 }
 703
 704 static bool globalObject_set(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)
 705 {
 706     UNUSED_PARAM(object);
 707     UNUSED_PARAM(propertyName);
 708     UNUSED_PARAM(value);
 709
 710     *exception = JSValueMakeNumber(ctx, 3);
 711     return true;
 712 }
 713
 714 static JSValueRef globalObject_call(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
 715 {
 716     UNUSED_PARAM(function);
 717     UNUSED_PARAM(thisObject);
 718     UNUSED_PARAM(argumentCount);
 719     UNUSED_PARAM(arguments);
 720     UNUSED_PARAM(exception);
 721
 722     return JSValueMakeNumber(ctx, 3);
 723 }
 724
 725 static JSValueRef functionGC(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
 726 {
 727     UNUSED_PARAM(function);
 728     UNUSED_PARAM(thisObject);
 729     UNUSED_PARAM(argumentCount);
 730     UNUSED_PARAM(arguments);
 731     UNUSED_PARAM(exception);
 732     JSGarbageCollect(context);
 733     return JSValueMakeUndefined(context);
 734 }
 735
 736 static JSStaticValue globalObject_staticValues[] = {
 737     { "globalStaticValue", globalObject_get, globalObject_set, kJSPropertyAttributeNone },
 738     { 0, 0, 0, 0 }
 739 };
 740
 741 static JSStaticFunction globalObject_staticFunctions[] = {
 742     { "globalStaticFunction", globalObject_call, kJSPropertyAttributeNone },
 743     { "gc", functionGC, kJSPropertyAttributeNone },
 744     { 0, 0, 0 }
 745 };
 746
 747 static char* createStringWithContentsOfFile(const char* fileName);
 748
 749 static void testInitializeFinalize()
 750 {
 751     JSObjectRef o = JSObjectMake(context, Derived_class(context), (void*)1);
 752     UNUSED_PARAM(o);
 753     ASSERT(JSObjectGetPrivate(o) == (void*)3);
 754 }
 755
 756 static JSValueRef jsNumberValue =  NULL;
 757
 758 static JSObjectRef aHeapRef = NULL;
 759
 760 static void makeGlobalNumberValue(JSContextRef context) {
 761     JSValueRef v = JSValueMakeNumber(context, 420);
 762     JSValueProtect(context, v);
 763     jsNumberValue = v;
 764     v = NULL;
 765 }
 766
 767 int main(int argc, char* argv[])
 768 {
 769     const char *scriptPath = "testapi.js";
 770     if (argc > 1) {
 771         scriptPath = argv[1];
 772     }
 773
 774     // Test garbage collection with a fresh context
 775     context = JSGlobalContextCreateInGroup(NULL, NULL);
 776     TestInitializeFinalize = true;
 777     testInitializeFinalize();
 778     JSGlobalContextRelease(context);
 779     TestInitializeFinalize = false;
 780
 781     ASSERT(Base_didFinalize);
 782
 783     JSClassDefinition globalObjectClassDefinition = kJSClassDefinitionEmpty;
 784     globalObjectClassDefinition.initialize = globalObject_initialize;
 785     globalObjectClassDefinition.staticValues = globalObject_staticValues;
 786     globalObjectClassDefinition.staticFunctions = globalObject_staticFunctions;
 787     globalObjectClassDefinition.attributes = kJSClassAttributeNoAutomaticPrototype;
 788     JSClassRef globalObjectClass = JSClassCreate(&globalObjectClassDefinition);
 789     context = JSGlobalContextCreateInGroup(NULL, globalObjectClass);
 790
 791     JSGlobalContextRetain(context);
 792     JSGlobalContextRelease(context);
 793     ASSERT(JSContextGetGlobalContext(context) == context);
 794
 795     JSReportExtraMemoryCost(context, 0);
 796     JSReportExtraMemoryCost(context, 1);
 797     JSReportExtraMemoryCost(context, 1024);
 798
 799     JSObjectRef globalObject = JSContextGetGlobalObject(context);
 800     ASSERT(JSValueIsObject(context, globalObject));
 801
 802     JSValueRef jsUndefined = JSValueMakeUndefined(context);
 803     JSValueRef jsNull = JSValueMakeNull(context);
 804     JSValueRef jsTrue = JSValueMakeBoolean(context, true);
 805     JSValueRef jsFalse = JSValueMakeBoolean(context, false);
 806     JSValueRef jsZero = JSValueMakeNumber(context, 0);
 807     JSValueRef jsOne = JSValueMakeNumber(context, 1);
 808     JSValueRef jsOneThird = JSValueMakeNumber(context, 1.0 / 3.0);
 809     JSObjectRef jsObjectNoProto = JSObjectMake(context, NULL, NULL);
 810     JSObjectSetPrototype(context, jsObjectNoProto, JSValueMakeNull(context));
 811
 812     // FIXME: test funny utf8 characters
 813     JSStringRef jsEmptyIString = JSStringCreateWithUTF8CString("");
 814     JSValueRef jsEmptyString = JSValueMakeString(context, jsEmptyIString);
 815
 816     JSStringRef jsOneIString = JSStringCreateWithUTF8CString("1");
 817     JSValueRef jsOneString = JSValueMakeString(context, jsOneIString);
 818
 819     UniChar singleUniChar = 65; // Capital A
 820     CFMutableStringRef cfString =
 821         CFStringCreateMutableWithExternalCharactersNoCopy(kCFAllocatorDefault,
 822                                                           &singleUniChar,
 823                                                           1,
 824                                                           1,
 825                                                           kCFAllocatorNull);
 826
 827     JSStringRef jsCFIString = JSStringCreateWithCFString(cfString);
 828     JSValueRef jsCFString = JSValueMakeString(context, jsCFIString);
 829
 830     CFStringRef cfEmptyString = CFStringCreateWithCString(kCFAllocatorDefault, "", kCFStringEncodingUTF8);
 831
 832     JSStringRef jsCFEmptyIString = JSStringCreateWithCFString(cfEmptyString);
 833     JSValueRef jsCFEmptyString = JSValueMakeString(context, jsCFEmptyIString);
 834
 835     CFIndex cfStringLength = CFStringGetLength(cfString);
 836     UniChar* buffer = (UniChar*)malloc(cfStringLength * sizeof(UniChar));
 837     CFStringGetCharacters(cfString,
 838                           CFRangeMake(0, cfStringLength),
 839                           buffer);
 840     JSStringRef jsCFIStringWithCharacters = JSStringCreateWithCharacters((JSChar*)buffer, cfStringLength);
 841     JSValueRef jsCFStringWithCharacters = JSValueMakeString(context, jsCFIStringWithCharacters);
 842
 843     JSStringRef jsCFEmptyIStringWithCharacters = JSStringCreateWithCharacters((JSChar*)buffer, CFStringGetLength(cfEmptyString));
 844     free(buffer);
 845     JSValueRef jsCFEmptyStringWithCharacters = JSValueMakeString(context, jsCFEmptyIStringWithCharacters);
 846
 847     ASSERT(JSValueGetType(context, jsUndefined) == kJSTypeUndefined);
 848     ASSERT(JSValueGetType(context, jsNull) == kJSTypeNull);
 849     ASSERT(JSValueGetType(context, jsTrue) == kJSTypeBoolean);
 850     ASSERT(JSValueGetType(context, jsFalse) == kJSTypeBoolean);
 851     ASSERT(JSValueGetType(context, jsZero) == kJSTypeNumber);
 852     ASSERT(JSValueGetType(context, jsOne) == kJSTypeNumber);
 853     ASSERT(JSValueGetType(context, jsOneThird) == kJSTypeNumber);
 854     ASSERT(JSValueGetType(context, jsEmptyString) == kJSTypeString);
 855     ASSERT(JSValueGetType(context, jsOneString) == kJSTypeString);
 856     ASSERT(JSValueGetType(context, jsCFString) == kJSTypeString);
 857     ASSERT(JSValueGetType(context, jsCFStringWithCharacters) == kJSTypeString);
 858     ASSERT(JSValueGetType(context, jsCFEmptyString) == kJSTypeString);
 859     ASSERT(JSValueGetType(context, jsCFEmptyStringWithCharacters) == kJSTypeString);
 860
 861     JSObjectRef myObject = JSObjectMake(context, MyObject_class(context), NULL);
 862     JSStringRef myObjectIString = JSStringCreateWithUTF8CString("MyObject");
 863     JSObjectSetProperty(context, globalObject, myObjectIString, myObject, kJSPropertyAttributeNone, NULL);
 864     JSStringRelease(myObjectIString);
 865
 866     JSObjectRef EvilExceptionObject = JSObjectMake(context, EvilExceptionObject_class(context), NULL);
 867     JSStringRef EvilExceptionObjectIString = JSStringCreateWithUTF8CString("EvilExceptionObject");
 868     JSObjectSetProperty(context, globalObject, EvilExceptionObjectIString, EvilExceptionObject, kJSPropertyAttributeNone, NULL);
 869     JSStringRelease(EvilExceptionObjectIString);
 870
 871     JSObjectRef EmptyObject = JSObjectMake(context, EmptyObject_class(context), NULL);
 872     JSStringRef EmptyObjectIString = JSStringCreateWithUTF8CString("EmptyObject");
 873     JSObjectSetProperty(context, globalObject, EmptyObjectIString, EmptyObject, kJSPropertyAttributeNone, NULL);
 874     JSStringRelease(EmptyObjectIString);
 875
 876     JSStringRef lengthStr = JSStringCreateWithUTF8CString("length");
 877     aHeapRef = JSObjectMakeArray(context, 0, 0, 0);
 878     JSObjectSetProperty(context, aHeapRef, lengthStr, JSValueMakeNumber(context, 10), 0, 0);
 879     JSStringRef privatePropertyName = JSStringCreateWithUTF8CString("privateProperty");
 880     if (!JSObjectSetPrivateProperty(context, myObject, privatePropertyName, aHeapRef)) {
 881         printf("FAIL: Could not set private property.\n");
 882         failed = 1;
 883     } else {
 884         printf("PASS: Set private property.\n");
 885     }
 886     if (JSObjectSetPrivateProperty(context, aHeapRef, privatePropertyName, aHeapRef)) {
 887         printf("FAIL: JSObjectSetPrivateProperty should fail on non-API objects.\n");
 888         failed = 1;
 889     } else {
 890         printf("PASS: Did not allow JSObjectSetPrivateProperty on a non-API object.\n");
 891     }
 892     if (JSObjectGetPrivateProperty(context, myObject, privatePropertyName) != aHeapRef) {
 893         printf("FAIL: Could not retrieve private property.\n");
 894         failed = 1;
 895     } else
 896         printf("PASS: Retrieved private property.\n");
 897     if (JSObjectGetPrivateProperty(context, aHeapRef, privatePropertyName)) {
 898         printf("FAIL: JSObjectGetPrivateProperty should return NULL when called on a non-API object.\n");
 899         failed = 1;
 900     } else
 901         printf("PASS: JSObjectGetPrivateProperty return NULL.\n");
 902
 903     if (JSObjectGetProperty(context, myObject, privatePropertyName, 0) == aHeapRef) {
 904         printf("FAIL: Accessed private property through ordinary property lookup.\n");
 905         failed = 1;
 906     } else
 907         printf("PASS: Cannot access private property through ordinary property lookup.\n");
 908
 909     JSGarbageCollect(context);
 910
 911     for (int i = 0; i < 10000; i++)
 912         JSObjectMake(context, 0, 0);
 913
 914     if (JSValueToNumber(context, JSObjectGetProperty(context, aHeapRef, lengthStr, 0), 0) != 10) {
 915         printf("FAIL: Private property has been collected.\n");
 916         failed = 1;
 917     } else
 918         printf("PASS: Private property does not appear to have been collected.\n");
 919     JSStringRelease(lengthStr);
 920
 921     JSStringRef validJSON = JSStringCreateWithUTF8CString("{\"aProperty\":true}");
 922     JSValueRef jsonObject = JSValueMakeFromJSONString(context, validJSON);
 923     JSStringRelease(validJSON);
 924     if (!JSValueIsObject(context, jsonObject)) {
 925         printf("FAIL: Did not parse valid JSON correctly\n");
 926         failed = 1;
 927     } else
 928         printf("PASS: Parsed valid JSON string.\n");
 929     JSStringRef propertyName = JSStringCreateWithUTF8CString("aProperty");
 930     assertEqualsAsBoolean(JSObjectGetProperty(context, JSValueToObject(context, jsonObject, 0), propertyName, 0), true);
 931     JSStringRelease(propertyName);
 932     JSStringRef invalidJSON = JSStringCreateWithUTF8CString("fail!");
 933     if (JSValueMakeFromJSONString(context, invalidJSON)) {
 934         printf("FAIL: Should return null for invalid JSON data\n");
 935         failed = 1;
 936     } else
 937         printf("PASS: Correctly returned null for invalid JSON data.\n");
 938     JSValueRef exception;
 939     JSStringRef str = JSValueCreateJSONString(context, jsonObject, 0, 0);
 940     if (!JSStringIsEqualToUTF8CString(str, "{\"aProperty\":true}")) {
 941         printf("FAIL: Did not correctly serialise with indent of 0.\n");
 942         failed = 1;
 943     } else
 944         printf("PASS: Correctly serialised with indent of 0.\n");
 945     JSStringRelease(str);
 946
 947     str = JSValueCreateJSONString(context, jsonObject, 4, 0);
 948     if (!JSStringIsEqualToUTF8CString(str, "{\n    \"aProperty\": true\n}")) {
 949         printf("FAIL: Did not correctly serialise with indent of 4.\n");
 950         failed = 1;
 951     } else
 952         printf("PASS: Correctly serialised with indent of 4.\n");
 953     JSStringRelease(str);
 954     JSStringRef src = JSStringCreateWithUTF8CString("({get a(){ throw '';}})");
 955     JSValueRef unstringifiableObj = JSEvaluateScript(context, src, NULL, NULL, 1, NULL);
 956
 957     str = JSValueCreateJSONString(context, unstringifiableObj, 4, 0);
 958     if (str) {
 959         printf("FAIL: Didn't return null when attempting to serialize unserializable value.\n");
 960         JSStringRelease(str);
 961         failed = 1;
 962     } else
 963         printf("PASS: returned null when attempting to serialize unserializable value.\n");
 964
 965     str = JSValueCreateJSONString(context, unstringifiableObj, 4, &exception);
 966     if (str) {
 967         printf("FAIL: Didn't return null when attempting to serialize unserializable value.\n");
 968         JSStringRelease(str);
 969         failed = 1;
 970     } else
 971         printf("PASS: returned null when attempting to serialize unserializable value.\n");
 972     if (!exception) {
 973         printf("FAIL: Did not set exception on serialisation error\n");
 974         failed = 1;
 975     } else
 976         printf("PASS: set exception on serialisation error\n");
 977     // Conversions that throw exceptions
 978     exception = NULL;
 979     ASSERT(NULL == JSValueToObject(context, jsNull, &exception));
 980     ASSERT(exception);
 981
 982     exception = NULL;
 983     // FIXME <rdar://4668451> - On i386 the isnan(double) macro tries to map to the isnan(float) function,
 984     // causing a build break with -Wshorten-64-to-32 enabled.  The issue is known by the appropriate team.
 985     // After that's resolved, we can remove these casts
 986     ASSERT(isnan((float)JSValueToNumber(context, jsObjectNoProto, &exception)));
 987     ASSERT(exception);
 988
 989     exception = NULL;
 990     ASSERT(!JSValueToStringCopy(context, jsObjectNoProto, &exception));
 991     ASSERT(exception);
 992
 993     ASSERT(JSValueToBoolean(context, myObject));
 994
 995     exception = NULL;
 996     ASSERT(!JSValueIsEqual(context, jsObjectNoProto, JSValueMakeNumber(context, 1), &exception));
 997     ASSERT(exception);
 998
 999     exception = NULL;
1000     JSObjectGetPropertyAtIndex(context, myObject, 0, &exception);
1001     ASSERT(1 == JSValueToNumber(context, exception, NULL));
1002
1003     assertEqualsAsBoolean(jsUndefined, false);
1004     assertEqualsAsBoolean(jsNull, false);
1005     assertEqualsAsBoolean(jsTrue, true);
1006     assertEqualsAsBoolean(jsFalse, false);
1007     assertEqualsAsBoolean(jsZero, false);
1008     assertEqualsAsBoolean(jsOne, true);
1009     assertEqualsAsBoolean(jsOneThird, true);
1010     assertEqualsAsBoolean(jsEmptyString, false);
1011     assertEqualsAsBoolean(jsOneString, true);
1012     assertEqualsAsBoolean(jsCFString, true);
1013     assertEqualsAsBoolean(jsCFStringWithCharacters, true);
1014     assertEqualsAsBoolean(jsCFEmptyString, false);
1015     assertEqualsAsBoolean(jsCFEmptyStringWithCharacters, false);
1016
1017     assertEqualsAsNumber(jsUndefined, nan(""));
1018     assertEqualsAsNumber(jsNull, 0);
1019     assertEqualsAsNumber(jsTrue, 1);
1020     assertEqualsAsNumber(jsFalse, 0);
1021     assertEqualsAsNumber(jsZero, 0);
1022     assertEqualsAsNumber(jsOne, 1);
1023     assertEqualsAsNumber(jsOneThird, 1.0 / 3.0);
1024     assertEqualsAsNumber(jsEmptyString, 0);
1025     assertEqualsAsNumber(jsOneString, 1);
1026     assertEqualsAsNumber(jsCFString, nan(""));
1027     assertEqualsAsNumber(jsCFStringWithCharacters, nan(""));
1028     assertEqualsAsNumber(jsCFEmptyString, 0);
1029     assertEqualsAsNumber(jsCFEmptyStringWithCharacters, 0);
1030     ASSERT(sizeof(JSChar) == sizeof(UniChar));
1031
1032     assertEqualsAsCharactersPtr(jsUndefined, "undefined");
1033     assertEqualsAsCharactersPtr(jsNull, "null");
1034     assertEqualsAsCharactersPtr(jsTrue, "true");
1035     assertEqualsAsCharactersPtr(jsFalse, "false");
1036     assertEqualsAsCharactersPtr(jsZero, "0");
1037     assertEqualsAsCharactersPtr(jsOne, "1");
1038     assertEqualsAsCharactersPtr(jsOneThird, "0.3333333333333333");
1039     assertEqualsAsCharactersPtr(jsEmptyString, "");
1040     assertEqualsAsCharactersPtr(jsOneString, "1");
1041     assertEqualsAsCharactersPtr(jsCFString, "A");
1042     assertEqualsAsCharactersPtr(jsCFStringWithCharacters, "A");
1043     assertEqualsAsCharactersPtr(jsCFEmptyString, "");
1044     assertEqualsAsCharactersPtr(jsCFEmptyStringWithCharacters, "");
1045
1046     assertEqualsAsUTF8String(jsUndefined, "undefined");
1047     assertEqualsAsUTF8String(jsNull, "null");
1048     assertEqualsAsUTF8String(jsTrue, "true");
1049     assertEqualsAsUTF8String(jsFalse, "false");
1050     assertEqualsAsUTF8String(jsZero, "0");
1051     assertEqualsAsUTF8String(jsOne, "1");
1052     assertEqualsAsUTF8String(jsOneThird, "0.3333333333333333");
1053     assertEqualsAsUTF8String(jsEmptyString, "");
1054     assertEqualsAsUTF8String(jsOneString, "1");
1055     assertEqualsAsUTF8String(jsCFString, "A");
1056     assertEqualsAsUTF8String(jsCFStringWithCharacters, "A");
1057     assertEqualsAsUTF8String(jsCFEmptyString, "");
1058     assertEqualsAsUTF8String(jsCFEmptyStringWithCharacters, "");
1059
1060     ASSERT(JSValueIsStrictEqual(context, jsTrue, jsTrue));
1061     ASSERT(!JSValueIsStrictEqual(context, jsOne, jsOneString));
1062
1063     ASSERT(JSValueIsEqual(context, jsOne, jsOneString, NULL));
1064     ASSERT(!JSValueIsEqual(context, jsTrue, jsFalse, NULL));
1065
1066     CFStringRef cfJSString = JSStringCopyCFString(kCFAllocatorDefault, jsCFIString);
1067     CFStringRef cfJSEmptyString = JSStringCopyCFString(kCFAllocatorDefault, jsCFEmptyIString);
1068     ASSERT(CFEqual(cfJSString, cfString));
1069     ASSERT(CFEqual(cfJSEmptyString, cfEmptyString));
1070     CFRelease(cfJSString);
1071     CFRelease(cfJSEmptyString);
1072
1073     CFRelease(cfString);
1074     CFRelease(cfEmptyString);
1075
1076     jsGlobalValue = JSObjectMake(context, NULL, NULL);
1077     makeGlobalNumberValue(context);
1078     JSValueProtect(context, jsGlobalValue);
1079     JSGarbageCollect(context);
1080     ASSERT(JSValueIsObject(context, jsGlobalValue));
1081     JSValueUnprotect(context, jsGlobalValue);
1082     JSValueUnprotect(context, jsNumberValue);
1083
1084     JSStringRef goodSyntax = JSStringCreateWithUTF8CString("x = 1;");
1085     JSStringRef badSyntax = JSStringCreateWithUTF8CString("x := 1;");
1086     ASSERT(JSCheckScriptSyntax(context, goodSyntax, NULL, 0, NULL));
1087     ASSERT(!JSCheckScriptSyntax(context, badSyntax, NULL, 0, NULL));
1088
1089     JSValueRef result;
1090     JSValueRef v;
1091     JSObjectRef o;
1092     JSStringRef string;
1093
1094     result = JSEvaluateScript(context, goodSyntax, NULL, NULL, 1, NULL);
1095     ASSERT(result);
1096     ASSERT(JSValueIsEqual(context, result, jsOne, NULL));
1097
1098     exception = NULL;
1099     result = JSEvaluateScript(context, badSyntax, NULL, NULL, 1, &exception);
1100     ASSERT(!result);
1101     ASSERT(JSValueIsObject(context, exception));
1102
1103     JSStringRef array = JSStringCreateWithUTF8CString("Array");
1104     JSObjectRef arrayConstructor = JSValueToObject(context, JSObjectGetProperty(context, globalObject, array, NULL), NULL);
1105     JSStringRelease(array);
1106     result = JSObjectCallAsConstructor(context, arrayConstructor, 0, NULL, NULL);
1107     ASSERT(result);
1108     ASSERT(JSValueIsObject(context, result));
1109     ASSERT(JSValueIsInstanceOfConstructor(context, result, arrayConstructor, NULL));
1110     ASSERT(!JSValueIsInstanceOfConstructor(context, JSValueMakeNull(context), arrayConstructor, NULL));
1111
1112     o = JSValueToObject(context, result, NULL);
1113     exception = NULL;
1114     ASSERT(JSValueIsUndefined(context, JSObjectGetPropertyAtIndex(context, o, 0, &exception)));
1115     ASSERT(!exception);
1116
1117     JSObjectSetPropertyAtIndex(context, o, 0, JSValueMakeNumber(context, 1), &exception);
1118     ASSERT(!exception);
1119
1120     exception = NULL;
1121     ASSERT(1 == JSValueToNumber(context, JSObjectGetPropertyAtIndex(context, o, 0, &exception), &exception));
1122     ASSERT(!exception);
1123
1124     JSStringRef functionBody;
1125     JSObjectRef function;
1126
1127     exception = NULL;
1128     functionBody = JSStringCreateWithUTF8CString("rreturn Array;");
1129     JSStringRef line = JSStringCreateWithUTF8CString("line");
1130     ASSERT(!JSObjectMakeFunction(context, NULL, 0, NULL, functionBody, NULL, 1, &exception));
1131     ASSERT(JSValueIsObject(context, exception));
1132     v = JSObjectGetProperty(context, JSValueToObject(context, exception, NULL), line, NULL);
1133     assertEqualsAsNumber(v, 1);
1134     JSStringRelease(functionBody);
1135     JSStringRelease(line);
1136
1137     exception = NULL;
1138     functionBody = JSStringCreateWithUTF8CString("return Array;");
1139     function = JSObjectMakeFunction(context, NULL, 0, NULL, functionBody, NULL, 1, &exception);
1140     JSStringRelease(functionBody);
1141     ASSERT(!exception);
1142     ASSERT(JSObjectIsFunction(context, function));
1143     v = JSObjectCallAsFunction(context, function, NULL, 0, NULL, NULL);
1144     ASSERT(v);
1145     ASSERT(JSValueIsEqual(context, v, arrayConstructor, NULL));
1146
1147     exception = NULL;
1148     function = JSObjectMakeFunction(context, NULL, 0, NULL, jsEmptyIString, NULL, 0, &exception);
1149     ASSERT(!exception);
1150     v = JSObjectCallAsFunction(context, function, NULL, 0, NULL, &exception);
1151     ASSERT(v && !exception);
1152     ASSERT(JSValueIsUndefined(context, v));
1153
1154     exception = NULL;
1155     v = NULL;
1156     JSStringRef foo = JSStringCreateWithUTF8CString("foo");
1157     JSStringRef argumentNames[] = { foo };
1158     functionBody = JSStringCreateWithUTF8CString("return foo;");
1159     function = JSObjectMakeFunction(context, foo, 1, argumentNames, functionBody, NULL, 1, &exception);
1160     ASSERT(function && !exception);
1161     JSValueRef arguments[] = { JSValueMakeNumber(context, 2) };
1162     v = JSObjectCallAsFunction(context, function, NULL, 1, arguments, &exception);
1163     JSStringRelease(foo);
1164     JSStringRelease(functionBody);
1165
1166     string = JSValueToStringCopy(context, function, NULL);
1167     assertEqualsAsUTF8String(JSValueMakeString(context, string), "function foo(foo) { return foo;\n}");
1168     JSStringRelease(string);
1169
1170     JSStringRef print = JSStringCreateWithUTF8CString("print");
1171     JSObjectRef printFunction = JSObjectMakeFunctionWithCallback(context, print, print_callAsFunction);
1172     JSObjectSetProperty(context, globalObject, print, printFunction, kJSPropertyAttributeNone, NULL);
1173     JSStringRelease(print);
1174
1175     ASSERT(!JSObjectSetPrivate(printFunction, (void*)1));
1176     ASSERT(!JSObjectGetPrivate(printFunction));
1177
1178     JSStringRef myConstructorIString = JSStringCreateWithUTF8CString("MyConstructor");
1179     JSObjectRef myConstructor = JSObjectMakeConstructor(context, NULL, myConstructor_callAsConstructor);
1180     JSObjectSetProperty(context, globalObject, myConstructorIString, myConstructor, kJSPropertyAttributeNone, NULL);
1181     JSStringRelease(myConstructorIString);
1182
1183     ASSERT(!JSObjectSetPrivate(myConstructor, (void*)1));
1184     ASSERT(!JSObjectGetPrivate(myConstructor));
1185
1186     string = JSStringCreateWithUTF8CString("Base");
1187     JSObjectRef baseConstructor = JSObjectMakeConstructor(context, Base_class(context), NULL);
1188     JSObjectSetProperty(context, globalObject, string, baseConstructor, kJSPropertyAttributeNone, NULL);
1189     JSStringRelease(string);
1190
1191     string = JSStringCreateWithUTF8CString("Derived");
1192     JSObjectRef derivedConstructor = JSObjectMakeConstructor(context, Derived_class(context), NULL);
1193     JSObjectSetProperty(context, globalObject, string, derivedConstructor, kJSPropertyAttributeNone, NULL);
1194     JSStringRelease(string);
1195
1196     string = JSStringCreateWithUTF8CString("Derived2");
1197     JSObjectRef derived2Constructor = JSObjectMakeConstructor(context, Derived2_class(context), NULL);
1198     JSObjectSetProperty(context, globalObject, string, derived2Constructor, kJSPropertyAttributeNone, NULL);
1199     JSStringRelease(string);
1200
1201     o = JSObjectMake(context, NULL, NULL);
1202     JSObjectSetProperty(context, o, jsOneIString, JSValueMakeNumber(context, 1), kJSPropertyAttributeNone, NULL);
1203     JSObjectSetProperty(context, o, jsCFIString,  JSValueMakeNumber(context, 1), kJSPropertyAttributeDontEnum, NULL);
1204     JSPropertyNameArrayRef nameArray = JSObjectCopyPropertyNames(context, o);
1205     size_t expectedCount = JSPropertyNameArrayGetCount(nameArray);
1206     size_t count;
1207     for (count = 0; count < expectedCount; ++count)
1208         JSPropertyNameArrayGetNameAtIndex(nameArray, count);
1209     JSPropertyNameArrayRelease(nameArray);
1210     ASSERT(count == 1); // jsCFString should not be enumerated
1211
1212     JSValueRef argumentsArrayValues[] = { JSValueMakeNumber(context, 10), JSValueMakeNumber(context, 20) };
1213     o = JSObjectMakeArray(context, sizeof(argumentsArrayValues) / sizeof(JSValueRef), argumentsArrayValues, NULL);
1214     string = JSStringCreateWithUTF8CString("length");
1215     v = JSObjectGetProperty(context, o, string, NULL);
1216     assertEqualsAsNumber(v, 2);
1217     v = JSObjectGetPropertyAtIndex(context, o, 0, NULL);
1218     assertEqualsAsNumber(v, 10);
1219     v = JSObjectGetPropertyAtIndex(context, o, 1, NULL);
1220     assertEqualsAsNumber(v, 20);
1221
1222     o = JSObjectMakeArray(context, 0, NULL, NULL);
1223     v = JSObjectGetProperty(context, o, string, NULL);
1224     assertEqualsAsNumber(v, 0);
1225     JSStringRelease(string);
1226
1227     JSValueRef argumentsDateValues[] = { JSValueMakeNumber(context, 0) };
1228     o = JSObjectMakeDate(context, 1, argumentsDateValues, NULL);
1229     if (timeZoneIsPST())
1230         assertEqualsAsUTF8String(o, "Wed Dec 31 1969 16:00:00 GMT-0800 (PST)");
1231
1232     string = JSStringCreateWithUTF8CString("an error message");
1233     JSValueRef argumentsErrorValues[] = { JSValueMakeString(context, string) };
1234     o = JSObjectMakeError(context, 1, argumentsErrorValues, NULL);
1235     assertEqualsAsUTF8String(o, "Error: an error message");
1236     JSStringRelease(string);
1237
1238     string = JSStringCreateWithUTF8CString("foo");
1239     JSStringRef string2 = JSStringCreateWithUTF8CString("gi");
1240     JSValueRef argumentsRegExpValues[] = { JSValueMakeString(context, string), JSValueMakeString(context, string2) };
1241     o = JSObjectMakeRegExp(context, 2, argumentsRegExpValues, NULL);
1242     assertEqualsAsUTF8String(o, "/foo/gi");
1243     JSStringRelease(string);
1244     JSStringRelease(string2);
1245
1246     JSClassDefinition nullDefinition = kJSClassDefinitionEmpty;
1247     nullDefinition.attributes = kJSClassAttributeNoAutomaticPrototype;
1248     JSClassRef nullClass = JSClassCreate(&nullDefinition);
1249     JSClassRelease(nullClass);
1250
1251     nullDefinition = kJSClassDefinitionEmpty;
1252     nullClass = JSClassCreate(&nullDefinition);
1253     JSClassRelease(nullClass);
1254
1255     functionBody = JSStringCreateWithUTF8CString("return this;");
1256     function = JSObjectMakeFunction(context, NULL, 0, NULL, functionBody, NULL, 1, NULL);
1257     JSStringRelease(functionBody);
1258     v = JSObjectCallAsFunction(context, function, NULL, 0, NULL, NULL);
1259     ASSERT(JSValueIsEqual(context, v, globalObject, NULL));
1260     v = JSObjectCallAsFunction(context, function, o, 0, NULL, NULL);
1261     ASSERT(JSValueIsEqual(context, v, o, NULL));
1262
1263     functionBody = JSStringCreateWithUTF8CString("return eval(\"this\");");
1264     function = JSObjectMakeFunction(context, NULL, 0, NULL, functionBody, NULL, 1, NULL);
1265     JSStringRelease(functionBody);
1266     v = JSObjectCallAsFunction(context, function, NULL, 0, NULL, NULL);
1267     ASSERT(JSValueIsEqual(context, v, globalObject, NULL));
1268     v = JSObjectCallAsFunction(context, function, o, 0, NULL, NULL);
1269     ASSERT(JSValueIsEqual(context, v, o, NULL));
1270
1271     JSStringRef script = JSStringCreateWithUTF8CString("this;");
1272     v = JSEvaluateScript(context, script, NULL, NULL, 1, NULL);
1273     ASSERT(JSValueIsEqual(context, v, globalObject, NULL));
1274     v = JSEvaluateScript(context, script, o, NULL, 1, NULL);
1275     ASSERT(JSValueIsEqual(context, v, o, NULL));
1276     JSStringRelease(script);
1277
1278     script = JSStringCreateWithUTF8CString("eval(this);");
1279     v = JSEvaluateScript(context, script, NULL, NULL, 1, NULL);
1280     ASSERT(JSValueIsEqual(context, v, globalObject, NULL));
1281     v = JSEvaluateScript(context, script, o, NULL, 1, NULL);
1282     ASSERT(JSValueIsEqual(context, v, o, NULL));
1283     JSStringRelease(script);
1284
1285     // Verify that creating a constructor for a class with no static functions does not trigger
1286     // an assert inside putDirect or lead to a crash during GC. <https://bugs.webkit.org/show_bug.cgi?id=25785>
1287     nullDefinition = kJSClassDefinitionEmpty;
1288     nullClass = JSClassCreate(&nullDefinition);
1289     myConstructor = JSObjectMakeConstructor(context, nullClass, 0);
1290     JSClassRelease(nullClass);
1291
1292     char* scriptUTF8 = createStringWithContentsOfFile(scriptPath);
1293     if (!scriptUTF8) {
1294         printf("FAIL: Test script could not be loaded.\n");
1295         failed = 1;
1296     } else {
1297         script = JSStringCreateWithUTF8CString(scriptUTF8);
1298         result = JSEvaluateScript(context, script, NULL, NULL, 1, &exception);
1299         if (result && JSValueIsUndefined(context, result))
1300             printf("PASS: Test script executed successfully.\n");
1301         else {
1302             printf("FAIL: Test script returned unexpected value:\n");
1303             JSStringRef exceptionIString = JSValueToStringCopy(context, exception, NULL);
1304             CFStringRef exceptionCF = JSStringCopyCFString(kCFAllocatorDefault, exceptionIString);
1305             CFShow(exceptionCF);
1306             CFRelease(exceptionCF);
1307             JSStringRelease(exceptionIString);
1308             failed = 1;
1309         }
1310         JSStringRelease(script);
1311         free(scriptUTF8);
1312     }
1313
1314     // Clear out local variables pointing at JSObjectRefs to allow their values to be collected
1315     function = NULL;
1316     v = NULL;
1317     o = NULL;
1318     globalObject = NULL;
1319     myConstructor = NULL;
1320
1321     JSStringRelease(jsEmptyIString);
1322     JSStringRelease(jsOneIString);
1323     JSStringRelease(jsCFIString);
1324     JSStringRelease(jsCFEmptyIString);
1325     JSStringRelease(jsCFIStringWithCharacters);
1326     JSStringRelease(jsCFEmptyIStringWithCharacters);
1327     JSStringRelease(goodSyntax);
1328     JSStringRelease(badSyntax);
1329
1330     JSGlobalContextRelease(context);
1331     JSClassRelease(globalObjectClass);
1332
1333     // Test for an infinite prototype chain that used to be created. This test
1334     // passes if the call to JSObjectHasProperty() does not hang.
1335
1336     JSClassDefinition prototypeLoopClassDefinition = kJSClassDefinitionEmpty;
1337     prototypeLoopClassDefinition.staticFunctions = globalObject_staticFunctions;
1338     JSClassRef prototypeLoopClass = JSClassCreate(&prototypeLoopClassDefinition);
1339     JSGlobalContextRef prototypeLoopContext = JSGlobalContextCreateInGroup(NULL, prototypeLoopClass);
1340
1341     JSStringRef nameProperty = JSStringCreateWithUTF8CString("name");
1342     JSObjectHasProperty(prototypeLoopContext, JSContextGetGlobalObject(prototypeLoopContext), nameProperty);
1343
1344     JSGlobalContextRelease(prototypeLoopContext);
1345     JSClassRelease(prototypeLoopClass);
1346
1347     printf("PASS: Infinite prototype chain does not occur.\n");
1348
1349     if (failed) {
1350         printf("FAIL: Some tests failed.\n");
1351         return 1;
1352     }
1353
1354     printf("PASS: Program exited normally.\n");
1355     return 0;
1356 }
1357
1358 static char* createStringWithContentsOfFile(const char* fileName)
1359 {
1360     char* buffer;
1361
1362     size_t buffer_size = 0;
1363     size_t buffer_capacity = 1024;
1364     buffer = (char*)malloc(buffer_capacity);
1365
1366     FILE* f = fopen(fileName, "r");
1367     if (!f) {
1368         fprintf(stderr, "Could not open file: %s\n", fileName);
1369         return 0;
1370     }
1371
1372     while (!feof(f) && !ferror(f)) {
1373         buffer_size += fread(buffer + buffer_size, 1, buffer_capacity - buffer_size, f);
1374         if (buffer_size == buffer_capacity) { // guarantees space for trailing '\0'
1375             buffer_capacity *= 2;
1376             buffer = (char*)realloc(buffer, buffer_capacity);
1377             ASSERT(buffer);
1378         }
1379
1380         ASSERT(buffer_size < buffer_capacity);
1381     }
1382     fclose(f);
1383     buffer[buffer_size] = '\0';
1384
1385     return buffer;
1386 }