#import "config.h"

#import "JSExportMacros.h"

#import <JavaScriptCore/JavaScriptCore.h>

#import "CurrentThisInsideBlockGetterTest.h"

#import "DateTests.h"

#import "JSCast.h"

#import "JSContextPrivate.h"

#import "JSExportTests.h"

#import "JSScript.h"

#import "JSValuePrivate.h"

#import "JSVirtualMachineInternal.h"

#import "JSVirtualMachinePrivate.h"

#import "JSWrapperMapTests.h"

#import "Regress141275.h"

#import "Regress141809.h"

#import <wtf/SafeStrerror.h>

#import <wtf/spi/darwin/DataVaultSPI.h>

#if PLATFORM(COCOA)

#import <wtf/cocoa/RuntimeApplicationChecksCocoa.h>

#endif

#if __has_include(<libproc.h>)

#define HAS_LIBPROC 1

#import <libproc.h>

#else

#define HAS_LIBPROC 0

#endif

#import <pthread.h>

#import <vector>

#import <wtf/MemoryFootprint.h>

#import <wtf/DataLog.h>

#import <wtf/RetainPtr.h>

extern "C" void JSSynchronousGarbageCollectForDebugging(JSContextRef);

extern "C" void JSSynchronousEdenCollectForDebugging(JSContextRef);

extern "C" bool _Block_has_signature(id);

extern "C" const char * _Block_signature(id);

extern int failed;

extern "C" void testObjectiveCAPI(const char*);

extern "C" void checkResult(NSString *, bool);

#if JSC_OBJC_API_ENABLED

@interface UnexportedObject : NSObject

@implementation UnexportedObject

@protocol ParentObject <JSExport>

@interface ParentObject : NSObject<ParentObject>

+ (NSString *)parentTest;

@implementation ParentObject

+ (NSString *)parentTest

{

return [self description];

}

@protocol TestObject <JSExport>

- (id)init;

@property int variable;

@property (readonly) int six;

@property CGPoint point;

+ (NSString *)classTest;

+ (NSString *)parentTest;

- (NSString *)getString;

JSExportAs(testArgumentTypes,

- (NSString *)testArgumentTypesWithInt:(int)i double:(double)d boolean:(BOOL)b string:(NSString *)s number:(NSNumber *)n array:(NSArray *)a dictionary:(NSDictionary *)o

);

- (void)callback:(JSValue *)function;

- (void)bogusCallback:(void(^)(int))function;

@interface TestObject : ParentObject <TestObject>

@property int six;

+ (id)testObject;

@implementation TestObject

@synthesize variable;

@synthesize six;

@synthesize point;

+ (id)testObject

{

return [[TestObject alloc] init];

}

+ (NSString *)classTest

{

return @"classTest - okay";

}

- (NSString *)getString

{

return @"42";

}

- (NSString *)testArgumentTypesWithInt:(int)i double:(double)d boolean:(BOOL)b string:(NSString *)s number:(NSNumber *)n array:(NSArray *)a dictionary:(NSDictionary *)o

{

return [NSString stringWithFormat:@"%d,%g,%d,%@,%d,%@,%@", i, d, b==YES?true:false,s,[n intValue],a[1],o[@"x"]];

}

- (void)callback:(JSValue *)function

{

[function callWithArguments:@[@(42)]];

}

- (void)bogusCallback:(void(^)(int))function

{

function(42);

}

bool testXYZTested = false;

@protocol TextXYZ <JSExport>

- (id)initWithString:(NSString*)string;

@property int x;

@property (readonly) int y;

@property (assign) JSValue *onclick;

@property (assign) JSValue *weakOnclick;

- (void)test:(NSString *)message;

@interface TextXYZ : NSObject <TextXYZ>

@property int x;

@property int y;

@property int z;

- (void)click;

@implementation TextXYZ {

JSManagedValue *m_weakOnclickHandler;

JSManagedValue *m_onclickHandler;

}

@synthesize x;

@synthesize y;

@synthesize z;

- (id)initWithString:(NSString*)string

