#import <JavaScriptCore/JavaScriptCore.h>

#import "CurrentThisInsideBlockGetterTest.h"

#import "DateTests.h"

#import "JSExportTests.h"

#import "Regress141275.h"

#import "Regress141809.h"

#import <pthread.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(void);

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:[NSArray arrayWithObject:[NSNumber numberWithInt: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:[NSArray array]];

}

@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;

JSVirtualMachine *m_sharedVirtualMachine;

}

- (id)initWithVirtualMachine:(JSVirtualMachine *)virtualMachine

{

self = [super init];

if (!self)

return nil;

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

m_sharedVirtualMachine = virtualMachine;

#if !__has_feature(objc_arc)

[m_sharedVirtualMachine retain];

#endif

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;

pthread_exit(nullptr);

}

static void testWeakValue()

{

@autoreleasepool {

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

TestObject *testObject = [TestObject testObject];

JSManagedValue *weakValue;

@autoreleasepool {

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

context[@"testObject"] = testObject;

weakValue = [[JSManagedValue alloc] initWithValue:context[@"testObject"]];

}

@autoreleasepool {

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

context[@"testObject"] = testObject;

JSSynchronousGarbageCollectForDebugging([context JSGlobalContextRef]);

checkResult(@"weak value == nil", ![weakValue value]);

checkResult(@"root is still alive", !context[@"testObject"].isUndefined);

}

}

}

static void testObjectiveCAPIMain()

