#undef ASSERT_ENABLED

#define ASSERT_ENABLED 1

#include "config.h"

#if USE(CF)

#include "JavaScriptCore.h"

#include "JavaScript.h"

#include "JSBasePrivate.h"

#include "JSContextRefPrivate.h"

#include "JSHeapFinalizerPrivate.h"

#include "JSMarkingConstraintPrivate.h"

#include "JSObjectRefPrivate.h"

#include "JSScriptRefPrivate.h"

#include "JSStringRefPrivate.h"

#include "JSWeakPrivate.h"

#if !OS(WINDOWS)

#include <libgen.h>

#include <limits.h>

#include <math.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#if !OS(WINDOWS)

#include <unistd.h>

#include <wtf/Assertions.h>

#if OS(WINDOWS)

#include <windows.h>

#include "CompareAndSwapTest.h"

#include "CustomGlobalObjectClassTest.h"

#include "ExecutionTimeLimitTest.h"

#include "FunctionOverridesTest.h"

#include "FunctionToStringTests.h"

#include "GlobalContextWithFinalizerTest.h"

#include "JSONParseTest.h"

#include "JSObjectGetProxyTargetTest.h"

#include "MultithreadedMultiVMExecutionTest.h"

#include "PingPongStackOverflowTest.h"

#include "TemporalCoreTest.h"

#include "TypedArrayCTest.h"

#include "VMManagerStopTheWorldTest.h"

#if defined(JSC_SUPPORTS_SWIFT) && JSC_SUPPORTS_SWIFT

#include "SwiftTestingHarness.h"

#if JSC_OBJC_API_ENABLED

void testObjectiveCAPI(const char*);

void initializeWTFForTesting(void);

void configureJSCForTesting(void);

int testLaunchJSCFromNonMainThread(const char* filter);

int testCAPIViaCpp(const char* filter);

bool assertTrue(bool value, const char* message);

static JSGlobalContextRef context;

int failed;

static void assertEqualsAsBoolean(JSValueRef value, bool expectedValue)

{

if (JSValueToBoolean(context, value) != expectedValue) {

fprintf(stderr, "assertEqualsAsBoolean failed: %p, %d\n", value, expectedValue);

failed = 1;

}

}

static void assertEqualsAsNumber(JSValueRef value, double expectedValue)

{

double number = JSValueToNumber(context, value, NULL);

// FIXME <rdar://4668451> - On i386 the isnan(double) macro tries to map to the isnan(float) function,

// causing a build break with -Wshorten-64-to-32 enabled. The issue is known by the appropriate team.

// After that's resolved, we can remove these casts

if (number != expectedValue && !(isnan((float)number) && isnan((float)expectedValue))) {

fprintf(stderr, "assertEqualsAsNumber failed: %p, %lf\n", value, expectedValue);

failed = 1;

}

}

static void assertEqualsAsUTF8String(JSValueRef value, const char* expectedValue)

{

JSStringRef valueAsString = JSValueToStringCopy(context, value, NULL);

size_t jsSize = JSStringGetMaximumUTF8CStringSize(valueAsString);

char* jsBuffer = (char*)malloc(jsSize);

JSStringGetUTF8CString(valueAsString, jsBuffer, jsSize);

unsigned i;

for (i = 0; jsBuffer[i]; i++) {

if (jsBuffer[i] != expectedValue[i]) {

fprintf(stderr, "assertEqualsAsUTF8String failed at character %d: %c(%d) != %c(%d)\n", i, jsBuffer[i], jsBuffer[i], expectedValue[i], expectedValue[i]);

fprintf(stderr, "value: %s\n", jsBuffer);

fprintf(stderr, "expectedValue: %s\n", expectedValue);

failed = 1;

}

}

if (jsSize < strlen(jsBuffer) + 1) {

fprintf(stderr, "assertEqualsAsUTF8String failed: jsSize was too small\n");

failed = 1;

}

free(jsBuffer);

JSStringRelease(valueAsString);

}

static void assertEqualsAsCharactersPtr(JSValueRef value, const char* expectedValue)