{

self = [super init];

if (!self)

return nil;

NSLog(@"%@", string);

return self;

}

- (void)test:(NSString *)message

{

testXYZTested = [message isEqual:@"test"] && x == 13 & y == 4 && z == 5;

}

- (void)setWeakOnclick:(JSValue *)value

{

m_weakOnclickHandler = [JSManagedValue managedValueWithValue:value];

}

- (void)setOnclick:(JSValue *)value

{

m_onclickHandler = [JSManagedValue managedValueWithValue:value];

[value.context.virtualMachine addManagedReference:m_onclickHandler withOwner:self];

}

- (JSValue *)weakOnclick

{

return [m_weakOnclickHandler value];

}

- (JSValue *)onclick

{

return [m_onclickHandler value];

}

- (void)click

{

if (!m_onclickHandler)

return;

JSValue *function = [m_onclickHandler value];

[function callWithArguments:@[]];

}

@class TinyDOMNode;

@protocol TinyDOMNode <JSExport>

- (void)appendChild:(TinyDOMNode *)child;

- (NSUInteger)numberOfChildren;

- (TinyDOMNode *)childAtIndex:(NSUInteger)index;

- (void)removeChildAtIndex:(NSUInteger)index;

@interface TinyDOMNode : NSObject<TinyDOMNode>

@implementation TinyDOMNode {

NSMutableArray *m_children;

RetainPtr<JSVirtualMachine> m_sharedVirtualMachine;

}

- (id)initWithVirtualMachine:(JSVirtualMachine *)virtualMachine

{

self = [super init];

if (!self)

return nil;

m_children = [[NSMutableArray alloc] initWithCapacity:0];

m_sharedVirtualMachine = virtualMachine;

return self;

}

- (void)appendChild:(TinyDOMNode *)child

{

[m_sharedVirtualMachine addManagedReference:child withOwner:self];

[m_children addObject:child];

}

- (NSUInteger)numberOfChildren

{

return [m_children count];

}

- (TinyDOMNode *)childAtIndex:(NSUInteger)index

{

if (index >= [m_children count])

return nil;

return [m_children objectAtIndex:index];

}

- (void)removeChildAtIndex:(NSUInteger)index

{

if (index >= [m_children count])

return;

[m_sharedVirtualMachine removeManagedReference:[m_children objectAtIndex:index] withOwner:self];

[m_children removeObjectAtIndex:index];

}

@interface JSCollection : NSObject

- (void)setValue:(JSValue *)value forKey:(NSString *)key;

- (JSValue *)valueForKey:(NSString *)key;

@implementation JSCollection {

NSMutableDictionary *_dict;

}

- (id)init

{

self = [super init];

if (!self)

return nil;

_dict = [[NSMutableDictionary alloc] init];

return self;

}

- (void)setValue:(JSValue *)value forKey:(NSString *)key

{

JSManagedValue *oldManagedValue = [_dict objectForKey:key];

if (oldManagedValue) {

JSValue* oldValue = [oldManagedValue value];

if (oldValue)

[oldValue.context.virtualMachine removeManagedReference:oldManagedValue withOwner:self];

}

JSManagedValue *managedValue = [JSManagedValue managedValueWithValue:value];

[value.context.virtualMachine addManagedReference:managedValue withOwner:self];

[_dict setObject:managedValue forKey:key];

}

- (JSValue *)valueForKey:(NSString *)key

{

JSManagedValue *managedValue = [_dict objectForKey:key];

if (!managedValue)

return nil;

return [managedValue value];

}

@protocol InitA <JSExport>

- (id)initWithA:(int)a;

- (int)initialize;

@protocol InitB <JSExport>

- (id)initWithA:(int)a b:(int)b;

@protocol InitC <JSExport>

- (id)_init;

@interface ClassA : NSObject<InitA>

@interface ClassB : ClassA<InitB>

@interface ClassC : ClassB<InitA, InitB>

@interface ClassCPrime : ClassB<InitA, InitC>

@interface ClassD : NSObject<InitA>

- (id)initWithA:(int)a;

@interface ClassE : ClassD

- (id)initWithA:(int)a;

