void test_obj_defprop() { HandleScope handle_scope; Persistent<Context> context = Context::New(); Context::Scope context_scope(context); Handle<Object> obj = Object::New(); Handle<Value> data = Integer::New(2); obj->SetAccessor(String::New("myprop"), ReadTestVal, WriteTestVal, data); Local<Object> global = context->Global(); global->Set(String::New("testobj"), obj); Handle<String> source = String::New("var n = testobj.myprop; testobj.myprop = (n+9); testobj.myprop"); // Compile the source code. Handle<Script> script = Script::Compile(source); // Run the script to get the result. Handle<Value> result = script->Run(); do_check_true(!result.IsEmpty()); do_check_true(result->IsInt32()); JSInt32 i = result->Int32Value(); do_check_eq(12, i); context.Dispose(); }
void test_step_locked_does_not_block_main_thread() { nsCOMPtr<mozIStorageConnection> db(getDatabase()); // Need to prepare our statement ahead of time so we make sure to only test // step and not prepare. nsCOMPtr<mozIStorageStatement> stmt; nsresult rv = db->CreateStatement(NS_LITERAL_CSTRING( "INSERT INTO test (data) VALUES ('test1')" ), getter_AddRefs(stmt)); do_check_success(rv); RefPtr<DatabaseLocker> locker(new DatabaseLocker("SELECT * FROM test")); do_check_true(locker); mozilla::ReentrantMonitorAutoEnter lock(locker->monitor); locker->RunInBackground(); // Wait for the locker to notify us that it has locked the database properly. locker->WaitFor(WRITE_LOCK); bool hasResult; rv = stmt->ExecuteStep(&hasResult); do_check_eq(rv, NS_ERROR_FILE_IS_LOCKED); locker->Notify(TEST_DONE); }
Handle<Value> AddOne(const Arguments& args) { do_check_eq(args.Length(), 1); Local<Value> v = args[0]; do_check_true(v->IsNumber()); Local<Number> n = v->ToNumber(); return Number::New(n->Value() + 1.0); }
void test_Exception() { HandleScope handle_scope; Persistent<Context> context = Context::New(); Handle<Script> script = Script::New(String::New("function foo(x) { throw x; };")); Context::Scope scope(context); TryCatch trycatch; Handle<Value> v = script->Run(); do_check_true(!v.IsEmpty()); do_check_true(!trycatch.HasCaught()); Handle<Function> fn = context->Global()->Get(String::NewSymbol("foo")).As<Function>(); do_check_true(!fn.IsEmpty()); Local<Value> args[1] = { Integer::New(4) }; v = fn->Call(context->Global(), 1, args); do_check_true(v.IsEmpty()); do_check_true(trycatch.HasCaught()); Handle<Value> exn = trycatch.Exception(); do_check_true(exn->IsInt32()); do_check_eq(exn->Int32Value(), 4); context.Dispose(); }
void test_Utf8Length() { HandleScope handle_scope; Persistent<Context> context = Context::New(); Context::Scope context_scope(context); char TEST_STRING[] = "this is a UTF-8 test! This is pi: π"; int TEST_LENGTH = strlen(TEST_STRING); Handle<String> str = String::New(TEST_STRING); do_check_eq(str->Utf8Length(), TEST_LENGTH); // Now, make a string with an embedded NULL. TEST_STRING[8] = '\0'; str = String::New(TEST_STRING, TEST_LENGTH); do_check_eq(str->Utf8Length(), TEST_LENGTH); context.Dispose(); }
void test_WriteAsciiEmpty() { HandleScope handle_scope; Persistent<Context> context = Context::New(); Context::Scope context_scope(context); Handle<String> str = String::Empty(); int written = str->WriteAscii(NULL, 0, 0); do_check_eq(written, 0); context.Dispose(); }
NS_IMETHODIMP Spinner::HandleResult(mozIStorageResultSet *aResultSet) { nsCOMPtr<mozIStorageRow> row; do_check_true(NS_SUCCEEDED(aResultSet->GetNextRow(getter_AddRefs(row))) && row); do_check_eq(row->AsInt32(0), 0); do_check_eq(row->AsInt64(0), 0); do_check_eq(row->AsDouble(0), 0.0); PRUint32 len = 100; do_check_eq(row->AsSharedUTF8String(0, &len), NULL); do_check_eq(len, 0); len = 100; do_check_eq(row->AsSharedWString(0, &len), NULL); do_check_eq(len, 0); len = 100; do_check_eq(row->AsSharedBlob(0, &len), NULL); do_check_eq(len, 0); do_check_eq(row->IsNull(0), true); return NS_OK; }
void test_Write() { HandleScope handle_scope; Persistent<Context> context = Context::New(); Context::Scope context_scope(context); char TEST_STRING[] = "this is a UTF-8 test! This is pi: π"; int TEST_LENGTH = strlen(TEST_STRING); Handle<String> str = String::New(TEST_STRING); char* buf = new char[TEST_LENGTH * 2]; for (int start = 0; start < TEST_LENGTH; start++) { // Fill the buffer with 'a' to ensure there are no NULLs to start with. fill_string(buf, 'a', TEST_LENGTH * 2); int copied = str->WriteAscii(buf, start, TEST_LENGTH * 2); do_check_eq(copied, TEST_LENGTH - start); do_check_eq(strlen(buf), TEST_LENGTH - start); } delete[] buf; context.Dispose(); }
void test_WriteUtf8() { HandleScope handle_scope; Persistent<Context> context = Context::New(); Context::Scope context_scope(context); char TEST_STRING[] = "this is a UTF-8 test! This is pi: π"; int TEST_LENGTH = strlen(TEST_STRING); Handle<String> str = String::New(TEST_STRING); char* buf = new char[TEST_LENGTH * 2]; // Fill the buffer with 'a' to ensure there are no NULLs to start with. fill_string(buf, 'a', TEST_LENGTH * 2); int charsWritten; int copied = str->WriteUtf8(buf, TEST_LENGTH * 2, &charsWritten); do_check_eq(copied, TEST_LENGTH + 1); // π is 2 bytes, so strlen (TEST_LENGTH) returns 1 larger than charsWritten do_check_eq(charsWritten, TEST_LENGTH - 1); do_check_eq(strlen(buf), TEST_LENGTH); delete[] buf; context.Dispose(); }
NS_IMETHOD Run() { mozilla::ReentrantMonitorAutoEnter lock(monitor); WaitFor(READ_LOCK); nsCString sql(mSQL); nsCOMPtr<mozIStorageStatement> stmt; do_check_success(mConnection->CreateStatement(sql, getter_AddRefs(stmt))); bool hasResult; nsresult rv = stmt->ExecuteStep(&hasResult); do_check_eq(rv, NS_ERROR_FILE_IS_LOCKED); // Finalize our statement and null out our connection before notifying to // ensure that we close on the proper thread. rv = stmt->Finalize(); do_check_eq(rv, NS_ERROR_FILE_IS_LOCKED); mConnection = nullptr; Notify(TEST_DONE); return NS_OK; }
void test_Length() { HandleScope handle_scope; Persistent<Context> context = Context::New(); Context::Scope context_scope(context); char TEST_STRING[] = "this is a test"; int TEST_LENGTH = strlen(TEST_STRING); Handle<String> str = String::New(TEST_STRING); do_check_eq(str->Length(), TEST_LENGTH); // Now, make a string with an embedded NULL. TEST_STRING[8] = '\0'; str = String::New(TEST_STRING, TEST_LENGTH); do_check_eq(str->Length(), TEST_LENGTH); // Finally, make sure that we end up calling strlen if no length is passed. str = String::New(TEST_STRING); int strlength = strlen(TEST_STRING); do_check_eq(str->Length(), strlength); context.Dispose(); }
void test_BasicCall() { HandleScope handle_scope; Handle<ObjectTemplate> templ = ObjectTemplate::New(); Handle<FunctionTemplate> fnT = v8::FunctionTemplate::New(AddOne); templ->Set("AddOne", fnT); Persistent<Context> context = Context::New(NULL, templ); Local<Value> addone = context->Global()->Get(String::New("AddOne")); do_check_true(!addone.IsEmpty()); do_check_true(!addone->IsUndefined()); do_check_true(addone->IsObject()); do_check_true(addone->IsFunction()); Local<Function> fn = addone.As<Function>(); do_check_eq(fn, fnT->GetFunction()); Local<Number> n = Number::New(0.5); Handle<Value> args[] = { n }; Local<Value> v = fn->Call(context->Global(), 1, args); do_check_true(!v.IsEmpty()); do_check_true(v->IsNumber()); Local<Number> n2 = v->ToNumber(); do_check_eq(n2->Value(), 1.5); }
void test_AsciiValue_operators() { HandleScope handle_scope; Persistent<Context> context = Context::New(); Context::Scope context_scope(context); char TEST_STRING[] = "ascii string value"; int TEST_LENGTH = strlen(TEST_STRING); Handle<String> str = String::New(TEST_STRING); do_check_eq(str->Length(), TEST_LENGTH); String::AsciiValue asciiString(str); const char* one = *asciiString; char* two = *asciiString; do_check_true(0 == strcmp(TEST_STRING, one)); do_check_true(0 == strcmp(TEST_STRING, two)); context.Dispose(); }
void test_Name() { HandleScope handle_scope; Handle<ObjectTemplate> templ = ObjectTemplate::New(); Handle<FunctionTemplate> fnT = v8::FunctionTemplate::New(AddOne); templ->Set("AddOne", fnT); fnT->SetClassName(String::NewSymbol("AddOne")); Persistent<Context> context = Context::New(NULL, templ); Handle<Script> script = Script::New(String::New("AddOne.name;")); Context::Scope scope(context); Handle<Value> v = script->Run(); do_check_true(!v.IsEmpty()); Handle<String> s = v->ToString(); do_check_eq(s, String::NewSymbol("AddOne")); context.Dispose(); }
void test_obj_tmplexn() { HandleScope scope; Persistent<Context> context = Context::New(); Context::Scope context_scope(context); Handle<ObjectTemplate> tmpl = ObjectTemplate::New(); tmpl->SetNamedPropertyHandler(NamedGetterThrows, NamedSetterThrows, 0, NamedDeleterThrows); tmpl->SetIndexedPropertyHandler(IndexedGetterThrows, IndexedSetterThrows, 0, IndexedDeleterThrows); Handle<Object> obj = tmpl->NewInstance(); Local<Object> global = context->Global(); global->Set(String::New("testobj"), obj); Handle<String> source = String::New("var n = 0;" "try { testobj.myprop; } catch (e) { n += e; };" "try { testobj.myprop = (n+9); } catch (e) { n += e; }" "try { delete testobj.myprop; } catch (e) { n += e; };" "try { testobj[4]; } catch (e) { n += e; };" "try { testobj[5] = (n+9); } catch (e) { n += e; }" "try { delete testobj[6]; } catch (e) { n += e; }; n"); // Compile the source code. Handle<Script> script = Script::Compile(source); TryCatch trycatch; // Run the script to get the result. Handle<Value> result = script->Run(); do_check_false(result.IsEmpty()); do_check_true(result->IsInt32()); do_check_false(trycatch.HasCaught()); JSInt32 i = result->Int32Value(); do_check_eq(i, 21); context.Dispose(); }
void test_NULLFallback() { nsCOMPtr<mozIStorageConnection> db(getMemoryDatabase()); nsCOMPtr<mozIStorageStatement> stmt; (void)db->CreateStatement(NS_LITERAL_CSTRING( "SELECT NULL" ), getter_AddRefs(stmt)); nsCOMPtr<mozIStorageValueArray> valueArray = do_QueryInterface(stmt); do_check_true(valueArray); bool hasMore; do_check_true(NS_SUCCEEDED(stmt->ExecuteStep(&hasMore)) && hasMore); do_check_eq(stmt->AsInt32(0), 0); do_check_eq(stmt->AsInt64(0), 0); do_check_eq(stmt->AsDouble(0), 0.0); PRUint32 len = 100; do_check_eq(stmt->AsSharedUTF8String(0, &len), NULL); do_check_eq(len, 0); len = 100; do_check_eq(stmt->AsSharedWString(0, &len), NULL); do_check_eq(len, 0); len = 100; do_check_eq(stmt->AsSharedBlob(0, &len), NULL); do_check_eq(len, 0); do_check_eq(stmt->IsNull(0), true); do_check_eq(valueArray->AsInt32(0), 0); do_check_eq(valueArray->AsInt64(0), 0); do_check_eq(valueArray->AsDouble(0), 0.0); len = 100; do_check_eq(valueArray->AsSharedUTF8String(0, &len), NULL); do_check_eq(len, 0); len = 100; do_check_eq(valueArray->AsSharedWString(0, &len), NULL); do_check_eq(len, 0); len = 100; do_check_eq(valueArray->AsSharedBlob(0, &len), NULL); do_check_eq(len, 0); do_check_eq(valueArray->IsNull(0), true); }