{

JSStringRef valueAsString = JSValueToStringCopy(context, value, NULL);

#if USE(CF)

size_t jsLength = JSStringGetLength(valueAsString);

const JSChar* jsBuffer = JSStringGetCharactersPtr(valueAsString);

CFStringRef expectedValueAsCFString = CFStringCreateWithCString(kCFAllocatorDefault,

expectedValue,

kCFStringEncodingUTF8);

CFIndex cfLength = CFStringGetLength(expectedValueAsCFString);

UniChar* cfBuffer = (UniChar*)malloc(cfLength * sizeof(UniChar));

CFStringGetCharacters(expectedValueAsCFString, CFRangeMake(0, cfLength), cfBuffer);

CFRelease(expectedValueAsCFString);

if (memcmp(jsBuffer, cfBuffer, cfLength * sizeof(UniChar)) != 0) {

fprintf(stderr, "assertEqualsAsCharactersPtr failed: jsBuffer != cfBuffer\n");

failed = 1;

}

if (jsLength != (size_t)cfLength) {

fprintf(stderr, "assertEqualsAsCharactersPtr failed: jsLength(%llu) != cfLength(%llu)\n", (unsigned long long)jsLength, (unsigned long long)cfLength);

failed = 1;

}

free(cfBuffer);

size_t bufferSize = JSStringGetMaximumUTF8CStringSize(valueAsString);

char* buffer = (char*)malloc(bufferSize);

JSStringGetUTF8CString(valueAsString, buffer, bufferSize);

if (strcmp(buffer, expectedValue)) {

fprintf(stderr, "assertEqualsAsCharactersPtr failed: jsBuffer != cfBuffer\n");

failed = 1;

}

free(buffer);

JSStringRelease(valueAsString);

}

static bool timeZoneIsPST(void)

{

char timeZoneName[70];

struct tm gtm;

memset(&gtm, 0, sizeof(gtm));

strftime(timeZoneName, sizeof(timeZoneName), "%Z", &gtm);

return 0 == strcmp("PST", timeZoneName);

}

static JSValueRef jsGlobalValue; // non-stack value for testing JSValueProtect()

static bool MyObject_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName)

{

UNUSED_PARAM(context);

UNUSED_PARAM(object);

if (JSStringIsEqualToUTF8CString(propertyName, "alwaysOne")

|| JSStringIsEqualToUTF8CString(propertyName, "cantFind")

|| JSStringIsEqualToUTF8CString(propertyName, "throwOnGet")

|| JSStringIsEqualToUTF8CString(propertyName, "myPropertyName")

|| JSStringIsEqualToUTF8CString(propertyName, "hasPropertyLie")

|| JSStringIsEqualToUTF8CString(propertyName, "0")) {

return true;

}

return false;

}

static JSValueRef throwException(JSContextRef context, JSObjectRef object, JSValueRef* exception)

{

JSStringRef script = JSStringCreateWithUTF8CString("throw 'an exception'");

JSStringRef sourceURL = JSStringCreateWithUTF8CString("test script");

JSValueRef result = JSEvaluateScript(context, script, object, sourceURL, 1, exception);

JSStringRelease(script);

JSStringRelease(sourceURL);

return result;

}

static JSValueRef MyObject_getProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)

{

UNUSED_PARAM(context);

UNUSED_PARAM(object);

if (JSStringIsEqualToUTF8CString(propertyName, "alwaysOne")) {

return JSValueMakeNumber(context, 1);

}

if (JSStringIsEqualToUTF8CString(propertyName, "myPropertyName")) {

return JSValueMakeNumber(context, 1);

}

if (JSStringIsEqualToUTF8CString(propertyName, "cantFind")) {

return JSValueMakeUndefined(context);

}

if (JSStringIsEqualToUTF8CString(propertyName, "hasPropertyLie")) {

return 0;

}

if (JSStringIsEqualToUTF8CString(propertyName, "throwOnGet")) {

return throwException(context, object, exception);

}

if (JSStringIsEqualToUTF8CString(propertyName, "0")) {

*exception = JSValueMakeNumber(context, 1);

return JSValueMakeNumber(context, 1);

}

return JSValueMakeNull(context);

}