@implementation ClassA {

int _a;

}

- (id)initWithA:(int)a

{

self = [super init];

if (!self)

return nil;

_a = a;

return self;

}

- (int)initialize

{

return 42;

}

@implementation ClassB {

int _b;

}

- (id)initWithA:(int)a b:(int)b

{

self = [super initWithA:a];

if (!self)

return nil;

_b = b;

return self;

}

@implementation ClassC {

int _c;

}

- (id)initWithA:(int)a

{

return [self initWithA:a b:0];

}

- (id)initWithA:(int)a b:(int)b

{

self = [super initWithA:a b:b];

if (!self)

return nil;

_c = a + b;

return self;

}

@implementation ClassCPrime

- (id)initWithA:(int)a

{

self = [super initWithA:a b:0];

if (!self)

return nil;

return self;

}

- (id)_init

{

return [self initWithA:42];

}

@implementation ClassD

- (id)initWithA:(int)a

{

self = nil;

return [[ClassE alloc] initWithA:a];

}

- (int)initialize

{

return 0;

}

@implementation ClassE {

int _a;

}

- (id)initWithA:(int)a

{

self = [super init];

if (!self)

return nil;

_a = a;

return self;

}

static bool evilAllocationObjectWasDealloced = false;

@interface EvilAllocationObject : NSObject

- (JSValue *)doEvilThingsWithContext:(JSContext *)context;

@implementation EvilAllocationObject {

JSContext *m_context;

}

- (id)initWithContext:(JSContext *)context

{

self = [super init];

if (!self)

return nil;

m_context = context;

return self;

}

- (void)dealloc

{

[self doEvilThingsWithContext:m_context];

evilAllocationObjectWasDealloced = true;

#if !__has_feature(objc_arc)

[super dealloc];

#endif

}

- (JSValue *)doEvilThingsWithContext:(JSContext *)context

{

JSValue *result = [context evaluateScript:@" \

})()"];

JSSynchronousGarbageCollectForDebugging([context JSGlobalContextRef]);

return result;

}

extern "C" void checkResult(NSString *description, bool passed)

{

NSLog(@"TEST: \"%@\": %@", description, passed ? @"PASSED" : @"FAILED");

if (!passed)

failed = 1;

}

static bool blockSignatureContainsClass()

{

static bool containsClass = ^{

id block = ^(NSString *string){ return string; };

return _Block_has_signature(block) && strstr(_Block_signature(block), "NSString");

}();

return containsClass;

}

static void* threadMain(void* contextPtr)

{

JSContext *context = (__bridge JSContext*)contextPtr;

// Do something to enter the VM.

TestObject *testObject = [TestObject testObject];

context[@"testObject"] = testObject;

return nullptr;

}

static void* multiVMThreadMain(void* okPtr)

{

bool& ok = *static_cast<bool*>(okPtr);

JSVirtualMachine *vm = [[JSVirtualMachine alloc] init];

JSContext* context = [[JSContext alloc] initWithVirtualMachine:vm];

[context evaluateScript:

@"var array = [{}];\n"

"for (var i = 0; i < 20; ++i) {\n"

" var newArray = new Array(array.length * 2);\n"

" for (var j = 0; j < newArray.length; ++j)\n"

" newArray[j] = {parent: array[j / 2]};\n"

" array = newArray;\n"

"}\n"];

if (context.exception) {

NSLog(@"Uncaught exception.\n");

ok = false;

}

if (![context.globalObject valueForProperty:@"array"].toObject) {

NSLog(@"Did not find \"array\" variable.\n");

ok = false;

}

JSSynchronousGarbageCollectForDebugging([context JSGlobalContextRef]);

return nullptr;

}

static void runJITThreadLimitTests()