{

@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 {

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 {

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"];

[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;

};

JSValue *result = [context evaluateScript:@"concatenate('Hello,', 'World!')"];

checkResult(@"concatenate", [result isEqualToObject:@"Hello, World!"]);

}

@autoreleasepool {

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

context[@"foo"] = @YES;

checkResult(@"@YES is boolean", [context[@"foo"] isBoolean]);

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

checkResult(@"@YES is boolean", [result isEqualToObject:@"boolean"]);

}

@autoreleasepool {

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

JSValue *result = [context evaluateScript:@"String(console)"];

checkResult(@"String(console)", [result isEqualToObject:@"[object Console]"]);

result = [context evaluateScript:@"typeof console.log"];

checkResult(@"typeof console.log", [result isEqualToObject:@"function"]);

}

@autoreleasepool {

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

TestObject* testObject = [TestObject testObject];

context[@"testObject"] = testObject;

JSValue *result = [context evaluateScript:@"String(testObject)"];

checkResult(@"String(testObject)", [result isEqualToObject:@"[object TestObject]"]);

}

@autoreleasepool {

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

TestObject* testObject = [TestObject testObject];

context[@"testObject"] = testObject;

JSValue *result = [context evaluateScript:@"String(testObject.__proto__)"];

checkResult(@"String(testObject.__proto__)", [result isEqualToObject:@"[object TestObjectPrototype]"]);

}

@autoreleasepool {

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

context[@"TestObject"] = [TestObject class];

JSValue *result = [context evaluateScript:@"String(TestObject)"];

checkResult(@"String(TestObject)", [result isEqualToObject:@"function TestObject() {\n [native code]\n}"]);

}

@autoreleasepool {

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

JSValue* value = [JSValue valueWithObject:[TestObject class] inContext:context];

checkResult(@"[value toObject] == [TestObject class]", [value toObject] == [TestObject class]);

}

@autoreleasepool {

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

context[@"TestObject"] = [TestObject class];

JSValue *result = [context evaluateScript:@"TestObject.parentTest()"];

checkResult(@"TestObject.parentTest()", [result isEqualToObject:@"TestObject"]);

}

@autoreleasepool {

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

TestObject* testObject = [TestObject testObject];

context[@"testObjectA"] = testObject;

context[@"testObjectB"] = testObject;

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

checkResult(@"testObjectA == testObjectB", result.isBoolean && [result toBool]);

}

@autoreleasepool {

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

TestObject* testObject = [TestObject testObject];

context[@"testObject"] = testObject;

testObject.point = (CGPoint){3,4};

JSValue *result = [context evaluateScript:@"var result = JSON.stringify(testObject.point); testObject.point = {x:12,y:14}; result"];

checkResult(@"testObject.point - result", [result isEqualToObject:@"{\"x\":3,\"y\":4}"]);

checkResult(@"testObject.point - {x:12,y:14}", testObject.point.x == 12 && testObject.point.y == 14);

}

@autoreleasepool {

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

TestObject* testObject = [TestObject testObject];

testObject.six = 6;

context[@"testObject"] = testObject;

context[@"mul"] = ^(int x, int y){ return x * y; };

JSValue *result = [context evaluateScript:@"mul(testObject.six, 7)"];

checkResult(@"mul(testObject.six, 7)", result.isNumber && [result toInt32] == 42);

}

@autoreleasepool {

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

TestObject* testObject = [TestObject testObject];

context[@"testObject"] = testObject;

context[@"testObject"][@"variable"] = @4;

[context evaluateScript:@"++testObject.variable"];

checkResult(@"++testObject.variable", testObject.variable == 5);

}

@autoreleasepool {

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

context[@"point"] = @{ @"x":@6, @"y":@7 };

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

checkResult(@"point.x + ',' + point.y", [result isEqualToObject:@"6,7"]);

}

@autoreleasepool {

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

context[@"point"] = @{ @"x":@6, @"y":@7 };

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

checkResult(@"point.x + ',' + point.y", [result isEqualToObject:@"6,7"]);

}

@autoreleasepool {

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

TestObject* testObject = [TestObject testObject];

context[@"testObject"] = testObject;

JSValue *result = [context evaluateScript:@"testObject.getString()"];

checkResult(@"testObject.getString()", result.isString && [result toInt32] == 42);

}

@autoreleasepool {

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

TestObject* testObject = [TestObject testObject];

context[@"testObject"] = testObject;

JSValue *result = [context evaluateScript:@"testObject.testArgumentTypes(101,0.5,true,'foo',666,[false,'bar',false],{x:'baz'})"];

checkResult(@"testObject.testArgumentTypes", [result isEqualToObject:@"101,0.5,1,foo,666,bar,baz"]);

}

@autoreleasepool {

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

TestObject* testObject = [TestObject testObject];

context[@"testObject"] = testObject;

JSValue *result = [context evaluateScript:@"testObject.getString.call(testObject)"];

checkResult(@"testObject.getString.call(testObject)", result.isString && [result toInt32] == 42);

}

@autoreleasepool {

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

TestObject* testObject = [TestObject testObject];

context[@"testObject"] = testObject;

checkResult(@"testObject.getString.call({}) pre", !context.exception);

[context evaluateScript:@"testObject.getString.call({})"];

checkResult(@"testObject.getString.call({}) post", context.exception);

}

@autoreleasepool {

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

TestObject* testObject = [TestObject testObject];

context[@"testObject"] = testObject;

JSValue *result = [context evaluateScript:@"var result = 0; testObject.callback(function(x){ result = x; }); result"];

checkResult(@"testObject.callback", result.isNumber && [result toInt32] == 42);

result = [context evaluateScript:@"testObject.bogusCallback"];

checkResult(@"testObject.bogusCallback == undefined", result.isUndefined);

}

@autoreleasepool {

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

TestObject *testObject = [TestObject testObject];

context[@"testObject"] = testObject;

JSValue *result = [context evaluateScript:@"Function.prototype.toString.call(testObject.callback)"];

checkResult(@"Function.prototype.toString", !context.exception && !result.isUndefined);

}

@autoreleasepool {

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

JSContext *context2 = [[JSContext alloc] initWithVirtualMachine:context1.virtualMachine];

JSValue *value = [JSValue valueWithDouble:42 inContext:context2];

context1[@"passValueBetweenContexts"] = value;

JSValue *result = [context1 evaluateScript:@"passValueBetweenContexts"];