static bool MyObject_setProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)

{

UNUSED_PARAM(context);

UNUSED_PARAM(object);

UNUSED_PARAM(value);

UNUSED_PARAM(exception);

if (JSStringIsEqualToUTF8CString(propertyName, "cantSet"))

return true; // pretend we set the property in order to swallow it

if (JSStringIsEqualToUTF8CString(propertyName, "throwOnSet")) {

throwException(context, object, exception);

}

return false;

}

static bool MyObject_deleteProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)

{

UNUSED_PARAM(context);

UNUSED_PARAM(object);

if (JSStringIsEqualToUTF8CString(propertyName, "cantDelete"))

return true;

if (JSStringIsEqualToUTF8CString(propertyName, "throwOnDelete")) {

throwException(context, object, exception);

return false;

}

return false;

}

static void MyObject_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef propertyNames)

{

UNUSED_PARAM(context);

UNUSED_PARAM(object);

JSStringRef propertyName;

propertyName = JSStringCreateWithUTF8CString("alwaysOne");

JSPropertyNameAccumulatorAddName(propertyNames, propertyName);

JSStringRelease(propertyName);

propertyName = JSStringCreateWithUTF8CString("myPropertyName");

JSPropertyNameAccumulatorAddName(propertyNames, propertyName);

JSStringRelease(propertyName);

}

static bool isValueEqualToString(JSContextRef context, JSValueRef value, const char* string)

{

if (!JSValueIsString(context, value))

return false;

JSStringRef valueString = JSValueToStringCopy(context, value, NULL);

if (!valueString)

return false;

bool isEqual = JSStringIsEqualToUTF8CString(valueString, string);

JSStringRelease(valueString);

return isEqual;

}

static JSValueRef MyObject_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

UNUSED_PARAM(context);

UNUSED_PARAM(object);

UNUSED_PARAM(thisObject);

UNUSED_PARAM(exception);

if (argumentCount > 0 && isValueEqualToString(context, arguments[0], "throwOnCall")) {

throwException(context, object, exception);

return JSValueMakeUndefined(context);

}

if (argumentCount > 0 && JSValueIsStrictEqual(context, arguments[0], JSValueMakeNumber(context, 0)))

return JSValueMakeNumber(context, 1);

return JSValueMakeUndefined(context);

}

static JSObjectRef MyObject_callAsConstructor(JSContextRef context, JSObjectRef object, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

UNUSED_PARAM(context);

UNUSED_PARAM(object);

if (argumentCount > 0 && isValueEqualToString(context, arguments[0], "throwOnConstruct")) {

throwException(context, object, exception);

return object;

}

if (argumentCount > 0 && JSValueIsStrictEqual(context, arguments[0], JSValueMakeNumber(context, 0)))

return JSValueToObject(context, JSValueMakeNumber(context, 1), exception);

return JSValueToObject(context, JSValueMakeNumber(context, 0), exception);

}

static bool MyObject_hasInstance(JSContextRef context, JSObjectRef constructor, JSValueRef possibleValue, JSValueRef* exception)

{

UNUSED_PARAM(context);

UNUSED_PARAM(constructor);

if (isValueEqualToString(context, possibleValue, "throwOnHasInstance")) {

throwException(context, constructor, exception);

return false;

}

JSStringRef numberString = JSStringCreateWithUTF8CString("Number");

JSObjectRef numberConstructor = JSValueToObject(context, JSObjectGetProperty(context, JSContextGetGlobalObject(context), numberString, exception), exception);

JSStringRelease(numberString);

return JSValueIsInstanceOfConstructor(context, possibleValue, numberConstructor, exception);

}

static JSValueRef MyObject_convertToType(JSContextRef context, JSObjectRef object, JSType type, JSValueRef* exception)

{

UNUSED_PARAM(object);

UNUSED_PARAM(exception);

switch (type) {

case kJSTypeNumber:

return JSValueMakeNumber(context, 1);

case kJSTypeString:

{

JSStringRef string = JSStringCreateWithUTF8CString("MyObjectAsString");

JSValueRef result = JSValueMakeString(context, string);

JSStringRelease(string);

return result;

}

default:

break;

}

// string conversion -- forward to default object class

return JSValueMakeNull(context);

}

