Updated V8 from git://github.com/v8/v8.git to 57f8959fb264354ba1a2e5118db512f588917061
[profile/ivi/qtjsbackend.git] / src / 3rdparty / v8 / test / cctest / test-strings.cc
1 // Copyright 2011 the V8 project authors. All rights reserved.
2
3 // Check that we can traverse very deep stacks of ConsStrings using
4 // StringInputBuffer.  Check that Get(int) works on very deep stacks
5 // of ConsStrings.  These operations may not be very fast, but they
6 // should be possible without getting errors due to too deep recursion.
7
8 #include <stdlib.h>
9
10 #include "v8.h"
11
12 #include "api.h"
13 #include "factory.h"
14 #include "cctest.h"
15 #include "zone-inl.h"
16
17 unsigned int seed = 123;
18
19 static uint32_t gen() {
20         uint64_t z;
21         z = seed;
22         z *= 279470273;
23         z %= 4294967291U;
24         seed = static_cast<unsigned int>(z);
25         return static_cast<uint32_t>(seed >> 16);
26 }
27
28
29 using namespace v8::internal;
30
31 static v8::Persistent<v8::Context> env;
32
33
34 static void InitializeVM() {
35   if (env.IsEmpty()) {
36     v8::HandleScope scope;
37     const char* extensions[] = { "v8/print" };
38     v8::ExtensionConfiguration config(1, extensions);
39     env = v8::Context::New(&config);
40   }
41   v8::HandleScope scope;
42   env->Enter();
43 }
44
45
46 static const int NUMBER_OF_BUILDING_BLOCKS = 128;
47 static const int DEEP_DEPTH = 8 * 1024;
48 static const int SUPER_DEEP_DEPTH = 80 * 1024;
49
50
51 class Resource: public v8::String::ExternalStringResource,
52                 public ZoneObject {
53  public:
54   explicit Resource(Vector<const uc16> string): data_(string.start()) {
55     length_ = string.length();
56   }
57   virtual const uint16_t* data() const { return data_; }
58   virtual size_t length() const { return length_; }
59
60  private:
61   const uc16* data_;
62   size_t length_;
63 };
64
65
66 class AsciiResource: public v8::String::ExternalAsciiStringResource,
67                 public ZoneObject {
68  public:
69   explicit AsciiResource(Vector<const char> string): data_(string.start()) {
70     length_ = string.length();
71   }
72   virtual const char* data() const { return data_; }
73   virtual size_t length() const { return length_; }
74
75  private:
76   const char* data_;
77   size_t length_;
78 };
79
80
81 static void InitializeBuildingBlocks(
82     Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS]) {
83   // A list of pointers that we don't have any interest in cleaning up.
84   // If they are reachable from a root then leak detection won't complain.
85   for (int i = 0; i < NUMBER_OF_BUILDING_BLOCKS; i++) {
86     int len = gen() % 16;
87     if (len > 14) {
88       len += 1234;
89     }
90     switch (gen() % 4) {
91       case 0: {
92         uc16 buf[2000];
93         for (int j = 0; j < len; j++) {
94           buf[j] = gen() % 65536;
95         }
96         building_blocks[i] =
97             FACTORY->NewStringFromTwoByte(Vector<const uc16>(buf, len));
98         for (int j = 0; j < len; j++) {
99           CHECK_EQ(buf[j], building_blocks[i]->Get(j));
100         }
101         break;
102       }
103       case 1: {
104         char buf[2000];
105         for (int j = 0; j < len; j++) {
106           buf[j] = gen() % 128;
107         }
108         building_blocks[i] =
109             FACTORY->NewStringFromAscii(Vector<const char>(buf, len));
110         for (int j = 0; j < len; j++) {
111           CHECK_EQ(buf[j], building_blocks[i]->Get(j));
112         }
113         break;
114       }
115       case 2: {
116         uc16* buf = ZONE->NewArray<uc16>(len);
117         for (int j = 0; j < len; j++) {
118           buf[j] = gen() % 65536;
119         }
120         Resource* resource = new Resource(Vector<const uc16>(buf, len));
121         building_blocks[i] = FACTORY->NewExternalStringFromTwoByte(resource);
122         for (int j = 0; j < len; j++) {
123           CHECK_EQ(buf[j], building_blocks[i]->Get(j));
124         }
125         break;
126       }
127       case 3: {
128         char* buf = NewArray<char>(len);
129         for (int j = 0; j < len; j++) {
130           buf[j] = gen() % 128;
131         }
132         building_blocks[i] =
133             FACTORY->NewStringFromAscii(Vector<const char>(buf, len));
134         for (int j = 0; j < len; j++) {
135           CHECK_EQ(buf[j], building_blocks[i]->Get(j));
136         }
137         DeleteArray<char>(buf);
138         break;
139       }
140     }
141   }
142 }
143
144
145 static Handle<String> ConstructLeft(
146     Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS],
147     int depth) {
148   Handle<String> answer = FACTORY->NewStringFromAscii(CStrVector(""));
149   for (int i = 0; i < depth; i++) {
150     answer = FACTORY->NewConsString(
151         answer,
152         building_blocks[i % NUMBER_OF_BUILDING_BLOCKS]);
153   }
154   return answer;
155 }
156
157
158 static Handle<String> ConstructRight(
159     Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS],
160     int depth) {
161   Handle<String> answer = FACTORY->NewStringFromAscii(CStrVector(""));
162   for (int i = depth - 1; i >= 0; i--) {
163     answer = FACTORY->NewConsString(
164         building_blocks[i % NUMBER_OF_BUILDING_BLOCKS],
165         answer);
166   }
167   return answer;
168 }
169
170
171 static Handle<String> ConstructBalancedHelper(
172     Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS],
173     int from,
174     int to) {
175   CHECK(to > from);
176   if (to - from == 1) {
177     return building_blocks[from % NUMBER_OF_BUILDING_BLOCKS];
178   }
179   if (to - from == 2) {
180     return FACTORY->NewConsString(
181         building_blocks[from % NUMBER_OF_BUILDING_BLOCKS],
182         building_blocks[(from+1) % NUMBER_OF_BUILDING_BLOCKS]);
183   }
184   Handle<String> part1 =
185     ConstructBalancedHelper(building_blocks, from, from + ((to - from) / 2));
186   Handle<String> part2 =
187     ConstructBalancedHelper(building_blocks, from + ((to - from) / 2), to);
188   return FACTORY->NewConsString(part1, part2);
189 }
190
191
192 static Handle<String> ConstructBalanced(
193     Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS]) {
194   return ConstructBalancedHelper(building_blocks, 0, DEEP_DEPTH);
195 }
196
197
198 static StringInputBuffer buffer;
199
200
201 static void Traverse(Handle<String> s1, Handle<String> s2) {
202   int i = 0;
203   buffer.Reset(*s1);
204   StringInputBuffer buffer2(*s2);
205   while (buffer.has_more()) {
206     CHECK(buffer2.has_more());
207     uint16_t c = buffer.GetNext();
208     CHECK_EQ(c, buffer2.GetNext());
209     i++;
210   }
211   CHECK_EQ(s1->length(), i);
212   CHECK_EQ(s2->length(), i);
213 }
214
215
216 static void TraverseFirst(Handle<String> s1, Handle<String> s2, int chars) {
217   int i = 0;
218   buffer.Reset(*s1);
219   StringInputBuffer buffer2(*s2);
220   while (buffer.has_more() && i < chars) {
221     CHECK(buffer2.has_more());
222     uint16_t c = buffer.GetNext();
223     CHECK_EQ(c, buffer2.GetNext());
224     i++;
225   }
226   s1->Get(s1->length() - 1);
227   s2->Get(s2->length() - 1);
228 }
229
230
231 TEST(Traverse) {
232   printf("TestTraverse\n");
233   InitializeVM();
234   v8::HandleScope scope;
235   Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS];
236   ZoneScope zone(Isolate::Current(), DELETE_ON_EXIT);
237   InitializeBuildingBlocks(building_blocks);
238   Handle<String> flat = ConstructBalanced(building_blocks);
239   FlattenString(flat);
240   Handle<String> left_asymmetric = ConstructLeft(building_blocks, DEEP_DEPTH);
241   Handle<String> right_asymmetric = ConstructRight(building_blocks, DEEP_DEPTH);
242   Handle<String> symmetric = ConstructBalanced(building_blocks);
243   printf("1\n");
244   Traverse(flat, symmetric);
245   printf("2\n");
246   Traverse(flat, left_asymmetric);
247   printf("3\n");
248   Traverse(flat, right_asymmetric);
249   printf("4\n");
250   Handle<String> left_deep_asymmetric =
251       ConstructLeft(building_blocks, SUPER_DEEP_DEPTH);
252   Handle<String> right_deep_asymmetric =
253       ConstructRight(building_blocks, SUPER_DEEP_DEPTH);
254   printf("5\n");
255   TraverseFirst(left_asymmetric, left_deep_asymmetric, 1050);
256   printf("6\n");
257   TraverseFirst(left_asymmetric, right_deep_asymmetric, 65536);
258   printf("7\n");
259   FlattenString(left_asymmetric);
260   printf("10\n");
261   Traverse(flat, left_asymmetric);
262   printf("11\n");
263   FlattenString(right_asymmetric);
264   printf("12\n");
265   Traverse(flat, right_asymmetric);
266   printf("14\n");
267   FlattenString(symmetric);
268   printf("15\n");
269   Traverse(flat, symmetric);
270   printf("16\n");
271   FlattenString(left_deep_asymmetric);
272   printf("18\n");
273 }
274
275
276 static const int DEEP_ASCII_DEPTH = 100000;
277
278
279 TEST(DeepAscii) {
280   printf("TestDeepAscii\n");
281   InitializeVM();
282   v8::HandleScope scope;
283
284   char* foo = NewArray<char>(DEEP_ASCII_DEPTH);
285   for (int i = 0; i < DEEP_ASCII_DEPTH; i++) {
286     foo[i] = "foo "[i % 4];
287   }
288   Handle<String> string =
289       FACTORY->NewStringFromAscii(Vector<const char>(foo, DEEP_ASCII_DEPTH));
290   Handle<String> foo_string = FACTORY->NewStringFromAscii(CStrVector("foo"));
291   for (int i = 0; i < DEEP_ASCII_DEPTH; i += 10) {
292     string = FACTORY->NewConsString(string, foo_string);
293   }
294   Handle<String> flat_string = FACTORY->NewConsString(string, foo_string);
295   FlattenString(flat_string);
296
297   for (int i = 0; i < 500; i++) {
298     TraverseFirst(flat_string, string, DEEP_ASCII_DEPTH);
299   }
300   DeleteArray<char>(foo);
301 }
302
303
304 TEST(Utf8Conversion) {
305   // Smoke test for converting strings to utf-8.
306   InitializeVM();
307   v8::HandleScope handle_scope;
308   // A simple ascii string
309   const char* ascii_string = "abcdef12345";
310   int len =
311       v8::String::New(ascii_string,
312                       StrLength(ascii_string))->Utf8Length();
313   CHECK_EQ(StrLength(ascii_string), len);
314   // A mixed ascii and non-ascii string
315   // U+02E4 -> CB A4
316   // U+0064 -> 64
317   // U+12E4 -> E1 8B A4
318   // U+0030 -> 30
319   // U+3045 -> E3 81 85
320   const uint16_t mixed_string[] = {0x02E4, 0x0064, 0x12E4, 0x0030, 0x3045};
321   // The characters we expect to be output
322   const unsigned char as_utf8[11] = {0xCB, 0xA4, 0x64, 0xE1, 0x8B, 0xA4, 0x30,
323       0xE3, 0x81, 0x85, 0x00};
324   // The number of bytes expected to be written for each length
325   const int lengths[12] = {0, 0, 2, 3, 3, 3, 6, 7, 7, 7, 10, 11};
326   const int char_lengths[12] = {0, 0, 1, 2, 2, 2, 3, 4, 4, 4, 5, 5};
327   v8::Handle<v8::String> mixed = v8::String::New(mixed_string, 5);
328   CHECK_EQ(10, mixed->Utf8Length());
329   // Try encoding the string with all capacities
330   char buffer[11];
331   const char kNoChar = static_cast<char>(-1);
332   for (int i = 0; i <= 11; i++) {
333     // Clear the buffer before reusing it
334     for (int j = 0; j < 11; j++)
335       buffer[j] = kNoChar;
336     int chars_written;
337     int written = mixed->WriteUtf8(buffer, i, &chars_written);
338     CHECK_EQ(lengths[i], written);
339     CHECK_EQ(char_lengths[i], chars_written);
340     // Check that the contents are correct
341     for (int j = 0; j < lengths[i]; j++)
342       CHECK_EQ(as_utf8[j], static_cast<unsigned char>(buffer[j]));
343     // Check that the rest of the buffer hasn't been touched
344     for (int j = lengths[i]; j < 11; j++)
345       CHECK_EQ(kNoChar, buffer[j]);
346   }
347 }
348
349
350 TEST(ExternalShortStringAdd) {
351   ZoneScope zone(Isolate::Current(), DELETE_ON_EXIT);
352
353   InitializeVM();
354   v8::HandleScope handle_scope;
355
356   // Make sure we cover all always-flat lengths and at least one above.
357   static const int kMaxLength = 20;
358   CHECK_GT(kMaxLength, i::ConsString::kMinLength);
359
360   // Allocate two JavaScript arrays for holding short strings.
361   v8::Handle<v8::Array> ascii_external_strings =
362       v8::Array::New(kMaxLength + 1);
363   v8::Handle<v8::Array> non_ascii_external_strings =
364       v8::Array::New(kMaxLength + 1);
365
366   // Generate short ascii and non-ascii external strings.
367   for (int i = 0; i <= kMaxLength; i++) {
368     char* ascii = ZONE->NewArray<char>(i + 1);
369     for (int j = 0; j < i; j++) {
370       ascii[j] = 'a';
371     }
372     // Terminating '\0' is left out on purpose. It is not required for external
373     // string data.
374     AsciiResource* ascii_resource =
375         new AsciiResource(Vector<const char>(ascii, i));
376     v8::Local<v8::String> ascii_external_string =
377         v8::String::NewExternal(ascii_resource);
378
379     ascii_external_strings->Set(v8::Integer::New(i), ascii_external_string);
380     uc16* non_ascii = ZONE->NewArray<uc16>(i + 1);
381     for (int j = 0; j < i; j++) {
382       non_ascii[j] = 0x1234;
383     }
384     // Terminating '\0' is left out on purpose. It is not required for external
385     // string data.
386     Resource* resource = new Resource(Vector<const uc16>(non_ascii, i));
387     v8::Local<v8::String> non_ascii_external_string =
388       v8::String::NewExternal(resource);
389     non_ascii_external_strings->Set(v8::Integer::New(i),
390                                     non_ascii_external_string);
391   }
392
393   // Add the arrays with the short external strings in the global object.
394   v8::Handle<v8::Object> global = env->Global();
395   global->Set(v8_str("external_ascii"), ascii_external_strings);
396   global->Set(v8_str("external_non_ascii"), non_ascii_external_strings);
397   global->Set(v8_str("max_length"), v8::Integer::New(kMaxLength));
398
399   // Add short external ascii and non-ascii strings checking the result.
400   static const char* source =
401     "function test() {"
402     "  var ascii_chars = 'aaaaaaaaaaaaaaaaaaaa';"
403     "  var non_ascii_chars = '\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234';"  //NOLINT
404     "  if (ascii_chars.length != max_length) return 1;"
405     "  if (non_ascii_chars.length != max_length) return 2;"
406     "  var ascii = Array(max_length + 1);"
407     "  var non_ascii = Array(max_length + 1);"
408     "  for (var i = 0; i <= max_length; i++) {"
409     "    ascii[i] = ascii_chars.substring(0, i);"
410     "    non_ascii[i] = non_ascii_chars.substring(0, i);"
411     "  };"
412     "  for (var i = 0; i <= max_length; i++) {"
413     "    if (ascii[i] != external_ascii[i]) return 3;"
414     "    if (non_ascii[i] != external_non_ascii[i]) return 4;"
415     "    for (var j = 0; j < i; j++) {"
416     "      if (external_ascii[i] !="
417     "          (external_ascii[j] + external_ascii[i - j])) return 5;"
418     "      if (external_non_ascii[i] !="
419     "          (external_non_ascii[j] + external_non_ascii[i - j])) return 6;"
420     "      if (non_ascii[i] != (non_ascii[j] + non_ascii[i - j])) return 7;"
421     "      if (ascii[i] != (ascii[j] + ascii[i - j])) return 8;"
422     "      if (ascii[i] != (external_ascii[j] + ascii[i - j])) return 9;"
423     "      if (ascii[i] != (ascii[j] + external_ascii[i - j])) return 10;"
424     "      if (non_ascii[i] !="
425     "          (external_non_ascii[j] + non_ascii[i - j])) return 11;"
426     "      if (non_ascii[i] !="
427     "          (non_ascii[j] + external_non_ascii[i - j])) return 12;"
428     "    }"
429     "  }"
430     "  return 0;"
431     "};"
432     "test()";
433   CHECK_EQ(0, CompileRun(source)->Int32Value());
434 }
435
436
437 TEST(CachedHashOverflow) {
438   // We incorrectly allowed strings to be tagged as array indices even if their
439   // values didn't fit in the hash field.
440   // See http://code.google.com/p/v8/issues/detail?id=728
441   ZoneScope zone(Isolate::Current(), DELETE_ON_EXIT);
442
443   InitializeVM();
444   v8::HandleScope handle_scope;
445   // Lines must be executed sequentially. Combining them into one script
446   // makes the bug go away.
447   const char* lines[] = {
448       "var x = [];",
449       "x[4] = 42;",
450       "var s = \"1073741828\";",
451       "x[s];",
452       "x[s] = 37;",
453       "x[4];",
454       "x[s];",
455       NULL
456   };
457
458   Handle<Smi> fortytwo(Smi::FromInt(42));
459   Handle<Smi> thirtyseven(Smi::FromInt(37));
460   Handle<Object> results[] = {
461       FACTORY->undefined_value(),
462       fortytwo,
463       FACTORY->undefined_value(),
464       FACTORY->undefined_value(),
465       thirtyseven,
466       fortytwo,
467       thirtyseven  // Bug yielded 42 here.
468   };
469
470   const char* line;
471   for (int i = 0; (line = lines[i]); i++) {
472     printf("%s\n", line);
473     v8::Local<v8::Value> result =
474         v8::Script::Compile(v8::String::New(line))->Run();
475     CHECK_EQ(results[i]->IsUndefined(), result->IsUndefined());
476     CHECK_EQ(results[i]->IsNumber(), result->IsNumber());
477     if (result->IsNumber()) {
478       CHECK_EQ(Smi::cast(results[i]->ToSmi()->ToObjectChecked())->value(),
479                result->ToInt32()->Value());
480     }
481   }
482 }
483
484
485 TEST(SliceFromCons) {
486   FLAG_string_slices = true;
487   InitializeVM();
488   v8::HandleScope scope;
489   Handle<String> string =
490       FACTORY->NewStringFromAscii(CStrVector("parentparentparent"));
491   Handle<String> parent = FACTORY->NewConsString(string, string);
492   CHECK(parent->IsConsString());
493   CHECK(!parent->IsFlat());
494   Handle<String> slice = FACTORY->NewSubString(parent, 1, 25);
495   // After slicing, the original string becomes a flat cons.
496   CHECK(parent->IsFlat());
497   CHECK(slice->IsSlicedString());
498   CHECK_EQ(SlicedString::cast(*slice)->parent(),
499            ConsString::cast(*parent)->first());
500   CHECK(SlicedString::cast(*slice)->parent()->IsSeqString());
501   CHECK(slice->IsFlat());
502 }
503
504
505 class AsciiVectorResource : public v8::String::ExternalAsciiStringResource {
506  public:
507   explicit AsciiVectorResource(i::Vector<const char> vector)
508       : data_(vector) {}
509   virtual ~AsciiVectorResource() {}
510   virtual size_t length() const { return data_.length(); }
511   virtual const char* data() const { return data_.start(); }
512  private:
513   i::Vector<const char> data_;
514 };
515
516
517 TEST(SliceFromExternal) {
518   FLAG_string_slices = true;
519   InitializeVM();
520   v8::HandleScope scope;
521   AsciiVectorResource resource(
522       i::Vector<const char>("abcdefghijklmnopqrstuvwxyz", 26));
523   Handle<String> string = FACTORY->NewExternalStringFromAscii(&resource);
524   CHECK(string->IsExternalString());
525   Handle<String> slice = FACTORY->NewSubString(string, 1, 25);
526   CHECK(slice->IsSlicedString());
527   CHECK(string->IsExternalString());
528   CHECK_EQ(SlicedString::cast(*slice)->parent(), *string);
529   CHECK(SlicedString::cast(*slice)->parent()->IsExternalString());
530   CHECK(slice->IsFlat());
531 }
532
533
534 TEST(TrivialSlice) {
535   // This tests whether a slice that contains the entire parent string
536   // actually creates a new string (it should not).
537   FLAG_string_slices = true;
538   InitializeVM();
539   HandleScope scope;
540   v8::Local<v8::Value> result;
541   Handle<String> string;
542   const char* init = "var str = 'abcdefghijklmnopqrstuvwxyz';";
543   const char* check = "str.slice(0,26)";
544   const char* crosscheck = "str.slice(1,25)";
545
546   CompileRun(init);
547
548   result = CompileRun(check);
549   CHECK(result->IsString());
550   string = v8::Utils::OpenHandle(v8::String::Cast(*result));
551   CHECK(!string->IsSlicedString());
552
553   string = FACTORY->NewSubString(string, 0, 26);
554   CHECK(!string->IsSlicedString());
555   result = CompileRun(crosscheck);
556   CHECK(result->IsString());
557   string = v8::Utils::OpenHandle(v8::String::Cast(*result));
558   CHECK(string->IsSlicedString());
559   CHECK_EQ("bcdefghijklmnopqrstuvwxy", *(string->ToCString()));
560 }
561
562
563 TEST(SliceFromSlice) {
564   // This tests whether a slice that contains the entire parent string
565   // actually creates a new string (it should not).
566   FLAG_string_slices = true;
567   InitializeVM();
568   HandleScope scope;
569   v8::Local<v8::Value> result;
570   Handle<String> string;
571   const char* init = "var str = 'abcdefghijklmnopqrstuvwxyz';";
572   const char* slice = "var slice = str.slice(1,-1); slice";
573   const char* slice_from_slice = "slice.slice(1,-1);";
574
575   CompileRun(init);
576   result = CompileRun(slice);
577   CHECK(result->IsString());
578   string = v8::Utils::OpenHandle(v8::String::Cast(*result));
579   CHECK(string->IsSlicedString());
580   CHECK(SlicedString::cast(*string)->parent()->IsSeqString());
581   CHECK_EQ("bcdefghijklmnopqrstuvwxy", *(string->ToCString()));
582
583   result = CompileRun(slice_from_slice);
584   CHECK(result->IsString());
585   string = v8::Utils::OpenHandle(v8::String::Cast(*result));
586   CHECK(string->IsSlicedString());
587   CHECK(SlicedString::cast(*string)->parent()->IsSeqString());
588   CHECK_EQ("cdefghijklmnopqrstuvwx", *(string->ToCString()));
589 }
590
591
592 TEST(AsciiArrayJoin) {
593   // Set heap limits.
594   static const int K = 1024;
595   v8::ResourceConstraints constraints;
596   constraints.set_max_young_space_size(256 * K);
597   constraints.set_max_old_space_size(4 * K * K);
598   v8::SetResourceConstraints(&constraints);
599
600   // String s is made of 2^17 = 131072 'c' characters and a is an array
601   // starting with 'bad', followed by 2^14 times the string s. That means the
602   // total length of the concatenated strings is 2^31 + 3. So on 32bit systems
603   // summing the lengths of the strings (as Smis) overflows and wraps.
604   static const char* join_causing_out_of_memory =
605       "var two_14 = Math.pow(2, 14);"
606       "var two_17 = Math.pow(2, 17);"
607       "var s = Array(two_17 + 1).join('c');"
608       "var a = ['bad'];"
609       "for (var i = 1; i <= two_14; i++) a.push(s);"
610       "a.join("");";
611
612   v8::HandleScope scope;
613   LocalContext context;
614   v8::V8::IgnoreOutOfMemoryException();
615   v8::Local<v8::Script> script =
616       v8::Script::Compile(v8::String::New(join_causing_out_of_memory));
617   v8::Local<v8::Value> result = script->Run();
618
619   // Check for out of memory state.
620   CHECK(result.IsEmpty());
621   CHECK(context->HasOutOfMemoryException());
622 }