{

#if ENABLE(DFG_JIT)

auto testDFG = [] {

unsigned defaultNumberOfThreads = JSC::Options::numberOfDFGCompilerThreads();

unsigned targetNumberOfThreads = 1;

unsigned initialNumberOfThreads = [JSVirtualMachine setNumberOfDFGCompilerThreads:targetNumberOfThreads];

checkResult(@"Initial number of DFG threads should be the value provided through Options", initialNumberOfThreads == defaultNumberOfThreads);

unsigned updatedNumberOfThreads = [JSVirtualMachine setNumberOfDFGCompilerThreads:initialNumberOfThreads];

checkResult(@"Number of DFG threads should have been updated", updatedNumberOfThreads == targetNumberOfThreads);

};

auto testFTL = [] {

unsigned defaultNumberOfThreads = JSC::Options::numberOfFTLCompilerThreads();

unsigned targetNumberOfThreads = 3;

unsigned initialNumberOfThreads = [JSVirtualMachine setNumberOfFTLCompilerThreads:targetNumberOfThreads];

checkResult(@"Initial number of FTL threads should be the value provided through Options", initialNumberOfThreads == defaultNumberOfThreads);

unsigned updatedNumberOfThreads = [JSVirtualMachine setNumberOfFTLCompilerThreads:initialNumberOfThreads];

checkResult(@"Number of FTL threads should have been updated", updatedNumberOfThreads == targetNumberOfThreads);

};

testDFG();

testFTL();

#endif // ENABLE(DFG_JIT)

}

static void testObjectiveCAPIMain()

