Experimental: merge from bleeding_edge. Merge up to and including...

test/cctest/test-regexp.cc

 // Copyright 2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 273 matching lines @@
   CHECK_MIN_MAX("a[bc]d", 3, 3);
   CHECK_MIN_MAX("a|bc", 1, 2);
   CHECK_MIN_MAX("ab|c", 1, 2);
   CHECK_MIN_MAX("a||bc", 0, 2);
   CHECK_MIN_MAX("|", 0, 0);
   CHECK_MIN_MAX("(?:ab)", 2, 2);
   CHECK_MIN_MAX("(?:ab|cde)", 2, 3);
   CHECK_MIN_MAX("(?:ab)|cde", 2, 3);
   CHECK_MIN_MAX("(ab)", 2, 2);
   CHECK_MIN_MAX("(ab|cde)", 2, 3);
-  CHECK_MIN_MAX("(ab)\\1", 4, 4);
-  CHECK_MIN_MAX("(ab|cde)\\1", 4, 6);
+  CHECK_MIN_MAX("(ab)\\1", 2, 4);
+  CHECK_MIN_MAX("(ab|cde)\\1", 2, 6);
   CHECK_MIN_MAX("(?:ab)?", 0, 2);
   CHECK_MIN_MAX("(?:ab)*", 0, RegExpTree::kInfinity);
   CHECK_MIN_MAX("(?:ab)+", 2, RegExpTree::kInfinity);
   CHECK_MIN_MAX("a?", 0, 1);
   CHECK_MIN_MAX("a*", 0, RegExpTree::kInfinity);
   CHECK_MIN_MAX("a+", 1, RegExpTree::kInfinity);
   CHECK_MIN_MAX("a??", 0, 1);
   CHECK_MIN_MAX("a*?", 0, RegExpTree::kInfinity);
   CHECK_MIN_MAX("a+?", 1, RegExpTree::kInfinity);
   CHECK_MIN_MAX("(?:a?)?", 0, 1);
@@ skipping 285 matching lines @@
   byte codes[1024];
   RegExpMacroAssemblerIrregexp m(Vector<byte>(codes, 1024));
   // ^f(o)o.
   Label fail, fail2, start;
   uc16 foo_chars[3];
   foo_chars[0] = 'f';
   foo_chars[1] = 'o';
   foo_chars[2] = 'o';
   Vector<const uc16> foo(foo_chars, 3);
   m.SetRegister(4, 42);
-  m.PushRegister(4);
+  m.PushRegister(4, RegExpMacroAssembler::kNoStackLimitCheck);
   m.AdvanceRegister(4, 42);
   m.GoTo(&start);
   m.Fail();
   m.Bind(&start);
   m.PushBacktrack(&fail2);
   m.CheckCharacters(foo, 0, &fail, true);
   m.WriteCurrentPositionToRegister(0, 0);
   m.PushCurrentPosition();
   m.AdvanceCurrentPosition(3);
   m.WriteCurrentPositionToRegister(1, 0);
@@ skipping 47 matching lines @@
   ~ContextInitializer() {
     env_->Exit();
     env_.Dispose();
   }
  private:
   v8::Persistent<v8::Context> env_;
   v8::HandleScope scope_;
   v8::internal::StackGuard stack_guard_;
 };
 