static JSValueRef LEGACY_NODELETE MyObject_convertToTypeWrapper(JSContextRef context, JSObjectRef object, JSType type, JSValueRef* exception)

{

UNUSED_PARAM(context);

UNUSED_PARAM(object);

UNUSED_PARAM(type);

UNUSED_PARAM(exception);

// Forward to default object class

return 0;

}

static bool LEGACY_NODELETE MyObject_set_nullGetForwardSet(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)

{

UNUSED_PARAM(ctx);

UNUSED_PARAM(object);

UNUSED_PARAM(propertyName);

UNUSED_PARAM(value);

UNUSED_PARAM(exception);

return false; // Forward to parent class.

}

static const JSStaticValue evilStaticValues[] = {

{ "nullGetSet", 0, 0, kJSPropertyAttributeNone },

{ "nullGetForwardSet", 0, MyObject_set_nullGetForwardSet, kJSPropertyAttributeNone },

{ 0, 0, 0, 0 }

};

static const JSStaticFunction evilStaticFunctions[] = {

{ "nullCall", 0, kJSPropertyAttributeNone },

{ 0, 0, 0 }

};

static const JSClassDefinition MyObject_definition = {

0,

kJSClassAttributeNone,

"MyObject",

NULL,

evilStaticValues,

evilStaticFunctions,

NULL,

NULL,

MyObject_hasProperty,

MyObject_getProperty,

MyObject_setProperty,

MyObject_deleteProperty,

MyObject_getPropertyNames,

MyObject_callAsFunction,

MyObject_callAsConstructor,

MyObject_hasInstance,

MyObject_convertToType,

};

static const JSClassDefinition MyObject_convertToTypeWrapperDefinition = {

0,

kJSClassAttributeNone,

"MyObject",

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

MyObject_convertToTypeWrapper,

};

static const JSClassDefinition MyObject_nullWrapperDefinition = {

0,

kJSClassAttributeNone,

"MyObject",

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

};

static JSClassRef MyObject_class(JSContextRef context)

{

UNUSED_PARAM(context);

static JSClassRef jsClass;

if (!jsClass) {

JSClassDefinition classDefinition = MyObject_convertToTypeWrapperDefinition;

JSClassDefinition nullClassDefinition = MyObject_nullWrapperDefinition;

JSClassRef baseClass = JSClassCreate(&MyObject_definition);

classDefinition.parentClass = baseClass;

JSClassRef wrapperClass = JSClassCreate(&classDefinition);

nullClassDefinition.parentClass = wrapperClass;

jsClass = JSClassCreate(&nullClassDefinition);

}

return jsClass;

}

static JSValueRef PropertyCatchalls_getProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)

{

UNUSED_PARAM(context);

UNUSED_PARAM(object);

UNUSED_PARAM(propertyName);

UNUSED_PARAM(exception);

if (JSStringIsEqualToUTF8CString(propertyName, "x")) {

static size_t count;

if (count++ < 5)

return NULL;

// Swallow all .x gets after 5, returning null.

return JSValueMakeNull(context);

}

if (JSStringIsEqualToUTF8CString(propertyName, "y")) {

static size_t count;

if (count++ < 5)

return NULL;

// Swallow all .y gets after 5, returning null.

return JSValueMakeNull(context);

}

if (JSStringIsEqualToUTF8CString(propertyName, "z")) {

static size_t count;

if (count++ < 5)

return NULL;

// Swallow all .y gets after 5, returning null.

return JSValueMakeNull(context);

}

return NULL;

}

static bool PropertyCatchalls_setProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)

{

UNUSED_PARAM(context);

UNUSED_PARAM(object);

UNUSED_PARAM(propertyName);

UNUSED_PARAM(value);

UNUSED_PARAM(exception);

if (JSStringIsEqualToUTF8CString(propertyName, "x")) {

static size_t count;

// Swallow all .x sets after 4.

return count++ > 4;

}

if (JSStringIsEqualToUTF8CString(propertyName, "make_throw") || JSStringIsEqualToUTF8CString(propertyName, "0")) {

*exception = JSValueMakeNumber(context, 5);

return true;

}

return false;

}