{

@autoreleasepool {

JSValue *value = [JSValue valueWithJSValueRef:nil inContext:nil];

checkResult(@"nil JSValue creation", !value);

}

@autoreleasepool {

JSVirtualMachine* vm = [[JSVirtualMachine alloc] init];

JSContext* context = [[JSContext alloc] initWithVirtualMachine:vm];

[context evaluateScript:@"bad"];

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *result = [context evaluateScript:@"2 + 2"];

checkResult(@"2 + 2", result.isNumber && [result toInt32] == 4);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

NSString *result = [NSString stringWithFormat:@"Two plus two is %@", [context evaluateScript:@"2 + 2"]];

checkResult(@"stringWithFormat", [result isEqual:@"Two plus two is 4"]);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

context[@"message"] = @"Hello";

JSValue *result = [context evaluateScript:@"message + ', World!'"];

checkResult(@"Hello, World!", result.isString && [result isEqualToObject:@"Hello, World!"]);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

checkResult(@"Promise is exposed", ![context[@"Promise"] isUndefined]);

JSValue *result = [context evaluateScript:@"typeof Promise"];

checkResult(@"typeof Promise is 'function'", result.isString && [result isEqualToObject:@"function"]);

}

@autoreleasepool {

JSVirtualMachine* vm = [[JSVirtualMachine alloc] init];

JSContext* context = [[JSContext alloc] initWithVirtualMachine:vm];

[context evaluateScript:@"result = 0; Promise.resolve(42).then(function (value) { result = value; });"];

checkResult(@"Microtask is drained", [context[@"result"] isEqualToObject:@42]);

}

@autoreleasepool {

JSVirtualMachine* vm = [[JSVirtualMachine alloc] init];

JSContext* context = [[JSContext alloc] initWithVirtualMachine:vm];

TestObject* testObject = [TestObject testObject];

context[@"testObject"] = testObject;

[context evaluateScript:@"result = 0; callbackResult = 0; Promise.resolve(42).then(function (value) { result = value; }); callbackResult = testObject.getString();"];

checkResult(@"Microtask is drained with same VM", [context[@"result"] isEqualToObject:@42] && [context[@"callbackResult"] isEqualToObject:@"42"]);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *result = [context evaluateScript:@"({ x:42 })"];

checkResult(@"({ x:42 })", result.isObject && [result[@"x"] isEqualToObject:@42]);

id obj = [result toObject];

checkResult(@"Check dictionary literal", [obj isKindOfClass:[NSDictionary class]]);

id num = (NSDictionary *)obj[@"x"];

checkResult(@"Check numeric literal", [num isKindOfClass:[NSNumber class]]);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *result = [context evaluateScript:@"[ ]"];

checkResult(@"[ ]", result.isArray);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *result = [context evaluateScript:@"new Date"];

checkResult(@"new Date", result.isDate);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *symbol = [context evaluateScript:@"Symbol('dope');"];

JSValue *notSymbol = [context evaluateScript:@"'dope'"];

checkResult(@"Should be a symbol value", symbol.isSymbol);

checkResult(@"Should not be a symbol value", !notSymbol.isSymbol);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *symbol = [JSValue valueWithNewSymbolFromDescription:@"dope" inContext:context];

checkResult(@"Should be a created from Obj-C", symbol.isSymbol);

}

#if (defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500) || (defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 130000)

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *arrayIterator = [context evaluateScript:@"Array.prototype[Symbol.iterator]"];

JSValue *iteratorSymbol = context[@"Symbol"][@"iterator"];

JSValue *array = [JSValue valueWithNewArrayInContext:context];

checkResult(@"Looking up by subscript with symbol should work", [array[iteratorSymbol] isEqual:arrayIterator]);

checkResult(@"Looking up by method with symbol should work", [[array valueForProperty:iteratorSymbol] isEqual:arrayIterator]);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *iteratorSymbol = context[@"Symbol"][@"iterator"];

JSValue *object = [JSValue valueWithNewObjectInContext:context];

JSValue *theAnswer = [JSValue valueWithUInt32:42 inContext:context];

object[iteratorSymbol] = theAnswer;

checkResult(@"Setting by subscript with symbol should work", [object[iteratorSymbol] isEqual:theAnswer]);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *iteratorSymbol = context[@"Symbol"][@"iterator"];

JSValue *object = [JSValue valueWithNewObjectInContext:context];

JSValue *theAnswer = [JSValue valueWithUInt32:42 inContext:context];

[object setValue:theAnswer forProperty:iteratorSymbol];

checkResult(@"Setting by method with symbol should work", [object[iteratorSymbol] isEqual:theAnswer]);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *iteratorSymbol = context[@"Symbol"][@"iterator"];

JSValue *object = [JSValue valueWithNewObjectInContext:context];

JSValue *theAnswer = [JSValue valueWithUInt32:42 inContext:context];

object[iteratorSymbol] = theAnswer;

checkResult(@"has property with symbol should work", [object hasProperty:iteratorSymbol]);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *iteratorSymbol = context[@"Symbol"][@"iterator"];

JSValue *object = [JSValue valueWithNewObjectInContext:context];

JSValue *theAnswer = [JSValue valueWithUInt32:42 inContext:context];

checkResult(@"delete property with symbol should work without property", [object deleteProperty:iteratorSymbol]);

object[iteratorSymbol] = theAnswer;

checkResult(@"delete property with symbol should work with property", [object deleteProperty:iteratorSymbol]);

checkResult(@"delete should be false with non-configurable property", ![context[@"Array"] deleteProperty:@"prototype"]);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *object = [JSValue valueWithNewObjectInContext:context];

NSObject *objCObject = [[NSObject alloc] init];

JSValue *result = object[objCObject];

checkResult(@"getting a non-convertable object should return undefined", [result isUndefined]);

object[objCObject] = @(1);

result = object[objCObject];

checkResult(@"getting a non-convertable object should return the stored value", [result toUInt32] == 1);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *object = [JSValue valueWithNewObjectInContext:context];

JSValue *iteratorSymbol = context[@"Symbol"][@"iterator"];

object[@"value"] = @(1);

context[@"object"] = object;

object[iteratorSymbol] = ^{

JSValue *result = [JSValue valueWithNewObjectInContext:context];

result[@"object"] = [JSContext currentThis];

result[@"next"] = ^{

JSValue *result = [JSValue valueWithNewObjectInContext:context];

JSValue *value = [JSContext currentThis][@"object"][@"value"];

[[JSContext currentThis][@"object"] deleteProperty:@"value"];

result[@"value"] = value;

result[@"done"] = [JSValue valueWithBool:[value isUndefined] inContext:context];

return result;

};

return result;

};

JSValue *count = [context evaluateScript:@"let count = 0; for (let v of object) { if (v !== 1) throw new Error(); count++; } count;"];

checkResult(@"iterator should not throw", ![context exception]);

checkResult(@"iteration count should be 1", [count toUInt32] == 1);

}