+// Helper functions for calling the Execute method.
+template <typename T>
+static RegExpMacroAssemblerIA32::Result ExecuteIA32(Code* code,
+                                                    const T** input,
+                                                    int start_offset,
+                                                    int end_offset,
+                                                    int* captures,
+                                                    bool at_start) {
+  return RegExpMacroAssemblerIA32::Execute(
+      code,
+      reinterpret_cast<Address*>(
+          reinterpret_cast<void*>(const_cast<T**>(input))),
+      start_offset,
+      end_offset,
+      captures,
+      at_start);
+}
+
+template <typename T>
+static RegExpMacroAssemblerIA32::Result ExecuteIA32(Code* code,
+                                                    T** input,
+                                                    int start_offset,
+                                                    int end_offset,
+                                                    int* captures,
+                                                    bool at_start) {
+  return RegExpMacroAssemblerIA32::Execute(
+      code,
+      reinterpret_cast<Address*>(reinterpret_cast<void*>(input)),
+      start_offset,
+      end_offset,
+      captures,
+      at_start);
+}
+
 
 TEST(MacroAssemblerIA32Success) {
   v8::V8::Initialize();
   ContextInitializer initializer;
 
   RegExpMacroAssemblerIA32 m(RegExpMacroAssemblerIA32::ASCII, 4);
 
   m.Succeed();
 
   Handle<String> source = Factory::NewStringFromAscii(CStrVector(""));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   int captures[4] = {42, 37, 87, 117};
   Handle<String> input = Factory::NewStringFromAscii(CStrVector("foofoo"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length();
 
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        captures,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  captures,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(-1, captures[0]);
   CHECK_EQ(-1, captures[1]);
   CHECK_EQ(-1, captures[2]);
   CHECK_EQ(-1, captures[3]);
 }
 
 
 TEST(MacroAssemblerIA32Simple) {
@@ skipping 19 matching lines @@
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   int captures[4] = {42, 37, 87, 117};
   Handle<String> input = Factory::NewStringFromAscii(CStrVector("foofoo"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length();
 
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        captures,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  captures,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, captures[0]);
   CHECK_EQ(3, captures[1]);
   CHECK_EQ(-1, captures[2]);
   CHECK_EQ(-1, captures[3]);
 
   input = Factory::NewStringFromAscii(CStrVector("barbarbar"));
   seq_input = Handle<SeqAsciiString>::cast(input);
   start_adr = seq_input->GetCharsAddress();
   start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   end_offset = start_offset + seq_input->length();
 
-  result = RegExpMacroAssemblerIA32::Execute(*code,
-                                             seq_input.location(),
-                                             start_offset,
-                                             end_offset,
-                                             captures,
-                                             true);
+  result = ExecuteIA32(*code,
+                       seq_input.location(),
+                       start_offset,
+                       end_offset,
+                       captures,
+                       true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::FAILURE, result);
 }
 
 
 TEST(MacroAssemblerIA32SimpleUC16) {
   v8::V8::Initialize();
   ContextInitializer initializer;
 
   RegExpMacroAssemblerIA32 m(RegExpMacroAssemblerIA32::UC16, 4);
@@ skipping 17 matching lines @@
   int captures[4] = {42, 37, 87, 117};
   const uc16 input_data[6] = {'f', 'o', 'o', 'f', 'o', '\xa0'};
   Handle<String> input =
       Factory::NewStringFromTwoByte(Vector<const uc16>(input_data, 6));
   Handle<SeqTwoByteString> seq_input = Handle<SeqTwoByteString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length() * sizeof(uc16);
 
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        captures,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  captures,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, captures[0]);
   CHECK_EQ(3, captures[1]);
   CHECK_EQ(-1, captures[2]);
   CHECK_EQ(-1, captures[3]);
 
   const uc16 input_data2[9] = {'b', 'a', 'r', 'b', 'a', 'r', 'b', 'a', '\xa0'};
   input = Factory::NewStringFromTwoByte(Vector<const uc16>(input_data2, 9));
   seq_input = Handle<SeqTwoByteString>::cast(input);
   start_adr = seq_input->GetCharsAddress();
   start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   end_offset = start_offset + seq_input->length() * sizeof(uc16);
 
-  result = RegExpMacroAssemblerIA32::Execute(*code,
-                                             seq_input.location(),
-                                             start_offset,
-                                             end_offset,
-                                             captures,
-                                             true);
+  result = ExecuteIA32(*code,
+                       seq_input.location(),
+                       start_offset,
+                       end_offset,
+                       captures,
+                       true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::FAILURE, result);
 }
 
 
 TEST(MacroAssemblerIA32Backtrack) {
   v8::V8::Initialize();
   ContextInitializer initializer;
 
   RegExpMacroAssemblerIA32 m(RegExpMacroAssemblerIA32::ASCII, 0);
@@ skipping 13 matching lines @@
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   Handle<String> input = Factory::NewStringFromAscii(CStrVector("foofoo"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length();
 
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        NULL,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  NULL,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::FAILURE, result);
 }
 
 
 TEST(MacroAssemblerIA32BackReferenceASCII) {
   v8::V8::Initialize();
   ContextInitializer initializer;
 
   RegExpMacroAssemblerIA32 m(RegExpMacroAssemblerIA32::ASCII, 3);
@@ skipping 18 matching lines @@
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   Handle<String> input = Factory::NewStringFromAscii(CStrVector("fooofo"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length();
 
   int output[3];
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        output,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  output,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, output[0]);
   CHECK_EQ(2, output[1]);
   CHECK_EQ(6, output[2]);
 }
 
 
 TEST(MacroAssemblerIA32BackReferenceUC16) {
   v8::V8::Initialize();
@@ skipping 24 matching lines @@
   Handle<String> input =
       Factory::NewStringFromTwoByte(Vector<const uc16>(input_data, 6));
   Handle<SeqTwoByteString> seq_input = Handle<SeqTwoByteString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
 
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length() * sizeof(input_data[0]);
 
   int output[3];
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        output,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  output,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, output[0]);
   CHECK_EQ(2, output[1]);
   CHECK_EQ(6, output[2]);
 }
 
 
 
 TEST(MacroAssemblerIA32AtStart) {
@@ skipping 27 matching lines @@
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   Handle<String> input = Factory::NewStringFromAscii(CStrVector("foobar"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length();
 
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        NULL,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  NULL,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
 
   start_offset += 3;
-  result = RegExpMacroAssemblerIA32::Execute(*code,
-                                              seq_input.location(),
-                                              start_offset,
-                                              end_offset,
-                                              NULL,
-                                              false);
+  result = ExecuteIA32(*code,
+                       seq_input.location(),
+                       start_offset,
+                       end_offset,
+                       NULL,
+                       false);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
 }
 
 
-
-
 TEST(MacroAssemblerIA32BackRefNoCase) {
   v8::V8::Initialize();
   ContextInitializer initializer;
 
   RegExpMacroAssemblerIA32 m(RegExpMacroAssemblerIA32::ASCII, 4);
 
   Label fail, succ;
 
   m.WriteCurrentPositionToRegister(0, 0);
   m.WriteCurrentPositionToRegister(2, 0);
@@ skipping 22 matching lines @@
 
   Handle<String> input =
       Factory::NewStringFromAscii(CStrVector("aBcAbCABCxYzab"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length();
 
   int output[4];
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        output,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  output,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, output[0]);
   CHECK_EQ(12, output[1]);
   CHECK_EQ(0, output[2]);
   CHECK_EQ(3, output[3]);
 }
 
 
 
 TEST(MacroAssemblerIA32Registers) {
   v8::V8::Initialize();
   ContextInitializer initializer;
 
   RegExpMacroAssemblerIA32 m(RegExpMacroAssemblerIA32::ASCII, 5);
 
   uc16 foo_chars[3] = {'f', 'o', 'o'};
   Vector<const uc16> foo(foo_chars, 3);
 
   enum registers { out1, out2, out3, out4, out5, sp, loop_cnt };
   Label fail;
   Label backtrack;
   m.WriteCurrentPositionToRegister(out1, 0);  // Output: [0]
-  m.PushRegister(out1);
+  m.PushRegister(out1, RegExpMacroAssembler::kNoStackLimitCheck);
   m.PushBacktrack(&backtrack);
   m.WriteStackPointerToRegister(sp);
   // Fill stack and registers
   m.AdvanceCurrentPosition(2);
   m.WriteCurrentPositionToRegister(out1, 0);
-  m.PushRegister(out1);
+  m.PushRegister(out1, RegExpMacroAssembler::kNoStackLimitCheck);
   m.PushBacktrack(&fail);
   // Drop backtrack stack frames.
   m.ReadStackPointerFromRegister(sp);
   // And take the first backtrack (to &backtrack)
   m.Backtrack();
 
   m.PushCurrentPosition();
   m.AdvanceCurrentPosition(2);
   m.PopCurrentPosition();
 
@@ skipping 14 matching lines @@
   Label loop2;
   m.SetRegister(loop_cnt, 2);  // loop counter
   m.Bind(&loop2);
   m.AdvanceRegister(loop_cnt, -1);
   m.AdvanceCurrentPosition(1);
   m.IfRegisterGE(loop_cnt, 0, &loop2);
   m.WriteCurrentPositionToRegister(out4, 0);  // [0,3,6,9]
 
   Label loop3;
   Label exit_loop3;
-  m.PushRegister(out4);
-  m.PushRegister(out4);
+  m.PushRegister(out4, RegExpMacroAssembler::kNoStackLimitCheck);
+  m.PushRegister(out4, RegExpMacroAssembler::kNoStackLimitCheck);
   m.ReadCurrentPositionFromRegister(out3);
   m.Bind(&loop3);
   m.AdvanceCurrentPosition(1);
   m.CheckGreedyLoop(&exit_loop3);
   m.GoTo(&loop3);
   m.Bind(&exit_loop3);
   m.PopCurrentPosition();
   m.WriteCurrentPositionToRegister(out5, 0);  // [0,3,6,9,9]
 
   m.Succeed();
 
   m.Bind(&fail);
   m.Fail();
 
   Handle<String> source =
       Factory::NewStringFromAscii(CStrVector("<loop test>"));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   // String long enough for test (content doesn't matter).
   Handle<String> input =
       Factory::NewStringFromAscii(CStrVector("foofoofoofoofoo"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length();
 
   int output[5];
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        output,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  output,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
   CHECK_EQ(0, output[0]);
   CHECK_EQ(3, output[1]);
   CHECK_EQ(6, output[2]);
   CHECK_EQ(9, output[3]);
   CHECK_EQ(9, output[4]);
 }
 
 
@@ skipping 15 matching lines @@
 
   // String long enough for test (content doesn't matter).
   Handle<String> input =
       Factory::NewStringFromAscii(CStrVector("dummy"));
   Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
   Address start_adr = seq_input->GetCharsAddress();
   int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
   int end_offset = start_offset + seq_input->length();
 
   RegExpMacroAssemblerIA32::Result result =
-      RegExpMacroAssemblerIA32::Execute(*code,
-                                        seq_input.location(),
-                                        start_offset,
-                                        end_offset,
-                                        NULL,
-                                        true);
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  NULL,
+                  true);
 
   CHECK_EQ(RegExpMacroAssemblerIA32::EXCEPTION, result);
   CHECK(Top::has_pending_exception());
   Top::clear_pending_exception();
 }
 
 
+TEST(MacroAssemblerIA32LotsOfRegisters) {
+  v8::V8::Initialize();
+  ContextInitializer initializer;
+
+  RegExpMacroAssemblerIA32 m(RegExpMacroAssemblerIA32::ASCII, 2);
+
+  // At least 2048, to ensure the allocated space for registers
+  // span one full page.
+  const int large_number = 8000;
+  m.WriteCurrentPositionToRegister(large_number, 42);
+  m.WriteCurrentPositionToRegister(0, 0);
+  m.WriteCurrentPositionToRegister(1, 1);
+  Label done;
+  m.CheckNotBackReference(0, &done);  // Performs a system-stack push.
+  m.Bind(&done);
+  m.PushRegister(large_number, RegExpMacroAssembler::kNoStackLimitCheck);
+  m.PopRegister(1);
+  m.Succeed();
+
+  Handle<String> source =
+      Factory::NewStringFromAscii(CStrVector("<huge register space test>"));
+  Handle<Object> code_object = m.GetCode(source);
+  Handle<Code> code = Handle<Code>::cast(code_object);
+
+  // String long enough for test (content doesn't matter).
+  Handle<String> input =
+      Factory::NewStringFromAscii(CStrVector("sample text"));
+  Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input);
+  Address start_adr = seq_input->GetCharsAddress();
+  int start_offset = start_adr - reinterpret_cast<Address>(*seq_input);
+  int end_offset = start_offset + seq_input->length();
+
+  int captures[2];
+  RegExpMacroAssemblerIA32::Result result =
+      ExecuteIA32(*code,
+                  seq_input.location(),
+                  start_offset,
+                  end_offset,
+                  captures,
+                  true);
+
+  CHECK_EQ(RegExpMacroAssemblerIA32::SUCCESS, result);
+  CHECK_EQ(0, captures[0]);
+  CHECK_EQ(42, captures[1]);
+
+  Top::clear_pending_exception();
+}
+
+
+
 #endif  // !defined ARM
 
 TEST(AddInverseToTable) {
   static const int kLimit = 1000;
   static const int kRangeCount = 16;
   for (int t = 0; t < 10; t++) {
     ZoneScope zone_scope(DELETE_ON_EXIT);
     ZoneList<CharacterRange>* ranges =
         new ZoneList<CharacterRange>(kRangeCount);
     for (int i = 0; i < kRangeCount; i++) {
@@ skipping 226 matching lines @@
     } else {
       CHECK(!InClass(i, included));
       CHECK(!InClass(i, excluded));
     }
   }
 }
 
 
 TEST(Graph) {
   V8::Initialize(NULL);
-  Execute("\\b\\w+\\b", false, true, true);
+  Execute("(?:(?:x(.))?\1)+$", false, true, true);
 }