static void PropertyCatchalls_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef propertyNames)

{

UNUSED_PARAM(context);

UNUSED_PARAM(object);

static size_t count;

static const char* numbers[] = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };

// Provide a property of a different name every time.

JSStringRef propertyName = JSStringCreateWithUTF8CString(numbers[count++ % 10]);

JSPropertyNameAccumulatorAddName(propertyNames, propertyName);

JSStringRelease(propertyName);

}

static const JSClassDefinition PropertyCatchalls_definition = {

0,

kJSClassAttributeNone,

"PropertyCatchalls",

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

PropertyCatchalls_getProperty,

PropertyCatchalls_setProperty,

NULL,

PropertyCatchalls_getPropertyNames,

NULL,

NULL,

NULL,

NULL,

};

static JSClassRef PropertyCatchalls_class(JSContextRef context)

{

UNUSED_PARAM(context);

static JSClassRef jsClass;

if (!jsClass)

jsClass = JSClassCreate(&PropertyCatchalls_definition);

return jsClass;

}

static bool EvilExceptionObject_hasInstance(JSContextRef context, JSObjectRef constructor, JSValueRef possibleValue, JSValueRef* exception)

{

UNUSED_PARAM(context);

UNUSED_PARAM(constructor);

JSStringRef hasInstanceName = JSStringCreateWithUTF8CString("hasInstance");

JSValueRef hasInstance = JSObjectGetProperty(context, constructor, hasInstanceName, exception);

JSStringRelease(hasInstanceName);

if (!hasInstance)

return false;

JSObjectRef function = JSValueToObject(context, hasInstance, exception);

JSValueRef result = JSObjectCallAsFunction(context, function, constructor, 1, &possibleValue, exception);

return result && JSValueToBoolean(context, result);

}

static JSValueRef EvilExceptionObject_convertToType(JSContextRef context, JSObjectRef object, JSType type, JSValueRef* exception)

{

UNUSED_PARAM(object);

UNUSED_PARAM(exception);

JSStringRef funcName;

switch (type) {

case kJSTypeNumber:

funcName = JSStringCreateWithUTF8CString("toNumber");

break;

case kJSTypeString:

funcName = JSStringCreateWithUTF8CString("toStringExplicit");

break;

default:

return JSValueMakeNull(context);

}

JSValueRef func = JSObjectGetProperty(context, object, funcName, exception);

JSStringRelease(funcName);

JSObjectRef function = JSValueToObject(context, func, exception);

if (!function)

return JSValueMakeNull(context);

JSValueRef value = JSObjectCallAsFunction(context, function, object, 0, NULL, exception);

if (!value) {

JSStringRef errorString = JSStringCreateWithUTF8CString("convertToType failed");

JSValueRef errorStringRef = JSValueMakeString(context, errorString);

JSStringRelease(errorString);

return errorStringRef;

}

return value;

}

static const JSClassDefinition EvilExceptionObject_definition = {

0,

kJSClassAttributeNone,

"EvilExceptionObject",

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

EvilExceptionObject_hasInstance,

EvilExceptionObject_convertToType,

};

static JSClassRef EvilExceptionObject_class(JSContextRef context)

{

UNUSED_PARAM(context);

static JSClassRef jsClass;

if (!jsClass)

jsClass = JSClassCreate(&EvilExceptionObject_definition);

return jsClass;

}

static const JSClassDefinition EmptyObject_definition = {

0,

kJSClassAttributeNone,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

};

static JSClassRef EmptyObject_class(JSContextRef context)

{

UNUSED_PARAM(context);

static JSClassRef jsClass;

if (!jsClass)

jsClass = JSClassCreate(&EmptyObject_definition);

return jsClass;

}

static JSValueRef Base_get(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)

{

UNUSED_PARAM(object);

UNUSED_PARAM(propertyName);

UNUSED_PARAM(exception);

return JSValueMakeNumber(ctx, 1); // distinguish base get form derived get

}

static bool Base_set(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)