#endif

@autoreleasepool {

JSCollection* myPrivateProperties = [[JSCollection alloc] init];

@autoreleasepool {

JSContext* context = [[JSContext alloc] init];

TestObject* rootObject = [TestObject testObject];

context[@"root"] = rootObject;

[context.virtualMachine addManagedReference:myPrivateProperties withOwner:rootObject];

[myPrivateProperties setValue:[JSValue valueWithBool:true inContext:context] forKey:@"is_ham"];

[myPrivateProperties setValue:[JSValue valueWithObject:@"hello!" inContext:context] forKey:@"message"];

[myPrivateProperties setValue:[JSValue valueWithInt32:42 inContext:context] forKey:@"my_number"];

[myPrivateProperties setValue:[JSValue valueWithNullInContext:context] forKey:@"definitely_null"];

[myPrivateProperties setValue:[JSValue valueWithUndefinedInContext:context] forKey:@"not_sure_if_undefined"];

JSSynchronousGarbageCollectForDebugging([context JSGlobalContextRef]);

JSValue *isHam = [myPrivateProperties valueForKey:@"is_ham"];

JSValue *message = [myPrivateProperties valueForKey:@"message"];

JSValue *myNumber = [myPrivateProperties valueForKey:@"my_number"];

JSValue *definitelyNull = [myPrivateProperties valueForKey:@"definitely_null"];

JSValue *notSureIfUndefined = [myPrivateProperties valueForKey:@"not_sure_if_undefined"];

checkResult(@"is_ham is true", isHam.isBoolean && [isHam toBool]);

checkResult(@"message is hello!", message.isString && [@"hello!" isEqualToString:[message toString]]);

checkResult(@"my_number is 42", myNumber.isNumber && [myNumber toInt32] == 42);

checkResult(@"definitely_null is null", definitelyNull.isNull);

checkResult(@"not_sure_if_undefined is undefined", notSureIfUndefined.isUndefined);

}

checkResult(@"is_ham is nil", ![myPrivateProperties valueForKey:@"is_ham"]);

checkResult(@"message is nil", ![myPrivateProperties valueForKey:@"message"]);

checkResult(@"my_number is 42", ![myPrivateProperties valueForKey:@"my_number"]);

checkResult(@"definitely_null is null", ![myPrivateProperties valueForKey:@"definitely_null"]);

checkResult(@"not_sure_if_undefined is undefined", ![myPrivateProperties valueForKey:@"not_sure_if_undefined"]);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *message = [JSValue valueWithObject:@"hello" inContext:context];

TestObject *rootObject = [TestObject testObject];

JSCollection *collection = [[JSCollection alloc] init];

context[@"root"] = rootObject;

@autoreleasepool {

JSValue *jsCollection = [JSValue valueWithObject:collection inContext:context];

JSManagedValue *weakCollection = [JSManagedValue managedValueWithValue:jsCollection andOwner:rootObject];

[context.virtualMachine addManagedReference:weakCollection withOwner:message];

JSSynchronousGarbageCollectForDebugging([context JSGlobalContextRef]);

}

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

__block int result;

context[@"blockCallback"] = ^(int value){

result = value;

};

[context evaluateScript:@"blockCallback(42)"];

checkResult(@"blockCallback", result == 42);

}

if (blockSignatureContainsClass()) {

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

__block bool result = false;

context[@"blockCallback"] = ^(NSString *value){

result = [@"42" isEqualToString:value] == YES;

};

[context evaluateScript:@"blockCallback(42)"];

checkResult(@"blockCallback(NSString *)", result);

}

} else

NSLog(@"Skipping 'blockCallback(NSString *)' test case");

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

checkResult(@"!context.exception", !context.exception);

[context evaluateScript:@"!@#$%^&*() THIS IS NOT VALID JAVASCRIPT SYNTAX !@#$%^&*()"];

checkResult(@"context.exception", context.exception);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

__block bool caught = false;

