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