{

UNUSED_PARAM(object);

UNUSED_PARAM(propertyName);

UNUSED_PARAM(value);

*exception = JSValueMakeNumber(ctx, 1); // distinguish base set from derived set

return true;

}

static JSValueRef Base_callAsFunction(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

UNUSED_PARAM(function);

UNUSED_PARAM(thisObject);

UNUSED_PARAM(argumentCount);

UNUSED_PARAM(arguments);

UNUSED_PARAM(exception);

return JSValueMakeNumber(ctx, 1); // distinguish base call from derived call

}

static JSValueRef LEGACY_NODELETE Base_returnHardNull(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

UNUSED_PARAM(ctx);

UNUSED_PARAM(function);

UNUSED_PARAM(thisObject);

UNUSED_PARAM(argumentCount);

UNUSED_PARAM(arguments);

UNUSED_PARAM(exception);

return 0; // should convert to undefined!

}

static const JSStaticFunction Base_staticFunctions[] = {

{ "baseProtoDup", NULL, kJSPropertyAttributeNone },

{ "baseProto", Base_callAsFunction, kJSPropertyAttributeNone },

{ "baseHardNull", Base_returnHardNull, kJSPropertyAttributeNone },

{ 0, 0, 0 }

};

static const JSStaticValue Base_staticValues[] = {

{ "baseDup", Base_get, Base_set, kJSPropertyAttributeNone },

{ "baseOnly", Base_get, Base_set, kJSPropertyAttributeNone },

{ 0, 0, 0, 0 }

};

static bool TestInitializeFinalize;

static void Base_initialize(JSContextRef context, JSObjectRef object)

{

UNUSED_PARAM(context);

if (TestInitializeFinalize) {

ASSERT((void*)1 == JSObjectGetPrivate(object));

JSObjectSetPrivate(object, (void*)2);

}

}

static unsigned Base_didFinalize;

static void Base_finalize(JSObjectRef object)

{

UNUSED_PARAM(object);

if (TestInitializeFinalize) {

ASSERT((void*)4 == JSObjectGetPrivate(object));

Base_didFinalize = true;

}

}

static JSClassRef Base_class(JSContextRef context)

{

UNUSED_PARAM(context);

static JSClassRef jsClass;

if (!jsClass) {

JSClassDefinition definition = kJSClassDefinitionEmpty;

definition.staticValues = Base_staticValues;

definition.staticFunctions = Base_staticFunctions;

definition.initialize = Base_initialize;

definition.finalize = Base_finalize;

jsClass = JSClassCreate(&definition);

}

return jsClass;

}

static JSValueRef Derived_get(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)

{

UNUSED_PARAM(object);

UNUSED_PARAM(propertyName);

UNUSED_PARAM(exception);

return JSValueMakeNumber(ctx, 2); // distinguish base get form derived get

}

static bool Derived_set(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)

{

UNUSED_PARAM(ctx);

UNUSED_PARAM(object);

UNUSED_PARAM(propertyName);

UNUSED_PARAM(value);

*exception = JSValueMakeNumber(ctx, 2); // distinguish base set from derived set

return true;

}

static JSValueRef Derived_callAsFunction(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

UNUSED_PARAM(function);

UNUSED_PARAM(thisObject);

UNUSED_PARAM(argumentCount);

UNUSED_PARAM(arguments);

UNUSED_PARAM(exception);

return JSValueMakeNumber(ctx, 2); // distinguish base call from derived call

}

static const JSStaticFunction Derived_staticFunctions[] = {

{ "protoOnly", Derived_callAsFunction, kJSPropertyAttributeNone },

{ "protoDup", NULL, kJSPropertyAttributeNone },

{ "baseProtoDup", Derived_callAsFunction, kJSPropertyAttributeNone },

{ 0, 0, 0 }

};

static const JSStaticValue Derived_staticValues[] = {

{ "derivedOnly", Derived_get, Derived_set, kJSPropertyAttributeNone },

{ "protoDup", Derived_get, Derived_set, kJSPropertyAttributeNone },

{ "baseDup", Derived_get, Derived_set, kJSPropertyAttributeNone },

{ 0, 0, 0, 0 }

};