context.exceptionHandler = ^(JSContext *context, JSValue *exception) {

(void)context;

(void)exception;

caught = true;

};

[context evaluateScript:@"!@#$%^&*() THIS IS NOT VALID JAVASCRIPT SYNTAX !@#$%^&*()"];

checkResult(@"JSContext.exceptionHandler", caught);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

__block int expectedExceptionLineNumber = 1;

__block bool sawExpectedExceptionLineNumber = false;

context.exceptionHandler = ^(JSContext *, JSValue *exception) {

sawExpectedExceptionLineNumber = [exception[@"line"] toInt32] == expectedExceptionLineNumber;

};

[context evaluateScript:@"!@#$%^&*() THIS IS NOT VALID JAVASCRIPT SYNTAX !@#$%^&*()"];

checkResult(@"evaluteScript exception on line 1", sawExpectedExceptionLineNumber);

expectedExceptionLineNumber = 2;

sawExpectedExceptionLineNumber = false;

[context evaluateScript:@"// Line 1\n!@#$%^&*() THIS IS NOT VALID JAVASCRIPT SYNTAX !@#$%^&*()"];

checkResult(@"evaluteScript exception on line 2", sawExpectedExceptionLineNumber);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

__block bool emptyExceptionSourceURL = false;

context.exceptionHandler = ^(JSContext *, JSValue *exception) {

emptyExceptionSourceURL = exception[@"sourceURL"].isUndefined;

};

[context evaluateScript:@"!@#$%^&*() THIS IS NOT VALID JAVASCRIPT SYNTAX !@#$%^&*()"];

checkResult(@"evaluteScript: exception has no sourceURL", emptyExceptionSourceURL);

__block NSString *exceptionSourceURL = nil;

context.exceptionHandler = ^(JSContext *, JSValue *exception) {

exceptionSourceURL = [exception[@"sourceURL"] toString];

};

NSURL *url = [NSURL fileURLWithPath:@"/foo/bar.js" isDirectory:NO];

[context evaluateScript:@"!@#$%^&*() THIS IS NOT VALID JAVASCRIPT SYNTAX !@#$%^&*()" withSourceURL:url];

checkResult(@"evaluateScript:withSourceURL: exception has expected sourceURL", [exceptionSourceURL isEqualToString:[url absoluteString]]);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

context[@"callback"] = ^{

JSContext *context = [JSContext currentContext];

context.exception = [JSValue valueWithNewErrorFromMessage:@"Something went wrong." inContext:context];

};

JSValue *result = [context evaluateScript:@"var result; try { callback(); } catch (e) { result = 'Caught exception'; }"];

checkResult(@"Explicit throw in callback - was caught by JavaScript", [result isEqualToObject:@"Caught exception"]);

checkResult(@"Explicit throw in callback - not thrown to Objective-C", !context.exception);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

context[@"callback"] = ^{

JSContext *context = [JSContext currentContext];

[context evaluateScript:@"!@#$%^&*() THIS IS NOT VALID JAVASCRIPT SYNTAX !@#$%^&*()"];

};

JSValue *result = [context evaluateScript:@"var result; try { callback(); } catch (e) { result = 'Caught exception'; }"];

checkResult(@"Implicit throw in callback - was caught by JavaScript", [result isEqualToObject:@"Caught exception"]);

checkResult(@"Implicit throw in callback - not thrown to Objective-C", !context.exception);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

[context evaluateScript:

@"function sum(array) { \

}"];

JSValue *array = [JSValue valueWithObject:@[@13, @2, @7] inContext:context];

JSValue *sumFunction = context[@"sum"];

JSValue *result = [sumFunction callWithArguments:@[ array ]];

checkResult(@"sum([13, 2, 7])", [result toInt32] == 22);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *mulAddFunction = [context evaluateScript:

@"(function(array, object) { \

})"];

JSValue *result = [mulAddFunction callWithArguments:@[ @[ @2, @4, @8 ], @{ @"x":@0.5, @"y":@42 } ]];

checkResult(@"mulAddFunction", result.isObject && [[result toString] isEqual:@"43,44,46"]);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *array = [JSValue valueWithNewArrayInContext:context];

