Lines Matching defs:string
31 #include <string>
78 using ::v8::String;
98 v8::Local<v8::String> profile_name = v8_str("my_profile1");
311 Local<String> undef_str = undef->ToString(env.local()).ToLocalChecked();
327 Local<String> bar_str = v8_str("bar");
343 Local<String> bar_str = v8_str("bar");
369 class TestResource: public String::ExternalStringResource {
398 class TestOneByteResource : public String::ExternalOneByteStringResource {
436 Local<String> source =
437 String::NewExternalTwoByte(env->GetIsolate(), resource)
446 String::Encoding encoding = String::UNKNOWN_ENCODING;
447 CHECK_EQ(static_cast<const String::ExternalStringResourceBase*>(resource),
449 CHECK_EQ(String::TWO_BYTE_ENCODING, encoding);
467 Local<String> source =
468 String::NewExternalOneByte(env->GetIsolate(), resource)
471 CHECK_EQ(static_cast<const String::ExternalStringResourceBase*>(resource),
473 String::Encoding encoding = String::UNKNOWN_ENCODING;
474 CHECK_EQ(static_cast<const String::ExternalStringResourceBase*>(resource),
476 CHECK_EQ(String::ONE_BYTE_ENCODING, encoding);
496 Local<String> source =
497 String::NewFromTwoByte(env->GetIsolate(), two_byte_source,
500 // Trigger GCs so that the newly allocated string moves to old gen.
505 String::Encoding encoding = String::UNKNOWN_ENCODING;
507 CHECK_EQ(String::ONE_BYTE_ENCODING, encoding);
530 Local<String> source = v8_str(c_source);
531 // Trigger GCs so that the newly allocated string moves to old gen.
559 Local<String> local_string =
560 String::NewFromTwoByte(env->GetIsolate(), two_byte_string,
567 // Trigger GCs so that the newly allocated string moves to old gen.
583 Local<String> local_string = v8_str("s1");
586 // Trigger GCs so that the newly allocated string moves to old gen.
600 // Create a cons string that will land in old pointer space.
601 Local<String> cons = Local<String>::Cast(CompileRun(
603 // Create a sliced string that will land in old pointer space.
604 Local<String> slice = Local<String>::Cast(CompileRun(
607 // Trigger GCs so that the newly allocated string moves to old gen.
612 // Turn into external string with unaligned resource data.
632 uint16_t* two_byte_string = AsciiToTwoByteString("test string");
633 Local<String> string =
634 String::NewExternalTwoByte(CcTest::isolate(),
637 i::Handle<i::String> istring = v8::Utils::OpenHandle(*string);
638 // Trigger GCs so that the newly allocated string moves to old gen.
641 i::Handle<i::String> isymbol =
654 const char* one_byte_string = "test string";
655 Local<String> string =
656 String::NewExternalOneByte(
660 i::Handle<i::String> istring = v8::Utils::OpenHandle(*string);
661 // Trigger GCs so that the newly allocated string moves to old gen.
664 i::Handle<i::String> isymbol =
673 class RandomLengthResource : public v8::String::ExternalStringResource {
686 : public v8::String::ExternalOneByteStringResource {
704 v8::MaybeLocal<v8::String> maybe_str =
705 v8::String::NewExternalOneByte(isolate, &r);
714 v8::MaybeLocal<v8::String> maybe_str =
715 v8::String::NewExternalTwoByte(isolate, &r);
729 uint16_t* two_byte_string = AsciiToTwoByteString("test string");
730 Local<String> string =
731 String::NewExternalTwoByte(
735 i::Handle<i::String> istring = v8::Utils::OpenHandle(*string);
753 const char* one_byte_string = "test string";
754 Local<String> string =
755 String::NewExternalOneByte(
759 i::Handle<i::String> istring = v8::Utils::OpenHandle(*string);
795 // Use a stack allocated external string resource allocated object.
802 Local<String> source =
803 String::NewExternalOneByte(env->GetIsolate(), &res_stack)
817 // Use a heap allocated external string resource allocated object.
825 Local<String> source =
826 String::NewExternalOneByte(env->GetIsolate(), res_heap)
853 Local<String> left = v8_str(one_byte_string_1);
856 Local<String> right =
857 String::NewFromTwoByte(env->GetIsolate(), two_byte_source,
862 Local<String> source = String::Concat(left, right);
863 right = String::NewExternalOneByte(
867 source = String::Concat(source, right);
868 right = String::NewExternalTwoByte(
872 source = String::Concat(source, right);
874 source = String::Concat(source, right);
877 right = String::NewFromTwoByte(env->GetIsolate(), two_byte_source,
882 source = String::Concat(source, right);
883 right = String::NewExternalTwoByte(
887 source = String::Concat(source, right);
945 Local<String> name, const v8::PropertyCallbackInfo<Value>& info) {
1220 CHECK_EQ(0, v8::String::Cast(*value)->Length());
1631 v8::Local<Value> boxed_string = CompileRun("new String(\"test\")");
1641 Local<v8::String> the_string = as_boxed->ValueOf();
1656 v8::Local<Value> boxed_string = CompileRun("new String(\"test\")");
1775 Local<String> str = v8_str("3.1415926");
1814 v8::Local<String> str1 = v8_str("");
1816 v8::Local<String> str2 = v8_str("x");
1836 static void GetM(Local<String> name,
1874 v8::Local<v8::String> class_name = v8_str("the_class_name");
1945 static void GetNirk(Local<String> name,
1951 static void GetRino(Local<String> name,
1983 v8::Local<v8::String> class_name = v8_str("B");
2068 v8::Local<v8::String> class_name = v8_str("B");
2129 v8::Local<v8::String> class_name = v8_str("B");
2133 v8::Local<v8::String> subclass_name = v8_str("C");
2175 v8::Local<v8::String> class_name = v8_str("B");
2178 v8::Local<v8::String> subclass_name = v8_str("C");
2211 static void GetKnurd(Local<String> property,
2346 v8::Local<v8::String> val_str = val->ToString(env.local()).ToLocalChecked();
2347 v8::Local<v8::String> name = String::Concat(v8_str("p"), val_str);
2383 v8::Local<v8::String> val_str = val->ToString(env.local()).ToLocalChecked();
2384 v8::Local<v8::String> name = String::Concat(v8_str("p"), val_str);
2400 void SimpleAccessorGetter(Local<String> name,
2404 String::Concat(v8_str("accessor_"), name))
2408 void SimpleAccessorSetter(Local<String> name, Local<Value> value,
2412 String::Concat(v8_str("accessor_"), name), value)
2422 SimpleAccessorGetter(Local<String>::Cast(sym->Name()), info);
2431 SimpleAccessorSetter(Local<String>::Cast(sym->Name()), value, info);
2459 i::Handle<i::String> name(v8::Utils::OpenHandle(*v8_str("length")));
2862 Local<v8::String> str = v8_str("str1");
2870 Local<v8::String> str2 = v8_str("str1");
3069 v8::String::NewFromUtf8(isolate, "my-private",
3097 CHECK(proxy->Set(env.local(), v8::String::NewFromUtf8(
3163 v8::String::NewFromUtf8(isolate, "my-private",
3191 CHECK(obj->Set(env.local(), v8::String::NewFromUtf8(
3248 v8::Local<String> name = v8_str("my-symbol");
3276 std::string script = std::string("var sym = ") + name;
3299 v8::Local<String> name = v8_str("my-private");
3740 v8::Local<v8::String> empty = v8_str("");
3741 v8::Local<v8::String> prop_name = v8_str("prop_name");
3886 v8::Persistent<String> global;
3893 CHECK_EQ(v8::Local<String>::New(isolate, global)->Length(), 3);
3902 CHECK_EQ(v8::Local<String>::New(isolate, global)->Length(), 3);
3910 v8::Persistent<String> global;
3920 CHECK_EQ(v8::Local<String>::New(isolate, global)->Length(), 3);
3929 CHECK_EQ(v8::Local<String>::New(isolate, global)->Length(), 6);
3938 v8::Persistent<String> global;
3948 CHECK_EQ(v8::Local<String>::New(isolate, global)->Length(), 3);
3952 Local<String> empty;
3969 v8::Global<String> unique(isolate, global);
3976 v8::Persistent<String> global;
3985 v8::Global<String> unique(isolate, global);
3989 v8::Global<String> copy = unique.Pass();
3998 v8::Global<String> copy(unique.Pass());
4007 v8::Global<String> copy = PassUnique(unique.Pass());
4018 v8::Global<String> unique = ReturnUnique(isolate, global);
4044 auto string =
4045 v8::String::NewFromUtf8(isolate, buffer.start(),
4047 cell_.Reset(isolate, string);
4087 v8::Global<v8::String> cell_;
4328 v8::Local<String> local = v8::Local<String>::New(isolate, v8_str("str"));
4329 v8::Persistent<String> global_string(isolate, local);
4333 CHECK(global_string == v8::Persistent<String>::Cast(global_value));
4340 v8::Persistent<String> global1;
4341 v8::Persistent<String> global2;
4351 Local<String> local1 = Local<String>::New(isolate, global1);
4352 Local<String> local2 = Local<String>::New(isolate, global2);
4367 Local<String> anotherLocal1 = Local<String>::New(isolate, global1);
4378 v8::Local<String> local =
4379 v8::Local<String>::New(CcTest::isolate(), v8_str("str"));
4534 WeakCallCounterAndPersistent<String> g1s2(&counter);
4535 WeakCallCounterAndPersistent<String> g1c1(&counter);
4537 WeakCallCounterAndPersistent<String> g2s2(&counter);
4538 WeakCallCounterAndPersistent<String> g2c1(&counter);
4757 String::Utf8Value exception_value(try_catch.Exception());
5154 Local<String> prop = v8_str("none");
5228 String::Utf8Value exception_value(try_catch.Exception());
5695 String::Utf8Value str_value(try_catch->Exception());
5859 printf("%s\n", *v8::String::Utf8Value(message->Get()));
6002 String::Utf8Value exception_value(try_catch.Exception());
6307 CHECK_EQ(0, strcmp(*v8::String::Utf8Value(try_catch.Exception()), "E1"));
6315 CHECK_EQ(0, strcmp(*v8::String::Utf8Value(try_catch.Exception()), "E2"));
6324 CHECK_EQ(0, strcmp(*v8::String::Utf8Value(resource), "inner"));
6326 strcmp(*v8::String::Utf8Value(message->Get()), "Uncaught Error: a"));
6425 // Assume String is not internalized.
6471 ->Equals(context.local(), v8_str("string"))
6581 String::Utf8Value exception_value(try_catch.Exception());
6631 String::Utf8Value exception_value(try_catch.Exception());
6782 String::Utf8Value exception_value(try_catch.Exception());
6792 String::Utf8Value exception_value(try_catch.Exception());
6924 Local<String> password = v8_str("Password");
7016 Local<String> source = v8_str(
7150 Local<String> source = v8_str(
7180 Local<String> str = v8_str("foo");
7181 v8::Persistent<String> p_str(isolate, str);
7455 v8::Isolate* isolate, v8::Local<v8::String> name) {
7586 v8::Isolate* isolate, v8::Local<String> name);
7592 v8::Isolate* isolate, v8::Local<String> name) {
8199 int GetUtf8Length(Local<String> str) {
8202 i::Handle<i::String> istr(v8::Utils::OpenHandle(*str));
8203 i::String::Flatten(istr);
8213 v8::Local<String> str = v8_str("abcde");
8215 v8::Local<String> str2 = v8_str("abc\303\260\342\230\203");
8216 v8::Local<String> str3 =
8217 v8::String::NewFromUtf8(context->GetIsolate(), "abc\0def",
8222 v8::Local<String> orphans_str =
8223 v8::String::NewFromTwoByte(context->GetIsolate(), orphans,
8228 v8::Local<String> lead_str =
8229 v8::String::NewFromTwoByte(context->GetIsolate(), lead,
8234 v8::Local<String> trail_str =
8235 v8::String::NewFromTwoByte(context->GetIsolate(), trail,
8240 v8::Local<String> pair_str =
8241 v8::String::NewFromTwoByte(context->GetIsolate(), pair,
8248 " left = left + String.fromCharCode(i);"
8253 " right = String.fromCharCode(i) + right;"
8256 Local<String> left_tree = global->Get(context.local(), v8_str("left"))
8258 .As<String>();
8259 Local<String> right_tree = global->Get(context.local(), v8_str("right"))
8261 .As<String>();
8333 String::REPLACE_INVALID_UTF8);
8343 String::REPLACE_INVALID_UTF8);
8353 String::REPLACE_INVALID_UTF8);
8364 String::REPLACE_INVALID_UTF8);
8474 len = str->Write(wbuf, 0, 6, String::NO_NULL_TERMINATION);
8489 String::NO_NULL_TERMINATION);
8500 String::NO_NULL_TERMINATION);
8512 String::NO_NULL_TERMINATION);
8526 CHECK_EQ(0, str->WriteOneByte(NULL, 0, 0, String::NO_NULL_TERMINATION));
8527 CHECK_EQ(0, str->WriteUtf8(NULL, 0, 0, String::NO_NULL_TERMINATION));
8528 CHECK_EQ(0, str->Write(NULL, 0, 0, String::NO_NULL_TERMINATION));
8544 Local<v8::String> string =
8545 Local<v8::String>::Cast(a->Get(context.local(), i).ToLocalChecked());
8548 int length = GetUtf8Length(string);
8564 "p.push(String.fromCharCode(0xd800));"
8565 "p.push(String.fromCharCode(0xdc00));"
8571 " p[1] = String.fromCharCode(lead++);"
8573 " p[2] = String.fromCharCode(trail++);"
8603 static bool SameSymbol(Local<String> s1, Local<String> s2) {
8604 i::Handle<i::String> is1(v8::Utils::OpenHandle(*s1));
8605 i::Handle<i::String> is2(v8::Utils::OpenHandle(*s2));
8614 Local<String> symbol1 =
8615 v8::String::NewFromUtf8(context->GetIsolate(), "abc",
8618 Local<String> symbol2 =
8619 v8::String::NewFromUtf8(context->GetIsolate(), "abc",
8639 Local<String> sym0 =
8640 v8::String::NewFromUtf8(context->GetIsolate(), "benedictus",
8643 Local<String> sym0b =
8644 v8::String::NewFromUtf8(context->GetIsolate(), "S\303\270ren",
8647 Local<String> sym1 =
8648 v8::String::NewFromUtf8(context->GetIsolate(), "\355\240\201\355\260\207",
8651 Local<String> sym2 =
8652 v8::String::NewFromUtf8(context->GetIsolate(), "\360\220\220\210",
8655 Local<String> sym3 = v8::String::NewFromUtf8(context->GetIsolate(),
8659 Local<String> sym4 =
8660 v8::String::NewFromUtf8(context->GetIsolate(), "x\360\220\220\210",
8676 CHECK(SameSymbol(sym0, Local<String>::Cast(s0)));
8677 CHECK(SameSymbol(sym0b, Local<String>::Cast(s0b)));
8678 CHECK(SameSymbol(sym1, Local<String>::Cast(s1)));
8679 CHECK(SameSymbol(sym2, Local<String>::Cast(s2)));
8680 CHECK(SameSymbol(sym3, Local<String>::Cast(s3)));
8681 CHECK(SameSymbol(sym4, Local<String>::Cast(s4)));
8700 v8::Local<v8::String> str =
8701 v8::String::NewFromUtf8(
8723 v8::Local<v8::String> str =
8724 v8::String::NewFromUtf8(
8728 v8::String::Value value(str);
8741 v8::Local<String> str = v8_str("42");
8775 v8::Local<String> foo = v8_str("foo");
8776 v8::Local<String> message = v8_str("message");
8817 v8::Local<String> foo = v8_str("foo");
8818 v8::Local<String> message = v8_str("message");
8835 v8::Local<String> foo_str = v8_str("foo");
8836 v8::Local<String> message_str = v8_str("message");
8926 static void YGetter(Local<String> name,
8933 static void YSetter(Local<String> name,
9033 v8::String::Utf8Value name(message->GetScriptOrigin().ResourceName());
9038 v8::String::Utf8Value source_line(
9125 String::Utf8Value exception_value(try_catch.Exception());
9135 String::Utf8Value finally_exception_value(try_catch.Exception());
9368 CompileRun("obj[0] = new String(1002);");
9431 Local<String> test = v8_str("propertyIsEnumerable.call(env1, 'prop')");
9844 Local<String> name,
9850 static void EchoSetter(Local<String> name, Local<Value> value,
9859 Local<String> name,
9865 static void UnreachableSetter(Local<String>,
10213 static void ConstTenGetter(Local<String> name,
10515 CHECK(property.As<v8::String>()
10549 concat_found = property.As<v8::String>()
10553 starts_with_found = property.As<v8::String>()
10613 static void ShadowYSetter(Local<String>,
10621 static void ShadowYGetter(Local<String> name,
11326 // Call the Object's constructor with a String.
11331 String::Utf8Value string_value1(
11343 String::Utf8Value string_value2(
11398 String::Utf8Value exception_value1(try_catch.Exception());
11406 String::Utf8Value exception_value2(try_catch.Exception());
11427 String::Utf8Value exception_value1(try_catch.Exception());
11434 String::Utf8Value exception_value2(try_catch.Exception());
11505 " var str = String(e);"
11575 Local<String> token = v8_str("<security token>");
11698 Local<String> token = v8_str("<security token>");
11823 String::Utf8Value exception_value1(try_catch.Exception());
11834 String::Utf8Value exception_value2(try_catch.Exception());
11858 String::Utf8Value exception_value1(try_catch.Exception());
11866 String::Utf8Value exception_value2(try_catch.Exception());
12261 Local<String> name,
12299 Local<String> name,
12834 static void ThrowingGetter(Local<String> name,
12964 Local<String> errorMessageString = message->Get();
13004 static void ParentGetter(Local<String> name,
13011 static void ChildGetter(Local<String> name,
13326 Local<String> customized_tostring = v8_str("customized toString");
13341 Local<String> value = instance->ToString(context.local()).ToLocalChecked();
13374 Local<String> customized_tostring = v8_str("customized toString");
13387 Local<String> value = instance->ToString(context.local()).ToLocalChecked();
13436 TEST_TOSTRINGTAG(Object, String, String);
13474 // Test non-String-valued @@toStringTag
14233 v8::Local<String> str(value->ToString(env).ToLocalChecked());
14247 std::string name;
14453 if (function->name.find(function_name) == std::string::npos)
14461 if (caller->name.find(caller_name) == std::string::npos)
14927 v8::String::Utf8Value line(message->GetSourceLine(context).ToLocalChecked());
14929 v8::String::Utf8Value name(message->GetScriptOrigin().ResourceName());
14937 v8::Local<v8::String> source = v8_str(
14988 v8::Local<v8::String> source0 = v8_str("1234");
14989 v8::Local<v8::String> source1 = v8_str("1234");
15029 v8::String::Utf8Value name(value);
15050 v8::String::Utf8Value symbol_name(Local<Symbol>::Cast(value)->Name());
15064 v8::String::Utf8Value elm(value);
15087 v8::String::Utf8Value elm(
15391 Local<String> token = v8_str("<security token>");
15474 class OneByteVectorResource : public v8::String::ExternalOneByteStringResource {
15486 class UC16VectorResource : public v8::String::ExternalStringResource {
15498 static void MorphAString(i::String* string,
15501 CHECK(i::StringShape(string).IsExternal());
15502 if (string->IsOneByteRepresentation()) {
15504 CHECK(string->map() == CcTest::heap()->external_one_byte_string_map());
15505 // Morph external string to be TwoByte string.
15506 string->set_map(CcTest::heap()->external_string_map());
15508 i::ExternalTwoByteString::cast(string);
15512 CHECK(string->map() == CcTest::heap()->external_string_map());
15513 // Morph external string to be one-byte string.
15514 string->set_map(CcTest::heap()->external_one_byte_string_map());
15515 i::ExternalOneByteString* morphed = i::ExternalOneByteString::cast(string);
15521 // Test that we can still flatten a string if the components it is built up
15538 Local<String> lhs(
15541 Local<String> rhs(
15562 Local<String> cons =
15563 v8_compile("cons")->Run(env.local()).ToLocalChecked().As<String>();
15623 v8::Local<v8::String> source =
15624 v8::String::NewExternalTwoByte(context->GetIsolate(), uc16_resource)
15636 v8::Persistent<v8::String> string;
15670 v8::Local<v8::String> string = v8::Local<v8::String>::New(
15671 CcTest::isolate(), regexp_interruption_data.string);
15672 string->MakeExternal(regexp_interruption_data.string_resource);
15678 // * turn the subject string from one-byte internal to two-byte external string
15689 v8::Local<v8::String> string = v8_str(one_byte_content);
15691 env->Global()->Set(env.local(), v8_str("a"), string).FromJust();
15692 regexp_interruption_data.string.Reset(env->GetIsolate(), string);
15704 regexp_interruption_data.string.Reset();
15999 v8::Local<v8::String> foo_string = v8_str("foo");
16708 v8::String::NewFromUtf8(c1->GetIsolate(), source,
16715 ->Set(c1.local(), v8::String::NewFromUtf8(c1->GetIsolate(), "foo",
16731 ->Set(c2.local(), v8::String::NewFromUtf8(c2->GetIsolate(), "foo",
16753 v8::Local<v8::String> src = v8_str(source);
16754 v8::Local<v8::String> origin = v8_str("stack-trace-test");
16763 v8::String::Utf8Value stack(
16775 v8::String::Utf8Value func_name(frame->GetFunctionName());
16776 v8::String::Utf8Value script_name(frame->GetScriptName());
16814 // This is the source string inside the eval which has the call to foo.
16829 // This is the source string inside the eval which has the call to baz.
16874 v8::Local<v8::String> origin = v8_str("capture-stack-trace-test");
16891 v8::Local<v8::String> overview_src = v8_str(overview_source);
16912 v8::Local<v8::String> detailed_src = v8_str(detailed_source);
16944 v8::Local<v8::String> function_name_src =
16945 v8::String::NewFromUtf8(isolate, function_name_source,
17647 v8::Local<v8::String> url = v8_str("eval_url");
17649 v8::Local<v8::String> name =
17709 v8::Local<v8::String> scriptSource = v8_str(
17729 v8::Local<v8::String> url = v8_str("source_url");
17731 v8::Local<v8::String> name =
17775 v8::Local<v8::String> url = v8_str("source_url");
17777 v8::Local<v8::String> name =
17833 v8::String::Utf8Value stack(
17858 CHECK_EQ(0, strcmp(*v8::String::Utf8Value(sourceURL), "source_url"));
17881 CHECK_EQ(0, strcmp(*v8::String::Utf8Value(sourceURL), "source_url"));
18030 virtual void VisitExternalString(v8::Local<v8::String> string) {
18031 if (!string->IsExternal()) {
18032 CHECK(string->IsExternalOneByte());
18035 v8::String::ExternalStringResource* resource =
18036 string->GetExternalStringResource();
18052 v8::String::ExternalStringResource* resource_[4];
18061 v8::Local<v8::String> cons =
18075 String::Encoding encoding;
18077 CHECK_EQ(String::TWO_BYTE_ENCODING, encoding);
18085 v8::Local<v8::String> cons =
18099 String::Encoding encoding;
18101 CHECK_EQ(String::ONE_BYTE_ENCODING, encoding);
18109 const char* string = "Some string";
18110 uint16_t* two_byte_string = AsciiToTwoByteString(string);
18113 v8::Local<v8::String> string0 =
18114 v8::String::NewExternalTwoByte(env->GetIsolate(), resource[0])
18117 v8::Local<v8::String> string1 =
18118 v8::String::NewExternalTwoByte(env->GetIsolate(), resource[1])
18123 v8::Local<v8::String> string2 =
18124 v8::String::NewFromUtf8(env->GetIsolate(), string,
18130 resource[3] = new TestResource(AsciiToTwoByteString("Some other string"));
18131 v8::Local<v8::String> string3 =
18132 v8::String::NewExternalTwoByte(env->GetIsolate(), resource[3])
18134 CcTest::heap()->CollectAllAvailableGarbage(); // Tenure string.
18136 i::Handle<i::String> string3_i = v8::Utils::OpenHandle(*string3);
18141 // We need to add usages for string* to avoid warnings in GCC 4.7
18160 const char* s = "One string to test them all, one string to find them.";
18163 v8::Local<v8::String> ring =
18164 v8::String::NewExternalOneByte(isolate, inscription).ToLocalChecked();
18184 CompileRun("var ring = 'One string to test them all';");
18185 const char* s = "One string to test them all";
18188 v8::Local<v8::String> ring =
18207 CompileRun("var ring = 'One string to test them all';");
18208 const char* s = "One string to test them all";
18211 v8::Local<v8::String> ring = CompileRun("ring").As<v8::String>();
18352 v8::MaybeLocal<v8::String> str(
18387 v8::String::Utf8Value value(try_catch.Exception());
18412 Local<v8::String> obj = v8_str("");
18489 v8::Local<v8::String> script = v8_str("function f() {}\n\nfunction g() {}");
18501 *v8::String::Utf8Value(script_origin_f.ResourceName())));
18511 *v8::String::Utf8Value(script_origin_f.SourceMapUrl())));
18515 *v8::String::Utf8Value(script_origin_g.ResourceName())));
18523 *v8::String::Utf8Value(script_origin_g.SourceMapUrl())));
18531 v8::Local<v8::String> script =
18540 strcmp("foo.bar.baz", *v8::String::Utf8Value(f->GetInferredName())));
18614 v8::String::NewFromUtf8(env->GetIsolate(), functions[i * 2],
18619 *v8::String::Utf8Value(f->GetDebugName())));
18681 CHECK_EQ(0, strcmp("display_a", *v8::String::Utf8Value(a->GetDisplayName())));
18682 CHECK_EQ(0, strcmp("display_b", *v8::String::Utf8Value(b->GetDisplayName())));
18688 0, strcmp("set_in_runtime", *v8::String
18696 v8::Local<v8::String> script = v8_str("function f() {}\n\nfunction g() {}");
18717 v8::Local<v8::String> script =
18757 v8::Local<v8::String> scriptSource =
18775 v8::Local<v8::String> script = v8_str(
18802 Local<String> name,
18811 Local<String> name,
19210 i::Handle<i::String> string = v8::Utils::OpenHandle(String::Cast(*result));
19211 int length = string->length();
19212 CHECK(string->IsOneByteRepresentation());
19214 i::Handle<i::String> flat_string = i::String::Flatten(string);
19216 CHECK(string->IsOneByteRepresentation());
19222 i::String::WriteToFlat(*flat_string, uc16_buffer, 0, length);
19231 // If the cons string has been short-circuited, skip the following checks.
19232 if (!string.is_identical_to(flat_string)) {
19233 // At this point, we should have a Cons string which is flat and one-byte,
19234 // with a first half that is a two-byte string (although it only contains
19237 CHECK(string->IsOneByteRepresentation());
19238 i::ConsString* cons = i::ConsString::cast(*string);
19243 // Check that some string operations work.
19303 Local<String> string =
19304 String::NewExternalTwoByte(isolate,
19307 CHECK(!string->IsOneByte() && string->ContainsOnlyOneByte());
19309 string = String::NewFromTwoByte(isolate, string_contents,
19312 CHECK(string->IsOneByte() && string->ContainsOnlyOneByte());
19314 Local<String> base = v8_str("a");
19315 Local<String> left = base;
19316 Local<String> right = base;
19318 left = String::Concat(base, left);
19319 right = String::Concat(right, base);
19321 Local<String> balanced = String::Concat(left, base);
19322 balanced = String::Concat(balanced, right);
19323 Local<String> cons_strings[] = {left, balanced, right};
19324 Local<String> two_byte =
19325 String::NewExternalTwoByte(isolate,
19331 string = cons_strings[i];
19332 CHECK(string->IsOneByte() && string->ContainsOnlyOneByte());
19334 string = String::Concat(two_byte, cons_strings[i]);
19335 CHECK(!string->IsOneByte() && string->ContainsOnlyOneByte());
19336 string = String::Concat(cons_strings[i], two_byte);
19337 CHECK(!string->IsOneByte() && string->ContainsOnlyOneByte());
19348 string = String::NewExternalTwoByte(
19352 CHECK_EQ(size, string->Length());
19353 CHECK(!string->ContainsOnlyOneByte());
19902 // Change the String.prototype in the second context and check
19906 CompileRun("String.prototype.charAt = function() { return \"not a\"; }");
20442 Local<String> property,
20542 CompileRun("var s = new String('foobar'); obj.__proto__ = s;");
20546 // These should fall through to the String prototype.
20634 Local<String> message = v8_str("Message");
20635 Local<String> expected_message = v8_str("Uncaught EvalError: Message");
20643 Local<String> actual_message = try_catch.Message()->Get();
20874 Local<String> password = v8_str("Password");
20880 Local<String> i = v8_str("i");
20881 Local<String> o = v8_str("o");
20882 Local<String> id = v8_str("id");
21634 CHECK(*v8::Utils::OpenHandle(*v8::String::Empty(isolate)) == *empty_string);
21640 Local<String> name,
21650 static void InstanceCheckedSetter(Local<String> name,
21751 Local<String> name, const v8::PropertyCallbackInfo<v8::Value>& info) {}
21755 Local<String> name, Local<Value> value,
22146 Local<String> json =
22148 v8::String::Utf8Value utf8(json);
22160 Local<String> json =
22162 v8::String::Utf8Value utf8(json);
22293 i::PrintF("%s\n", *String::Utf8Value(args[i]));
22567 Local<String> property,
22817 Local<String> values[runs];
22820 Local<String> value;
22825 Local<String> expected;
22838 Local<String>, Local<Value>, const v8::PropertyCallbackInfo<void>& info) {
23001 // build source string
23520 String::Utf8Value utf8_name(script_name);
23611 v8::String::Utf8Value url(script->GetUnboundScript()->GetSourceURL());
23617 v8::String::Utf8Value url(
23819 // Helper for constructing a string from chunks (the compilation needs it
24280 v8::Local<v8::String> source_string = v8_str(source);
24300 v8::Local<v8::String> source_string = v8_str(source);
24369 v8::Local<v8::String> source_str = v8_str("function foo() {}");
24402 v8::Local<v8::String> incompatible_source_str =
24425 new RandomLengthOneByteResource(i::String::kMaxLength);
24426 v8::Local<v8::String> str =
24427 v8::String::NewExternalOneByte(CcTest::isolate(), r).ToLocalChecked();
24430 v8::Local<v8::String> result = v8::String::Concat(str, str);
24567 const int length = i::String::kMaxLength + 1;
24575 CHECK(v8::String::NewFromUtf8(isolate, data, v8::NewStringType::kNormal,
24583 CHECK(v8::String::NewFromOneByte(isolate, data, v8::NewStringType::kNormal,
24591 CHECK(v8::String::NewFromTwoByte(isolate, data, v8::NewStringType::kNormal,
24654 .As<v8::String>();
25028 CHECK(!CompileRun("String.prototype.__proto__ = p;"
25178 String::Utf8Value result_allowed(
25189 String::Utf8Value result_denied(