static void Derived_initialize(JSContextRef context, JSObjectRef object)

{

UNUSED_PARAM(context);

if (TestInitializeFinalize) {

ASSERT((void*)2 == JSObjectGetPrivate(object));

JSObjectSetPrivate(object, (void*)3);

}

}

static void Derived_finalize(JSObjectRef object)

{

if (TestInitializeFinalize) {

ASSERT((void*)3 == JSObjectGetPrivate(object));

JSObjectSetPrivate(object, (void*)4);

}

}

static JSClassRef Derived_class(JSContextRef context)

{

static JSClassRef jsClass;

if (!jsClass) {

JSClassDefinition definition = kJSClassDefinitionEmpty;

definition.parentClass = Base_class(context);

definition.staticValues = Derived_staticValues;

definition.staticFunctions = Derived_staticFunctions;

definition.initialize = Derived_initialize;

definition.finalize = Derived_finalize;

jsClass = JSClassCreate(&definition);

}

return jsClass;

}

static JSClassRef Derived2_class(JSContextRef context)

{

static JSClassRef jsClass;

if (!jsClass) {

JSClassDefinition definition = kJSClassDefinitionEmpty;

definition.parentClass = Derived_class(context);

jsClass = JSClassCreate(&definition);

}

return jsClass;

}

static JSValueRef print_callAsFunction(JSContextRef ctx, JSObjectRef functionObject, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

UNUSED_PARAM(functionObject);

UNUSED_PARAM(thisObject);

UNUSED_PARAM(exception);

ASSERT(JSContextGetGlobalContext(ctx) == context);

if (argumentCount > 0) {

JSStringRef string = JSValueToStringCopy(ctx, arguments[0], NULL);

size_t sizeUTF8 = JSStringGetMaximumUTF8CStringSize(string);

char* stringUTF8 = (char*)malloc(sizeUTF8);

JSStringGetUTF8CString(string, stringUTF8, sizeUTF8);

printf("%s\n", stringUTF8);

free(stringUTF8);

JSStringRelease(string);

}

return JSValueMakeUndefined(ctx);

}

static JSObjectRef myConstructor_callAsConstructor(JSContextRef context, JSObjectRef constructorObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

UNUSED_PARAM(constructorObject);

UNUSED_PARAM(exception);

JSObjectRef result = JSObjectMake(context, NULL, NULL);

if (argumentCount > 0) {

JSStringRef value = JSStringCreateWithUTF8CString("value");

JSObjectSetProperty(context, result, value, arguments[0], kJSPropertyAttributeNone, NULL);

JSStringRelease(value);

}

return result;

}

static JSObjectRef LEGACY_NODELETE myBadConstructor_callAsConstructor(JSContextRef context, JSObjectRef constructorObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

{

UNUSED_PARAM(context);

UNUSED_PARAM(constructorObject);

UNUSED_PARAM(argumentCount);

UNUSED_PARAM(arguments);

UNUSED_PARAM(exception);

return 0;

}

static void globalObject_initialize(JSContextRef context, JSObjectRef object)

{

UNUSED_PARAM(object);

// Ensure that an execution context is passed in

ASSERT(context);

JSObjectRef globalObject = JSContextGetGlobalObject(context);

ASSERT(globalObject);

// Ensure that the standard global properties have been set on the global object

JSStringRef array = JSStringCreateWithUTF8CString("Array");

JSObjectRef arrayConstructor = JSValueToObject(context, JSObjectGetProperty(context, globalObject, array, NULL), NULL);

JSStringRelease(array);

UNUSED_PARAM(arrayConstructor);

ASSERT(arrayConstructor);

}

static JSValueRef globalObject_get(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)

{

UNUSED_PARAM(object);

UNUSED_PARAM(propertyName);

UNUSED_PARAM(exception);

return JSValueMakeNumber(ctx, 3);

}

static bool globalObject_set(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)

{

UNUSED_PARAM(object);

UNUSED_PARAM(propertyName);

UNUSED_PARAM(value);

*exception = JSValueMakeNumber(ctx, 3);

return true;

}