checkResult(@"arrayLengthEmpty", [[array[@"length"] toNumber] unsignedIntegerValue] == 0);

JSValue *value1 = [JSValue valueWithInt32:42 inContext:context];

JSValue *value2 = [JSValue valueWithInt32:24 inContext:context];

NSUInteger lowIndex = 5;

NSUInteger maxLength = UINT_MAX;

[array setValue:value1 atIndex:lowIndex];

checkResult(@"array.length after put to low index", [[array[@"length"] toNumber] unsignedIntegerValue] == (lowIndex + 1));

[array setValue:value1 atIndex:(maxLength - 1)];

checkResult(@"array.length after put to maxLength - 1", [[array[@"length"] toNumber] unsignedIntegerValue] == maxLength);

[array setValue:value2 atIndex:maxLength];

checkResult(@"array.length after put to maxLength", [[array[@"length"] toNumber] unsignedIntegerValue] == maxLength);

[array setValue:value2 atIndex:(maxLength + 1)];

checkResult(@"array.length after put to maxLength + 1", [[array[@"length"] toNumber] unsignedIntegerValue] == maxLength);

if (sizeof(NSUInteger) == 8)

checkResult(@"valueAtIndex:0 is undefined", [array valueAtIndex:0].isUndefined);

else

checkResult(@"valueAtIndex:0", [[array valueAtIndex:0] toInt32] == 24);

checkResult(@"valueAtIndex:lowIndex", [[array valueAtIndex:lowIndex] toInt32] == 42);

checkResult(@"valueAtIndex:maxLength - 1", [[array valueAtIndex:(maxLength - 1)] toInt32] == 42);

checkResult(@"valueAtIndex:maxLength", [[array valueAtIndex:maxLength] toInt32] == 24);

checkResult(@"valueAtIndex:maxLength + 1", [[array valueAtIndex:(maxLength + 1)] toInt32] == 24);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

JSValue *object = [JSValue valueWithNewObjectInContext:context];

object[@"point"] = @{ @"x":@1, @"y":@2 };

object[@"point"][@"x"] = @3;

CGPoint point = [object[@"point"] toPoint];

checkResult(@"toPoint", point.x == 3 && point.y == 2);

object[@{ @"toString":^{ return @"foo"; } }] = @"bar";

checkResult(@"toString in object literal used as subscript", [[object[@"foo"] toString] isEqual:@"bar"]);

object[[@"foobar" substringToIndex:3]] = @"bar";

checkResult(@"substring used as subscript", [[object[@"foo"] toString] isEqual:@"bar"]);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

TextXYZ *testXYZ = [[TextXYZ alloc] init];

context[@"testXYZ"] = testXYZ;

testXYZ.x = 3;

testXYZ.y = 4;

testXYZ.z = 5;

[context evaluateScript:@"testXYZ.x = 13; testXYZ.y = 14;"];

[context evaluateScript:@"testXYZ.test('test')"];

checkResult(@"TextXYZ - testXYZTested", testXYZTested);

JSValue *result = [context evaluateScript:@"testXYZ.x + ',' + testXYZ.y + ',' + testXYZ.z"];

checkResult(@"TextXYZ - result", [result isEqualToObject:@"13,4,undefined"]);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

[context[@"Object"][@"prototype"] defineProperty:@"getterProperty" descriptor:@{

JSPropertyDescriptorGetKey:^{

return [JSContext currentThis][@"x"];

}

}];

JSValue *object = [JSValue valueWithObject:@{ @"x":@101 } inContext:context];

int result = [object [@"getterProperty"] toInt32];

checkResult(@"getterProperty", result == 101);

}

@autoreleasepool {

JSContext *context = [[JSContext alloc] init];

context[@"concatenate"] = ^{

NSArray *arguments = [JSContext currentArguments];

if (![arguments count])

return @"";

NSString *message = [arguments[0] description];

for (NSUInteger index = 1; index < [arguments count]; ++index)

message = [NSString stringWithFormat:@"%@ %@", message, arguments[index]];

return message;