• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2012 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 //     * Redistributions of source code must retain the above copyright
7 //       notice, this list of conditions and the following disclaimer.
8 //     * Redistributions in binary form must reproduce the above
9 //       copyright notice, this list of conditions and the following
10 //       disclaimer in the documentation and/or other materials provided
11 //       with the distribution.
12 //     * Neither the name of Google Inc. nor the names of its
13 //       contributors may be used to endorse or promote products derived
14 //       from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 
28 #ifdef ENABLE_DEBUGGER_SUPPORT
29 
30 #include <stdlib.h>
31 
32 #include "v8.h"
33 
34 #include "api.h"
35 #include "cctest.h"
36 #include "compilation-cache.h"
37 #include "debug.h"
38 #include "deoptimizer.h"
39 #include "platform.h"
40 #include "stub-cache.h"
41 #include "utils.h"
42 
43 
44 using ::v8::internal::EmbeddedVector;
45 using ::v8::internal::Object;
46 using ::v8::internal::OS;
47 using ::v8::internal::Handle;
48 using ::v8::internal::Heap;
49 using ::v8::internal::JSGlobalProxy;
50 using ::v8::internal::Code;
51 using ::v8::internal::Debug;
52 using ::v8::internal::Debugger;
53 using ::v8::internal::CommandMessage;
54 using ::v8::internal::CommandMessageQueue;
55 using ::v8::internal::StepAction;
56 using ::v8::internal::StepIn;  // From StepAction enum
57 using ::v8::internal::StepNext;  // From StepAction enum
58 using ::v8::internal::StepOut;  // From StepAction enum
59 using ::v8::internal::Vector;
60 using ::v8::internal::StrLength;
61 
62 // Size of temp buffer for formatting small strings.
63 #define SMALL_STRING_BUFFER_SIZE 80
64 
65 // --- A d d i t i o n a l   C h e c k   H e l p e r s
66 
67 
68 // Helper function used by the CHECK_EQ function when given Address
69 // arguments.  Should not be called directly.
CheckEqualsHelper(const char * file,int line,const char * expected_source,::v8::internal::Address expected,const char * value_source,::v8::internal::Address value)70 static inline void CheckEqualsHelper(const char* file, int line,
71                                      const char* expected_source,
72                                      ::v8::internal::Address expected,
73                                      const char* value_source,
74                                      ::v8::internal::Address value) {
75   if (expected != value) {
76     V8_Fatal(file, line, "CHECK_EQ(%s, %s) failed\n#   "
77                          "Expected: %i\n#   Found: %i",
78              expected_source, value_source, expected, value);
79   }
80 }
81 
82 
83 // Helper function used by the CHECK_NE function when given Address
84 // arguments.  Should not be called directly.
CheckNonEqualsHelper(const char * file,int line,const char * unexpected_source,::v8::internal::Address unexpected,const char * value_source,::v8::internal::Address value)85 static inline void CheckNonEqualsHelper(const char* file, int line,
86                                         const char* unexpected_source,
87                                         ::v8::internal::Address unexpected,
88                                         const char* value_source,
89                                         ::v8::internal::Address value) {
90   if (unexpected == value) {
91     V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n#   Value: %i",
92              unexpected_source, value_source, value);
93   }
94 }
95 
96 
97 // Helper function used by the CHECK function when given code
98 // arguments.  Should not be called directly.
CheckEqualsHelper(const char * file,int line,const char * expected_source,const Code * expected,const char * value_source,const Code * value)99 static inline void CheckEqualsHelper(const char* file, int line,
100                                      const char* expected_source,
101                                      const Code* expected,
102                                      const char* value_source,
103                                      const Code* value) {
104   if (expected != value) {
105     V8_Fatal(file, line, "CHECK_EQ(%s, %s) failed\n#   "
106                          "Expected: %p\n#   Found: %p",
107              expected_source, value_source, expected, value);
108   }
109 }
110 
111 
CheckNonEqualsHelper(const char * file,int line,const char * expected_source,const Code * expected,const char * value_source,const Code * value)112 static inline void CheckNonEqualsHelper(const char* file, int line,
113                                         const char* expected_source,
114                                         const Code* expected,
115                                         const char* value_source,
116                                         const Code* value) {
117   if (expected == value) {
118     V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n#   Value: %p",
119              expected_source, value_source, value);
120   }
121 }
122 
123 
124 // --- H e l p e r   C l a s s e s
125 
126 
127 // Helper class for creating a V8 enviromnent for running tests
128 class DebugLocalContext {
129  public:
DebugLocalContext(v8::ExtensionConfiguration * extensions=0,v8::Handle<v8::ObjectTemplate> global_template=v8::Handle<v8::ObjectTemplate> (),v8::Handle<v8::Value> global_object=v8::Handle<v8::Value> ())130   inline DebugLocalContext(
131       v8::ExtensionConfiguration* extensions = 0,
132       v8::Handle<v8::ObjectTemplate> global_template =
133           v8::Handle<v8::ObjectTemplate>(),
134       v8::Handle<v8::Value> global_object = v8::Handle<v8::Value>())
135       : context_(v8::Context::New(extensions, global_template, global_object)) {
136     context_->Enter();
137   }
~DebugLocalContext()138   inline ~DebugLocalContext() {
139     context_->Exit();
140     context_.Dispose();
141   }
operator ->()142   inline v8::Context* operator->() { return *context_; }
operator *()143   inline v8::Context* operator*() { return *context_; }
IsReady()144   inline bool IsReady() { return !context_.IsEmpty(); }
ExposeDebug()145   void ExposeDebug() {
146     v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
147     // Expose the debug context global object in the global object for testing.
148     debug->Load();
149     debug->debug_context()->set_security_token(
150         v8::Utils::OpenHandle(*context_)->security_token());
151 
152     Handle<JSGlobalProxy> global(Handle<JSGlobalProxy>::cast(
153         v8::Utils::OpenHandle(*context_->Global())));
154     Handle<v8::internal::String> debug_string =
155         FACTORY->LookupAsciiSymbol("debug");
156     SetProperty(global, debug_string,
157         Handle<Object>(debug->debug_context()->global_proxy()), DONT_ENUM,
158         ::v8::internal::kNonStrictMode);
159   }
160 
161  private:
162   v8::Persistent<v8::Context> context_;
163 };
164 
165 
166 // --- H e l p e r   F u n c t i o n s
167 
168 
169 // Compile and run the supplied source and return the fequested function.
CompileFunction(DebugLocalContext * env,const char * source,const char * function_name)170 static v8::Local<v8::Function> CompileFunction(DebugLocalContext* env,
171                                                const char* source,
172                                                const char* function_name) {
173   v8::Script::Compile(v8::String::New(source))->Run();
174   return v8::Local<v8::Function>::Cast(
175       (*env)->Global()->Get(v8::String::New(function_name)));
176 }
177 
178 
179 // Compile and run the supplied source and return the requested function.
CompileFunction(const char * source,const char * function_name)180 static v8::Local<v8::Function> CompileFunction(const char* source,
181                                                const char* function_name) {
182   v8::Script::Compile(v8::String::New(source))->Run();
183   return v8::Local<v8::Function>::Cast(
184     v8::Context::GetCurrent()->Global()->Get(v8::String::New(function_name)));
185 }
186 
187 
188 // Is there any debug info for the function?
HasDebugInfo(v8::Handle<v8::Function> fun)189 static bool HasDebugInfo(v8::Handle<v8::Function> fun) {
190   Handle<v8::internal::JSFunction> f = v8::Utils::OpenHandle(*fun);
191   Handle<v8::internal::SharedFunctionInfo> shared(f->shared());
192   return Debug::HasDebugInfo(shared);
193 }
194 
195 
196 // Set a break point in a function and return the associated break point
197 // number.
SetBreakPoint(Handle<v8::internal::JSFunction> fun,int position)198 static int SetBreakPoint(Handle<v8::internal::JSFunction> fun, int position) {
199   static int break_point = 0;
200   Handle<v8::internal::SharedFunctionInfo> shared(fun->shared());
201   v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
202   debug->SetBreakPoint(
203       shared,
204       Handle<Object>(v8::internal::Smi::FromInt(++break_point)),
205       &position);
206   return break_point;
207 }
208 
209 
210 // Set a break point in a function and return the associated break point
211 // number.
SetBreakPoint(v8::Handle<v8::Function> fun,int position)212 static int SetBreakPoint(v8::Handle<v8::Function> fun, int position) {
213   return SetBreakPoint(v8::Utils::OpenHandle(*fun), position);
214 }
215 
216 
217 // Set a break point in a function using the Debug object and return the
218 // associated break point number.
SetBreakPointFromJS(const char * function_name,int line,int position)219 static int SetBreakPointFromJS(const char* function_name,
220                                int line, int position) {
221   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
222   OS::SNPrintF(buffer,
223                "debug.Debug.setBreakPoint(%s,%d,%d)",
224                function_name, line, position);
225   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
226   v8::Handle<v8::String> str = v8::String::New(buffer.start());
227   return v8::Script::Compile(str)->Run()->Int32Value();
228 }
229 
230 
231 // Set a break point in a script identified by id using the global Debug object.
SetScriptBreakPointByIdFromJS(int script_id,int line,int column)232 static int SetScriptBreakPointByIdFromJS(int script_id, int line, int column) {
233   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
234   if (column >= 0) {
235     // Column specified set script break point on precise location.
236     OS::SNPrintF(buffer,
237                  "debug.Debug.setScriptBreakPointById(%d,%d,%d)",
238                  script_id, line, column);
239   } else {
240     // Column not specified set script break point on line.
241     OS::SNPrintF(buffer,
242                  "debug.Debug.setScriptBreakPointById(%d,%d)",
243                  script_id, line);
244   }
245   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
246   {
247     v8::TryCatch try_catch;
248     v8::Handle<v8::String> str = v8::String::New(buffer.start());
249     v8::Handle<v8::Value> value = v8::Script::Compile(str)->Run();
250     CHECK(!try_catch.HasCaught());
251     return value->Int32Value();
252   }
253 }
254 
255 
256 // Set a break point in a script identified by name using the global Debug
257 // object.
SetScriptBreakPointByNameFromJS(const char * script_name,int line,int column)258 static int SetScriptBreakPointByNameFromJS(const char* script_name,
259                                            int line, int column) {
260   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
261   if (column >= 0) {
262     // Column specified set script break point on precise location.
263     OS::SNPrintF(buffer,
264                  "debug.Debug.setScriptBreakPointByName(\"%s\",%d,%d)",
265                  script_name, line, column);
266   } else {
267     // Column not specified set script break point on line.
268     OS::SNPrintF(buffer,
269                  "debug.Debug.setScriptBreakPointByName(\"%s\",%d)",
270                  script_name, line);
271   }
272   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
273   {
274     v8::TryCatch try_catch;
275     v8::Handle<v8::String> str = v8::String::New(buffer.start());
276     v8::Handle<v8::Value> value = v8::Script::Compile(str)->Run();
277     CHECK(!try_catch.HasCaught());
278     return value->Int32Value();
279   }
280 }
281 
282 
283 // Clear a break point.
ClearBreakPoint(int break_point)284 static void ClearBreakPoint(int break_point) {
285   v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
286   debug->ClearBreakPoint(
287       Handle<Object>(v8::internal::Smi::FromInt(break_point)));
288 }
289 
290 
291 // Clear a break point using the global Debug object.
ClearBreakPointFromJS(int break_point_number)292 static void ClearBreakPointFromJS(int break_point_number) {
293   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
294   OS::SNPrintF(buffer,
295                "debug.Debug.clearBreakPoint(%d)",
296                break_point_number);
297   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
298   v8::Script::Compile(v8::String::New(buffer.start()))->Run();
299 }
300 
301 
EnableScriptBreakPointFromJS(int break_point_number)302 static void EnableScriptBreakPointFromJS(int break_point_number) {
303   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
304   OS::SNPrintF(buffer,
305                "debug.Debug.enableScriptBreakPoint(%d)",
306                break_point_number);
307   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
308   v8::Script::Compile(v8::String::New(buffer.start()))->Run();
309 }
310 
311 
DisableScriptBreakPointFromJS(int break_point_number)312 static void DisableScriptBreakPointFromJS(int break_point_number) {
313   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
314   OS::SNPrintF(buffer,
315                "debug.Debug.disableScriptBreakPoint(%d)",
316                break_point_number);
317   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
318   v8::Script::Compile(v8::String::New(buffer.start()))->Run();
319 }
320 
321 
ChangeScriptBreakPointConditionFromJS(int break_point_number,const char * condition)322 static void ChangeScriptBreakPointConditionFromJS(int break_point_number,
323                                                   const char* condition) {
324   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
325   OS::SNPrintF(buffer,
326                "debug.Debug.changeScriptBreakPointCondition(%d, \"%s\")",
327                break_point_number, condition);
328   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
329   v8::Script::Compile(v8::String::New(buffer.start()))->Run();
330 }
331 
332 
ChangeScriptBreakPointIgnoreCountFromJS(int break_point_number,int ignoreCount)333 static void ChangeScriptBreakPointIgnoreCountFromJS(int break_point_number,
334                                                     int ignoreCount) {
335   EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
336   OS::SNPrintF(buffer,
337                "debug.Debug.changeScriptBreakPointIgnoreCount(%d, %d)",
338                break_point_number, ignoreCount);
339   buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
340   v8::Script::Compile(v8::String::New(buffer.start()))->Run();
341 }
342 
343 
344 // Change break on exception.
ChangeBreakOnException(bool caught,bool uncaught)345 static void ChangeBreakOnException(bool caught, bool uncaught) {
346   v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
347   debug->ChangeBreakOnException(v8::internal::BreakException, caught);
348   debug->ChangeBreakOnException(v8::internal::BreakUncaughtException, uncaught);
349 }
350 
351 
352 // Change break on exception using the global Debug object.
ChangeBreakOnExceptionFromJS(bool caught,bool uncaught)353 static void ChangeBreakOnExceptionFromJS(bool caught, bool uncaught) {
354   if (caught) {
355     v8::Script::Compile(
356         v8::String::New("debug.Debug.setBreakOnException()"))->Run();
357   } else {
358     v8::Script::Compile(
359         v8::String::New("debug.Debug.clearBreakOnException()"))->Run();
360   }
361   if (uncaught) {
362     v8::Script::Compile(
363         v8::String::New("debug.Debug.setBreakOnUncaughtException()"))->Run();
364   } else {
365     v8::Script::Compile(
366         v8::String::New("debug.Debug.clearBreakOnUncaughtException()"))->Run();
367   }
368 }
369 
370 
371 // Prepare to step to next break location.
PrepareStep(StepAction step_action)372 static void PrepareStep(StepAction step_action) {
373   v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
374   debug->PrepareStep(step_action, 1);
375 }
376 
377 
378 // This function is in namespace v8::internal to be friend with class
379 // v8::internal::Debug.
380 namespace v8 {
381 namespace internal {
382 
383 // Collect the currently debugged functions.
GetDebuggedFunctions()384 Handle<FixedArray> GetDebuggedFunctions() {
385   Debug* debug = Isolate::Current()->debug();
386 
387   v8::internal::DebugInfoListNode* node = debug->debug_info_list_;
388 
389   // Find the number of debugged functions.
390   int count = 0;
391   while (node) {
392     count++;
393     node = node->next();
394   }
395 
396   // Allocate array for the debugged functions
397   Handle<FixedArray> debugged_functions =
398       FACTORY->NewFixedArray(count);
399 
400   // Run through the debug info objects and collect all functions.
401   count = 0;
402   while (node) {
403     debugged_functions->set(count++, *node->debug_info());
404     node = node->next();
405   }
406 
407   return debugged_functions;
408 }
409 
410 
ComputeCallDebugBreak(int argc)411 static Handle<Code> ComputeCallDebugBreak(int argc) {
412   return Isolate::Current()->stub_cache()->ComputeCallDebugBreak(argc,
413                                                                  Code::CALL_IC);
414 }
415 
416 
417 // Check that the debugger has been fully unloaded.
CheckDebuggerUnloaded(bool check_functions)418 void CheckDebuggerUnloaded(bool check_functions) {
419   // Check that the debugger context is cleared and that there is no debug
420   // information stored for the debugger.
421   CHECK(Isolate::Current()->debug()->debug_context().is_null());
422   CHECK_EQ(NULL, Isolate::Current()->debug()->debug_info_list_);
423 
424   // Collect garbage to ensure weak handles are cleared.
425   HEAP->CollectAllGarbage(Heap::kNoGCFlags);
426   HEAP->CollectAllGarbage(Heap::kMakeHeapIterableMask);
427 
428   // Iterate the head and check that there are no debugger related objects left.
429   HeapIterator iterator;
430   for (HeapObject* obj = iterator.next(); obj != NULL; obj = iterator.next()) {
431     CHECK(!obj->IsDebugInfo());
432     CHECK(!obj->IsBreakPointInfo());
433 
434     // If deep check of functions is requested check that no debug break code
435     // is left in all functions.
436     if (check_functions) {
437       if (obj->IsJSFunction()) {
438         JSFunction* fun = JSFunction::cast(obj);
439         for (RelocIterator it(fun->shared()->code()); !it.done(); it.next()) {
440           RelocInfo::Mode rmode = it.rinfo()->rmode();
441           if (RelocInfo::IsCodeTarget(rmode)) {
442             CHECK(!Debug::IsDebugBreak(it.rinfo()->target_address()));
443           } else if (RelocInfo::IsJSReturn(rmode)) {
444             CHECK(!Debug::IsDebugBreakAtReturn(it.rinfo()));
445           }
446         }
447       }
448     }
449   }
450 }
451 
452 
ForceUnloadDebugger()453 void ForceUnloadDebugger() {
454   Isolate::Current()->debugger()->never_unload_debugger_ = false;
455   Isolate::Current()->debugger()->UnloadDebugger();
456 }
457 
458 
459 } }  // namespace v8::internal
460 
461 
462 // Check that the debugger has been fully unloaded.
CheckDebuggerUnloaded(bool check_functions=false)463 static void CheckDebuggerUnloaded(bool check_functions = false) {
464   // Let debugger to unload itself synchronously
465   v8::Debug::ProcessDebugMessages();
466 
467   v8::internal::CheckDebuggerUnloaded(check_functions);
468 }
469 
470 
471 // Inherit from BreakLocationIterator to get access to protected parts for
472 // testing.
473 class TestBreakLocationIterator: public v8::internal::BreakLocationIterator {
474  public:
TestBreakLocationIterator(Handle<v8::internal::DebugInfo> debug_info)475   explicit TestBreakLocationIterator(Handle<v8::internal::DebugInfo> debug_info)
476     : BreakLocationIterator(debug_info, v8::internal::SOURCE_BREAK_LOCATIONS) {}
it()477   v8::internal::RelocIterator* it() { return reloc_iterator_; }
it_original()478   v8::internal::RelocIterator* it_original() {
479     return reloc_iterator_original_;
480   }
481 };
482 
483 
484 // Compile a function, set a break point and check that the call at the break
485 // location in the code is the expected debug_break function.
CheckDebugBreakFunction(DebugLocalContext * env,const char * source,const char * name,int position,v8::internal::RelocInfo::Mode mode,Code * debug_break)486 void CheckDebugBreakFunction(DebugLocalContext* env,
487                              const char* source, const char* name,
488                              int position, v8::internal::RelocInfo::Mode mode,
489                              Code* debug_break) {
490   v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
491 
492   // Create function and set the break point.
493   Handle<v8::internal::JSFunction> fun = v8::Utils::OpenHandle(
494       *CompileFunction(env, source, name));
495   int bp = SetBreakPoint(fun, position);
496 
497   // Check that the debug break function is as expected.
498   Handle<v8::internal::SharedFunctionInfo> shared(fun->shared());
499   CHECK(Debug::HasDebugInfo(shared));
500   TestBreakLocationIterator it1(Debug::GetDebugInfo(shared));
501   it1.FindBreakLocationFromPosition(position);
502   v8::internal::RelocInfo::Mode actual_mode = it1.it()->rinfo()->rmode();
503   if (actual_mode == v8::internal::RelocInfo::CODE_TARGET_WITH_ID) {
504     actual_mode = v8::internal::RelocInfo::CODE_TARGET;
505   }
506   CHECK_EQ(mode, actual_mode);
507   if (mode != v8::internal::RelocInfo::JS_RETURN) {
508     CHECK_EQ(debug_break,
509         Code::GetCodeFromTargetAddress(it1.it()->rinfo()->target_address()));
510   } else {
511     CHECK(Debug::IsDebugBreakAtReturn(it1.it()->rinfo()));
512   }
513 
514   // Clear the break point and check that the debug break function is no longer
515   // there
516   ClearBreakPoint(bp);
517   CHECK(!debug->HasDebugInfo(shared));
518   CHECK(debug->EnsureDebugInfo(shared));
519   TestBreakLocationIterator it2(Debug::GetDebugInfo(shared));
520   it2.FindBreakLocationFromPosition(position);
521   actual_mode = it2.it()->rinfo()->rmode();
522   if (actual_mode == v8::internal::RelocInfo::CODE_TARGET_WITH_ID) {
523     actual_mode = v8::internal::RelocInfo::CODE_TARGET;
524   }
525   CHECK_EQ(mode, actual_mode);
526   if (mode == v8::internal::RelocInfo::JS_RETURN) {
527     CHECK(!Debug::IsDebugBreakAtReturn(it2.it()->rinfo()));
528   }
529 }
530 
531 
532 // --- D e b u g   E v e n t   H a n d l e r s
533 // ---
534 // --- The different tests uses a number of debug event handlers.
535 // ---
536 
537 
538 // Source for the JavaScript function which picks out the function
539 // name of a frame.
540 const char* frame_function_name_source =
541     "function frame_function_name(exec_state, frame_number) {"
542     "  return exec_state.frame(frame_number).func().name();"
543     "}";
544 v8::Local<v8::Function> frame_function_name;
545 
546 
547 // Source for the JavaScript function which pick out the name of the
548 // first argument of a frame.
549 const char* frame_argument_name_source =
550     "function frame_argument_name(exec_state, frame_number) {"
551     "  return exec_state.frame(frame_number).argumentName(0);"
552     "}";
553 v8::Local<v8::Function> frame_argument_name;
554 
555 
556 // Source for the JavaScript function which pick out the value of the
557 // first argument of a frame.
558 const char* frame_argument_value_source =
559     "function frame_argument_value(exec_state, frame_number) {"
560     "  return exec_state.frame(frame_number).argumentValue(0).value_;"
561     "}";
562 v8::Local<v8::Function> frame_argument_value;
563 
564 
565 // Source for the JavaScript function which pick out the name of the
566 // first argument of a frame.
567 const char* frame_local_name_source =
568     "function frame_local_name(exec_state, frame_number) {"
569     "  return exec_state.frame(frame_number).localName(0);"
570     "}";
571 v8::Local<v8::Function> frame_local_name;
572 
573 
574 // Source for the JavaScript function which pick out the value of the
575 // first argument of a frame.
576 const char* frame_local_value_source =
577     "function frame_local_value(exec_state, frame_number) {"
578     "  return exec_state.frame(frame_number).localValue(0).value_;"
579     "}";
580 v8::Local<v8::Function> frame_local_value;
581 
582 
583 // Source for the JavaScript function which picks out the source line for the
584 // top frame.
585 const char* frame_source_line_source =
586     "function frame_source_line(exec_state) {"
587     "  return exec_state.frame(0).sourceLine();"
588     "}";
589 v8::Local<v8::Function> frame_source_line;
590 
591 
592 // Source for the JavaScript function which picks out the source column for the
593 // top frame.
594 const char* frame_source_column_source =
595     "function frame_source_column(exec_state) {"
596     "  return exec_state.frame(0).sourceColumn();"
597     "}";
598 v8::Local<v8::Function> frame_source_column;
599 
600 
601 // Source for the JavaScript function which picks out the script name for the
602 // top frame.
603 const char* frame_script_name_source =
604     "function frame_script_name(exec_state) {"
605     "  return exec_state.frame(0).func().script().name();"
606     "}";
607 v8::Local<v8::Function> frame_script_name;
608 
609 
610 // Source for the JavaScript function which picks out the script data for the
611 // top frame.
612 const char* frame_script_data_source =
613     "function frame_script_data(exec_state) {"
614     "  return exec_state.frame(0).func().script().data();"
615     "}";
616 v8::Local<v8::Function> frame_script_data;
617 
618 
619 // Source for the JavaScript function which picks out the script data from
620 // AfterCompile event
621 const char* compiled_script_data_source =
622     "function compiled_script_data(event_data) {"
623     "  return event_data.script().data();"
624     "}";
625 v8::Local<v8::Function> compiled_script_data;
626 
627 
628 // Source for the JavaScript function which returns the number of frames.
629 static const char* frame_count_source =
630     "function frame_count(exec_state) {"
631     "  return exec_state.frameCount();"
632     "}";
633 v8::Handle<v8::Function> frame_count;
634 
635 
636 // Global variable to store the last function hit - used by some tests.
637 char last_function_hit[80];
638 
639 // Global variable to store the name and data for last script hit - used by some
640 // tests.
641 char last_script_name_hit[80];
642 char last_script_data_hit[80];
643 
644 // Global variables to store the last source position - used by some tests.
645 int last_source_line = -1;
646 int last_source_column = -1;
647 
648 // Debug event handler which counts the break points which have been hit.
649 int break_point_hit_count = 0;
650 int break_point_hit_count_deoptimize = 0;
DebugEventBreakPointHitCount(v8::DebugEvent event,v8::Handle<v8::Object> exec_state,v8::Handle<v8::Object> event_data,v8::Handle<v8::Value> data)651 static void DebugEventBreakPointHitCount(v8::DebugEvent event,
652                                          v8::Handle<v8::Object> exec_state,
653                                          v8::Handle<v8::Object> event_data,
654                                          v8::Handle<v8::Value> data) {
655   Debug* debug = v8::internal::Isolate::Current()->debug();
656   // When hitting a debug event listener there must be a break set.
657   CHECK_NE(debug->break_id(), 0);
658 
659   // Count the number of breaks.
660   if (event == v8::Break) {
661     break_point_hit_count++;
662     if (!frame_function_name.IsEmpty()) {
663       // Get the name of the function.
664       const int argc = 2;
665       v8::Handle<v8::Value> argv[argc] = { exec_state, v8::Integer::New(0) };
666       v8::Handle<v8::Value> result = frame_function_name->Call(exec_state,
667                                                                argc, argv);
668       if (result->IsUndefined()) {
669         last_function_hit[0] = '\0';
670       } else {
671         CHECK(result->IsString());
672         v8::Handle<v8::String> function_name(result->ToString());
673         function_name->WriteAscii(last_function_hit);
674       }
675     }
676 
677     if (!frame_source_line.IsEmpty()) {
678       // Get the source line.
679       const int argc = 1;
680       v8::Handle<v8::Value> argv[argc] = { exec_state };
681       v8::Handle<v8::Value> result = frame_source_line->Call(exec_state,
682                                                              argc, argv);
683       CHECK(result->IsNumber());
684       last_source_line = result->Int32Value();
685     }
686 
687     if (!frame_source_column.IsEmpty()) {
688       // Get the source column.
689       const int argc = 1;
690       v8::Handle<v8::Value> argv[argc] = { exec_state };
691       v8::Handle<v8::Value> result = frame_source_column->Call(exec_state,
692                                                                argc, argv);
693       CHECK(result->IsNumber());
694       last_source_column = result->Int32Value();
695     }
696 
697     if (!frame_script_name.IsEmpty()) {
698       // Get the script name of the function script.
699       const int argc = 1;
700       v8::Handle<v8::Value> argv[argc] = { exec_state };
701       v8::Handle<v8::Value> result = frame_script_name->Call(exec_state,
702                                                              argc, argv);
703       if (result->IsUndefined()) {
704         last_script_name_hit[0] = '\0';
705       } else {
706         CHECK(result->IsString());
707         v8::Handle<v8::String> script_name(result->ToString());
708         script_name->WriteAscii(last_script_name_hit);
709       }
710     }
711 
712     if (!frame_script_data.IsEmpty()) {
713       // Get the script data of the function script.
714       const int argc = 1;
715       v8::Handle<v8::Value> argv[argc] = { exec_state };
716       v8::Handle<v8::Value> result = frame_script_data->Call(exec_state,
717                                                              argc, argv);
718       if (result->IsUndefined()) {
719         last_script_data_hit[0] = '\0';
720       } else {
721         result = result->ToString();
722         CHECK(result->IsString());
723         v8::Handle<v8::String> script_data(result->ToString());
724         script_data->WriteAscii(last_script_data_hit);
725       }
726     }
727 
728     // Perform a full deoptimization when the specified number of
729     // breaks have been hit.
730     if (break_point_hit_count == break_point_hit_count_deoptimize) {
731       i::Deoptimizer::DeoptimizeAll();
732     }
733   } else if (event == v8::AfterCompile && !compiled_script_data.IsEmpty()) {
734     const int argc = 1;
735     v8::Handle<v8::Value> argv[argc] = { event_data };
736     v8::Handle<v8::Value> result = compiled_script_data->Call(exec_state,
737                                                               argc, argv);
738     if (result->IsUndefined()) {
739       last_script_data_hit[0] = '\0';
740     } else {
741       result = result->ToString();
742       CHECK(result->IsString());
743       v8::Handle<v8::String> script_data(result->ToString());
744       script_data->WriteAscii(last_script_data_hit);
745     }
746   }
747 }
748 
749 
750 // Debug event handler which counts a number of events and collects the stack
751 // height if there is a function compiled for that.
752 int exception_hit_count = 0;
753 int uncaught_exception_hit_count = 0;
754 int last_js_stack_height = -1;
755 
DebugEventCounterClear()756 static void DebugEventCounterClear() {
757   break_point_hit_count = 0;
758   exception_hit_count = 0;
759   uncaught_exception_hit_count = 0;
760 }
761 
DebugEventCounter(v8::DebugEvent event,v8::Handle<v8::Object> exec_state,v8::Handle<v8::Object> event_data,v8::Handle<v8::Value> data)762 static void DebugEventCounter(v8::DebugEvent event,
763                               v8::Handle<v8::Object> exec_state,
764                               v8::Handle<v8::Object> event_data,
765                               v8::Handle<v8::Value> data) {
766   v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
767 
768   // When hitting a debug event listener there must be a break set.
769   CHECK_NE(debug->break_id(), 0);
770 
771   // Count the number of breaks.
772   if (event == v8::Break) {
773     break_point_hit_count++;
774   } else if (event == v8::Exception) {
775     exception_hit_count++;
776 
777     // Check whether the exception was uncaught.
778     v8::Local<v8::String> fun_name = v8::String::New("uncaught");
779     v8::Local<v8::Function> fun =
780         v8::Function::Cast(*event_data->Get(fun_name));
781     v8::Local<v8::Value> result = *fun->Call(event_data, 0, NULL);
782     if (result->IsTrue()) {
783       uncaught_exception_hit_count++;
784     }
785   }
786 
787   // Collect the JavsScript stack height if the function frame_count is
788   // compiled.
789   if (!frame_count.IsEmpty()) {
790     static const int kArgc = 1;
791     v8::Handle<v8::Value> argv[kArgc] = { exec_state };
792     // Using exec_state as receiver is just to have a receiver.
793     v8::Handle<v8::Value> result =  frame_count->Call(exec_state, kArgc, argv);
794     last_js_stack_height = result->Int32Value();
795   }
796 }
797 
798 
799 // Debug event handler which evaluates a number of expressions when a break
800 // point is hit. Each evaluated expression is compared with an expected value.
801 // For this debug event handler to work the following two global varaibles
802 // must be initialized.
803 //   checks: An array of expressions and expected results
804 //   evaluate_check_function: A JavaScript function (see below)
805 
806 // Structure for holding checks to do.
807 struct EvaluateCheck {
808   const char* expr;  // An expression to evaluate when a break point is hit.
809   v8::Handle<v8::Value> expected;  // The expected result.
810 };
811 // Array of checks to do.
812 struct EvaluateCheck* checks = NULL;
813 // Source for The JavaScript function which can do the evaluation when a break
814 // point is hit.
815 const char* evaluate_check_source =
816     "function evaluate_check(exec_state, expr, expected) {"
817     "  return exec_state.frame(0).evaluate(expr).value() === expected;"
818     "}";
819 v8::Local<v8::Function> evaluate_check_function;
820 
821 // The actual debug event described by the longer comment above.
DebugEventEvaluate(v8::DebugEvent event,v8::Handle<v8::Object> exec_state,v8::Handle<v8::Object> event_data,v8::Handle<v8::Value> data)822 static void DebugEventEvaluate(v8::DebugEvent event,
823                                v8::Handle<v8::Object> exec_state,
824                                v8::Handle<v8::Object> event_data,
825                                v8::Handle<v8::Value> data) {
826   v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
827   // When hitting a debug event listener there must be a break set.
828   CHECK_NE(debug->break_id(), 0);
829 
830   if (event == v8::Break) {
831     for (int i = 0; checks[i].expr != NULL; i++) {
832       const int argc = 3;
833       v8::Handle<v8::Value> argv[argc] = { exec_state,
834                                            v8::String::New(checks[i].expr),
835                                            checks[i].expected };
836       v8::Handle<v8::Value> result =
837           evaluate_check_function->Call(exec_state, argc, argv);
838       if (!result->IsTrue()) {
839         v8::String::AsciiValue ascii(checks[i].expected->ToString());
840         V8_Fatal(__FILE__, __LINE__, "%s != %s", checks[i].expr, *ascii);
841       }
842     }
843   }
844 }
845 
846 
847 // This debug event listener removes a breakpoint in a function
848 int debug_event_remove_break_point = 0;
DebugEventRemoveBreakPoint(v8::DebugEvent event,v8::Handle<v8::Object> exec_state,v8::Handle<v8::Object> event_data,v8::Handle<v8::Value> data)849 static void DebugEventRemoveBreakPoint(v8::DebugEvent event,
850                                        v8::Handle<v8::Object> exec_state,
851                                        v8::Handle<v8::Object> event_data,
852                                        v8::Handle<v8::Value> data) {
853   v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
854   // When hitting a debug event listener there must be a break set.
855   CHECK_NE(debug->break_id(), 0);
856 
857   if (event == v8::Break) {
858     break_point_hit_count++;
859     CHECK(data->IsFunction());
860     ClearBreakPoint(debug_event_remove_break_point);
861   }
862 }
863 
864 
865 // Debug event handler which counts break points hit and performs a step
866 // afterwards.
867 StepAction step_action = StepIn;  // Step action to perform when stepping.
DebugEventStep(v8::DebugEvent event,v8::Handle<v8::Object> exec_state,v8::Handle<v8::Object> event_data,v8::Handle<v8::Value> data)868 static void DebugEventStep(v8::DebugEvent event,
869                            v8::Handle<v8::Object> exec_state,
870                            v8::Handle<v8::Object> event_data,
871                            v8::Handle<v8::Value> data) {
872   v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
873   // When hitting a debug event listener there must be a break set.
874   CHECK_NE(debug->break_id(), 0);
875 
876   if (event == v8::Break) {
877     break_point_hit_count++;
878     PrepareStep(step_action);
879   }
880 }
881 
882 
883 // Debug event handler which counts break points hit and performs a step
884 // afterwards. For each call the expected function is checked.
885 // For this debug event handler to work the following two global varaibles
886 // must be initialized.
887 //   expected_step_sequence: An array of the expected function call sequence.
888 //   frame_function_name: A JavaScript function (see below).
889 
890 // String containing the expected function call sequence. Note: this only works
891 // if functions have name length of one.
892 const char* expected_step_sequence = NULL;
893 
894 // The actual debug event described by the longer comment above.
DebugEventStepSequence(v8::DebugEvent event,v8::Handle<v8::Object> exec_state,v8::Handle<v8::Object> event_data,v8::Handle<v8::Value> data)895 static void DebugEventStepSequence(v8::DebugEvent event,
896                                    v8::Handle<v8::Object> exec_state,
897                                    v8::Handle<v8::Object> event_data,
898                                    v8::Handle<v8::Value> data) {
899   v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
900   // When hitting a debug event listener there must be a break set.
901   CHECK_NE(debug->break_id(), 0);
902 
903   if (event == v8::Break || event == v8::Exception) {
904     // Check that the current function is the expected.
905     CHECK(break_point_hit_count <
906           StrLength(expected_step_sequence));
907     const int argc = 2;
908     v8::Handle<v8::Value> argv[argc] = { exec_state, v8::Integer::New(0) };
909     v8::Handle<v8::Value> result = frame_function_name->Call(exec_state,
910                                                              argc, argv);
911     CHECK(result->IsString());
912     v8::String::AsciiValue function_name(result->ToString());
913     CHECK_EQ(1, StrLength(*function_name));
914     CHECK_EQ((*function_name)[0],
915               expected_step_sequence[break_point_hit_count]);
916 
917     // Perform step.
918     break_point_hit_count++;
919     PrepareStep(step_action);
920   }
921 }
922 
923 
924 // Debug event handler which performs a garbage collection.
DebugEventBreakPointCollectGarbage(v8::DebugEvent event,v8::Handle<v8::Object> exec_state,v8::Handle<v8::Object> event_data,v8::Handle<v8::Value> data)925 static void DebugEventBreakPointCollectGarbage(
926     v8::DebugEvent event,
927     v8::Handle<v8::Object> exec_state,
928     v8::Handle<v8::Object> event_data,
929     v8::Handle<v8::Value> data) {
930   v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
931   // When hitting a debug event listener there must be a break set.
932   CHECK_NE(debug->break_id(), 0);
933 
934   // Perform a garbage collection when break point is hit and continue. Based
935   // on the number of break points hit either scavenge or mark compact
936   // collector is used.
937   if (event == v8::Break) {
938     break_point_hit_count++;
939     if (break_point_hit_count % 2 == 0) {
940       // Scavenge.
941       HEAP->CollectGarbage(v8::internal::NEW_SPACE);
942     } else {
943       // Mark sweep compact.
944       HEAP->CollectAllGarbage(Heap::kNoGCFlags);
945     }
946   }
947 }
948 
949 
950 // Debug event handler which re-issues a debug break and calls the garbage
951 // collector to have the heap verified.
DebugEventBreak(v8::DebugEvent event,v8::Handle<v8::Object> exec_state,v8::Handle<v8::Object> event_data,v8::Handle<v8::Value> data)952 static void DebugEventBreak(v8::DebugEvent event,
953                             v8::Handle<v8::Object> exec_state,
954                             v8::Handle<v8::Object> event_data,
955                             v8::Handle<v8::Value> data) {
956   v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
957   // When hitting a debug event listener there must be a break set.
958   CHECK_NE(debug->break_id(), 0);
959 
960   if (event == v8::Break) {
961     // Count the number of breaks.
962     break_point_hit_count++;
963 
964     // Run the garbage collector to enforce heap verification if option
965     // --verify-heap is set.
966     HEAP->CollectGarbage(v8::internal::NEW_SPACE);
967 
968     // Set the break flag again to come back here as soon as possible.
969     v8::Debug::DebugBreak();
970   }
971 }
972 
973 
974 // Debug event handler which re-issues a debug break until a limit has been
975 // reached.
976 int max_break_point_hit_count = 0;
977 bool terminate_after_max_break_point_hit = false;
DebugEventBreakMax(v8::DebugEvent event,v8::Handle<v8::Object> exec_state,v8::Handle<v8::Object> event_data,v8::Handle<v8::Value> data)978 static void DebugEventBreakMax(v8::DebugEvent event,
979                                v8::Handle<v8::Object> exec_state,
980                                v8::Handle<v8::Object> event_data,
981                                v8::Handle<v8::Value> data) {
982   v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
983   // When hitting a debug event listener there must be a break set.
984   CHECK_NE(debug->break_id(), 0);
985 
986   if (event == v8::Break) {
987     if (break_point_hit_count < max_break_point_hit_count) {
988       // Count the number of breaks.
989       break_point_hit_count++;
990 
991       // Collect the JavsScript stack height if the function frame_count is
992       // compiled.
993       if (!frame_count.IsEmpty()) {
994         static const int kArgc = 1;
995         v8::Handle<v8::Value> argv[kArgc] = { exec_state };
996         // Using exec_state as receiver is just to have a receiver.
997         v8::Handle<v8::Value> result =
998             frame_count->Call(exec_state, kArgc, argv);
999         last_js_stack_height = result->Int32Value();
1000       }
1001 
1002       // Set the break flag again to come back here as soon as possible.
1003       v8::Debug::DebugBreak();
1004 
1005     } else if (terminate_after_max_break_point_hit) {
1006       // Terminate execution after the last break if requested.
1007       v8::V8::TerminateExecution();
1008     }
1009 
1010     // Perform a full deoptimization when the specified number of
1011     // breaks have been hit.
1012     if (break_point_hit_count == break_point_hit_count_deoptimize) {
1013       i::Deoptimizer::DeoptimizeAll();
1014     }
1015   }
1016 }
1017 
1018 
1019 // --- M e s s a g e   C a l l b a c k
1020 
1021 
1022 // Message callback which counts the number of messages.
1023 int message_callback_count = 0;
1024 
MessageCallbackCountClear()1025 static void MessageCallbackCountClear() {
1026   message_callback_count = 0;
1027 }
1028 
MessageCallbackCount(v8::Handle<v8::Message> message,v8::Handle<v8::Value> data)1029 static void MessageCallbackCount(v8::Handle<v8::Message> message,
1030                                  v8::Handle<v8::Value> data) {
1031   message_callback_count++;
1032 }
1033 
1034 
1035 // --- T h e   A c t u a l   T e s t s
1036 
1037 
1038 // Test that the debug break function is the expected one for different kinds
1039 // of break locations.
TEST(DebugStub)1040 TEST(DebugStub) {
1041   using ::v8::internal::Builtins;
1042   using ::v8::internal::Isolate;
1043   v8::HandleScope scope;
1044   DebugLocalContext env;
1045 
1046   CheckDebugBreakFunction(&env,
1047                           "function f1(){}", "f1",
1048                           0,
1049                           v8::internal::RelocInfo::JS_RETURN,
1050                           NULL);
1051   CheckDebugBreakFunction(&env,
1052                           "function f2(){x=1;}", "f2",
1053                           0,
1054                           v8::internal::RelocInfo::CODE_TARGET_CONTEXT,
1055                           Isolate::Current()->builtins()->builtin(
1056                               Builtins::kStoreIC_DebugBreak));
1057   CheckDebugBreakFunction(&env,
1058                           "function f3(){var a=x;}", "f3",
1059                           0,
1060                           v8::internal::RelocInfo::CODE_TARGET_CONTEXT,
1061                           Isolate::Current()->builtins()->builtin(
1062                               Builtins::kLoadIC_DebugBreak));
1063 
1064 // TODO(1240753): Make the test architecture independent or split
1065 // parts of the debugger into architecture dependent files. This
1066 // part currently disabled as it is not portable between IA32/ARM.
1067 // Currently on ICs for keyed store/load on ARM.
1068 #if !defined (__arm__) && !defined(__thumb__)
1069   CheckDebugBreakFunction(
1070       &env,
1071       "function f4(){var index='propertyName'; var a={}; a[index] = 'x';}",
1072       "f4",
1073       0,
1074       v8::internal::RelocInfo::CODE_TARGET,
1075       Isolate::Current()->builtins()->builtin(
1076           Builtins::kKeyedStoreIC_DebugBreak));
1077   CheckDebugBreakFunction(
1078       &env,
1079       "function f5(){var index='propertyName'; var a={}; return a[index];}",
1080       "f5",
1081       0,
1082       v8::internal::RelocInfo::CODE_TARGET,
1083       Isolate::Current()->builtins()->builtin(
1084           Builtins::kKeyedLoadIC_DebugBreak));
1085 #endif
1086 
1087   // Check the debug break code stubs for call ICs with different number of
1088   // parameters.
1089   Handle<Code> debug_break_0 = v8::internal::ComputeCallDebugBreak(0);
1090   Handle<Code> debug_break_1 = v8::internal::ComputeCallDebugBreak(1);
1091   Handle<Code> debug_break_4 = v8::internal::ComputeCallDebugBreak(4);
1092 
1093   CheckDebugBreakFunction(&env,
1094                           "function f4_0(){x();}", "f4_0",
1095                           0,
1096                           v8::internal::RelocInfo::CODE_TARGET_CONTEXT,
1097                           *debug_break_0);
1098 
1099   CheckDebugBreakFunction(&env,
1100                           "function f4_1(){x(1);}", "f4_1",
1101                           0,
1102                           v8::internal::RelocInfo::CODE_TARGET_CONTEXT,
1103                           *debug_break_1);
1104 
1105   CheckDebugBreakFunction(&env,
1106                           "function f4_4(){x(1,2,3,4);}", "f4_4",
1107                           0,
1108                           v8::internal::RelocInfo::CODE_TARGET_CONTEXT,
1109                           *debug_break_4);
1110 }
1111 
1112 
1113 // Test that the debug info in the VM is in sync with the functions being
1114 // debugged.
TEST(DebugInfo)1115 TEST(DebugInfo) {
1116   v8::HandleScope scope;
1117   DebugLocalContext env;
1118   // Create a couple of functions for the test.
1119   v8::Local<v8::Function> foo =
1120       CompileFunction(&env, "function foo(){}", "foo");
1121   v8::Local<v8::Function> bar =
1122       CompileFunction(&env, "function bar(){}", "bar");
1123   // Initially no functions are debugged.
1124   CHECK_EQ(0, v8::internal::GetDebuggedFunctions()->length());
1125   CHECK(!HasDebugInfo(foo));
1126   CHECK(!HasDebugInfo(bar));
1127   // One function (foo) is debugged.
1128   int bp1 = SetBreakPoint(foo, 0);
1129   CHECK_EQ(1, v8::internal::GetDebuggedFunctions()->length());
1130   CHECK(HasDebugInfo(foo));
1131   CHECK(!HasDebugInfo(bar));
1132   // Two functions are debugged.
1133   int bp2 = SetBreakPoint(bar, 0);
1134   CHECK_EQ(2, v8::internal::GetDebuggedFunctions()->length());
1135   CHECK(HasDebugInfo(foo));
1136   CHECK(HasDebugInfo(bar));
1137   // One function (bar) is debugged.
1138   ClearBreakPoint(bp1);
1139   CHECK_EQ(1, v8::internal::GetDebuggedFunctions()->length());
1140   CHECK(!HasDebugInfo(foo));
1141   CHECK(HasDebugInfo(bar));
1142   // No functions are debugged.
1143   ClearBreakPoint(bp2);
1144   CHECK_EQ(0, v8::internal::GetDebuggedFunctions()->length());
1145   CHECK(!HasDebugInfo(foo));
1146   CHECK(!HasDebugInfo(bar));
1147 }
1148 
1149 
1150 // Test that a break point can be set at an IC store location.
TEST(BreakPointICStore)1151 TEST(BreakPointICStore) {
1152   break_point_hit_count = 0;
1153   v8::HandleScope scope;
1154   DebugLocalContext env;
1155 
1156   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
1157                                    v8::Undefined());
1158   v8::Script::Compile(v8::String::New("function foo(){bar=0;}"))->Run();
1159   v8::Local<v8::Function> foo =
1160       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
1161 
1162   // Run without breakpoints.
1163   foo->Call(env->Global(), 0, NULL);
1164   CHECK_EQ(0, break_point_hit_count);
1165 
1166   // Run with breakpoint
1167   int bp = SetBreakPoint(foo, 0);
1168   foo->Call(env->Global(), 0, NULL);
1169   CHECK_EQ(1, break_point_hit_count);
1170   foo->Call(env->Global(), 0, NULL);
1171   CHECK_EQ(2, break_point_hit_count);
1172 
1173   // Run without breakpoints.
1174   ClearBreakPoint(bp);
1175   foo->Call(env->Global(), 0, NULL);
1176   CHECK_EQ(2, break_point_hit_count);
1177 
1178   v8::Debug::SetDebugEventListener(NULL);
1179   CheckDebuggerUnloaded();
1180 }
1181 
1182 
1183 // Test that a break point can be set at an IC load location.
TEST(BreakPointICLoad)1184 TEST(BreakPointICLoad) {
1185   break_point_hit_count = 0;
1186   v8::HandleScope scope;
1187   DebugLocalContext env;
1188   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
1189                                    v8::Undefined());
1190   v8::Script::Compile(v8::String::New("bar=1"))->Run();
1191   v8::Script::Compile(v8::String::New("function foo(){var x=bar;}"))->Run();
1192   v8::Local<v8::Function> foo =
1193       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
1194 
1195   // Run without breakpoints.
1196   foo->Call(env->Global(), 0, NULL);
1197   CHECK_EQ(0, break_point_hit_count);
1198 
1199   // Run with breakpoint.
1200   int bp = SetBreakPoint(foo, 0);
1201   foo->Call(env->Global(), 0, NULL);
1202   CHECK_EQ(1, break_point_hit_count);
1203   foo->Call(env->Global(), 0, NULL);
1204   CHECK_EQ(2, break_point_hit_count);
1205 
1206   // Run without breakpoints.
1207   ClearBreakPoint(bp);
1208   foo->Call(env->Global(), 0, NULL);
1209   CHECK_EQ(2, break_point_hit_count);
1210 
1211   v8::Debug::SetDebugEventListener(NULL);
1212   CheckDebuggerUnloaded();
1213 }
1214 
1215 
1216 // Test that a break point can be set at an IC call location.
TEST(BreakPointICCall)1217 TEST(BreakPointICCall) {
1218   break_point_hit_count = 0;
1219   v8::HandleScope scope;
1220   DebugLocalContext env;
1221   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
1222                                    v8::Undefined());
1223   v8::Script::Compile(v8::String::New("function bar(){}"))->Run();
1224   v8::Script::Compile(v8::String::New("function foo(){bar();}"))->Run();
1225   v8::Local<v8::Function> foo =
1226       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
1227 
1228   // Run without breakpoints.
1229   foo->Call(env->Global(), 0, NULL);
1230   CHECK_EQ(0, break_point_hit_count);
1231 
1232   // Run with breakpoint
1233   int bp = SetBreakPoint(foo, 0);
1234   foo->Call(env->Global(), 0, NULL);
1235   CHECK_EQ(1, break_point_hit_count);
1236   foo->Call(env->Global(), 0, NULL);
1237   CHECK_EQ(2, break_point_hit_count);
1238 
1239   // Run without breakpoints.
1240   ClearBreakPoint(bp);
1241   foo->Call(env->Global(), 0, NULL);
1242   CHECK_EQ(2, break_point_hit_count);
1243 
1244   v8::Debug::SetDebugEventListener(NULL);
1245   CheckDebuggerUnloaded();
1246 }
1247 
1248 
1249 // Test that a break point can be set at an IC call location and survive a GC.
TEST(BreakPointICCallWithGC)1250 TEST(BreakPointICCallWithGC) {
1251   break_point_hit_count = 0;
1252   v8::HandleScope scope;
1253   DebugLocalContext env;
1254   v8::Debug::SetDebugEventListener(DebugEventBreakPointCollectGarbage,
1255                                    v8::Undefined());
1256   v8::Script::Compile(v8::String::New("function bar(){return 1;}"))->Run();
1257   v8::Script::Compile(v8::String::New("function foo(){return bar();}"))->Run();
1258   v8::Local<v8::Function> foo =
1259       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
1260 
1261   // Run without breakpoints.
1262   CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
1263   CHECK_EQ(0, break_point_hit_count);
1264 
1265   // Run with breakpoint.
1266   int bp = SetBreakPoint(foo, 0);
1267   CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
1268   CHECK_EQ(1, break_point_hit_count);
1269   CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
1270   CHECK_EQ(2, break_point_hit_count);
1271 
1272   // Run without breakpoints.
1273   ClearBreakPoint(bp);
1274   foo->Call(env->Global(), 0, NULL);
1275   CHECK_EQ(2, break_point_hit_count);
1276 
1277   v8::Debug::SetDebugEventListener(NULL);
1278   CheckDebuggerUnloaded();
1279 }
1280 
1281 
1282 // Test that a break point can be set at an IC call location and survive a GC.
TEST(BreakPointConstructCallWithGC)1283 TEST(BreakPointConstructCallWithGC) {
1284   break_point_hit_count = 0;
1285   v8::HandleScope scope;
1286   DebugLocalContext env;
1287   v8::Debug::SetDebugEventListener(DebugEventBreakPointCollectGarbage,
1288                                    v8::Undefined());
1289   v8::Script::Compile(v8::String::New("function bar(){ this.x = 1;}"))->Run();
1290   v8::Script::Compile(v8::String::New(
1291       "function foo(){return new bar(1).x;}"))->Run();
1292   v8::Local<v8::Function> foo =
1293       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
1294 
1295   // Run without breakpoints.
1296   CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
1297   CHECK_EQ(0, break_point_hit_count);
1298 
1299   // Run with breakpoint.
1300   int bp = SetBreakPoint(foo, 0);
1301   CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
1302   CHECK_EQ(1, break_point_hit_count);
1303   CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
1304   CHECK_EQ(2, break_point_hit_count);
1305 
1306   // Run without breakpoints.
1307   ClearBreakPoint(bp);
1308   foo->Call(env->Global(), 0, NULL);
1309   CHECK_EQ(2, break_point_hit_count);
1310 
1311   v8::Debug::SetDebugEventListener(NULL);
1312   CheckDebuggerUnloaded();
1313 }
1314 
1315 
1316 // Test that a break point can be set at a return store location.
TEST(BreakPointReturn)1317 TEST(BreakPointReturn) {
1318   break_point_hit_count = 0;
1319   v8::HandleScope scope;
1320   DebugLocalContext env;
1321 
1322   // Create a functions for checking the source line and column when hitting
1323   // a break point.
1324   frame_source_line = CompileFunction(&env,
1325                                       frame_source_line_source,
1326                                       "frame_source_line");
1327   frame_source_column = CompileFunction(&env,
1328                                         frame_source_column_source,
1329                                         "frame_source_column");
1330 
1331 
1332   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
1333                                    v8::Undefined());
1334   v8::Script::Compile(v8::String::New("function foo(){}"))->Run();
1335   v8::Local<v8::Function> foo =
1336       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
1337 
1338   // Run without breakpoints.
1339   foo->Call(env->Global(), 0, NULL);
1340   CHECK_EQ(0, break_point_hit_count);
1341 
1342   // Run with breakpoint
1343   int bp = SetBreakPoint(foo, 0);
1344   foo->Call(env->Global(), 0, NULL);
1345   CHECK_EQ(1, break_point_hit_count);
1346   CHECK_EQ(0, last_source_line);
1347   CHECK_EQ(15, last_source_column);
1348   foo->Call(env->Global(), 0, NULL);
1349   CHECK_EQ(2, break_point_hit_count);
1350   CHECK_EQ(0, last_source_line);
1351   CHECK_EQ(15, last_source_column);
1352 
1353   // Run without breakpoints.
1354   ClearBreakPoint(bp);
1355   foo->Call(env->Global(), 0, NULL);
1356   CHECK_EQ(2, break_point_hit_count);
1357 
1358   v8::Debug::SetDebugEventListener(NULL);
1359   CheckDebuggerUnloaded();
1360 }
1361 
1362 
CallWithBreakPoints(v8::Local<v8::Object> recv,v8::Local<v8::Function> f,int break_point_count,int call_count)1363 static void CallWithBreakPoints(v8::Local<v8::Object> recv,
1364                                 v8::Local<v8::Function> f,
1365                                 int break_point_count,
1366                                 int call_count) {
1367   break_point_hit_count = 0;
1368   for (int i = 0; i < call_count; i++) {
1369     f->Call(recv, 0, NULL);
1370     CHECK_EQ((i + 1) * break_point_count, break_point_hit_count);
1371   }
1372 }
1373 
1374 // Test GC during break point processing.
TEST(GCDuringBreakPointProcessing)1375 TEST(GCDuringBreakPointProcessing) {
1376   break_point_hit_count = 0;
1377   v8::HandleScope scope;
1378   DebugLocalContext env;
1379 
1380   v8::Debug::SetDebugEventListener(DebugEventBreakPointCollectGarbage,
1381                                    v8::Undefined());
1382   v8::Local<v8::Function> foo;
1383 
1384   // Test IC store break point with garbage collection.
1385   foo = CompileFunction(&env, "function foo(){bar=0;}", "foo");
1386   SetBreakPoint(foo, 0);
1387   CallWithBreakPoints(env->Global(), foo, 1, 10);
1388 
1389   // Test IC load break point with garbage collection.
1390   foo = CompileFunction(&env, "bar=1;function foo(){var x=bar;}", "foo");
1391   SetBreakPoint(foo, 0);
1392   CallWithBreakPoints(env->Global(), foo, 1, 10);
1393 
1394   // Test IC call break point with garbage collection.
1395   foo = CompileFunction(&env, "function bar(){};function foo(){bar();}", "foo");
1396   SetBreakPoint(foo, 0);
1397   CallWithBreakPoints(env->Global(), foo, 1, 10);
1398 
1399   // Test return break point with garbage collection.
1400   foo = CompileFunction(&env, "function foo(){}", "foo");
1401   SetBreakPoint(foo, 0);
1402   CallWithBreakPoints(env->Global(), foo, 1, 25);
1403 
1404   // Test debug break slot break point with garbage collection.
1405   foo = CompileFunction(&env, "function foo(){var a;}", "foo");
1406   SetBreakPoint(foo, 0);
1407   CallWithBreakPoints(env->Global(), foo, 1, 25);
1408 
1409   v8::Debug::SetDebugEventListener(NULL);
1410   CheckDebuggerUnloaded();
1411 }
1412 
1413 
1414 // Call the function three times with different garbage collections in between
1415 // and make sure that the break point survives.
CallAndGC(v8::Local<v8::Object> recv,v8::Local<v8::Function> f)1416 static void CallAndGC(v8::Local<v8::Object> recv,
1417                       v8::Local<v8::Function> f) {
1418   break_point_hit_count = 0;
1419 
1420   for (int i = 0; i < 3; i++) {
1421     // Call function.
1422     f->Call(recv, 0, NULL);
1423     CHECK_EQ(1 + i * 3, break_point_hit_count);
1424 
1425     // Scavenge and call function.
1426     HEAP->CollectGarbage(v8::internal::NEW_SPACE);
1427     f->Call(recv, 0, NULL);
1428     CHECK_EQ(2 + i * 3, break_point_hit_count);
1429 
1430     // Mark sweep (and perhaps compact) and call function.
1431     HEAP->CollectAllGarbage(Heap::kNoGCFlags);
1432     f->Call(recv, 0, NULL);
1433     CHECK_EQ(3 + i * 3, break_point_hit_count);
1434   }
1435 }
1436 
1437 
1438 // Test that a break point can be set at a return store location.
TEST(BreakPointSurviveGC)1439 TEST(BreakPointSurviveGC) {
1440   break_point_hit_count = 0;
1441   v8::HandleScope scope;
1442   DebugLocalContext env;
1443 
1444   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
1445                                    v8::Undefined());
1446   v8::Local<v8::Function> foo;
1447 
1448   // Test IC store break point with garbage collection.
1449   {
1450     CompileFunction(&env, "function foo(){}", "foo");
1451     foo = CompileFunction(&env, "function foo(){bar=0;}", "foo");
1452     SetBreakPoint(foo, 0);
1453   }
1454   CallAndGC(env->Global(), foo);
1455 
1456   // Test IC load break point with garbage collection.
1457   {
1458     CompileFunction(&env, "function foo(){}", "foo");
1459     foo = CompileFunction(&env, "bar=1;function foo(){var x=bar;}", "foo");
1460     SetBreakPoint(foo, 0);
1461   }
1462   CallAndGC(env->Global(), foo);
1463 
1464   // Test IC call break point with garbage collection.
1465   {
1466     CompileFunction(&env, "function foo(){}", "foo");
1467     foo = CompileFunction(&env,
1468                           "function bar(){};function foo(){bar();}",
1469                           "foo");
1470     SetBreakPoint(foo, 0);
1471   }
1472   CallAndGC(env->Global(), foo);
1473 
1474   // Test return break point with garbage collection.
1475   {
1476     CompileFunction(&env, "function foo(){}", "foo");
1477     foo = CompileFunction(&env, "function foo(){}", "foo");
1478     SetBreakPoint(foo, 0);
1479   }
1480   CallAndGC(env->Global(), foo);
1481 
1482   // Test non IC break point with garbage collection.
1483   {
1484     CompileFunction(&env, "function foo(){}", "foo");
1485     foo = CompileFunction(&env, "function foo(){var bar=0;}", "foo");
1486     SetBreakPoint(foo, 0);
1487   }
1488   CallAndGC(env->Global(), foo);
1489 
1490 
1491   v8::Debug::SetDebugEventListener(NULL);
1492   CheckDebuggerUnloaded();
1493 }
1494 
1495 
1496 // Test that break points can be set using the global Debug object.
TEST(BreakPointThroughJavaScript)1497 TEST(BreakPointThroughJavaScript) {
1498   break_point_hit_count = 0;
1499   v8::HandleScope scope;
1500   DebugLocalContext env;
1501   env.ExposeDebug();
1502 
1503   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
1504                                    v8::Undefined());
1505   v8::Script::Compile(v8::String::New("function bar(){}"))->Run();
1506   v8::Script::Compile(v8::String::New("function foo(){bar();bar();}"))->Run();
1507   //                                               012345678901234567890
1508   //                                                         1         2
1509   // Break points are set at position 3 and 9
1510   v8::Local<v8::Script> foo = v8::Script::Compile(v8::String::New("foo()"));
1511 
1512   // Run without breakpoints.
1513   foo->Run();
1514   CHECK_EQ(0, break_point_hit_count);
1515 
1516   // Run with one breakpoint
1517   int bp1 = SetBreakPointFromJS("foo", 0, 3);
1518   foo->Run();
1519   CHECK_EQ(1, break_point_hit_count);
1520   foo->Run();
1521   CHECK_EQ(2, break_point_hit_count);
1522 
1523   // Run with two breakpoints
1524   int bp2 = SetBreakPointFromJS("foo", 0, 9);
1525   foo->Run();
1526   CHECK_EQ(4, break_point_hit_count);
1527   foo->Run();
1528   CHECK_EQ(6, break_point_hit_count);
1529 
1530   // Run with one breakpoint
1531   ClearBreakPointFromJS(bp2);
1532   foo->Run();
1533   CHECK_EQ(7, break_point_hit_count);
1534   foo->Run();
1535   CHECK_EQ(8, break_point_hit_count);
1536 
1537   // Run without breakpoints.
1538   ClearBreakPointFromJS(bp1);
1539   foo->Run();
1540   CHECK_EQ(8, break_point_hit_count);
1541 
1542   v8::Debug::SetDebugEventListener(NULL);
1543   CheckDebuggerUnloaded();
1544 
1545   // Make sure that the break point numbers are consecutive.
1546   CHECK_EQ(1, bp1);
1547   CHECK_EQ(2, bp2);
1548 }
1549 
1550 
1551 // Test that break points on scripts identified by name can be set using the
1552 // global Debug object.
TEST(ScriptBreakPointByNameThroughJavaScript)1553 TEST(ScriptBreakPointByNameThroughJavaScript) {
1554   break_point_hit_count = 0;
1555   v8::HandleScope scope;
1556   DebugLocalContext env;
1557   env.ExposeDebug();
1558 
1559   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
1560                                    v8::Undefined());
1561 
1562   v8::Local<v8::String> script = v8::String::New(
1563     "function f() {\n"
1564     "  function h() {\n"
1565     "    a = 0;  // line 2\n"
1566     "  }\n"
1567     "  b = 1;  // line 4\n"
1568     "  return h();\n"
1569     "}\n"
1570     "\n"
1571     "function g() {\n"
1572     "  function h() {\n"
1573     "    a = 0;\n"
1574     "  }\n"
1575     "  b = 2;  // line 12\n"
1576     "  h();\n"
1577     "  b = 3;  // line 14\n"
1578     "  f();    // line 15\n"
1579     "}");
1580 
1581   // Compile the script and get the two functions.
1582   v8::ScriptOrigin origin =
1583       v8::ScriptOrigin(v8::String::New("test"));
1584   v8::Script::Compile(script, &origin)->Run();
1585   v8::Local<v8::Function> f =
1586       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
1587   v8::Local<v8::Function> g =
1588       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("g")));
1589 
1590   // Call f and g without break points.
1591   break_point_hit_count = 0;
1592   f->Call(env->Global(), 0, NULL);
1593   CHECK_EQ(0, break_point_hit_count);
1594   g->Call(env->Global(), 0, NULL);
1595   CHECK_EQ(0, break_point_hit_count);
1596 
1597   // Call f and g with break point on line 12.
1598   int sbp1 = SetScriptBreakPointByNameFromJS("test", 12, 0);
1599   break_point_hit_count = 0;
1600   f->Call(env->Global(), 0, NULL);
1601   CHECK_EQ(0, break_point_hit_count);
1602   g->Call(env->Global(), 0, NULL);
1603   CHECK_EQ(1, break_point_hit_count);
1604 
1605   // Remove the break point again.
1606   break_point_hit_count = 0;
1607   ClearBreakPointFromJS(sbp1);
1608   f->Call(env->Global(), 0, NULL);
1609   CHECK_EQ(0, break_point_hit_count);
1610   g->Call(env->Global(), 0, NULL);
1611   CHECK_EQ(0, break_point_hit_count);
1612 
1613   // Call f and g with break point on line 2.
1614   int sbp2 = SetScriptBreakPointByNameFromJS("test", 2, 0);
1615   break_point_hit_count = 0;
1616   f->Call(env->Global(), 0, NULL);
1617   CHECK_EQ(1, break_point_hit_count);
1618   g->Call(env->Global(), 0, NULL);
1619   CHECK_EQ(2, break_point_hit_count);
1620 
1621   // Call f and g with break point on line 2, 4, 12, 14 and 15.
1622   int sbp3 = SetScriptBreakPointByNameFromJS("test", 4, 0);
1623   int sbp4 = SetScriptBreakPointByNameFromJS("test", 12, 0);
1624   int sbp5 = SetScriptBreakPointByNameFromJS("test", 14, 0);
1625   int sbp6 = SetScriptBreakPointByNameFromJS("test", 15, 0);
1626   break_point_hit_count = 0;
1627   f->Call(env->Global(), 0, NULL);
1628   CHECK_EQ(2, break_point_hit_count);
1629   g->Call(env->Global(), 0, NULL);
1630   CHECK_EQ(7, break_point_hit_count);
1631 
1632   // Remove all the break points again.
1633   break_point_hit_count = 0;
1634   ClearBreakPointFromJS(sbp2);
1635   ClearBreakPointFromJS(sbp3);
1636   ClearBreakPointFromJS(sbp4);
1637   ClearBreakPointFromJS(sbp5);
1638   ClearBreakPointFromJS(sbp6);
1639   f->Call(env->Global(), 0, NULL);
1640   CHECK_EQ(0, break_point_hit_count);
1641   g->Call(env->Global(), 0, NULL);
1642   CHECK_EQ(0, break_point_hit_count);
1643 
1644   v8::Debug::SetDebugEventListener(NULL);
1645   CheckDebuggerUnloaded();
1646 
1647   // Make sure that the break point numbers are consecutive.
1648   CHECK_EQ(1, sbp1);
1649   CHECK_EQ(2, sbp2);
1650   CHECK_EQ(3, sbp3);
1651   CHECK_EQ(4, sbp4);
1652   CHECK_EQ(5, sbp5);
1653   CHECK_EQ(6, sbp6);
1654 }
1655 
1656 
TEST(ScriptBreakPointByIdThroughJavaScript)1657 TEST(ScriptBreakPointByIdThroughJavaScript) {
1658   break_point_hit_count = 0;
1659   v8::HandleScope scope;
1660   DebugLocalContext env;
1661   env.ExposeDebug();
1662 
1663   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
1664                                    v8::Undefined());
1665 
1666   v8::Local<v8::String> source = v8::String::New(
1667     "function f() {\n"
1668     "  function h() {\n"
1669     "    a = 0;  // line 2\n"
1670     "  }\n"
1671     "  b = 1;  // line 4\n"
1672     "  return h();\n"
1673     "}\n"
1674     "\n"
1675     "function g() {\n"
1676     "  function h() {\n"
1677     "    a = 0;\n"
1678     "  }\n"
1679     "  b = 2;  // line 12\n"
1680     "  h();\n"
1681     "  b = 3;  // line 14\n"
1682     "  f();    // line 15\n"
1683     "}");
1684 
1685   // Compile the script and get the two functions.
1686   v8::ScriptOrigin origin =
1687       v8::ScriptOrigin(v8::String::New("test"));
1688   v8::Local<v8::Script> script = v8::Script::Compile(source, &origin);
1689   script->Run();
1690   v8::Local<v8::Function> f =
1691       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
1692   v8::Local<v8::Function> g =
1693       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("g")));
1694 
1695   // Get the script id knowing that internally it is a 32 integer.
1696   uint32_t script_id = script->Id()->Uint32Value();
1697 
1698   // Call f and g without break points.
1699   break_point_hit_count = 0;
1700   f->Call(env->Global(), 0, NULL);
1701   CHECK_EQ(0, break_point_hit_count);
1702   g->Call(env->Global(), 0, NULL);
1703   CHECK_EQ(0, break_point_hit_count);
1704 
1705   // Call f and g with break point on line 12.
1706   int sbp1 = SetScriptBreakPointByIdFromJS(script_id, 12, 0);
1707   break_point_hit_count = 0;
1708   f->Call(env->Global(), 0, NULL);
1709   CHECK_EQ(0, break_point_hit_count);
1710   g->Call(env->Global(), 0, NULL);
1711   CHECK_EQ(1, break_point_hit_count);
1712 
1713   // Remove the break point again.
1714   break_point_hit_count = 0;
1715   ClearBreakPointFromJS(sbp1);
1716   f->Call(env->Global(), 0, NULL);
1717   CHECK_EQ(0, break_point_hit_count);
1718   g->Call(env->Global(), 0, NULL);
1719   CHECK_EQ(0, break_point_hit_count);
1720 
1721   // Call f and g with break point on line 2.
1722   int sbp2 = SetScriptBreakPointByIdFromJS(script_id, 2, 0);
1723   break_point_hit_count = 0;
1724   f->Call(env->Global(), 0, NULL);
1725   CHECK_EQ(1, break_point_hit_count);
1726   g->Call(env->Global(), 0, NULL);
1727   CHECK_EQ(2, break_point_hit_count);
1728 
1729   // Call f and g with break point on line 2, 4, 12, 14 and 15.
1730   int sbp3 = SetScriptBreakPointByIdFromJS(script_id, 4, 0);
1731   int sbp4 = SetScriptBreakPointByIdFromJS(script_id, 12, 0);
1732   int sbp5 = SetScriptBreakPointByIdFromJS(script_id, 14, 0);
1733   int sbp6 = SetScriptBreakPointByIdFromJS(script_id, 15, 0);
1734   break_point_hit_count = 0;
1735   f->Call(env->Global(), 0, NULL);
1736   CHECK_EQ(2, break_point_hit_count);
1737   g->Call(env->Global(), 0, NULL);
1738   CHECK_EQ(7, break_point_hit_count);
1739 
1740   // Remove all the break points again.
1741   break_point_hit_count = 0;
1742   ClearBreakPointFromJS(sbp2);
1743   ClearBreakPointFromJS(sbp3);
1744   ClearBreakPointFromJS(sbp4);
1745   ClearBreakPointFromJS(sbp5);
1746   ClearBreakPointFromJS(sbp6);
1747   f->Call(env->Global(), 0, NULL);
1748   CHECK_EQ(0, break_point_hit_count);
1749   g->Call(env->Global(), 0, NULL);
1750   CHECK_EQ(0, break_point_hit_count);
1751 
1752   v8::Debug::SetDebugEventListener(NULL);
1753   CheckDebuggerUnloaded();
1754 
1755   // Make sure that the break point numbers are consecutive.
1756   CHECK_EQ(1, sbp1);
1757   CHECK_EQ(2, sbp2);
1758   CHECK_EQ(3, sbp3);
1759   CHECK_EQ(4, sbp4);
1760   CHECK_EQ(5, sbp5);
1761   CHECK_EQ(6, sbp6);
1762 }
1763 
1764 
1765 // Test conditional script break points.
TEST(EnableDisableScriptBreakPoint)1766 TEST(EnableDisableScriptBreakPoint) {
1767   break_point_hit_count = 0;
1768   v8::HandleScope scope;
1769   DebugLocalContext env;
1770   env.ExposeDebug();
1771 
1772   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
1773                                    v8::Undefined());
1774 
1775   v8::Local<v8::String> script = v8::String::New(
1776     "function f() {\n"
1777     "  a = 0;  // line 1\n"
1778     "};");
1779 
1780   // Compile the script and get function f.
1781   v8::ScriptOrigin origin =
1782       v8::ScriptOrigin(v8::String::New("test"));
1783   v8::Script::Compile(script, &origin)->Run();
1784   v8::Local<v8::Function> f =
1785       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
1786 
1787   // Set script break point on line 1 (in function f).
1788   int sbp = SetScriptBreakPointByNameFromJS("test", 1, 0);
1789 
1790   // Call f while enabeling and disabling the script break point.
1791   break_point_hit_count = 0;
1792   f->Call(env->Global(), 0, NULL);
1793   CHECK_EQ(1, break_point_hit_count);
1794 
1795   DisableScriptBreakPointFromJS(sbp);
1796   f->Call(env->Global(), 0, NULL);
1797   CHECK_EQ(1, break_point_hit_count);
1798 
1799   EnableScriptBreakPointFromJS(sbp);
1800   f->Call(env->Global(), 0, NULL);
1801   CHECK_EQ(2, break_point_hit_count);
1802 
1803   DisableScriptBreakPointFromJS(sbp);
1804   f->Call(env->Global(), 0, NULL);
1805   CHECK_EQ(2, break_point_hit_count);
1806 
1807   // Reload the script and get f again checking that the disabeling survives.
1808   v8::Script::Compile(script, &origin)->Run();
1809   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
1810   f->Call(env->Global(), 0, NULL);
1811   CHECK_EQ(2, break_point_hit_count);
1812 
1813   EnableScriptBreakPointFromJS(sbp);
1814   f->Call(env->Global(), 0, NULL);
1815   CHECK_EQ(3, break_point_hit_count);
1816 
1817   v8::Debug::SetDebugEventListener(NULL);
1818   CheckDebuggerUnloaded();
1819 }
1820 
1821 
1822 // Test conditional script break points.
TEST(ConditionalScriptBreakPoint)1823 TEST(ConditionalScriptBreakPoint) {
1824   break_point_hit_count = 0;
1825   v8::HandleScope scope;
1826   DebugLocalContext env;
1827   env.ExposeDebug();
1828 
1829   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
1830                                    v8::Undefined());
1831 
1832   v8::Local<v8::String> script = v8::String::New(
1833     "count = 0;\n"
1834     "function f() {\n"
1835     "  g(count++);  // line 2\n"
1836     "};\n"
1837     "function g(x) {\n"
1838     "  var a=x;  // line 5\n"
1839     "};");
1840 
1841   // Compile the script and get function f.
1842   v8::ScriptOrigin origin =
1843       v8::ScriptOrigin(v8::String::New("test"));
1844   v8::Script::Compile(script, &origin)->Run();
1845   v8::Local<v8::Function> f =
1846       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
1847 
1848   // Set script break point on line 5 (in function g).
1849   int sbp1 = SetScriptBreakPointByNameFromJS("test", 5, 0);
1850 
1851   // Call f with different conditions on the script break point.
1852   break_point_hit_count = 0;
1853   ChangeScriptBreakPointConditionFromJS(sbp1, "false");
1854   f->Call(env->Global(), 0, NULL);
1855   CHECK_EQ(0, break_point_hit_count);
1856 
1857   ChangeScriptBreakPointConditionFromJS(sbp1, "true");
1858   break_point_hit_count = 0;
1859   f->Call(env->Global(), 0, NULL);
1860   CHECK_EQ(1, break_point_hit_count);
1861 
1862   ChangeScriptBreakPointConditionFromJS(sbp1, "x % 2 == 0");
1863   break_point_hit_count = 0;
1864   for (int i = 0; i < 10; i++) {
1865     f->Call(env->Global(), 0, NULL);
1866   }
1867   CHECK_EQ(5, break_point_hit_count);
1868 
1869   // Reload the script and get f again checking that the condition survives.
1870   v8::Script::Compile(script, &origin)->Run();
1871   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
1872 
1873   break_point_hit_count = 0;
1874   for (int i = 0; i < 10; i++) {
1875     f->Call(env->Global(), 0, NULL);
1876   }
1877   CHECK_EQ(5, break_point_hit_count);
1878 
1879   v8::Debug::SetDebugEventListener(NULL);
1880   CheckDebuggerUnloaded();
1881 }
1882 
1883 
1884 // Test ignore count on script break points.
TEST(ScriptBreakPointIgnoreCount)1885 TEST(ScriptBreakPointIgnoreCount) {
1886   break_point_hit_count = 0;
1887   v8::HandleScope scope;
1888   DebugLocalContext env;
1889   env.ExposeDebug();
1890 
1891   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
1892                                    v8::Undefined());
1893 
1894   v8::Local<v8::String> script = v8::String::New(
1895     "function f() {\n"
1896     "  a = 0;  // line 1\n"
1897     "};");
1898 
1899   // Compile the script and get function f.
1900   v8::ScriptOrigin origin =
1901       v8::ScriptOrigin(v8::String::New("test"));
1902   v8::Script::Compile(script, &origin)->Run();
1903   v8::Local<v8::Function> f =
1904       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
1905 
1906   // Set script break point on line 1 (in function f).
1907   int sbp = SetScriptBreakPointByNameFromJS("test", 1, 0);
1908 
1909   // Call f with different ignores on the script break point.
1910   break_point_hit_count = 0;
1911   ChangeScriptBreakPointIgnoreCountFromJS(sbp, 1);
1912   f->Call(env->Global(), 0, NULL);
1913   CHECK_EQ(0, break_point_hit_count);
1914   f->Call(env->Global(), 0, NULL);
1915   CHECK_EQ(1, break_point_hit_count);
1916 
1917   ChangeScriptBreakPointIgnoreCountFromJS(sbp, 5);
1918   break_point_hit_count = 0;
1919   for (int i = 0; i < 10; i++) {
1920     f->Call(env->Global(), 0, NULL);
1921   }
1922   CHECK_EQ(5, break_point_hit_count);
1923 
1924   // Reload the script and get f again checking that the ignore survives.
1925   v8::Script::Compile(script, &origin)->Run();
1926   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
1927 
1928   break_point_hit_count = 0;
1929   for (int i = 0; i < 10; i++) {
1930     f->Call(env->Global(), 0, NULL);
1931   }
1932   CHECK_EQ(5, break_point_hit_count);
1933 
1934   v8::Debug::SetDebugEventListener(NULL);
1935   CheckDebuggerUnloaded();
1936 }
1937 
1938 
1939 // Test that script break points survive when a script is reloaded.
TEST(ScriptBreakPointReload)1940 TEST(ScriptBreakPointReload) {
1941   break_point_hit_count = 0;
1942   v8::HandleScope scope;
1943   DebugLocalContext env;
1944   env.ExposeDebug();
1945 
1946   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
1947                                    v8::Undefined());
1948 
1949   v8::Local<v8::Function> f;
1950   v8::Local<v8::String> script = v8::String::New(
1951     "function f() {\n"
1952     "  function h() {\n"
1953     "    a = 0;  // line 2\n"
1954     "  }\n"
1955     "  b = 1;  // line 4\n"
1956     "  return h();\n"
1957     "}");
1958 
1959   v8::ScriptOrigin origin_1 = v8::ScriptOrigin(v8::String::New("1"));
1960   v8::ScriptOrigin origin_2 = v8::ScriptOrigin(v8::String::New("2"));
1961 
1962   // Set a script break point before the script is loaded.
1963   SetScriptBreakPointByNameFromJS("1", 2, 0);
1964 
1965   // Compile the script and get the function.
1966   v8::Script::Compile(script, &origin_1)->Run();
1967   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
1968 
1969   // Call f and check that the script break point is active.
1970   break_point_hit_count = 0;
1971   f->Call(env->Global(), 0, NULL);
1972   CHECK_EQ(1, break_point_hit_count);
1973 
1974   // Compile the script again with a different script data and get the
1975   // function.
1976   v8::Script::Compile(script, &origin_2)->Run();
1977   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
1978 
1979   // Call f and check that no break points are set.
1980   break_point_hit_count = 0;
1981   f->Call(env->Global(), 0, NULL);
1982   CHECK_EQ(0, break_point_hit_count);
1983 
1984   // Compile the script again and get the function.
1985   v8::Script::Compile(script, &origin_1)->Run();
1986   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
1987 
1988   // Call f and check that the script break point is active.
1989   break_point_hit_count = 0;
1990   f->Call(env->Global(), 0, NULL);
1991   CHECK_EQ(1, break_point_hit_count);
1992 
1993   v8::Debug::SetDebugEventListener(NULL);
1994   CheckDebuggerUnloaded();
1995 }
1996 
1997 
1998 // Test when several scripts has the same script data
TEST(ScriptBreakPointMultiple)1999 TEST(ScriptBreakPointMultiple) {
2000   break_point_hit_count = 0;
2001   v8::HandleScope scope;
2002   DebugLocalContext env;
2003   env.ExposeDebug();
2004 
2005   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
2006                                    v8::Undefined());
2007 
2008   v8::Local<v8::Function> f;
2009   v8::Local<v8::String> script_f = v8::String::New(
2010     "function f() {\n"
2011     "  a = 0;  // line 1\n"
2012     "}");
2013 
2014   v8::Local<v8::Function> g;
2015   v8::Local<v8::String> script_g = v8::String::New(
2016     "function g() {\n"
2017     "  b = 0;  // line 1\n"
2018     "}");
2019 
2020   v8::ScriptOrigin origin =
2021       v8::ScriptOrigin(v8::String::New("test"));
2022 
2023   // Set a script break point before the scripts are loaded.
2024   int sbp = SetScriptBreakPointByNameFromJS("test", 1, 0);
2025 
2026   // Compile the scripts with same script data and get the functions.
2027   v8::Script::Compile(script_f, &origin)->Run();
2028   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
2029   v8::Script::Compile(script_g, &origin)->Run();
2030   g = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("g")));
2031 
2032   // Call f and g and check that the script break point is active.
2033   break_point_hit_count = 0;
2034   f->Call(env->Global(), 0, NULL);
2035   CHECK_EQ(1, break_point_hit_count);
2036   g->Call(env->Global(), 0, NULL);
2037   CHECK_EQ(2, break_point_hit_count);
2038 
2039   // Clear the script break point.
2040   ClearBreakPointFromJS(sbp);
2041 
2042   // Call f and g and check that the script break point is no longer active.
2043   break_point_hit_count = 0;
2044   f->Call(env->Global(), 0, NULL);
2045   CHECK_EQ(0, break_point_hit_count);
2046   g->Call(env->Global(), 0, NULL);
2047   CHECK_EQ(0, break_point_hit_count);
2048 
2049   // Set script break point with the scripts loaded.
2050   sbp = SetScriptBreakPointByNameFromJS("test", 1, 0);
2051 
2052   // Call f and g and check that the script break point is active.
2053   break_point_hit_count = 0;
2054   f->Call(env->Global(), 0, NULL);
2055   CHECK_EQ(1, break_point_hit_count);
2056   g->Call(env->Global(), 0, NULL);
2057   CHECK_EQ(2, break_point_hit_count);
2058 
2059   v8::Debug::SetDebugEventListener(NULL);
2060   CheckDebuggerUnloaded();
2061 }
2062 
2063 
2064 // Test the script origin which has both name and line offset.
TEST(ScriptBreakPointLineOffset)2065 TEST(ScriptBreakPointLineOffset) {
2066   break_point_hit_count = 0;
2067   v8::HandleScope scope;
2068   DebugLocalContext env;
2069   env.ExposeDebug();
2070 
2071   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
2072                                    v8::Undefined());
2073 
2074   v8::Local<v8::Function> f;
2075   v8::Local<v8::String> script = v8::String::New(
2076     "function f() {\n"
2077     "  a = 0;  // line 8 as this script has line offset 7\n"
2078     "  b = 0;  // line 9 as this script has line offset 7\n"
2079     "}");
2080 
2081   // Create script origin both name and line offset.
2082   v8::ScriptOrigin origin(v8::String::New("test.html"),
2083                           v8::Integer::New(7));
2084 
2085   // Set two script break points before the script is loaded.
2086   int sbp1 = SetScriptBreakPointByNameFromJS("test.html", 8, 0);
2087   int sbp2 = SetScriptBreakPointByNameFromJS("test.html", 9, 0);
2088 
2089   // Compile the script and get the function.
2090   v8::Script::Compile(script, &origin)->Run();
2091   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
2092 
2093   // Call f and check that the script break point is active.
2094   break_point_hit_count = 0;
2095   f->Call(env->Global(), 0, NULL);
2096   CHECK_EQ(2, break_point_hit_count);
2097 
2098   // Clear the script break points.
2099   ClearBreakPointFromJS(sbp1);
2100   ClearBreakPointFromJS(sbp2);
2101 
2102   // Call f and check that no script break points are active.
2103   break_point_hit_count = 0;
2104   f->Call(env->Global(), 0, NULL);
2105   CHECK_EQ(0, break_point_hit_count);
2106 
2107   // Set a script break point with the script loaded.
2108   sbp1 = SetScriptBreakPointByNameFromJS("test.html", 9, 0);
2109 
2110   // Call f and check that the script break point is active.
2111   break_point_hit_count = 0;
2112   f->Call(env->Global(), 0, NULL);
2113   CHECK_EQ(1, break_point_hit_count);
2114 
2115   v8::Debug::SetDebugEventListener(NULL);
2116   CheckDebuggerUnloaded();
2117 }
2118 
2119 
2120 // Test script break points set on lines.
TEST(ScriptBreakPointLine)2121 TEST(ScriptBreakPointLine) {
2122   v8::HandleScope scope;
2123   DebugLocalContext env;
2124   env.ExposeDebug();
2125 
2126   // Create a function for checking the function when hitting a break point.
2127   frame_function_name = CompileFunction(&env,
2128                                         frame_function_name_source,
2129                                         "frame_function_name");
2130 
2131   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
2132                                    v8::Undefined());
2133 
2134   v8::Local<v8::Function> f;
2135   v8::Local<v8::Function> g;
2136   v8::Local<v8::String> script = v8::String::New(
2137     "a = 0                      // line 0\n"
2138     "function f() {\n"
2139     "  a = 1;                   // line 2\n"
2140     "}\n"
2141     " a = 2;                    // line 4\n"
2142     "  /* xx */ function g() {  // line 5\n"
2143     "    function h() {         // line 6\n"
2144     "      a = 3;               // line 7\n"
2145     "    }\n"
2146     "    h();                   // line 9\n"
2147     "    a = 4;                 // line 10\n"
2148     "  }\n"
2149     " a=5;                      // line 12");
2150 
2151   // Set a couple script break point before the script is loaded.
2152   int sbp1 = SetScriptBreakPointByNameFromJS("test.html", 0, -1);
2153   int sbp2 = SetScriptBreakPointByNameFromJS("test.html", 1, -1);
2154   int sbp3 = SetScriptBreakPointByNameFromJS("test.html", 5, -1);
2155 
2156   // Compile the script and get the function.
2157   break_point_hit_count = 0;
2158   v8::ScriptOrigin origin(v8::String::New("test.html"), v8::Integer::New(0));
2159   v8::Script::Compile(script, &origin)->Run();
2160   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
2161   g = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("g")));
2162 
2163   // Check that a break point was hit when the script was run.
2164   CHECK_EQ(1, break_point_hit_count);
2165   CHECK_EQ(0, StrLength(last_function_hit));
2166 
2167   // Call f and check that the script break point.
2168   f->Call(env->Global(), 0, NULL);
2169   CHECK_EQ(2, break_point_hit_count);
2170   CHECK_EQ("f", last_function_hit);
2171 
2172   // Call g and check that the script break point.
2173   g->Call(env->Global(), 0, NULL);
2174   CHECK_EQ(3, break_point_hit_count);
2175   CHECK_EQ("g", last_function_hit);
2176 
2177   // Clear the script break point on g and set one on h.
2178   ClearBreakPointFromJS(sbp3);
2179   int sbp4 = SetScriptBreakPointByNameFromJS("test.html", 6, -1);
2180 
2181   // Call g and check that the script break point in h is hit.
2182   g->Call(env->Global(), 0, NULL);
2183   CHECK_EQ(4, break_point_hit_count);
2184   CHECK_EQ("h", last_function_hit);
2185 
2186   // Clear break points in f and h. Set a new one in the script between
2187   // functions f and g and test that there is no break points in f and g any
2188   // more.
2189   ClearBreakPointFromJS(sbp2);
2190   ClearBreakPointFromJS(sbp4);
2191   int sbp5 = SetScriptBreakPointByNameFromJS("test.html", 4, -1);
2192   break_point_hit_count = 0;
2193   f->Call(env->Global(), 0, NULL);
2194   g->Call(env->Global(), 0, NULL);
2195   CHECK_EQ(0, break_point_hit_count);
2196 
2197   // Reload the script which should hit two break points.
2198   break_point_hit_count = 0;
2199   v8::Script::Compile(script, &origin)->Run();
2200   CHECK_EQ(2, break_point_hit_count);
2201   CHECK_EQ(0, StrLength(last_function_hit));
2202 
2203   // Set a break point in the code after the last function decleration.
2204   int sbp6 = SetScriptBreakPointByNameFromJS("test.html", 12, -1);
2205 
2206   // Reload the script which should hit three break points.
2207   break_point_hit_count = 0;
2208   v8::Script::Compile(script, &origin)->Run();
2209   CHECK_EQ(3, break_point_hit_count);
2210   CHECK_EQ(0, StrLength(last_function_hit));
2211 
2212   // Clear the last break points, and reload the script which should not hit any
2213   // break points.
2214   ClearBreakPointFromJS(sbp1);
2215   ClearBreakPointFromJS(sbp5);
2216   ClearBreakPointFromJS(sbp6);
2217   break_point_hit_count = 0;
2218   v8::Script::Compile(script, &origin)->Run();
2219   CHECK_EQ(0, break_point_hit_count);
2220 
2221   v8::Debug::SetDebugEventListener(NULL);
2222   CheckDebuggerUnloaded();
2223 }
2224 
2225 
2226 // Test top level script break points set on lines.
TEST(ScriptBreakPointLineTopLevel)2227 TEST(ScriptBreakPointLineTopLevel) {
2228   v8::HandleScope scope;
2229   DebugLocalContext env;
2230   env.ExposeDebug();
2231 
2232   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
2233                                    v8::Undefined());
2234 
2235   v8::Local<v8::String> script = v8::String::New(
2236     "function f() {\n"
2237     "  a = 1;                   // line 1\n"
2238     "}\n"
2239     "a = 2;                     // line 3\n");
2240   v8::Local<v8::Function> f;
2241   {
2242     v8::HandleScope scope;
2243     v8::Script::Compile(script, v8::String::New("test.html"))->Run();
2244   }
2245   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
2246 
2247   HEAP->CollectAllGarbage(Heap::kNoGCFlags);
2248 
2249   SetScriptBreakPointByNameFromJS("test.html", 3, -1);
2250 
2251   // Call f and check that there was no break points.
2252   break_point_hit_count = 0;
2253   f->Call(env->Global(), 0, NULL);
2254   CHECK_EQ(0, break_point_hit_count);
2255 
2256   // Recompile and run script and check that break point was hit.
2257   break_point_hit_count = 0;
2258   v8::Script::Compile(script, v8::String::New("test.html"))->Run();
2259   CHECK_EQ(1, break_point_hit_count);
2260 
2261   // Call f and check that there are still no break points.
2262   break_point_hit_count = 0;
2263   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
2264   CHECK_EQ(0, break_point_hit_count);
2265 
2266   v8::Debug::SetDebugEventListener(NULL);
2267   CheckDebuggerUnloaded();
2268 }
2269 
2270 
2271 // Test that it is possible to add and remove break points in a top level
2272 // function which has no references but has not been collected yet.
TEST(ScriptBreakPointTopLevelCrash)2273 TEST(ScriptBreakPointTopLevelCrash) {
2274   v8::HandleScope scope;
2275   DebugLocalContext env;
2276   env.ExposeDebug();
2277 
2278   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
2279                                    v8::Undefined());
2280 
2281   v8::Local<v8::String> script_source = v8::String::New(
2282     "function f() {\n"
2283     "  return 0;\n"
2284     "}\n"
2285     "f()");
2286 
2287   int sbp1 = SetScriptBreakPointByNameFromJS("test.html", 3, -1);
2288   {
2289     v8::HandleScope scope;
2290     break_point_hit_count = 0;
2291     v8::Script::Compile(script_source, v8::String::New("test.html"))->Run();
2292     CHECK_EQ(1, break_point_hit_count);
2293   }
2294 
2295   int sbp2 = SetScriptBreakPointByNameFromJS("test.html", 3, -1);
2296   ClearBreakPointFromJS(sbp1);
2297   ClearBreakPointFromJS(sbp2);
2298 
2299   v8::Debug::SetDebugEventListener(NULL);
2300   CheckDebuggerUnloaded();
2301 }
2302 
2303 
2304 // Test that it is possible to remove the last break point for a function
2305 // inside the break handling of that break point.
TEST(RemoveBreakPointInBreak)2306 TEST(RemoveBreakPointInBreak) {
2307   v8::HandleScope scope;
2308   DebugLocalContext env;
2309 
2310   v8::Local<v8::Function> foo =
2311       CompileFunction(&env, "function foo(){a=1;}", "foo");
2312   debug_event_remove_break_point = SetBreakPoint(foo, 0);
2313 
2314   // Register the debug event listener pasing the function
2315   v8::Debug::SetDebugEventListener(DebugEventRemoveBreakPoint, foo);
2316 
2317   break_point_hit_count = 0;
2318   foo->Call(env->Global(), 0, NULL);
2319   CHECK_EQ(1, break_point_hit_count);
2320 
2321   break_point_hit_count = 0;
2322   foo->Call(env->Global(), 0, NULL);
2323   CHECK_EQ(0, break_point_hit_count);
2324 
2325   v8::Debug::SetDebugEventListener(NULL);
2326   CheckDebuggerUnloaded();
2327 }
2328 
2329 
2330 // Test that the debugger statement causes a break.
TEST(DebuggerStatement)2331 TEST(DebuggerStatement) {
2332   break_point_hit_count = 0;
2333   v8::HandleScope scope;
2334   DebugLocalContext env;
2335   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
2336                                    v8::Undefined());
2337   v8::Script::Compile(v8::String::New("function bar(){debugger}"))->Run();
2338   v8::Script::Compile(v8::String::New(
2339       "function foo(){debugger;debugger;}"))->Run();
2340   v8::Local<v8::Function> foo =
2341       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
2342   v8::Local<v8::Function> bar =
2343       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("bar")));
2344 
2345   // Run function with debugger statement
2346   bar->Call(env->Global(), 0, NULL);
2347   CHECK_EQ(1, break_point_hit_count);
2348 
2349   // Run function with two debugger statement
2350   foo->Call(env->Global(), 0, NULL);
2351   CHECK_EQ(3, break_point_hit_count);
2352 
2353   v8::Debug::SetDebugEventListener(NULL);
2354   CheckDebuggerUnloaded();
2355 }
2356 
2357 
2358 // Test setting a breakpoint on the debugger statement.
TEST(DebuggerStatementBreakpoint)2359 TEST(DebuggerStatementBreakpoint) {
2360     break_point_hit_count = 0;
2361     v8::HandleScope scope;
2362     DebugLocalContext env;
2363     v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
2364                                      v8::Undefined());
2365     v8::Script::Compile(v8::String::New("function foo(){debugger;}"))->Run();
2366     v8::Local<v8::Function> foo =
2367     v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
2368 
2369     // The debugger statement triggers breakpint hit
2370     foo->Call(env->Global(), 0, NULL);
2371     CHECK_EQ(1, break_point_hit_count);
2372 
2373     int bp = SetBreakPoint(foo, 0);
2374 
2375     // Set breakpoint does not duplicate hits
2376     foo->Call(env->Global(), 0, NULL);
2377     CHECK_EQ(2, break_point_hit_count);
2378 
2379     ClearBreakPoint(bp);
2380     v8::Debug::SetDebugEventListener(NULL);
2381     CheckDebuggerUnloaded();
2382 }
2383 
2384 
2385 // Thest that the evaluation of expressions when a break point is hit generates
2386 // the correct results.
TEST(DebugEvaluate)2387 TEST(DebugEvaluate) {
2388   v8::HandleScope scope;
2389   DebugLocalContext env;
2390   env.ExposeDebug();
2391 
2392   // Create a function for checking the evaluation when hitting a break point.
2393   evaluate_check_function = CompileFunction(&env,
2394                                             evaluate_check_source,
2395                                             "evaluate_check");
2396   // Register the debug event listener
2397   v8::Debug::SetDebugEventListener(DebugEventEvaluate);
2398 
2399   // Different expected vaules of x and a when in a break point (u = undefined,
2400   // d = Hello, world!).
2401   struct EvaluateCheck checks_uu[] = {
2402     {"x", v8::Undefined()},
2403     {"a", v8::Undefined()},
2404     {NULL, v8::Handle<v8::Value>()}
2405   };
2406   struct EvaluateCheck checks_hu[] = {
2407     {"x", v8::String::New("Hello, world!")},
2408     {"a", v8::Undefined()},
2409     {NULL, v8::Handle<v8::Value>()}
2410   };
2411   struct EvaluateCheck checks_hh[] = {
2412     {"x", v8::String::New("Hello, world!")},
2413     {"a", v8::String::New("Hello, world!")},
2414     {NULL, v8::Handle<v8::Value>()}
2415   };
2416 
2417   // Simple test function. The "y=0" is in the function foo to provide a break
2418   // location. For "y=0" the "y" is at position 15 in the barbar function
2419   // therefore setting breakpoint at position 15 will break at "y=0" and
2420   // setting it higher will break after.
2421   v8::Local<v8::Function> foo = CompileFunction(&env,
2422     "function foo(x) {"
2423     "  var a;"
2424     "  y=0;"  // To ensure break location 1.
2425     "  a=x;"
2426     "  y=0;"  // To ensure break location 2.
2427     "}",
2428     "foo");
2429   const int foo_break_position_1 = 15;
2430   const int foo_break_position_2 = 29;
2431 
2432   // Arguments with one parameter "Hello, world!"
2433   v8::Handle<v8::Value> argv_foo[1] = { v8::String::New("Hello, world!") };
2434 
2435   // Call foo with breakpoint set before a=x and undefined as parameter.
2436   int bp = SetBreakPoint(foo, foo_break_position_1);
2437   checks = checks_uu;
2438   foo->Call(env->Global(), 0, NULL);
2439 
2440   // Call foo with breakpoint set before a=x and parameter "Hello, world!".
2441   checks = checks_hu;
2442   foo->Call(env->Global(), 1, argv_foo);
2443 
2444   // Call foo with breakpoint set after a=x and parameter "Hello, world!".
2445   ClearBreakPoint(bp);
2446   SetBreakPoint(foo, foo_break_position_2);
2447   checks = checks_hh;
2448   foo->Call(env->Global(), 1, argv_foo);
2449 
2450   // Test function with an inner function. The "y=0" is in function barbar
2451   // to provide a break location. For "y=0" the "y" is at position 8 in the
2452   // barbar function therefore setting breakpoint at position 8 will break at
2453   // "y=0" and setting it higher will break after.
2454   v8::Local<v8::Function> bar = CompileFunction(&env,
2455     "y = 0;"
2456     "x = 'Goodbye, world!';"
2457     "function bar(x, b) {"
2458     "  var a;"
2459     "  function barbar() {"
2460     "    y=0; /* To ensure break location.*/"
2461     "    a=x;"
2462     "  };"
2463     "  debug.Debug.clearAllBreakPoints();"
2464     "  barbar();"
2465     "  y=0;a=x;"
2466     "}",
2467     "bar");
2468   const int barbar_break_position = 8;
2469 
2470   // Call bar setting breakpoint before a=x in barbar and undefined as
2471   // parameter.
2472   checks = checks_uu;
2473   v8::Handle<v8::Value> argv_bar_1[2] = {
2474     v8::Undefined(),
2475     v8::Number::New(barbar_break_position)
2476   };
2477   bar->Call(env->Global(), 2, argv_bar_1);
2478 
2479   // Call bar setting breakpoint before a=x in barbar and parameter
2480   // "Hello, world!".
2481   checks = checks_hu;
2482   v8::Handle<v8::Value> argv_bar_2[2] = {
2483     v8::String::New("Hello, world!"),
2484     v8::Number::New(barbar_break_position)
2485   };
2486   bar->Call(env->Global(), 2, argv_bar_2);
2487 
2488   // Call bar setting breakpoint after a=x in barbar and parameter
2489   // "Hello, world!".
2490   checks = checks_hh;
2491   v8::Handle<v8::Value> argv_bar_3[2] = {
2492     v8::String::New("Hello, world!"),
2493     v8::Number::New(barbar_break_position + 1)
2494   };
2495   bar->Call(env->Global(), 2, argv_bar_3);
2496 
2497   v8::Debug::SetDebugEventListener(NULL);
2498   CheckDebuggerUnloaded();
2499 }
2500 
2501 // Copies a C string to a 16-bit string.  Does not check for buffer overflow.
2502 // Does not use the V8 engine to convert strings, so it can be used
2503 // in any thread.  Returns the length of the string.
AsciiToUtf16(const char * input_buffer,uint16_t * output_buffer)2504 int AsciiToUtf16(const char* input_buffer, uint16_t* output_buffer) {
2505   int i;
2506   for (i = 0; input_buffer[i] != '\0'; ++i) {
2507     // ASCII does not use chars > 127, but be careful anyway.
2508     output_buffer[i] = static_cast<unsigned char>(input_buffer[i]);
2509   }
2510   output_buffer[i] = 0;
2511   return i;
2512 }
2513 
2514 // Copies a 16-bit string to a C string by dropping the high byte of
2515 // each character.  Does not check for buffer overflow.
2516 // Can be used in any thread.  Requires string length as an input.
Utf16ToAscii(const uint16_t * input_buffer,int length,char * output_buffer,int output_len=-1)2517 int Utf16ToAscii(const uint16_t* input_buffer, int length,
2518                  char* output_buffer, int output_len = -1) {
2519   if (output_len >= 0) {
2520     if (length > output_len - 1) {
2521       length = output_len - 1;
2522     }
2523   }
2524 
2525   for (int i = 0; i < length; ++i) {
2526     output_buffer[i] = static_cast<char>(input_buffer[i]);
2527   }
2528   output_buffer[length] = '\0';
2529   return length;
2530 }
2531 
2532 
2533 // We match parts of the message to get evaluate result int value.
GetEvaluateStringResult(char * message,char * buffer,int buffer_size)2534 bool GetEvaluateStringResult(char *message, char* buffer, int buffer_size) {
2535   if (strstr(message, "\"command\":\"evaluate\"") == NULL) {
2536     return false;
2537   }
2538   const char* prefix = "\"text\":\"";
2539   char* pos1 = strstr(message, prefix);
2540   if (pos1 == NULL) {
2541     return false;
2542   }
2543   pos1 += strlen(prefix);
2544   char* pos2 = strchr(pos1, '"');
2545   if (pos2 == NULL) {
2546     return false;
2547   }
2548   Vector<char> buf(buffer, buffer_size);
2549   int len = static_cast<int>(pos2 - pos1);
2550   if (len > buffer_size - 1) {
2551     len = buffer_size - 1;
2552   }
2553   OS::StrNCpy(buf, pos1, len);
2554   buffer[buffer_size - 1] = '\0';
2555   return true;
2556 }
2557 
2558 
2559 struct EvaluateResult {
2560   static const int kBufferSize = 20;
2561   char buffer[kBufferSize];
2562 };
2563 
2564 struct DebugProcessDebugMessagesData {
2565   static const int kArraySize = 5;
2566   int counter;
2567   EvaluateResult results[kArraySize];
2568 
resetDebugProcessDebugMessagesData2569   void reset() {
2570     counter = 0;
2571   }
currentDebugProcessDebugMessagesData2572   EvaluateResult* current() {
2573     return &results[counter % kArraySize];
2574   }
nextDebugProcessDebugMessagesData2575   void next() {
2576     counter++;
2577   }
2578 };
2579 
2580 DebugProcessDebugMessagesData process_debug_messages_data;
2581 
DebugProcessDebugMessagesHandler(const uint16_t * message,int length,v8::Debug::ClientData * client_data)2582 static void DebugProcessDebugMessagesHandler(
2583     const uint16_t* message,
2584     int length,
2585     v8::Debug::ClientData* client_data) {
2586 
2587   const int kBufferSize = 100000;
2588   char print_buffer[kBufferSize];
2589   Utf16ToAscii(message, length, print_buffer, kBufferSize);
2590 
2591   EvaluateResult* array_item = process_debug_messages_data.current();
2592 
2593   bool res = GetEvaluateStringResult(print_buffer,
2594                                      array_item->buffer,
2595                                      EvaluateResult::kBufferSize);
2596   if (res) {
2597     process_debug_messages_data.next();
2598   }
2599 }
2600 
2601 // Test that the evaluation of expressions works even from ProcessDebugMessages
2602 // i.e. with empty stack.
TEST(DebugEvaluateWithoutStack)2603 TEST(DebugEvaluateWithoutStack) {
2604   v8::Debug::SetMessageHandler(DebugProcessDebugMessagesHandler);
2605 
2606   v8::HandleScope scope;
2607   DebugLocalContext env;
2608 
2609   const char* source =
2610       "var v1 = 'Pinguin';\n function getAnimal() { return 'Capy' + 'bara'; }";
2611 
2612   v8::Script::Compile(v8::String::New(source))->Run();
2613 
2614   v8::Debug::ProcessDebugMessages();
2615 
2616   const int kBufferSize = 1000;
2617   uint16_t buffer[kBufferSize];
2618 
2619   const char* command_111 = "{\"seq\":111,"
2620       "\"type\":\"request\","
2621       "\"command\":\"evaluate\","
2622       "\"arguments\":{"
2623       "    \"global\":true,"
2624       "    \"expression\":\"v1\",\"disable_break\":true"
2625       "}}";
2626 
2627   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_111, buffer));
2628 
2629   const char* command_112 = "{\"seq\":112,"
2630       "\"type\":\"request\","
2631       "\"command\":\"evaluate\","
2632       "\"arguments\":{"
2633       "    \"global\":true,"
2634       "    \"expression\":\"getAnimal()\",\"disable_break\":true"
2635       "}}";
2636 
2637   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_112, buffer));
2638 
2639   const char* command_113 = "{\"seq\":113,"
2640      "\"type\":\"request\","
2641      "\"command\":\"evaluate\","
2642      "\"arguments\":{"
2643      "    \"global\":true,"
2644      "    \"expression\":\"239 + 566\",\"disable_break\":true"
2645      "}}";
2646 
2647   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_113, buffer));
2648 
2649   v8::Debug::ProcessDebugMessages();
2650 
2651   CHECK_EQ(3, process_debug_messages_data.counter);
2652 
2653   CHECK_EQ(strcmp("Pinguin", process_debug_messages_data.results[0].buffer), 0);
2654   CHECK_EQ(strcmp("Capybara", process_debug_messages_data.results[1].buffer),
2655            0);
2656   CHECK_EQ(strcmp("805", process_debug_messages_data.results[2].buffer), 0);
2657 
2658   v8::Debug::SetMessageHandler(NULL);
2659   v8::Debug::SetDebugEventListener(NULL);
2660   CheckDebuggerUnloaded();
2661 }
2662 
2663 
2664 // Simple test of the stepping mechanism using only store ICs.
TEST(DebugStepLinear)2665 TEST(DebugStepLinear) {
2666   v8::HandleScope scope;
2667   DebugLocalContext env;
2668 
2669   // Create a function for testing stepping.
2670   v8::Local<v8::Function> foo = CompileFunction(&env,
2671                                                 "function foo(){a=1;b=1;c=1;}",
2672                                                 "foo");
2673 
2674   // Run foo to allow it to get optimized.
2675   CompileRun("a=0; b=0; c=0; foo();");
2676 
2677   SetBreakPoint(foo, 3);
2678 
2679   // Register a debug event listener which steps and counts.
2680   v8::Debug::SetDebugEventListener(DebugEventStep);
2681 
2682   step_action = StepIn;
2683   break_point_hit_count = 0;
2684   foo->Call(env->Global(), 0, NULL);
2685 
2686   // With stepping all break locations are hit.
2687   CHECK_EQ(4, break_point_hit_count);
2688 
2689   v8::Debug::SetDebugEventListener(NULL);
2690   CheckDebuggerUnloaded();
2691 
2692   // Register a debug event listener which just counts.
2693   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
2694 
2695   SetBreakPoint(foo, 3);
2696   break_point_hit_count = 0;
2697   foo->Call(env->Global(), 0, NULL);
2698 
2699   // Without stepping only active break points are hit.
2700   CHECK_EQ(1, break_point_hit_count);
2701 
2702   v8::Debug::SetDebugEventListener(NULL);
2703   CheckDebuggerUnloaded();
2704 }
2705 
2706 
2707 // Test of the stepping mechanism for keyed load in a loop.
TEST(DebugStepKeyedLoadLoop)2708 TEST(DebugStepKeyedLoadLoop) {
2709   v8::HandleScope scope;
2710   DebugLocalContext env;
2711 
2712   // Register a debug event listener which steps and counts.
2713   v8::Debug::SetDebugEventListener(DebugEventStep);
2714 
2715   // Create a function for testing stepping of keyed load. The statement 'y=1'
2716   // is there to have more than one breakable statement in the loop, TODO(315).
2717   v8::Local<v8::Function> foo = CompileFunction(
2718       &env,
2719       "function foo(a) {\n"
2720       "  var x;\n"
2721       "  var len = a.length;\n"
2722       "  for (var i = 0; i < len; i++) {\n"
2723       "    y = 1;\n"
2724       "    x = a[i];\n"
2725       "  }\n"
2726       "}\n"
2727       "y=0\n",
2728       "foo");
2729 
2730   // Create array [0,1,2,3,4,5,6,7,8,9]
2731   v8::Local<v8::Array> a = v8::Array::New(10);
2732   for (int i = 0; i < 10; i++) {
2733     a->Set(v8::Number::New(i), v8::Number::New(i));
2734   }
2735 
2736   // Call function without any break points to ensure inlining is in place.
2737   const int kArgc = 1;
2738   v8::Handle<v8::Value> args[kArgc] = { a };
2739   foo->Call(env->Global(), kArgc, args);
2740 
2741   // Set up break point and step through the function.
2742   SetBreakPoint(foo, 3);
2743   step_action = StepNext;
2744   break_point_hit_count = 0;
2745   foo->Call(env->Global(), kArgc, args);
2746 
2747   // With stepping all break locations are hit.
2748   CHECK_EQ(34, break_point_hit_count);
2749 
2750   v8::Debug::SetDebugEventListener(NULL);
2751   CheckDebuggerUnloaded();
2752 }
2753 
2754 
2755 // Test of the stepping mechanism for keyed store in a loop.
TEST(DebugStepKeyedStoreLoop)2756 TEST(DebugStepKeyedStoreLoop) {
2757   v8::HandleScope scope;
2758   DebugLocalContext env;
2759 
2760   // Register a debug event listener which steps and counts.
2761   v8::Debug::SetDebugEventListener(DebugEventStep);
2762 
2763   // Create a function for testing stepping of keyed store. The statement 'y=1'
2764   // is there to have more than one breakable statement in the loop, TODO(315).
2765   v8::Local<v8::Function> foo = CompileFunction(
2766       &env,
2767       "function foo(a) {\n"
2768       "  var len = a.length;\n"
2769       "  for (var i = 0; i < len; i++) {\n"
2770       "    y = 1;\n"
2771       "    a[i] = 42;\n"
2772       "  }\n"
2773       "}\n"
2774       "y=0\n",
2775       "foo");
2776 
2777   // Create array [0,1,2,3,4,5,6,7,8,9]
2778   v8::Local<v8::Array> a = v8::Array::New(10);
2779   for (int i = 0; i < 10; i++) {
2780     a->Set(v8::Number::New(i), v8::Number::New(i));
2781   }
2782 
2783   // Call function without any break points to ensure inlining is in place.
2784   const int kArgc = 1;
2785   v8::Handle<v8::Value> args[kArgc] = { a };
2786   foo->Call(env->Global(), kArgc, args);
2787 
2788   // Set up break point and step through the function.
2789   SetBreakPoint(foo, 3);
2790   step_action = StepNext;
2791   break_point_hit_count = 0;
2792   foo->Call(env->Global(), kArgc, args);
2793 
2794   // With stepping all break locations are hit.
2795   CHECK_EQ(33, break_point_hit_count);
2796 
2797   v8::Debug::SetDebugEventListener(NULL);
2798   CheckDebuggerUnloaded();
2799 }
2800 
2801 
2802 // Test of the stepping mechanism for named load in a loop.
TEST(DebugStepNamedLoadLoop)2803 TEST(DebugStepNamedLoadLoop) {
2804   v8::HandleScope scope;
2805   DebugLocalContext env;
2806 
2807   // Register a debug event listener which steps and counts.
2808   v8::Debug::SetDebugEventListener(DebugEventStep);
2809 
2810   // Create a function for testing stepping of named load.
2811   v8::Local<v8::Function> foo = CompileFunction(
2812       &env,
2813       "function foo() {\n"
2814           "  var a = [];\n"
2815           "  var s = \"\";\n"
2816           "  for (var i = 0; i < 10; i++) {\n"
2817           "    var v = new V(i, i + 1);\n"
2818           "    v.y;\n"
2819           "    a.length;\n"  // Special case: array length.
2820           "    s.length;\n"  // Special case: string length.
2821           "  }\n"
2822           "}\n"
2823           "function V(x, y) {\n"
2824           "  this.x = x;\n"
2825           "  this.y = y;\n"
2826           "}\n",
2827           "foo");
2828 
2829   // Call function without any break points to ensure inlining is in place.
2830   foo->Call(env->Global(), 0, NULL);
2831 
2832   // Set up break point and step through the function.
2833   SetBreakPoint(foo, 4);
2834   step_action = StepNext;
2835   break_point_hit_count = 0;
2836   foo->Call(env->Global(), 0, NULL);
2837 
2838   // With stepping all break locations are hit.
2839   CHECK_EQ(54, break_point_hit_count);
2840 
2841   v8::Debug::SetDebugEventListener(NULL);
2842   CheckDebuggerUnloaded();
2843 }
2844 
2845 
DoDebugStepNamedStoreLoop(int expected)2846 static void DoDebugStepNamedStoreLoop(int expected) {
2847   v8::HandleScope scope;
2848   DebugLocalContext env;
2849 
2850   // Register a debug event listener which steps and counts.
2851   v8::Debug::SetDebugEventListener(DebugEventStep);
2852 
2853   // Create a function for testing stepping of named store.
2854   v8::Local<v8::Function> foo = CompileFunction(
2855       &env,
2856       "function foo() {\n"
2857           "  var a = {a:1};\n"
2858           "  for (var i = 0; i < 10; i++) {\n"
2859           "    a.a = 2\n"
2860           "  }\n"
2861           "}\n",
2862           "foo");
2863 
2864   // Call function without any break points to ensure inlining is in place.
2865   foo->Call(env->Global(), 0, NULL);
2866 
2867   // Set up break point and step through the function.
2868   SetBreakPoint(foo, 3);
2869   step_action = StepNext;
2870   break_point_hit_count = 0;
2871   foo->Call(env->Global(), 0, NULL);
2872 
2873   // With stepping all expected break locations are hit.
2874   CHECK_EQ(expected, break_point_hit_count);
2875 
2876   v8::Debug::SetDebugEventListener(NULL);
2877   CheckDebuggerUnloaded();
2878 }
2879 
2880 
2881 // Test of the stepping mechanism for named load in a loop.
TEST(DebugStepNamedStoreLoop)2882 TEST(DebugStepNamedStoreLoop) {
2883   DoDebugStepNamedStoreLoop(23);
2884 }
2885 
2886 
2887 // Test the stepping mechanism with different ICs.
TEST(DebugStepLinearMixedICs)2888 TEST(DebugStepLinearMixedICs) {
2889   v8::HandleScope scope;
2890   DebugLocalContext env;
2891 
2892   // Register a debug event listener which steps and counts.
2893   v8::Debug::SetDebugEventListener(DebugEventStep);
2894 
2895   // Create a function for testing stepping.
2896   v8::Local<v8::Function> foo = CompileFunction(&env,
2897       "function bar() {};"
2898       "function foo() {"
2899       "  var x;"
2900       "  var index='name';"
2901       "  var y = {};"
2902       "  a=1;b=2;x=a;y[index]=3;x=y[index];bar();}", "foo");
2903 
2904   // Run functions to allow them to get optimized.
2905   CompileRun("a=0; b=0; bar(); foo();");
2906 
2907   SetBreakPoint(foo, 0);
2908 
2909   step_action = StepIn;
2910   break_point_hit_count = 0;
2911   foo->Call(env->Global(), 0, NULL);
2912 
2913   // With stepping all break locations are hit.
2914   CHECK_EQ(11, break_point_hit_count);
2915 
2916   v8::Debug::SetDebugEventListener(NULL);
2917   CheckDebuggerUnloaded();
2918 
2919   // Register a debug event listener which just counts.
2920   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
2921 
2922   SetBreakPoint(foo, 0);
2923   break_point_hit_count = 0;
2924   foo->Call(env->Global(), 0, NULL);
2925 
2926   // Without stepping only active break points are hit.
2927   CHECK_EQ(1, break_point_hit_count);
2928 
2929   v8::Debug::SetDebugEventListener(NULL);
2930   CheckDebuggerUnloaded();
2931 }
2932 
2933 
TEST(DebugStepDeclarations)2934 TEST(DebugStepDeclarations) {
2935   v8::HandleScope scope;
2936   DebugLocalContext env;
2937 
2938   // Register a debug event listener which steps and counts.
2939   v8::Debug::SetDebugEventListener(DebugEventStep);
2940 
2941   // Create a function for testing stepping. Run it to allow it to get
2942   // optimized.
2943   const char* src = "function foo() { "
2944                     "  var a;"
2945                     "  var b = 1;"
2946                     "  var c = foo;"
2947                     "  var d = Math.floor;"
2948                     "  var e = b + d(1.2);"
2949                     "}"
2950                     "foo()";
2951   v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
2952 
2953   SetBreakPoint(foo, 0);
2954 
2955   // Stepping through the declarations.
2956   step_action = StepIn;
2957   break_point_hit_count = 0;
2958   foo->Call(env->Global(), 0, NULL);
2959   CHECK_EQ(6, break_point_hit_count);
2960 
2961   // Get rid of the debug event listener.
2962   v8::Debug::SetDebugEventListener(NULL);
2963   CheckDebuggerUnloaded();
2964 }
2965 
2966 
TEST(DebugStepLocals)2967 TEST(DebugStepLocals) {
2968   v8::HandleScope scope;
2969   DebugLocalContext env;
2970 
2971   // Register a debug event listener which steps and counts.
2972   v8::Debug::SetDebugEventListener(DebugEventStep);
2973 
2974   // Create a function for testing stepping. Run it to allow it to get
2975   // optimized.
2976   const char* src = "function foo() { "
2977                     "  var a,b;"
2978                     "  a = 1;"
2979                     "  b = a + 2;"
2980                     "  b = 1 + 2 + 3;"
2981                     "  a = Math.floor(b);"
2982                     "}"
2983                     "foo()";
2984   v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
2985 
2986   SetBreakPoint(foo, 0);
2987 
2988   // Stepping through the declarations.
2989   step_action = StepIn;
2990   break_point_hit_count = 0;
2991   foo->Call(env->Global(), 0, NULL);
2992   CHECK_EQ(6, break_point_hit_count);
2993 
2994   // Get rid of the debug event listener.
2995   v8::Debug::SetDebugEventListener(NULL);
2996   CheckDebuggerUnloaded();
2997 }
2998 
2999 
TEST(DebugStepIf)3000 TEST(DebugStepIf) {
3001   v8::HandleScope scope;
3002   DebugLocalContext env;
3003 
3004   // Register a debug event listener which steps and counts.
3005   v8::Debug::SetDebugEventListener(DebugEventStep);
3006 
3007   // Create a function for testing stepping. Run it to allow it to get
3008   // optimized.
3009   const int argc = 1;
3010   const char* src = "function foo(x) { "
3011                     "  a = 1;"
3012                     "  if (x) {"
3013                     "    b = 1;"
3014                     "  } else {"
3015                     "    c = 1;"
3016                     "    d = 1;"
3017                     "  }"
3018                     "}"
3019                     "a=0; b=0; c=0; d=0; foo()";
3020   v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3021   SetBreakPoint(foo, 0);
3022 
3023   // Stepping through the true part.
3024   step_action = StepIn;
3025   break_point_hit_count = 0;
3026   v8::Handle<v8::Value> argv_true[argc] = { v8::True() };
3027   foo->Call(env->Global(), argc, argv_true);
3028   CHECK_EQ(4, break_point_hit_count);
3029 
3030   // Stepping through the false part.
3031   step_action = StepIn;
3032   break_point_hit_count = 0;
3033   v8::Handle<v8::Value> argv_false[argc] = { v8::False() };
3034   foo->Call(env->Global(), argc, argv_false);
3035   CHECK_EQ(5, break_point_hit_count);
3036 
3037   // Get rid of the debug event listener.
3038   v8::Debug::SetDebugEventListener(NULL);
3039   CheckDebuggerUnloaded();
3040 }
3041 
3042 
TEST(DebugStepSwitch)3043 TEST(DebugStepSwitch) {
3044   v8::HandleScope scope;
3045   DebugLocalContext env;
3046 
3047   // Register a debug event listener which steps and counts.
3048   v8::Debug::SetDebugEventListener(DebugEventStep);
3049 
3050   // Create a function for testing stepping. Run it to allow it to get
3051   // optimized.
3052   const int argc = 1;
3053   const char* src = "function foo(x) { "
3054                     "  a = 1;"
3055                     "  switch (x) {"
3056                     "    case 1:"
3057                     "      b = 1;"
3058                     "    case 2:"
3059                     "      c = 1;"
3060                     "      break;"
3061                     "    case 3:"
3062                     "      d = 1;"
3063                     "      e = 1;"
3064                     "      f = 1;"
3065                     "      break;"
3066                     "  }"
3067                     "}"
3068                     "a=0; b=0; c=0; d=0; e=0; f=0; foo()";
3069   v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3070   SetBreakPoint(foo, 0);
3071 
3072   // One case with fall-through.
3073   step_action = StepIn;
3074   break_point_hit_count = 0;
3075   v8::Handle<v8::Value> argv_1[argc] = { v8::Number::New(1) };
3076   foo->Call(env->Global(), argc, argv_1);
3077   CHECK_EQ(6, break_point_hit_count);
3078 
3079   // Another case.
3080   step_action = StepIn;
3081   break_point_hit_count = 0;
3082   v8::Handle<v8::Value> argv_2[argc] = { v8::Number::New(2) };
3083   foo->Call(env->Global(), argc, argv_2);
3084   CHECK_EQ(5, break_point_hit_count);
3085 
3086   // Last case.
3087   step_action = StepIn;
3088   break_point_hit_count = 0;
3089   v8::Handle<v8::Value> argv_3[argc] = { v8::Number::New(3) };
3090   foo->Call(env->Global(), argc, argv_3);
3091   CHECK_EQ(7, break_point_hit_count);
3092 
3093   // Get rid of the debug event listener.
3094   v8::Debug::SetDebugEventListener(NULL);
3095   CheckDebuggerUnloaded();
3096 }
3097 
3098 
TEST(DebugStepWhile)3099 TEST(DebugStepWhile) {
3100   v8::HandleScope scope;
3101   DebugLocalContext env;
3102 
3103   // Register a debug event listener which steps and counts.
3104   v8::Debug::SetDebugEventListener(DebugEventStep);
3105 
3106   // Create a function for testing stepping. Run it to allow it to get
3107   // optimized.
3108   const int argc = 1;
3109   const char* src = "function foo(x) { "
3110                     "  var a = 0;"
3111                     "  while (a < x) {"
3112                     "    a++;"
3113                     "  }"
3114                     "}"
3115                     "foo()";
3116   v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3117   SetBreakPoint(foo, 8);  // "var a = 0;"
3118 
3119   // Looping 10 times.
3120   step_action = StepIn;
3121   break_point_hit_count = 0;
3122   v8::Handle<v8::Value> argv_10[argc] = { v8::Number::New(10) };
3123   foo->Call(env->Global(), argc, argv_10);
3124   CHECK_EQ(22, break_point_hit_count);
3125 
3126   // Looping 100 times.
3127   step_action = StepIn;
3128   break_point_hit_count = 0;
3129   v8::Handle<v8::Value> argv_100[argc] = { v8::Number::New(100) };
3130   foo->Call(env->Global(), argc, argv_100);
3131   CHECK_EQ(202, break_point_hit_count);
3132 
3133   // Get rid of the debug event listener.
3134   v8::Debug::SetDebugEventListener(NULL);
3135   CheckDebuggerUnloaded();
3136 }
3137 
3138 
TEST(DebugStepDoWhile)3139 TEST(DebugStepDoWhile) {
3140   v8::HandleScope scope;
3141   DebugLocalContext env;
3142 
3143   // Register a debug event listener which steps and counts.
3144   v8::Debug::SetDebugEventListener(DebugEventStep);
3145 
3146   // Create a function for testing stepping. Run it to allow it to get
3147   // optimized.
3148   const int argc = 1;
3149   const char* src = "function foo(x) { "
3150                     "  var a = 0;"
3151                     "  do {"
3152                     "    a++;"
3153                     "  } while (a < x)"
3154                     "}"
3155                     "foo()";
3156   v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3157   SetBreakPoint(foo, 8);  // "var a = 0;"
3158 
3159   // Looping 10 times.
3160   step_action = StepIn;
3161   break_point_hit_count = 0;
3162   v8::Handle<v8::Value> argv_10[argc] = { v8::Number::New(10) };
3163   foo->Call(env->Global(), argc, argv_10);
3164   CHECK_EQ(22, break_point_hit_count);
3165 
3166   // Looping 100 times.
3167   step_action = StepIn;
3168   break_point_hit_count = 0;
3169   v8::Handle<v8::Value> argv_100[argc] = { v8::Number::New(100) };
3170   foo->Call(env->Global(), argc, argv_100);
3171   CHECK_EQ(202, break_point_hit_count);
3172 
3173   // Get rid of the debug event listener.
3174   v8::Debug::SetDebugEventListener(NULL);
3175   CheckDebuggerUnloaded();
3176 }
3177 
3178 
TEST(DebugStepFor)3179 TEST(DebugStepFor) {
3180   v8::HandleScope scope;
3181   DebugLocalContext env;
3182 
3183   // Register a debug event listener which steps and counts.
3184   v8::Debug::SetDebugEventListener(DebugEventStep);
3185 
3186   // Create a function for testing stepping. Run it to allow it to get
3187   // optimized.
3188   const int argc = 1;
3189   const char* src = "function foo(x) { "
3190                     "  a = 1;"
3191                     "  for (i = 0; i < x; i++) {"
3192                     "    b = 1;"
3193                     "  }"
3194                     "}"
3195                     "a=0; b=0; i=0; foo()";
3196   v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3197 
3198   SetBreakPoint(foo, 8);  // "a = 1;"
3199 
3200   // Looping 10 times.
3201   step_action = StepIn;
3202   break_point_hit_count = 0;
3203   v8::Handle<v8::Value> argv_10[argc] = { v8::Number::New(10) };
3204   foo->Call(env->Global(), argc, argv_10);
3205   CHECK_EQ(23, break_point_hit_count);
3206 
3207   // Looping 100 times.
3208   step_action = StepIn;
3209   break_point_hit_count = 0;
3210   v8::Handle<v8::Value> argv_100[argc] = { v8::Number::New(100) };
3211   foo->Call(env->Global(), argc, argv_100);
3212   CHECK_EQ(203, break_point_hit_count);
3213 
3214   // Get rid of the debug event listener.
3215   v8::Debug::SetDebugEventListener(NULL);
3216   CheckDebuggerUnloaded();
3217 }
3218 
3219 
TEST(DebugStepForContinue)3220 TEST(DebugStepForContinue) {
3221   v8::HandleScope scope;
3222   DebugLocalContext env;
3223 
3224   // Register a debug event listener which steps and counts.
3225   v8::Debug::SetDebugEventListener(DebugEventStep);
3226 
3227   // Create a function for testing stepping. Run it to allow it to get
3228   // optimized.
3229   const int argc = 1;
3230   const char* src = "function foo(x) { "
3231                     "  var a = 0;"
3232                     "  var b = 0;"
3233                     "  var c = 0;"
3234                     "  for (var i = 0; i < x; i++) {"
3235                     "    a++;"
3236                     "    if (a % 2 == 0) continue;"
3237                     "    b++;"
3238                     "    c++;"
3239                     "  }"
3240                     "  return b;"
3241                     "}"
3242                     "foo()";
3243   v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3244   v8::Handle<v8::Value> result;
3245   SetBreakPoint(foo, 8);  // "var a = 0;"
3246 
3247   // Each loop generates 4 or 5 steps depending on whether a is equal.
3248 
3249   // Looping 10 times.
3250   step_action = StepIn;
3251   break_point_hit_count = 0;
3252   v8::Handle<v8::Value> argv_10[argc] = { v8::Number::New(10) };
3253   result = foo->Call(env->Global(), argc, argv_10);
3254   CHECK_EQ(5, result->Int32Value());
3255   CHECK_EQ(51, break_point_hit_count);
3256 
3257   // Looping 100 times.
3258   step_action = StepIn;
3259   break_point_hit_count = 0;
3260   v8::Handle<v8::Value> argv_100[argc] = { v8::Number::New(100) };
3261   result = foo->Call(env->Global(), argc, argv_100);
3262   CHECK_EQ(50, result->Int32Value());
3263   CHECK_EQ(456, break_point_hit_count);
3264 
3265   // Get rid of the debug event listener.
3266   v8::Debug::SetDebugEventListener(NULL);
3267   CheckDebuggerUnloaded();
3268 }
3269 
3270 
TEST(DebugStepForBreak)3271 TEST(DebugStepForBreak) {
3272   v8::HandleScope scope;
3273   DebugLocalContext env;
3274 
3275   // Register a debug event listener which steps and counts.
3276   v8::Debug::SetDebugEventListener(DebugEventStep);
3277 
3278   // Create a function for testing stepping. Run it to allow it to get
3279   // optimized.
3280   const int argc = 1;
3281   const char* src = "function foo(x) { "
3282                     "  var a = 0;"
3283                     "  var b = 0;"
3284                     "  var c = 0;"
3285                     "  for (var i = 0; i < 1000; i++) {"
3286                     "    a++;"
3287                     "    if (a == x) break;"
3288                     "    b++;"
3289                     "    c++;"
3290                     "  }"
3291                     "  return b;"
3292                     "}"
3293                     "foo()";
3294   v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3295   v8::Handle<v8::Value> result;
3296   SetBreakPoint(foo, 8);  // "var a = 0;"
3297 
3298   // Each loop generates 5 steps except for the last (when break is executed)
3299   // which only generates 4.
3300 
3301   // Looping 10 times.
3302   step_action = StepIn;
3303   break_point_hit_count = 0;
3304   v8::Handle<v8::Value> argv_10[argc] = { v8::Number::New(10) };
3305   result = foo->Call(env->Global(), argc, argv_10);
3306   CHECK_EQ(9, result->Int32Value());
3307   CHECK_EQ(54, break_point_hit_count);
3308 
3309   // Looping 100 times.
3310   step_action = StepIn;
3311   break_point_hit_count = 0;
3312   v8::Handle<v8::Value> argv_100[argc] = { v8::Number::New(100) };
3313   result = foo->Call(env->Global(), argc, argv_100);
3314   CHECK_EQ(99, result->Int32Value());
3315   CHECK_EQ(504, break_point_hit_count);
3316 
3317   // Get rid of the debug event listener.
3318   v8::Debug::SetDebugEventListener(NULL);
3319   CheckDebuggerUnloaded();
3320 }
3321 
3322 
TEST(DebugStepForIn)3323 TEST(DebugStepForIn) {
3324   v8::HandleScope scope;
3325   DebugLocalContext env;
3326 
3327   // Register a debug event listener which steps and counts.
3328   v8::Debug::SetDebugEventListener(DebugEventStep);
3329 
3330   // Create a function for testing stepping. Run it to allow it to get
3331   // optimized.
3332   v8::Local<v8::Function> foo;
3333   const char* src_1 = "function foo() { "
3334                       "  var a = [1, 2];"
3335                       "  for (x in a) {"
3336                       "    b = 0;"
3337                       "  }"
3338                       "}"
3339                       "foo()";
3340   foo = CompileFunction(&env, src_1, "foo");
3341   SetBreakPoint(foo, 0);  // "var a = ..."
3342 
3343   step_action = StepIn;
3344   break_point_hit_count = 0;
3345   foo->Call(env->Global(), 0, NULL);
3346   CHECK_EQ(6, break_point_hit_count);
3347 
3348   // Create a function for testing stepping. Run it to allow it to get
3349   // optimized.
3350   const char* src_2 = "function foo() { "
3351                       "  var a = {a:[1, 2, 3]};"
3352                       "  for (x in a.a) {"
3353                       "    b = 0;"
3354                       "  }"
3355                       "}"
3356                       "foo()";
3357   foo = CompileFunction(&env, src_2, "foo");
3358   SetBreakPoint(foo, 0);  // "var a = ..."
3359 
3360   step_action = StepIn;
3361   break_point_hit_count = 0;
3362   foo->Call(env->Global(), 0, NULL);
3363   CHECK_EQ(8, break_point_hit_count);
3364 
3365   // Get rid of the debug event listener.
3366   v8::Debug::SetDebugEventListener(NULL);
3367   CheckDebuggerUnloaded();
3368 }
3369 
3370 
TEST(DebugStepWith)3371 TEST(DebugStepWith) {
3372   v8::HandleScope scope;
3373   DebugLocalContext env;
3374 
3375   // Register a debug event listener which steps and counts.
3376   v8::Debug::SetDebugEventListener(DebugEventStep);
3377 
3378   // Create a function for testing stepping. Run it to allow it to get
3379   // optimized.
3380   const char* src = "function foo(x) { "
3381                     "  var a = {};"
3382                     "  with (a) {}"
3383                     "  with (b) {}"
3384                     "}"
3385                     "foo()";
3386   env->Global()->Set(v8::String::New("b"), v8::Object::New());
3387   v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3388   v8::Handle<v8::Value> result;
3389   SetBreakPoint(foo, 8);  // "var a = {};"
3390 
3391   step_action = StepIn;
3392   break_point_hit_count = 0;
3393   foo->Call(env->Global(), 0, NULL);
3394   CHECK_EQ(4, break_point_hit_count);
3395 
3396   // Get rid of the debug event listener.
3397   v8::Debug::SetDebugEventListener(NULL);
3398   CheckDebuggerUnloaded();
3399 }
3400 
3401 
TEST(DebugConditional)3402 TEST(DebugConditional) {
3403   v8::HandleScope scope;
3404   DebugLocalContext env;
3405 
3406   // Register a debug event listener which steps and counts.
3407   v8::Debug::SetDebugEventListener(DebugEventStep);
3408 
3409   // Create a function for testing stepping. Run it to allow it to get
3410   // optimized.
3411   const char* src = "function foo(x) { "
3412                     "  var a;"
3413                     "  a = x ? 1 : 2;"
3414                     "  return a;"
3415                     "}"
3416                     "foo()";
3417   v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3418   SetBreakPoint(foo, 0);  // "var a;"
3419 
3420   step_action = StepIn;
3421   break_point_hit_count = 0;
3422   foo->Call(env->Global(), 0, NULL);
3423   CHECK_EQ(5, break_point_hit_count);
3424 
3425   step_action = StepIn;
3426   break_point_hit_count = 0;
3427   const int argc = 1;
3428   v8::Handle<v8::Value> argv_true[argc] = { v8::True() };
3429   foo->Call(env->Global(), argc, argv_true);
3430   CHECK_EQ(5, break_point_hit_count);
3431 
3432   // Get rid of the debug event listener.
3433   v8::Debug::SetDebugEventListener(NULL);
3434   CheckDebuggerUnloaded();
3435 }
3436 
3437 
TEST(StepInOutSimple)3438 TEST(StepInOutSimple) {
3439   v8::HandleScope scope;
3440   DebugLocalContext env;
3441 
3442   // Create a function for checking the function when hitting a break point.
3443   frame_function_name = CompileFunction(&env,
3444                                         frame_function_name_source,
3445                                         "frame_function_name");
3446 
3447   // Register a debug event listener which steps and counts.
3448   v8::Debug::SetDebugEventListener(DebugEventStepSequence);
3449 
3450   // Create a function for testing stepping. Run it to allow it to get
3451   // optimized.
3452   const char* src = "function a() {b();c();}; "
3453                     "function b() {c();}; "
3454                     "function c() {}; "
3455                     "a(); b(); c()";
3456   v8::Local<v8::Function> a = CompileFunction(&env, src, "a");
3457   SetBreakPoint(a, 0);
3458 
3459   // Step through invocation of a with step in.
3460   step_action = StepIn;
3461   break_point_hit_count = 0;
3462   expected_step_sequence = "abcbaca";
3463   a->Call(env->Global(), 0, NULL);
3464   CHECK_EQ(StrLength(expected_step_sequence),
3465            break_point_hit_count);
3466 
3467   // Step through invocation of a with step next.
3468   step_action = StepNext;
3469   break_point_hit_count = 0;
3470   expected_step_sequence = "aaa";
3471   a->Call(env->Global(), 0, NULL);
3472   CHECK_EQ(StrLength(expected_step_sequence),
3473            break_point_hit_count);
3474 
3475   // Step through invocation of a with step out.
3476   step_action = StepOut;
3477   break_point_hit_count = 0;
3478   expected_step_sequence = "a";
3479   a->Call(env->Global(), 0, NULL);
3480   CHECK_EQ(StrLength(expected_step_sequence),
3481            break_point_hit_count);
3482 
3483   // Get rid of the debug event listener.
3484   v8::Debug::SetDebugEventListener(NULL);
3485   CheckDebuggerUnloaded();
3486 }
3487 
3488 
TEST(StepInOutTree)3489 TEST(StepInOutTree) {
3490   v8::HandleScope scope;
3491   DebugLocalContext env;
3492 
3493   // Create a function for checking the function when hitting a break point.
3494   frame_function_name = CompileFunction(&env,
3495                                         frame_function_name_source,
3496                                         "frame_function_name");
3497 
3498   // Register a debug event listener which steps and counts.
3499   v8::Debug::SetDebugEventListener(DebugEventStepSequence);
3500 
3501   // Create a function for testing stepping. Run it to allow it to get
3502   // optimized.
3503   const char* src = "function a() {b(c(d()),d());c(d());d()}; "
3504                     "function b(x,y) {c();}; "
3505                     "function c(x) {}; "
3506                     "function d() {}; "
3507                     "a(); b(); c(); d()";
3508   v8::Local<v8::Function> a = CompileFunction(&env, src, "a");
3509   SetBreakPoint(a, 0);
3510 
3511   // Step through invocation of a with step in.
3512   step_action = StepIn;
3513   break_point_hit_count = 0;
3514   expected_step_sequence = "adacadabcbadacada";
3515   a->Call(env->Global(), 0, NULL);
3516   CHECK_EQ(StrLength(expected_step_sequence),
3517            break_point_hit_count);
3518 
3519   // Step through invocation of a with step next.
3520   step_action = StepNext;
3521   break_point_hit_count = 0;
3522   expected_step_sequence = "aaaa";
3523   a->Call(env->Global(), 0, NULL);
3524   CHECK_EQ(StrLength(expected_step_sequence),
3525            break_point_hit_count);
3526 
3527   // Step through invocation of a with step out.
3528   step_action = StepOut;
3529   break_point_hit_count = 0;
3530   expected_step_sequence = "a";
3531   a->Call(env->Global(), 0, NULL);
3532   CHECK_EQ(StrLength(expected_step_sequence),
3533            break_point_hit_count);
3534 
3535   // Get rid of the debug event listener.
3536   v8::Debug::SetDebugEventListener(NULL);
3537   CheckDebuggerUnloaded(true);
3538 }
3539 
3540 
TEST(StepInOutBranch)3541 TEST(StepInOutBranch) {
3542   v8::HandleScope scope;
3543   DebugLocalContext env;
3544 
3545   // Create a function for checking the function when hitting a break point.
3546   frame_function_name = CompileFunction(&env,
3547                                         frame_function_name_source,
3548                                         "frame_function_name");
3549 
3550   // Register a debug event listener which steps and counts.
3551   v8::Debug::SetDebugEventListener(DebugEventStepSequence);
3552 
3553   // Create a function for testing stepping. Run it to allow it to get
3554   // optimized.
3555   const char* src = "function a() {b(false);c();}; "
3556                     "function b(x) {if(x){c();};}; "
3557                     "function c() {}; "
3558                     "a(); b(); c()";
3559   v8::Local<v8::Function> a = CompileFunction(&env, src, "a");
3560   SetBreakPoint(a, 0);
3561 
3562   // Step through invocation of a.
3563   step_action = StepIn;
3564   break_point_hit_count = 0;
3565   expected_step_sequence = "abbaca";
3566   a->Call(env->Global(), 0, NULL);
3567   CHECK_EQ(StrLength(expected_step_sequence),
3568            break_point_hit_count);
3569 
3570   // Get rid of the debug event listener.
3571   v8::Debug::SetDebugEventListener(NULL);
3572   CheckDebuggerUnloaded();
3573 }
3574 
3575 
3576 // Test that step in does not step into native functions.
TEST(DebugStepNatives)3577 TEST(DebugStepNatives) {
3578   v8::HandleScope scope;
3579   DebugLocalContext env;
3580 
3581   // Create a function for testing stepping.
3582   v8::Local<v8::Function> foo = CompileFunction(
3583       &env,
3584       "function foo(){debugger;Math.sin(1);}",
3585       "foo");
3586 
3587   // Register a debug event listener which steps and counts.
3588   v8::Debug::SetDebugEventListener(DebugEventStep);
3589 
3590   step_action = StepIn;
3591   break_point_hit_count = 0;
3592   foo->Call(env->Global(), 0, NULL);
3593 
3594   // With stepping all break locations are hit.
3595   CHECK_EQ(3, break_point_hit_count);
3596 
3597   v8::Debug::SetDebugEventListener(NULL);
3598   CheckDebuggerUnloaded();
3599 
3600   // Register a debug event listener which just counts.
3601   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
3602 
3603   break_point_hit_count = 0;
3604   foo->Call(env->Global(), 0, NULL);
3605 
3606   // Without stepping only active break points are hit.
3607   CHECK_EQ(1, break_point_hit_count);
3608 
3609   v8::Debug::SetDebugEventListener(NULL);
3610   CheckDebuggerUnloaded();
3611 }
3612 
3613 
3614 // Test that step in works with function.apply.
TEST(DebugStepFunctionApply)3615 TEST(DebugStepFunctionApply) {
3616   v8::HandleScope scope;
3617   DebugLocalContext env;
3618 
3619   // Create a function for testing stepping.
3620   v8::Local<v8::Function> foo = CompileFunction(
3621       &env,
3622       "function bar(x, y, z) { if (x == 1) { a = y; b = z; } }"
3623       "function foo(){ debugger; bar.apply(this, [1,2,3]); }",
3624       "foo");
3625 
3626   // Register a debug event listener which steps and counts.
3627   v8::Debug::SetDebugEventListener(DebugEventStep);
3628 
3629   step_action = StepIn;
3630   break_point_hit_count = 0;
3631   foo->Call(env->Global(), 0, NULL);
3632 
3633   // With stepping all break locations are hit.
3634   CHECK_EQ(7, break_point_hit_count);
3635 
3636   v8::Debug::SetDebugEventListener(NULL);
3637   CheckDebuggerUnloaded();
3638 
3639   // Register a debug event listener which just counts.
3640   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
3641 
3642   break_point_hit_count = 0;
3643   foo->Call(env->Global(), 0, NULL);
3644 
3645   // Without stepping only the debugger statement is hit.
3646   CHECK_EQ(1, break_point_hit_count);
3647 
3648   v8::Debug::SetDebugEventListener(NULL);
3649   CheckDebuggerUnloaded();
3650 }
3651 
3652 
3653 // Test that step in works with function.call.
TEST(DebugStepFunctionCall)3654 TEST(DebugStepFunctionCall) {
3655   v8::HandleScope scope;
3656   DebugLocalContext env;
3657 
3658   // Create a function for testing stepping.
3659   v8::Local<v8::Function> foo = CompileFunction(
3660       &env,
3661       "function bar(x, y, z) { if (x == 1) { a = y; b = z; } }"
3662       "function foo(a){ debugger;"
3663       "                 if (a) {"
3664       "                   bar.call(this, 1, 2, 3);"
3665       "                 } else {"
3666       "                   bar.call(this, 0);"
3667       "                 }"
3668       "}",
3669       "foo");
3670 
3671   // Register a debug event listener which steps and counts.
3672   v8::Debug::SetDebugEventListener(DebugEventStep);
3673   step_action = StepIn;
3674 
3675   // Check stepping where the if condition in bar is false.
3676   break_point_hit_count = 0;
3677   foo->Call(env->Global(), 0, NULL);
3678   CHECK_EQ(6, break_point_hit_count);
3679 
3680   // Check stepping where the if condition in bar is true.
3681   break_point_hit_count = 0;
3682   const int argc = 1;
3683   v8::Handle<v8::Value> argv[argc] = { v8::True() };
3684   foo->Call(env->Global(), argc, argv);
3685   CHECK_EQ(8, break_point_hit_count);
3686 
3687   v8::Debug::SetDebugEventListener(NULL);
3688   CheckDebuggerUnloaded();
3689 
3690   // Register a debug event listener which just counts.
3691   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
3692 
3693   break_point_hit_count = 0;
3694   foo->Call(env->Global(), 0, NULL);
3695 
3696   // Without stepping only the debugger statement is hit.
3697   CHECK_EQ(1, break_point_hit_count);
3698 
3699   v8::Debug::SetDebugEventListener(NULL);
3700   CheckDebuggerUnloaded();
3701 }
3702 
3703 
3704 // Tests that breakpoint will be hit if it's set in script.
TEST(PauseInScript)3705 TEST(PauseInScript) {
3706   v8::HandleScope scope;
3707   DebugLocalContext env;
3708   env.ExposeDebug();
3709 
3710   // Register a debug event listener which counts.
3711   v8::Debug::SetDebugEventListener(DebugEventCounter);
3712 
3713   // Create a script that returns a function.
3714   const char* src = "(function (evt) {})";
3715   const char* script_name = "StepInHandlerTest";
3716 
3717   // Set breakpoint in the script.
3718   SetScriptBreakPointByNameFromJS(script_name, 0, -1);
3719   break_point_hit_count = 0;
3720 
3721   v8::ScriptOrigin origin(v8::String::New(script_name), v8::Integer::New(0));
3722   v8::Handle<v8::Script> script = v8::Script::Compile(v8::String::New(src),
3723                                                       &origin);
3724   v8::Local<v8::Value> r = script->Run();
3725 
3726   CHECK(r->IsFunction());
3727   CHECK_EQ(1, break_point_hit_count);
3728 
3729   // Get rid of the debug event listener.
3730   v8::Debug::SetDebugEventListener(NULL);
3731   CheckDebuggerUnloaded();
3732 }
3733 
3734 
3735 // Test break on exceptions. For each exception break combination the number
3736 // of debug event exception callbacks and message callbacks are collected. The
3737 // number of debug event exception callbacks are used to check that the
3738 // debugger is called correctly and the number of message callbacks is used to
3739 // check that uncaught exceptions are still returned even if there is a break
3740 // for them.
TEST(BreakOnException)3741 TEST(BreakOnException) {
3742   v8::HandleScope scope;
3743   DebugLocalContext env;
3744   env.ExposeDebug();
3745 
3746   v8::internal::Isolate::Current()->TraceException(false);
3747 
3748   // Create functions for testing break on exception.
3749   CompileFunction(&env, "function throws(){throw 1;}", "throws");
3750   v8::Local<v8::Function> caught =
3751       CompileFunction(&env,
3752                       "function caught(){try {throws();} catch(e) {};}",
3753                       "caught");
3754   v8::Local<v8::Function> notCaught =
3755       CompileFunction(&env, "function notCaught(){throws();}", "notCaught");
3756 
3757   v8::V8::AddMessageListener(MessageCallbackCount);
3758   v8::Debug::SetDebugEventListener(DebugEventCounter);
3759 
3760   // Initial state should be no break on exceptions.
3761   DebugEventCounterClear();
3762   MessageCallbackCountClear();
3763   caught->Call(env->Global(), 0, NULL);
3764   CHECK_EQ(0, exception_hit_count);
3765   CHECK_EQ(0, uncaught_exception_hit_count);
3766   CHECK_EQ(0, message_callback_count);
3767   notCaught->Call(env->Global(), 0, NULL);
3768   CHECK_EQ(0, exception_hit_count);
3769   CHECK_EQ(0, uncaught_exception_hit_count);
3770   CHECK_EQ(1, message_callback_count);
3771 
3772   // No break on exception
3773   DebugEventCounterClear();
3774   MessageCallbackCountClear();
3775   ChangeBreakOnException(false, false);
3776   caught->Call(env->Global(), 0, NULL);
3777   CHECK_EQ(0, exception_hit_count);
3778   CHECK_EQ(0, uncaught_exception_hit_count);
3779   CHECK_EQ(0, message_callback_count);
3780   notCaught->Call(env->Global(), 0, NULL);
3781   CHECK_EQ(0, exception_hit_count);
3782   CHECK_EQ(0, uncaught_exception_hit_count);
3783   CHECK_EQ(1, message_callback_count);
3784 
3785   // Break on uncaught exception
3786   DebugEventCounterClear();
3787   MessageCallbackCountClear();
3788   ChangeBreakOnException(false, true);
3789   caught->Call(env->Global(), 0, NULL);
3790   CHECK_EQ(0, exception_hit_count);
3791   CHECK_EQ(0, uncaught_exception_hit_count);
3792   CHECK_EQ(0, message_callback_count);
3793   notCaught->Call(env->Global(), 0, NULL);
3794   CHECK_EQ(1, exception_hit_count);
3795   CHECK_EQ(1, uncaught_exception_hit_count);
3796   CHECK_EQ(1, message_callback_count);
3797 
3798   // Break on exception and uncaught exception
3799   DebugEventCounterClear();
3800   MessageCallbackCountClear();
3801   ChangeBreakOnException(true, true);
3802   caught->Call(env->Global(), 0, NULL);
3803   CHECK_EQ(1, exception_hit_count);
3804   CHECK_EQ(0, uncaught_exception_hit_count);
3805   CHECK_EQ(0, message_callback_count);
3806   notCaught->Call(env->Global(), 0, NULL);
3807   CHECK_EQ(2, exception_hit_count);
3808   CHECK_EQ(1, uncaught_exception_hit_count);
3809   CHECK_EQ(1, message_callback_count);
3810 
3811   // Break on exception
3812   DebugEventCounterClear();
3813   MessageCallbackCountClear();
3814   ChangeBreakOnException(true, false);
3815   caught->Call(env->Global(), 0, NULL);
3816   CHECK_EQ(1, exception_hit_count);
3817   CHECK_EQ(0, uncaught_exception_hit_count);
3818   CHECK_EQ(0, message_callback_count);
3819   notCaught->Call(env->Global(), 0, NULL);
3820   CHECK_EQ(2, exception_hit_count);
3821   CHECK_EQ(1, uncaught_exception_hit_count);
3822   CHECK_EQ(1, message_callback_count);
3823 
3824   // No break on exception using JavaScript
3825   DebugEventCounterClear();
3826   MessageCallbackCountClear();
3827   ChangeBreakOnExceptionFromJS(false, false);
3828   caught->Call(env->Global(), 0, NULL);
3829   CHECK_EQ(0, exception_hit_count);
3830   CHECK_EQ(0, uncaught_exception_hit_count);
3831   CHECK_EQ(0, message_callback_count);
3832   notCaught->Call(env->Global(), 0, NULL);
3833   CHECK_EQ(0, exception_hit_count);
3834   CHECK_EQ(0, uncaught_exception_hit_count);
3835   CHECK_EQ(1, message_callback_count);
3836 
3837   // Break on uncaught exception using JavaScript
3838   DebugEventCounterClear();
3839   MessageCallbackCountClear();
3840   ChangeBreakOnExceptionFromJS(false, true);
3841   caught->Call(env->Global(), 0, NULL);
3842   CHECK_EQ(0, exception_hit_count);
3843   CHECK_EQ(0, uncaught_exception_hit_count);
3844   CHECK_EQ(0, message_callback_count);
3845   notCaught->Call(env->Global(), 0, NULL);
3846   CHECK_EQ(1, exception_hit_count);
3847   CHECK_EQ(1, uncaught_exception_hit_count);
3848   CHECK_EQ(1, message_callback_count);
3849 
3850   // Break on exception and uncaught exception using JavaScript
3851   DebugEventCounterClear();
3852   MessageCallbackCountClear();
3853   ChangeBreakOnExceptionFromJS(true, true);
3854   caught->Call(env->Global(), 0, NULL);
3855   CHECK_EQ(1, exception_hit_count);
3856   CHECK_EQ(0, message_callback_count);
3857   CHECK_EQ(0, uncaught_exception_hit_count);
3858   notCaught->Call(env->Global(), 0, NULL);
3859   CHECK_EQ(2, exception_hit_count);
3860   CHECK_EQ(1, uncaught_exception_hit_count);
3861   CHECK_EQ(1, message_callback_count);
3862 
3863   // Break on exception using JavaScript
3864   DebugEventCounterClear();
3865   MessageCallbackCountClear();
3866   ChangeBreakOnExceptionFromJS(true, false);
3867   caught->Call(env->Global(), 0, NULL);
3868   CHECK_EQ(1, exception_hit_count);
3869   CHECK_EQ(0, uncaught_exception_hit_count);
3870   CHECK_EQ(0, message_callback_count);
3871   notCaught->Call(env->Global(), 0, NULL);
3872   CHECK_EQ(2, exception_hit_count);
3873   CHECK_EQ(1, uncaught_exception_hit_count);
3874   CHECK_EQ(1, message_callback_count);
3875 
3876   v8::Debug::SetDebugEventListener(NULL);
3877   CheckDebuggerUnloaded();
3878   v8::V8::RemoveMessageListeners(MessageCallbackCount);
3879 }
3880 
3881 
3882 // Test break on exception from compiler errors. When compiling using
3883 // v8::Script::Compile there is no JavaScript stack whereas when compiling using
3884 // eval there are JavaScript frames.
TEST(BreakOnCompileException)3885 TEST(BreakOnCompileException) {
3886   v8::HandleScope scope;
3887   DebugLocalContext env;
3888 
3889   // For this test, we want to break on uncaught exceptions:
3890   ChangeBreakOnException(false, true);
3891 
3892   v8::internal::Isolate::Current()->TraceException(false);
3893 
3894   // Create a function for checking the function when hitting a break point.
3895   frame_count = CompileFunction(&env, frame_count_source, "frame_count");
3896 
3897   v8::V8::AddMessageListener(MessageCallbackCount);
3898   v8::Debug::SetDebugEventListener(DebugEventCounter);
3899 
3900   DebugEventCounterClear();
3901   MessageCallbackCountClear();
3902 
3903   // Check initial state.
3904   CHECK_EQ(0, exception_hit_count);
3905   CHECK_EQ(0, uncaught_exception_hit_count);
3906   CHECK_EQ(0, message_callback_count);
3907   CHECK_EQ(-1, last_js_stack_height);
3908 
3909   // Throws SyntaxError: Unexpected end of input
3910   v8::Script::Compile(v8::String::New("+++"));
3911   CHECK_EQ(1, exception_hit_count);
3912   CHECK_EQ(1, uncaught_exception_hit_count);
3913   CHECK_EQ(1, message_callback_count);
3914   CHECK_EQ(0, last_js_stack_height);  // No JavaScript stack.
3915 
3916   // Throws SyntaxError: Unexpected identifier
3917   v8::Script::Compile(v8::String::New("x x"));
3918   CHECK_EQ(2, exception_hit_count);
3919   CHECK_EQ(2, uncaught_exception_hit_count);
3920   CHECK_EQ(2, message_callback_count);
3921   CHECK_EQ(0, last_js_stack_height);  // No JavaScript stack.
3922 
3923   // Throws SyntaxError: Unexpected end of input
3924   v8::Script::Compile(v8::String::New("eval('+++')"))->Run();
3925   CHECK_EQ(3, exception_hit_count);
3926   CHECK_EQ(3, uncaught_exception_hit_count);
3927   CHECK_EQ(3, message_callback_count);
3928   CHECK_EQ(1, last_js_stack_height);
3929 
3930   // Throws SyntaxError: Unexpected identifier
3931   v8::Script::Compile(v8::String::New("eval('x x')"))->Run();
3932   CHECK_EQ(4, exception_hit_count);
3933   CHECK_EQ(4, uncaught_exception_hit_count);
3934   CHECK_EQ(4, message_callback_count);
3935   CHECK_EQ(1, last_js_stack_height);
3936 }
3937 
3938 
TEST(StepWithException)3939 TEST(StepWithException) {
3940   v8::HandleScope scope;
3941   DebugLocalContext env;
3942 
3943   // For this test, we want to break on uncaught exceptions:
3944   ChangeBreakOnException(false, true);
3945 
3946   // Create a function for checking the function when hitting a break point.
3947   frame_function_name = CompileFunction(&env,
3948                                         frame_function_name_source,
3949                                         "frame_function_name");
3950 
3951   // Register a debug event listener which steps and counts.
3952   v8::Debug::SetDebugEventListener(DebugEventStepSequence);
3953 
3954   // Create functions for testing stepping.
3955   const char* src = "function a() { n(); }; "
3956                     "function b() { c(); }; "
3957                     "function c() { n(); }; "
3958                     "function d() { x = 1; try { e(); } catch(x) { x = 2; } }; "
3959                     "function e() { n(); }; "
3960                     "function f() { x = 1; try { g(); } catch(x) { x = 2; } }; "
3961                     "function g() { h(); }; "
3962                     "function h() { x = 1; throw 1; }; ";
3963 
3964   // Step through invocation of a.
3965   v8::Local<v8::Function> a = CompileFunction(&env, src, "a");
3966   SetBreakPoint(a, 0);
3967   step_action = StepIn;
3968   break_point_hit_count = 0;
3969   expected_step_sequence = "aa";
3970   a->Call(env->Global(), 0, NULL);
3971   CHECK_EQ(StrLength(expected_step_sequence),
3972            break_point_hit_count);
3973 
3974   // Step through invocation of b + c.
3975   v8::Local<v8::Function> b = CompileFunction(&env, src, "b");
3976   SetBreakPoint(b, 0);
3977   step_action = StepIn;
3978   break_point_hit_count = 0;
3979   expected_step_sequence = "bcc";
3980   b->Call(env->Global(), 0, NULL);
3981   CHECK_EQ(StrLength(expected_step_sequence),
3982            break_point_hit_count);
3983   // Step through invocation of d + e.
3984   v8::Local<v8::Function> d = CompileFunction(&env, src, "d");
3985   SetBreakPoint(d, 0);
3986   ChangeBreakOnException(false, true);
3987   step_action = StepIn;
3988   break_point_hit_count = 0;
3989   expected_step_sequence = "ddedd";
3990   d->Call(env->Global(), 0, NULL);
3991   CHECK_EQ(StrLength(expected_step_sequence),
3992            break_point_hit_count);
3993 
3994   // Step through invocation of d + e now with break on caught exceptions.
3995   ChangeBreakOnException(true, true);
3996   step_action = StepIn;
3997   break_point_hit_count = 0;
3998   expected_step_sequence = "ddeedd";
3999   d->Call(env->Global(), 0, NULL);
4000   CHECK_EQ(StrLength(expected_step_sequence),
4001            break_point_hit_count);
4002 
4003   // Step through invocation of f + g + h.
4004   v8::Local<v8::Function> f = CompileFunction(&env, src, "f");
4005   SetBreakPoint(f, 0);
4006   ChangeBreakOnException(false, true);
4007   step_action = StepIn;
4008   break_point_hit_count = 0;
4009   expected_step_sequence = "ffghhff";
4010   f->Call(env->Global(), 0, NULL);
4011   CHECK_EQ(StrLength(expected_step_sequence),
4012            break_point_hit_count);
4013 
4014   // Step through invocation of f + g + h now with break on caught exceptions.
4015   ChangeBreakOnException(true, true);
4016   step_action = StepIn;
4017   break_point_hit_count = 0;
4018   expected_step_sequence = "ffghhhff";
4019   f->Call(env->Global(), 0, NULL);
4020   CHECK_EQ(StrLength(expected_step_sequence),
4021            break_point_hit_count);
4022 
4023   // Get rid of the debug event listener.
4024   v8::Debug::SetDebugEventListener(NULL);
4025   CheckDebuggerUnloaded();
4026 }
4027 
4028 
TEST(DebugBreak)4029 TEST(DebugBreak) {
4030   v8::HandleScope scope;
4031   DebugLocalContext env;
4032 
4033   // This test should be run with option --verify-heap. As --verify-heap is
4034   // only available in debug mode only check for it in that case.
4035 #ifdef DEBUG
4036   CHECK(v8::internal::FLAG_verify_heap);
4037 #endif
4038 
4039   // Register a debug event listener which sets the break flag and counts.
4040   v8::Debug::SetDebugEventListener(DebugEventBreak);
4041 
4042   // Create a function for testing stepping.
4043   const char* src = "function f0() {}"
4044                     "function f1(x1) {}"
4045                     "function f2(x1,x2) {}"
4046                     "function f3(x1,x2,x3) {}";
4047   v8::Local<v8::Function> f0 = CompileFunction(&env, src, "f0");
4048   v8::Local<v8::Function> f1 = CompileFunction(&env, src, "f1");
4049   v8::Local<v8::Function> f2 = CompileFunction(&env, src, "f2");
4050   v8::Local<v8::Function> f3 = CompileFunction(&env, src, "f3");
4051 
4052   // Call the function to make sure it is compiled.
4053   v8::Handle<v8::Value> argv[] = { v8::Number::New(1),
4054                                    v8::Number::New(1),
4055                                    v8::Number::New(1),
4056                                    v8::Number::New(1) };
4057 
4058   // Call all functions to make sure that they are compiled.
4059   f0->Call(env->Global(), 0, NULL);
4060   f1->Call(env->Global(), 0, NULL);
4061   f2->Call(env->Global(), 0, NULL);
4062   f3->Call(env->Global(), 0, NULL);
4063 
4064   // Set the debug break flag.
4065   v8::Debug::DebugBreak();
4066 
4067   // Call all functions with different argument count.
4068   break_point_hit_count = 0;
4069   for (unsigned int i = 0; i < ARRAY_SIZE(argv); i++) {
4070     f0->Call(env->Global(), i, argv);
4071     f1->Call(env->Global(), i, argv);
4072     f2->Call(env->Global(), i, argv);
4073     f3->Call(env->Global(), i, argv);
4074   }
4075 
4076   // One break for each function called.
4077   CHECK_EQ(4 * ARRAY_SIZE(argv), break_point_hit_count);
4078 
4079   // Get rid of the debug event listener.
4080   v8::Debug::SetDebugEventListener(NULL);
4081   CheckDebuggerUnloaded();
4082 }
4083 
4084 
4085 // Test to ensure that JavaScript code keeps running while the debug break
4086 // through the stack limit flag is set but breaks are disabled.
TEST(DisableBreak)4087 TEST(DisableBreak) {
4088   v8::HandleScope scope;
4089   DebugLocalContext env;
4090 
4091   // Register a debug event listener which sets the break flag and counts.
4092   v8::Debug::SetDebugEventListener(DebugEventCounter);
4093 
4094   // Create a function for testing stepping.
4095   const char* src = "function f() {g()};function g(){i=0; while(i<10){i++}}";
4096   v8::Local<v8::Function> f = CompileFunction(&env, src, "f");
4097 
4098   // Set the debug break flag.
4099   v8::Debug::DebugBreak();
4100 
4101   // Call all functions with different argument count.
4102   break_point_hit_count = 0;
4103   f->Call(env->Global(), 0, NULL);
4104   CHECK_EQ(1, break_point_hit_count);
4105 
4106   {
4107     v8::Debug::DebugBreak();
4108     v8::internal::DisableBreak disable_break(true);
4109     f->Call(env->Global(), 0, NULL);
4110     CHECK_EQ(1, break_point_hit_count);
4111   }
4112 
4113   f->Call(env->Global(), 0, NULL);
4114   CHECK_EQ(2, break_point_hit_count);
4115 
4116   // Get rid of the debug event listener.
4117   v8::Debug::SetDebugEventListener(NULL);
4118   CheckDebuggerUnloaded();
4119 }
4120 
4121 static const char* kSimpleExtensionSource =
4122   "(function Foo() {"
4123   "  return 4;"
4124   "})() ";
4125 
4126 // http://crbug.com/28933
4127 // Test that debug break is disabled when bootstrapper is active.
TEST(NoBreakWhenBootstrapping)4128 TEST(NoBreakWhenBootstrapping) {
4129   v8::HandleScope scope;
4130 
4131   // Register a debug event listener which sets the break flag and counts.
4132   v8::Debug::SetDebugEventListener(DebugEventCounter);
4133 
4134   // Set the debug break flag.
4135   v8::Debug::DebugBreak();
4136   break_point_hit_count = 0;
4137   {
4138     // Create a context with an extension to make sure that some JavaScript
4139     // code is executed during bootstrapping.
4140     v8::RegisterExtension(new v8::Extension("simpletest",
4141                                             kSimpleExtensionSource));
4142     const char* extension_names[] = { "simpletest" };
4143     v8::ExtensionConfiguration extensions(1, extension_names);
4144     v8::Persistent<v8::Context> context = v8::Context::New(&extensions);
4145     context.Dispose();
4146   }
4147   // Check that no DebugBreak events occured during the context creation.
4148   CHECK_EQ(0, break_point_hit_count);
4149 
4150   // Get rid of the debug event listener.
4151   v8::Debug::SetDebugEventListener(NULL);
4152   CheckDebuggerUnloaded();
4153 }
4154 
NamedEnum(const v8::AccessorInfo &)4155 static v8::Handle<v8::Array> NamedEnum(const v8::AccessorInfo&) {
4156   v8::Handle<v8::Array> result = v8::Array::New(3);
4157   result->Set(v8::Integer::New(0), v8::String::New("a"));
4158   result->Set(v8::Integer::New(1), v8::String::New("b"));
4159   result->Set(v8::Integer::New(2), v8::String::New("c"));
4160   return result;
4161 }
4162 
4163 
IndexedEnum(const v8::AccessorInfo &)4164 static v8::Handle<v8::Array> IndexedEnum(const v8::AccessorInfo&) {
4165   v8::Handle<v8::Array> result = v8::Array::New(2);
4166   result->Set(v8::Integer::New(0), v8::Number::New(1));
4167   result->Set(v8::Integer::New(1), v8::Number::New(10));
4168   return result;
4169 }
4170 
4171 
NamedGetter(v8::Local<v8::String> name,const v8::AccessorInfo & info)4172 static v8::Handle<v8::Value> NamedGetter(v8::Local<v8::String> name,
4173                                          const v8::AccessorInfo& info) {
4174   v8::String::AsciiValue n(name);
4175   if (strcmp(*n, "a") == 0) {
4176     return v8::String::New("AA");
4177   } else if (strcmp(*n, "b") == 0) {
4178     return v8::String::New("BB");
4179   } else if (strcmp(*n, "c") == 0) {
4180     return v8::String::New("CC");
4181   } else {
4182     return v8::Undefined();
4183   }
4184 
4185   return name;
4186 }
4187 
4188 
IndexedGetter(uint32_t index,const v8::AccessorInfo & info)4189 static v8::Handle<v8::Value> IndexedGetter(uint32_t index,
4190                                            const v8::AccessorInfo& info) {
4191   return v8::Number::New(index + 1);
4192 }
4193 
4194 
TEST(InterceptorPropertyMirror)4195 TEST(InterceptorPropertyMirror) {
4196   // Create a V8 environment with debug access.
4197   v8::HandleScope scope;
4198   DebugLocalContext env;
4199   env.ExposeDebug();
4200 
4201   // Create object with named interceptor.
4202   v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New();
4203   named->SetNamedPropertyHandler(NamedGetter, NULL, NULL, NULL, NamedEnum);
4204   env->Global()->Set(v8::String::New("intercepted_named"),
4205                      named->NewInstance());
4206 
4207   // Create object with indexed interceptor.
4208   v8::Handle<v8::ObjectTemplate> indexed = v8::ObjectTemplate::New();
4209   indexed->SetIndexedPropertyHandler(IndexedGetter,
4210                                      NULL,
4211                                      NULL,
4212                                      NULL,
4213                                      IndexedEnum);
4214   env->Global()->Set(v8::String::New("intercepted_indexed"),
4215                      indexed->NewInstance());
4216 
4217   // Create object with both named and indexed interceptor.
4218   v8::Handle<v8::ObjectTemplate> both = v8::ObjectTemplate::New();
4219   both->SetNamedPropertyHandler(NamedGetter, NULL, NULL, NULL, NamedEnum);
4220   both->SetIndexedPropertyHandler(IndexedGetter, NULL, NULL, NULL, IndexedEnum);
4221   env->Global()->Set(v8::String::New("intercepted_both"), both->NewInstance());
4222 
4223   // Get mirrors for the three objects with interceptor.
4224   CompileRun(
4225       "var named_mirror = debug.MakeMirror(intercepted_named);"
4226       "var indexed_mirror = debug.MakeMirror(intercepted_indexed);"
4227       "var both_mirror = debug.MakeMirror(intercepted_both)");
4228   CHECK(CompileRun(
4229        "named_mirror instanceof debug.ObjectMirror")->BooleanValue());
4230   CHECK(CompileRun(
4231         "indexed_mirror instanceof debug.ObjectMirror")->BooleanValue());
4232   CHECK(CompileRun(
4233         "both_mirror instanceof debug.ObjectMirror")->BooleanValue());
4234 
4235   // Get the property names from the interceptors
4236   CompileRun(
4237       "named_names = named_mirror.propertyNames();"
4238       "indexed_names = indexed_mirror.propertyNames();"
4239       "both_names = both_mirror.propertyNames()");
4240   CHECK_EQ(3, CompileRun("named_names.length")->Int32Value());
4241   CHECK_EQ(2, CompileRun("indexed_names.length")->Int32Value());
4242   CHECK_EQ(5, CompileRun("both_names.length")->Int32Value());
4243 
4244   // Check the expected number of properties.
4245   const char* source;
4246   source = "named_mirror.properties().length";
4247   CHECK_EQ(3, CompileRun(source)->Int32Value());
4248 
4249   source = "indexed_mirror.properties().length";
4250   CHECK_EQ(2, CompileRun(source)->Int32Value());
4251 
4252   source = "both_mirror.properties().length";
4253   CHECK_EQ(5, CompileRun(source)->Int32Value());
4254 
4255   // 1 is PropertyKind.Named;
4256   source = "both_mirror.properties(1).length";
4257   CHECK_EQ(3, CompileRun(source)->Int32Value());
4258 
4259   // 2 is PropertyKind.Indexed;
4260   source = "both_mirror.properties(2).length";
4261   CHECK_EQ(2, CompileRun(source)->Int32Value());
4262 
4263   // 3 is PropertyKind.Named  | PropertyKind.Indexed;
4264   source = "both_mirror.properties(3).length";
4265   CHECK_EQ(5, CompileRun(source)->Int32Value());
4266 
4267   // Get the interceptor properties for the object with only named interceptor.
4268   CompileRun("var named_values = named_mirror.properties()");
4269 
4270   // Check that the properties are interceptor properties.
4271   for (int i = 0; i < 3; i++) {
4272     EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
4273     OS::SNPrintF(buffer,
4274                  "named_values[%d] instanceof debug.PropertyMirror", i);
4275     CHECK(CompileRun(buffer.start())->BooleanValue());
4276 
4277     // 5 is PropertyType.Interceptor
4278     OS::SNPrintF(buffer, "named_values[%d].propertyType()", i);
4279     CHECK_EQ(5, CompileRun(buffer.start())->Int32Value());
4280 
4281     OS::SNPrintF(buffer, "named_values[%d].isNative()", i);
4282     CHECK(CompileRun(buffer.start())->BooleanValue());
4283   }
4284 
4285   // Get the interceptor properties for the object with only indexed
4286   // interceptor.
4287   CompileRun("var indexed_values = indexed_mirror.properties()");
4288 
4289   // Check that the properties are interceptor properties.
4290   for (int i = 0; i < 2; i++) {
4291     EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
4292     OS::SNPrintF(buffer,
4293                  "indexed_values[%d] instanceof debug.PropertyMirror", i);
4294     CHECK(CompileRun(buffer.start())->BooleanValue());
4295   }
4296 
4297   // Get the interceptor properties for the object with both types of
4298   // interceptors.
4299   CompileRun("var both_values = both_mirror.properties()");
4300 
4301   // Check that the properties are interceptor properties.
4302   for (int i = 0; i < 5; i++) {
4303     EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
4304     OS::SNPrintF(buffer, "both_values[%d] instanceof debug.PropertyMirror", i);
4305     CHECK(CompileRun(buffer.start())->BooleanValue());
4306   }
4307 
4308   // Check the property names.
4309   source = "both_values[0].name() == 'a'";
4310   CHECK(CompileRun(source)->BooleanValue());
4311 
4312   source = "both_values[1].name() == 'b'";
4313   CHECK(CompileRun(source)->BooleanValue());
4314 
4315   source = "both_values[2].name() == 'c'";
4316   CHECK(CompileRun(source)->BooleanValue());
4317 
4318   source = "both_values[3].name() == 1";
4319   CHECK(CompileRun(source)->BooleanValue());
4320 
4321   source = "both_values[4].name() == 10";
4322   CHECK(CompileRun(source)->BooleanValue());
4323 }
4324 
4325 
TEST(HiddenPrototypePropertyMirror)4326 TEST(HiddenPrototypePropertyMirror) {
4327   // Create a V8 environment with debug access.
4328   v8::HandleScope scope;
4329   DebugLocalContext env;
4330   env.ExposeDebug();
4331 
4332   v8::Handle<v8::FunctionTemplate> t0 = v8::FunctionTemplate::New();
4333   t0->InstanceTemplate()->Set(v8::String::New("x"), v8::Number::New(0));
4334   v8::Handle<v8::FunctionTemplate> t1 = v8::FunctionTemplate::New();
4335   t1->SetHiddenPrototype(true);
4336   t1->InstanceTemplate()->Set(v8::String::New("y"), v8::Number::New(1));
4337   v8::Handle<v8::FunctionTemplate> t2 = v8::FunctionTemplate::New();
4338   t2->SetHiddenPrototype(true);
4339   t2->InstanceTemplate()->Set(v8::String::New("z"), v8::Number::New(2));
4340   v8::Handle<v8::FunctionTemplate> t3 = v8::FunctionTemplate::New();
4341   t3->InstanceTemplate()->Set(v8::String::New("u"), v8::Number::New(3));
4342 
4343   // Create object and set them on the global object.
4344   v8::Handle<v8::Object> o0 = t0->GetFunction()->NewInstance();
4345   env->Global()->Set(v8::String::New("o0"), o0);
4346   v8::Handle<v8::Object> o1 = t1->GetFunction()->NewInstance();
4347   env->Global()->Set(v8::String::New("o1"), o1);
4348   v8::Handle<v8::Object> o2 = t2->GetFunction()->NewInstance();
4349   env->Global()->Set(v8::String::New("o2"), o2);
4350   v8::Handle<v8::Object> o3 = t3->GetFunction()->NewInstance();
4351   env->Global()->Set(v8::String::New("o3"), o3);
4352 
4353   // Get mirrors for the four objects.
4354   CompileRun(
4355       "var o0_mirror = debug.MakeMirror(o0);"
4356       "var o1_mirror = debug.MakeMirror(o1);"
4357       "var o2_mirror = debug.MakeMirror(o2);"
4358       "var o3_mirror = debug.MakeMirror(o3)");
4359   CHECK(CompileRun("o0_mirror instanceof debug.ObjectMirror")->BooleanValue());
4360   CHECK(CompileRun("o1_mirror instanceof debug.ObjectMirror")->BooleanValue());
4361   CHECK(CompileRun("o2_mirror instanceof debug.ObjectMirror")->BooleanValue());
4362   CHECK(CompileRun("o3_mirror instanceof debug.ObjectMirror")->BooleanValue());
4363 
4364   // Check that each object has one property.
4365   CHECK_EQ(1, CompileRun(
4366               "o0_mirror.propertyNames().length")->Int32Value());
4367   CHECK_EQ(1, CompileRun(
4368               "o1_mirror.propertyNames().length")->Int32Value());
4369   CHECK_EQ(1, CompileRun(
4370               "o2_mirror.propertyNames().length")->Int32Value());
4371   CHECK_EQ(1, CompileRun(
4372               "o3_mirror.propertyNames().length")->Int32Value());
4373 
4374   // Set o1 as prototype for o0. o1 has the hidden prototype flag so all
4375   // properties on o1 should be seen on o0.
4376   o0->Set(v8::String::New("__proto__"), o1);
4377   CHECK_EQ(2, CompileRun(
4378               "o0_mirror.propertyNames().length")->Int32Value());
4379   CHECK_EQ(0, CompileRun(
4380               "o0_mirror.property('x').value().value()")->Int32Value());
4381   CHECK_EQ(1, CompileRun(
4382               "o0_mirror.property('y').value().value()")->Int32Value());
4383 
4384   // Set o2 as prototype for o0 (it will end up after o1 as o1 has the hidden
4385   // prototype flag. o2 also has the hidden prototype flag so all properties
4386   // on o2 should be seen on o0 as well as properties on o1.
4387   o0->Set(v8::String::New("__proto__"), o2);
4388   CHECK_EQ(3, CompileRun(
4389               "o0_mirror.propertyNames().length")->Int32Value());
4390   CHECK_EQ(0, CompileRun(
4391               "o0_mirror.property('x').value().value()")->Int32Value());
4392   CHECK_EQ(1, CompileRun(
4393               "o0_mirror.property('y').value().value()")->Int32Value());
4394   CHECK_EQ(2, CompileRun(
4395               "o0_mirror.property('z').value().value()")->Int32Value());
4396 
4397   // Set o3 as prototype for o0 (it will end up after o1 and o2 as both o1 and
4398   // o2 has the hidden prototype flag. o3 does not have the hidden prototype
4399   // flag so properties on o3 should not be seen on o0 whereas the properties
4400   // from o1 and o2 should still be seen on o0.
4401   // Final prototype chain: o0 -> o1 -> o2 -> o3
4402   // Hidden prototypes:           ^^    ^^
4403   o0->Set(v8::String::New("__proto__"), o3);
4404   CHECK_EQ(3, CompileRun(
4405               "o0_mirror.propertyNames().length")->Int32Value());
4406   CHECK_EQ(1, CompileRun(
4407               "o3_mirror.propertyNames().length")->Int32Value());
4408   CHECK_EQ(0, CompileRun(
4409               "o0_mirror.property('x').value().value()")->Int32Value());
4410   CHECK_EQ(1, CompileRun(
4411               "o0_mirror.property('y').value().value()")->Int32Value());
4412   CHECK_EQ(2, CompileRun(
4413               "o0_mirror.property('z').value().value()")->Int32Value());
4414   CHECK(CompileRun("o0_mirror.property('u').isUndefined()")->BooleanValue());
4415 
4416   // The prototype (__proto__) for o0 should be o3 as o1 and o2 are hidden.
4417   CHECK(CompileRun("o0_mirror.protoObject() == o3_mirror")->BooleanValue());
4418 }
4419 
4420 
ProtperyXNativeGetter(v8::Local<v8::String> property,const v8::AccessorInfo & info)4421 static v8::Handle<v8::Value> ProtperyXNativeGetter(
4422     v8::Local<v8::String> property, const v8::AccessorInfo& info) {
4423   return v8::Integer::New(10);
4424 }
4425 
4426 
TEST(NativeGetterPropertyMirror)4427 TEST(NativeGetterPropertyMirror) {
4428   // Create a V8 environment with debug access.
4429   v8::HandleScope scope;
4430   DebugLocalContext env;
4431   env.ExposeDebug();
4432 
4433   v8::Handle<v8::String> name = v8::String::New("x");
4434   // Create object with named accessor.
4435   v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New();
4436   named->SetAccessor(name, &ProtperyXNativeGetter, NULL,
4437       v8::Handle<v8::Value>(), v8::DEFAULT, v8::None);
4438 
4439   // Create object with named property getter.
4440   env->Global()->Set(v8::String::New("instance"), named->NewInstance());
4441   CHECK_EQ(10, CompileRun("instance.x")->Int32Value());
4442 
4443   // Get mirror for the object with property getter.
4444   CompileRun("var instance_mirror = debug.MakeMirror(instance);");
4445   CHECK(CompileRun(
4446       "instance_mirror instanceof debug.ObjectMirror")->BooleanValue());
4447 
4448   CompileRun("var named_names = instance_mirror.propertyNames();");
4449   CHECK_EQ(1, CompileRun("named_names.length")->Int32Value());
4450   CHECK(CompileRun("named_names[0] == 'x'")->BooleanValue());
4451   CHECK(CompileRun(
4452       "instance_mirror.property('x').value().isNumber()")->BooleanValue());
4453   CHECK(CompileRun(
4454       "instance_mirror.property('x').value().value() == 10")->BooleanValue());
4455 }
4456 
4457 
ProtperyXNativeGetterThrowingError(v8::Local<v8::String> property,const v8::AccessorInfo & info)4458 static v8::Handle<v8::Value> ProtperyXNativeGetterThrowingError(
4459     v8::Local<v8::String> property, const v8::AccessorInfo& info) {
4460   return CompileRun("throw new Error('Error message');");
4461 }
4462 
4463 
TEST(NativeGetterThrowingErrorPropertyMirror)4464 TEST(NativeGetterThrowingErrorPropertyMirror) {
4465   // Create a V8 environment with debug access.
4466   v8::HandleScope scope;
4467   DebugLocalContext env;
4468   env.ExposeDebug();
4469 
4470   v8::Handle<v8::String> name = v8::String::New("x");
4471   // Create object with named accessor.
4472   v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New();
4473   named->SetAccessor(name, &ProtperyXNativeGetterThrowingError, NULL,
4474       v8::Handle<v8::Value>(), v8::DEFAULT, v8::None);
4475 
4476   // Create object with named property getter.
4477   env->Global()->Set(v8::String::New("instance"), named->NewInstance());
4478 
4479   // Get mirror for the object with property getter.
4480   CompileRun("var instance_mirror = debug.MakeMirror(instance);");
4481   CHECK(CompileRun(
4482       "instance_mirror instanceof debug.ObjectMirror")->BooleanValue());
4483   CompileRun("named_names = instance_mirror.propertyNames();");
4484   CHECK_EQ(1, CompileRun("named_names.length")->Int32Value());
4485   CHECK(CompileRun("named_names[0] == 'x'")->BooleanValue());
4486   CHECK(CompileRun(
4487       "instance_mirror.property('x').value().isError()")->BooleanValue());
4488 
4489   // Check that the message is that passed to the Error constructor.
4490   CHECK(CompileRun(
4491       "instance_mirror.property('x').value().message() == 'Error message'")->
4492           BooleanValue());
4493 }
4494 
4495 
4496 // Test that hidden properties object is not returned as an unnamed property
4497 // among regular properties.
4498 // See http://crbug.com/26491
TEST(NoHiddenProperties)4499 TEST(NoHiddenProperties) {
4500   // Create a V8 environment with debug access.
4501   v8::HandleScope scope;
4502   DebugLocalContext env;
4503   env.ExposeDebug();
4504 
4505   // Create an object in the global scope.
4506   const char* source = "var obj = {a: 1};";
4507   v8::Script::Compile(v8::String::New(source))->Run();
4508   v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(
4509       env->Global()->Get(v8::String::New("obj")));
4510   // Set a hidden property on the object.
4511   obj->SetHiddenValue(v8::String::New("v8::test-debug::a"),
4512                       v8::Int32::New(11));
4513 
4514   // Get mirror for the object with property getter.
4515   CompileRun("var obj_mirror = debug.MakeMirror(obj);");
4516   CHECK(CompileRun(
4517       "obj_mirror instanceof debug.ObjectMirror")->BooleanValue());
4518   CompileRun("var named_names = obj_mirror.propertyNames();");
4519   // There should be exactly one property. But there is also an unnamed
4520   // property whose value is hidden properties dictionary. The latter
4521   // property should not be in the list of reguar properties.
4522   CHECK_EQ(1, CompileRun("named_names.length")->Int32Value());
4523   CHECK(CompileRun("named_names[0] == 'a'")->BooleanValue());
4524   CHECK(CompileRun(
4525       "obj_mirror.property('a').value().value() == 1")->BooleanValue());
4526 
4527   // Object created by t0 will become hidden prototype of object 'obj'.
4528   v8::Handle<v8::FunctionTemplate> t0 = v8::FunctionTemplate::New();
4529   t0->InstanceTemplate()->Set(v8::String::New("b"), v8::Number::New(2));
4530   t0->SetHiddenPrototype(true);
4531   v8::Handle<v8::FunctionTemplate> t1 = v8::FunctionTemplate::New();
4532   t1->InstanceTemplate()->Set(v8::String::New("c"), v8::Number::New(3));
4533 
4534   // Create proto objects, add hidden properties to them and set them on
4535   // the global object.
4536   v8::Handle<v8::Object> protoObj = t0->GetFunction()->NewInstance();
4537   protoObj->SetHiddenValue(v8::String::New("v8::test-debug::b"),
4538                            v8::Int32::New(12));
4539   env->Global()->Set(v8::String::New("protoObj"), protoObj);
4540   v8::Handle<v8::Object> grandProtoObj = t1->GetFunction()->NewInstance();
4541   grandProtoObj->SetHiddenValue(v8::String::New("v8::test-debug::c"),
4542                                 v8::Int32::New(13));
4543   env->Global()->Set(v8::String::New("grandProtoObj"), grandProtoObj);
4544 
4545   // Setting prototypes: obj->protoObj->grandProtoObj
4546   protoObj->Set(v8::String::New("__proto__"), grandProtoObj);
4547   obj->Set(v8::String::New("__proto__"), protoObj);
4548 
4549   // Get mirror for the object with property getter.
4550   CompileRun("var obj_mirror = debug.MakeMirror(obj);");
4551   CHECK(CompileRun(
4552       "obj_mirror instanceof debug.ObjectMirror")->BooleanValue());
4553   CompileRun("var named_names = obj_mirror.propertyNames();");
4554   // There should be exactly two properties - one from the object itself and
4555   // another from its hidden prototype.
4556   CHECK_EQ(2, CompileRun("named_names.length")->Int32Value());
4557   CHECK(CompileRun("named_names.sort(); named_names[0] == 'a' &&"
4558                    "named_names[1] == 'b'")->BooleanValue());
4559   CHECK(CompileRun(
4560       "obj_mirror.property('a').value().value() == 1")->BooleanValue());
4561   CHECK(CompileRun(
4562       "obj_mirror.property('b').value().value() == 2")->BooleanValue());
4563 }
4564 
4565 
4566 // Multithreaded tests of JSON debugger protocol
4567 
4568 // Support classes
4569 
4570 // Provides synchronization between k threads, where k is an input to the
4571 // constructor.  The Wait() call blocks a thread until it is called for the
4572 // k'th time, then all calls return.  Each ThreadBarrier object can only
4573 // be used once.
4574 class ThreadBarrier {
4575  public:
4576   explicit ThreadBarrier(int num_threads);
4577   ~ThreadBarrier();
4578   void Wait();
4579  private:
4580   int num_threads_;
4581   int num_blocked_;
4582   v8::internal::Mutex* lock_;
4583   v8::internal::Semaphore* sem_;
4584   bool invalid_;
4585 };
4586 
ThreadBarrier(int num_threads)4587 ThreadBarrier::ThreadBarrier(int num_threads)
4588     : num_threads_(num_threads), num_blocked_(0) {
4589   lock_ = OS::CreateMutex();
4590   sem_ = OS::CreateSemaphore(0);
4591   invalid_ = false;  // A barrier may only be used once.  Then it is invalid.
4592 }
4593 
4594 // Do not call, due to race condition with Wait().
4595 // Could be resolved with Pthread condition variables.
~ThreadBarrier()4596 ThreadBarrier::~ThreadBarrier() {
4597   lock_->Lock();
4598   delete lock_;
4599   delete sem_;
4600 }
4601 
Wait()4602 void ThreadBarrier::Wait() {
4603   lock_->Lock();
4604   CHECK(!invalid_);
4605   if (num_blocked_ == num_threads_ - 1) {
4606     // Signal and unblock all waiting threads.
4607     for (int i = 0; i < num_threads_ - 1; ++i) {
4608       sem_->Signal();
4609     }
4610     invalid_ = true;
4611     printf("BARRIER\n\n");
4612     fflush(stdout);
4613     lock_->Unlock();
4614   } else {  // Wait for the semaphore.
4615     ++num_blocked_;
4616     lock_->Unlock();  // Potential race condition with destructor because
4617     sem_->Wait();  // these two lines are not atomic.
4618   }
4619 }
4620 
4621 // A set containing enough barriers and semaphores for any of the tests.
4622 class Barriers {
4623  public:
4624   Barriers();
4625   void Initialize();
4626   ThreadBarrier barrier_1;
4627   ThreadBarrier barrier_2;
4628   ThreadBarrier barrier_3;
4629   ThreadBarrier barrier_4;
4630   ThreadBarrier barrier_5;
4631   v8::internal::Semaphore* semaphore_1;
4632   v8::internal::Semaphore* semaphore_2;
4633 };
4634 
Barriers()4635 Barriers::Barriers() : barrier_1(2), barrier_2(2),
4636     barrier_3(2), barrier_4(2), barrier_5(2) {}
4637 
Initialize()4638 void Barriers::Initialize() {
4639   semaphore_1 = OS::CreateSemaphore(0);
4640   semaphore_2 = OS::CreateSemaphore(0);
4641 }
4642 
4643 
4644 // We match parts of the message to decide if it is a break message.
IsBreakEventMessage(char * message)4645 bool IsBreakEventMessage(char *message) {
4646   const char* type_event = "\"type\":\"event\"";
4647   const char* event_break = "\"event\":\"break\"";
4648   // Does the message contain both type:event and event:break?
4649   return strstr(message, type_event) != NULL &&
4650          strstr(message, event_break) != NULL;
4651 }
4652 
4653 
4654 // We match parts of the message to decide if it is a exception message.
IsExceptionEventMessage(char * message)4655 bool IsExceptionEventMessage(char *message) {
4656   const char* type_event = "\"type\":\"event\"";
4657   const char* event_exception = "\"event\":\"exception\"";
4658   // Does the message contain both type:event and event:exception?
4659   return strstr(message, type_event) != NULL &&
4660       strstr(message, event_exception) != NULL;
4661 }
4662 
4663 
4664 // We match the message wether it is an evaluate response message.
IsEvaluateResponseMessage(char * message)4665 bool IsEvaluateResponseMessage(char* message) {
4666   const char* type_response = "\"type\":\"response\"";
4667   const char* command_evaluate = "\"command\":\"evaluate\"";
4668   // Does the message contain both type:response and command:evaluate?
4669   return strstr(message, type_response) != NULL &&
4670          strstr(message, command_evaluate) != NULL;
4671 }
4672 
4673 
StringToInt(const char * s)4674 static int StringToInt(const char* s) {
4675   return atoi(s);  // NOLINT
4676 }
4677 
4678 
4679 // We match parts of the message to get evaluate result int value.
GetEvaluateIntResult(char * message)4680 int GetEvaluateIntResult(char *message) {
4681   const char* value = "\"value\":";
4682   char* pos = strstr(message, value);
4683   if (pos == NULL) {
4684     return -1;
4685   }
4686   int res = -1;
4687   res = StringToInt(pos + strlen(value));
4688   return res;
4689 }
4690 
4691 
4692 // We match parts of the message to get hit breakpoint id.
GetBreakpointIdFromBreakEventMessage(char * message)4693 int GetBreakpointIdFromBreakEventMessage(char *message) {
4694   const char* breakpoints = "\"breakpoints\":[";
4695   char* pos = strstr(message, breakpoints);
4696   if (pos == NULL) {
4697     return -1;
4698   }
4699   int res = -1;
4700   res = StringToInt(pos + strlen(breakpoints));
4701   return res;
4702 }
4703 
4704 
4705 // We match parts of the message to get total frames number.
GetTotalFramesInt(char * message)4706 int GetTotalFramesInt(char *message) {
4707   const char* prefix = "\"totalFrames\":";
4708   char* pos = strstr(message, prefix);
4709   if (pos == NULL) {
4710     return -1;
4711   }
4712   pos += strlen(prefix);
4713   int res = StringToInt(pos);
4714   return res;
4715 }
4716 
4717 
4718 // We match parts of the message to get source line.
GetSourceLineFromBreakEventMessage(char * message)4719 int GetSourceLineFromBreakEventMessage(char *message) {
4720   const char* source_line = "\"sourceLine\":";
4721   char* pos = strstr(message, source_line);
4722   if (pos == NULL) {
4723     return -1;
4724   }
4725   int res = -1;
4726   res = StringToInt(pos + strlen(source_line));
4727   return res;
4728 }
4729 
4730 /* Test MessageQueues */
4731 /* Tests the message queues that hold debugger commands and
4732  * response messages to the debugger.  Fills queues and makes
4733  * them grow.
4734  */
4735 Barriers message_queue_barriers;
4736 
4737 // This is the debugger thread, that executes no v8 calls except
4738 // placing JSON debugger commands in the queue.
4739 class MessageQueueDebuggerThread : public v8::internal::Thread {
4740  public:
MessageQueueDebuggerThread()4741   MessageQueueDebuggerThread()
4742       : Thread("MessageQueueDebuggerThread") { }
4743   void Run();
4744 };
4745 
MessageHandler(const uint16_t * message,int length,v8::Debug::ClientData * client_data)4746 static void MessageHandler(const uint16_t* message, int length,
4747                            v8::Debug::ClientData* client_data) {
4748   static char print_buffer[1000];
4749   Utf16ToAscii(message, length, print_buffer);
4750   if (IsBreakEventMessage(print_buffer)) {
4751     // Lets test script wait until break occurs to send commands.
4752     // Signals when a break is reported.
4753     message_queue_barriers.semaphore_2->Signal();
4754   }
4755 
4756   // Allow message handler to block on a semaphore, to test queueing of
4757   // messages while blocked.
4758   message_queue_barriers.semaphore_1->Wait();
4759 }
4760 
Run()4761 void MessageQueueDebuggerThread::Run() {
4762   const int kBufferSize = 1000;
4763   uint16_t buffer_1[kBufferSize];
4764   uint16_t buffer_2[kBufferSize];
4765   const char* command_1 =
4766       "{\"seq\":117,"
4767        "\"type\":\"request\","
4768        "\"command\":\"evaluate\","
4769        "\"arguments\":{\"expression\":\"1+2\"}}";
4770   const char* command_2 =
4771     "{\"seq\":118,"
4772      "\"type\":\"request\","
4773      "\"command\":\"evaluate\","
4774      "\"arguments\":{\"expression\":\"1+a\"}}";
4775   const char* command_3 =
4776     "{\"seq\":119,"
4777      "\"type\":\"request\","
4778      "\"command\":\"evaluate\","
4779      "\"arguments\":{\"expression\":\"c.d * b\"}}";
4780   const char* command_continue =
4781     "{\"seq\":106,"
4782      "\"type\":\"request\","
4783      "\"command\":\"continue\"}";
4784   const char* command_single_step =
4785     "{\"seq\":107,"
4786      "\"type\":\"request\","
4787      "\"command\":\"continue\","
4788      "\"arguments\":{\"stepaction\":\"next\"}}";
4789 
4790   /* Interleaved sequence of actions by the two threads:*/
4791   // Main thread compiles and runs source_1
4792   message_queue_barriers.semaphore_1->Signal();
4793   message_queue_barriers.barrier_1.Wait();
4794   // Post 6 commands, filling the command queue and making it expand.
4795   // These calls return immediately, but the commands stay on the queue
4796   // until the execution of source_2.
4797   // Note: AsciiToUtf16 executes before SendCommand, so command is copied
4798   // to buffer before buffer is sent to SendCommand.
4799   v8::Debug::SendCommand(buffer_1, AsciiToUtf16(command_1, buffer_1));
4800   v8::Debug::SendCommand(buffer_2, AsciiToUtf16(command_2, buffer_2));
4801   v8::Debug::SendCommand(buffer_2, AsciiToUtf16(command_3, buffer_2));
4802   v8::Debug::SendCommand(buffer_2, AsciiToUtf16(command_3, buffer_2));
4803   v8::Debug::SendCommand(buffer_2, AsciiToUtf16(command_3, buffer_2));
4804   message_queue_barriers.barrier_2.Wait();
4805   // Main thread compiles and runs source_2.
4806   // Queued commands are executed at the start of compilation of source_2(
4807   // beforeCompile event).
4808   // Free the message handler to process all the messages from the queue. 7
4809   // messages are expected: 2 afterCompile events and 5 responses.
4810   // All the commands added so far will fail to execute as long as call stack
4811   // is empty on beforeCompile event.
4812   for (int i = 0; i < 6 ; ++i) {
4813     message_queue_barriers.semaphore_1->Signal();
4814   }
4815   message_queue_barriers.barrier_3.Wait();
4816   // Main thread compiles and runs source_3.
4817   // Don't stop in the afterCompile handler.
4818   message_queue_barriers.semaphore_1->Signal();
4819   // source_3 includes a debugger statement, which causes a break event.
4820   // Wait on break event from hitting "debugger" statement
4821   message_queue_barriers.semaphore_2->Wait();
4822   // These should execute after the "debugger" statement in source_2
4823   v8::Debug::SendCommand(buffer_1, AsciiToUtf16(command_1, buffer_1));
4824   v8::Debug::SendCommand(buffer_2, AsciiToUtf16(command_2, buffer_2));
4825   v8::Debug::SendCommand(buffer_2, AsciiToUtf16(command_3, buffer_2));
4826   v8::Debug::SendCommand(buffer_2, AsciiToUtf16(command_single_step, buffer_2));
4827   // Run after 2 break events, 4 responses.
4828   for (int i = 0; i < 6 ; ++i) {
4829     message_queue_barriers.semaphore_1->Signal();
4830   }
4831   // Wait on break event after a single step executes.
4832   message_queue_barriers.semaphore_2->Wait();
4833   v8::Debug::SendCommand(buffer_1, AsciiToUtf16(command_2, buffer_1));
4834   v8::Debug::SendCommand(buffer_2, AsciiToUtf16(command_continue, buffer_2));
4835   // Run after 2 responses.
4836   for (int i = 0; i < 2 ; ++i) {
4837     message_queue_barriers.semaphore_1->Signal();
4838   }
4839   // Main thread continues running source_3 to end, waits for this thread.
4840 }
4841 
4842 
4843 // This thread runs the v8 engine.
TEST(MessageQueues)4844 TEST(MessageQueues) {
4845   MessageQueueDebuggerThread message_queue_debugger_thread;
4846 
4847   // Create a V8 environment
4848   v8::HandleScope scope;
4849   DebugLocalContext env;
4850   message_queue_barriers.Initialize();
4851   v8::Debug::SetMessageHandler(MessageHandler);
4852   message_queue_debugger_thread.Start();
4853 
4854   const char* source_1 = "a = 3; b = 4; c = new Object(); c.d = 5;";
4855   const char* source_2 = "e = 17;";
4856   const char* source_3 = "a = 4; debugger; a = 5; a = 6; a = 7;";
4857 
4858   // See MessageQueueDebuggerThread::Run for interleaved sequence of
4859   // API calls and events in the two threads.
4860   CompileRun(source_1);
4861   message_queue_barriers.barrier_1.Wait();
4862   message_queue_barriers.barrier_2.Wait();
4863   CompileRun(source_2);
4864   message_queue_barriers.barrier_3.Wait();
4865   CompileRun(source_3);
4866   message_queue_debugger_thread.Join();
4867   fflush(stdout);
4868 }
4869 
4870 
4871 class TestClientData : public v8::Debug::ClientData {
4872  public:
TestClientData()4873   TestClientData() {
4874     constructor_call_counter++;
4875   }
~TestClientData()4876   virtual ~TestClientData() {
4877     destructor_call_counter++;
4878   }
4879 
ResetCounters()4880   static void ResetCounters() {
4881     constructor_call_counter = 0;
4882     destructor_call_counter = 0;
4883   }
4884 
4885   static int constructor_call_counter;
4886   static int destructor_call_counter;
4887 };
4888 
4889 int TestClientData::constructor_call_counter = 0;
4890 int TestClientData::destructor_call_counter = 0;
4891 
4892 
4893 // Tests that MessageQueue doesn't destroy client data when expands and
4894 // does destroy when it dies.
TEST(MessageQueueExpandAndDestroy)4895 TEST(MessageQueueExpandAndDestroy) {
4896   TestClientData::ResetCounters();
4897   { // Create a scope for the queue.
4898     CommandMessageQueue queue(1);
4899     queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
4900                                   new TestClientData()));
4901     queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
4902                                   new TestClientData()));
4903     queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
4904                                   new TestClientData()));
4905     CHECK_EQ(0, TestClientData::destructor_call_counter);
4906     queue.Get().Dispose();
4907     CHECK_EQ(1, TestClientData::destructor_call_counter);
4908     queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
4909                                   new TestClientData()));
4910     queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
4911                                   new TestClientData()));
4912     queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
4913                                   new TestClientData()));
4914     queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
4915                                   new TestClientData()));
4916     queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
4917                                   new TestClientData()));
4918     CHECK_EQ(1, TestClientData::destructor_call_counter);
4919     queue.Get().Dispose();
4920     CHECK_EQ(2, TestClientData::destructor_call_counter);
4921   }
4922   // All the client data should be destroyed when the queue is destroyed.
4923   CHECK_EQ(TestClientData::destructor_call_counter,
4924            TestClientData::destructor_call_counter);
4925 }
4926 
4927 
4928 static int handled_client_data_instances_count = 0;
MessageHandlerCountingClientData(const v8::Debug::Message & message)4929 static void MessageHandlerCountingClientData(
4930     const v8::Debug::Message& message) {
4931   if (message.GetClientData() != NULL) {
4932     handled_client_data_instances_count++;
4933   }
4934 }
4935 
4936 
4937 // Tests that all client data passed to the debugger are sent to the handler.
TEST(SendClientDataToHandler)4938 TEST(SendClientDataToHandler) {
4939   // Create a V8 environment
4940   v8::HandleScope scope;
4941   DebugLocalContext env;
4942   TestClientData::ResetCounters();
4943   handled_client_data_instances_count = 0;
4944   v8::Debug::SetMessageHandler2(MessageHandlerCountingClientData);
4945   const char* source_1 = "a = 3; b = 4; c = new Object(); c.d = 5;";
4946   const int kBufferSize = 1000;
4947   uint16_t buffer[kBufferSize];
4948   const char* command_1 =
4949       "{\"seq\":117,"
4950        "\"type\":\"request\","
4951        "\"command\":\"evaluate\","
4952        "\"arguments\":{\"expression\":\"1+2\"}}";
4953   const char* command_2 =
4954     "{\"seq\":118,"
4955      "\"type\":\"request\","
4956      "\"command\":\"evaluate\","
4957      "\"arguments\":{\"expression\":\"1+a\"}}";
4958   const char* command_continue =
4959     "{\"seq\":106,"
4960      "\"type\":\"request\","
4961      "\"command\":\"continue\"}";
4962 
4963   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_1, buffer),
4964                          new TestClientData());
4965   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_2, buffer), NULL);
4966   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_2, buffer),
4967                          new TestClientData());
4968   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_2, buffer),
4969                          new TestClientData());
4970   // All the messages will be processed on beforeCompile event.
4971   CompileRun(source_1);
4972   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_continue, buffer));
4973   CHECK_EQ(3, TestClientData::constructor_call_counter);
4974   CHECK_EQ(TestClientData::constructor_call_counter,
4975            handled_client_data_instances_count);
4976   CHECK_EQ(TestClientData::constructor_call_counter,
4977            TestClientData::destructor_call_counter);
4978 }
4979 
4980 
4981 /* Test ThreadedDebugging */
4982 /* This test interrupts a running infinite loop that is
4983  * occupying the v8 thread by a break command from the
4984  * debugger thread.  It then changes the value of a
4985  * global object, to make the loop terminate.
4986  */
4987 
4988 Barriers threaded_debugging_barriers;
4989 
4990 class V8Thread : public v8::internal::Thread {
4991  public:
V8Thread()4992   V8Thread() : Thread("V8Thread") { }
4993   void Run();
4994 };
4995 
4996 class DebuggerThread : public v8::internal::Thread {
4997  public:
DebuggerThread()4998   DebuggerThread() : Thread("DebuggerThread") { }
4999   void Run();
5000 };
5001 
5002 
ThreadedAtBarrier1(const v8::Arguments & args)5003 static v8::Handle<v8::Value> ThreadedAtBarrier1(const v8::Arguments& args) {
5004   threaded_debugging_barriers.barrier_1.Wait();
5005   return v8::Undefined();
5006 }
5007 
5008 
ThreadedMessageHandler(const v8::Debug::Message & message)5009 static void ThreadedMessageHandler(const v8::Debug::Message& message) {
5010   static char print_buffer[1000];
5011   v8::String::Value json(message.GetJSON());
5012   Utf16ToAscii(*json, json.length(), print_buffer);
5013   if (IsBreakEventMessage(print_buffer)) {
5014     // Check that we are inside the while loop.
5015     int source_line = GetSourceLineFromBreakEventMessage(print_buffer);
5016     CHECK(8 <= source_line && source_line <= 13);
5017     threaded_debugging_barriers.barrier_2.Wait();
5018   }
5019 }
5020 
5021 
Run()5022 void V8Thread::Run() {
5023   const char* source =
5024       "flag = true;\n"
5025       "function bar( new_value ) {\n"
5026       "  flag = new_value;\n"
5027       "  return \"Return from bar(\" + new_value + \")\";\n"
5028       "}\n"
5029       "\n"
5030       "function foo() {\n"
5031       "  var x = 1;\n"
5032       "  while ( flag == true ) {\n"
5033       "    if ( x == 1 ) {\n"
5034       "      ThreadedAtBarrier1();\n"
5035       "    }\n"
5036       "    x = x + 1;\n"
5037       "  }\n"
5038       "}\n"
5039       "\n"
5040       "foo();\n";
5041 
5042   v8::V8::Initialize();
5043   v8::HandleScope scope;
5044   DebugLocalContext env;
5045   v8::Debug::SetMessageHandler2(&ThreadedMessageHandler);
5046   v8::Handle<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
5047   global_template->Set(v8::String::New("ThreadedAtBarrier1"),
5048                        v8::FunctionTemplate::New(ThreadedAtBarrier1));
5049   v8::Handle<v8::Context> context = v8::Context::New(NULL, global_template);
5050   v8::Context::Scope context_scope(context);
5051 
5052   CompileRun(source);
5053 }
5054 
Run()5055 void DebuggerThread::Run() {
5056   const int kBufSize = 1000;
5057   uint16_t buffer[kBufSize];
5058 
5059   const char* command_1 = "{\"seq\":102,"
5060       "\"type\":\"request\","
5061       "\"command\":\"evaluate\","
5062       "\"arguments\":{\"expression\":\"bar(false)\"}}";
5063   const char* command_2 = "{\"seq\":103,"
5064       "\"type\":\"request\","
5065       "\"command\":\"continue\"}";
5066 
5067   threaded_debugging_barriers.barrier_1.Wait();
5068   v8::Debug::DebugBreak();
5069   threaded_debugging_barriers.barrier_2.Wait();
5070   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_1, buffer));
5071   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_2, buffer));
5072 }
5073 
5074 
TEST(ThreadedDebugging)5075 TEST(ThreadedDebugging) {
5076   DebuggerThread debugger_thread;
5077   V8Thread v8_thread;
5078 
5079   // Create a V8 environment
5080   threaded_debugging_barriers.Initialize();
5081 
5082   v8_thread.Start();
5083   debugger_thread.Start();
5084 
5085   v8_thread.Join();
5086   debugger_thread.Join();
5087 }
5088 
5089 /* Test RecursiveBreakpoints */
5090 /* In this test, the debugger evaluates a function with a breakpoint, after
5091  * hitting a breakpoint in another function.  We do this with both values
5092  * of the flag enabling recursive breakpoints, and verify that the second
5093  * breakpoint is hit when enabled, and missed when disabled.
5094  */
5095 
5096 class BreakpointsV8Thread : public v8::internal::Thread {
5097  public:
BreakpointsV8Thread()5098   BreakpointsV8Thread() : Thread("BreakpointsV8Thread") { }
5099   void Run();
5100 };
5101 
5102 class BreakpointsDebuggerThread : public v8::internal::Thread {
5103  public:
BreakpointsDebuggerThread(bool global_evaluate)5104   explicit BreakpointsDebuggerThread(bool global_evaluate)
5105       : Thread("BreakpointsDebuggerThread"),
5106         global_evaluate_(global_evaluate) {}
5107   void Run();
5108 
5109  private:
5110   bool global_evaluate_;
5111 };
5112 
5113 
5114 Barriers* breakpoints_barriers;
5115 int break_event_breakpoint_id;
5116 int evaluate_int_result;
5117 
BreakpointsMessageHandler(const v8::Debug::Message & message)5118 static void BreakpointsMessageHandler(const v8::Debug::Message& message) {
5119   static char print_buffer[1000];
5120   v8::String::Value json(message.GetJSON());
5121   Utf16ToAscii(*json, json.length(), print_buffer);
5122 
5123   if (IsBreakEventMessage(print_buffer)) {
5124     break_event_breakpoint_id =
5125         GetBreakpointIdFromBreakEventMessage(print_buffer);
5126     breakpoints_barriers->semaphore_1->Signal();
5127   } else if (IsEvaluateResponseMessage(print_buffer)) {
5128     evaluate_int_result = GetEvaluateIntResult(print_buffer);
5129     breakpoints_barriers->semaphore_1->Signal();
5130   }
5131 }
5132 
5133 
Run()5134 void BreakpointsV8Thread::Run() {
5135   const char* source_1 = "var y_global = 3;\n"
5136     "function cat( new_value ) {\n"
5137     "  var x = new_value;\n"
5138     "  y_global = y_global + 4;\n"
5139     "  x = 3 * x + 1;\n"
5140     "  y_global = y_global + 5;\n"
5141     "  return x;\n"
5142     "}\n"
5143     "\n"
5144     "function dog() {\n"
5145     "  var x = 1;\n"
5146     "  x = y_global;"
5147     "  var z = 3;"
5148     "  x += 100;\n"
5149     "  return x;\n"
5150     "}\n"
5151     "\n";
5152   const char* source_2 = "cat(17);\n"
5153     "cat(19);\n";
5154 
5155   v8::V8::Initialize();
5156   v8::HandleScope scope;
5157   DebugLocalContext env;
5158   v8::Debug::SetMessageHandler2(&BreakpointsMessageHandler);
5159 
5160   CompileRun(source_1);
5161   breakpoints_barriers->barrier_1.Wait();
5162   breakpoints_barriers->barrier_2.Wait();
5163   CompileRun(source_2);
5164 }
5165 
5166 
Run()5167 void BreakpointsDebuggerThread::Run() {
5168   const int kBufSize = 1000;
5169   uint16_t buffer[kBufSize];
5170 
5171   const char* command_1 = "{\"seq\":101,"
5172       "\"type\":\"request\","
5173       "\"command\":\"setbreakpoint\","
5174       "\"arguments\":{\"type\":\"function\",\"target\":\"cat\",\"line\":3}}";
5175   const char* command_2 = "{\"seq\":102,"
5176       "\"type\":\"request\","
5177       "\"command\":\"setbreakpoint\","
5178       "\"arguments\":{\"type\":\"function\",\"target\":\"dog\",\"line\":3}}";
5179   const char* command_3;
5180   if (this->global_evaluate_) {
5181     command_3 = "{\"seq\":103,"
5182         "\"type\":\"request\","
5183         "\"command\":\"evaluate\","
5184         "\"arguments\":{\"expression\":\"dog()\",\"disable_break\":false,"
5185         "\"global\":true}}";
5186   } else {
5187     command_3 = "{\"seq\":103,"
5188         "\"type\":\"request\","
5189         "\"command\":\"evaluate\","
5190         "\"arguments\":{\"expression\":\"dog()\",\"disable_break\":false}}";
5191   }
5192   const char* command_4;
5193   if (this->global_evaluate_) {
5194     command_4 = "{\"seq\":104,"
5195         "\"type\":\"request\","
5196         "\"command\":\"evaluate\","
5197         "\"arguments\":{\"expression\":\"100 + 8\",\"disable_break\":true,"
5198         "\"global\":true}}";
5199   } else {
5200     command_4 = "{\"seq\":104,"
5201         "\"type\":\"request\","
5202         "\"command\":\"evaluate\","
5203         "\"arguments\":{\"expression\":\"x + 1\",\"disable_break\":true}}";
5204   }
5205   const char* command_5 = "{\"seq\":105,"
5206       "\"type\":\"request\","
5207       "\"command\":\"continue\"}";
5208   const char* command_6 = "{\"seq\":106,"
5209       "\"type\":\"request\","
5210       "\"command\":\"continue\"}";
5211   const char* command_7;
5212   if (this->global_evaluate_) {
5213     command_7 = "{\"seq\":107,"
5214         "\"type\":\"request\","
5215         "\"command\":\"evaluate\","
5216         "\"arguments\":{\"expression\":\"dog()\",\"disable_break\":true,"
5217         "\"global\":true}}";
5218   } else {
5219     command_7 = "{\"seq\":107,"
5220         "\"type\":\"request\","
5221         "\"command\":\"evaluate\","
5222         "\"arguments\":{\"expression\":\"dog()\",\"disable_break\":true}}";
5223   }
5224   const char* command_8 = "{\"seq\":108,"
5225       "\"type\":\"request\","
5226       "\"command\":\"continue\"}";
5227 
5228 
5229   // v8 thread initializes, runs source_1
5230   breakpoints_barriers->barrier_1.Wait();
5231   // 1:Set breakpoint in cat() (will get id 1).
5232   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_1, buffer));
5233   // 2:Set breakpoint in dog() (will get id 2).
5234   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_2, buffer));
5235   breakpoints_barriers->barrier_2.Wait();
5236   // V8 thread starts compiling source_2.
5237   // Automatic break happens, to run queued commands
5238   // breakpoints_barriers->semaphore_1->Wait();
5239   // Commands 1 through 3 run, thread continues.
5240   // v8 thread runs source_2 to breakpoint in cat().
5241   // message callback receives break event.
5242   breakpoints_barriers->semaphore_1->Wait();
5243   // Must have hit breakpoint #1.
5244   CHECK_EQ(1, break_event_breakpoint_id);
5245   // 4:Evaluate dog() (which has a breakpoint).
5246   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_3, buffer));
5247   // V8 thread hits breakpoint in dog().
5248   breakpoints_barriers->semaphore_1->Wait();  // wait for break event
5249   // Must have hit breakpoint #2.
5250   CHECK_EQ(2, break_event_breakpoint_id);
5251   // 5:Evaluate (x + 1).
5252   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_4, buffer));
5253   // Evaluate (x + 1) finishes.
5254   breakpoints_barriers->semaphore_1->Wait();
5255   // Must have result 108.
5256   CHECK_EQ(108, evaluate_int_result);
5257   // 6:Continue evaluation of dog().
5258   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_5, buffer));
5259   // Evaluate dog() finishes.
5260   breakpoints_barriers->semaphore_1->Wait();
5261   // Must have result 107.
5262   CHECK_EQ(107, evaluate_int_result);
5263   // 7:Continue evaluation of source_2, finish cat(17), hit breakpoint
5264   // in cat(19).
5265   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_6, buffer));
5266   // Message callback gets break event.
5267   breakpoints_barriers->semaphore_1->Wait();  // wait for break event
5268   // Must have hit breakpoint #1.
5269   CHECK_EQ(1, break_event_breakpoint_id);
5270   // 8: Evaluate dog() with breaks disabled.
5271   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_7, buffer));
5272   // Evaluate dog() finishes.
5273   breakpoints_barriers->semaphore_1->Wait();
5274   // Must have result 116.
5275   CHECK_EQ(116, evaluate_int_result);
5276   // 9: Continue evaluation of source2, reach end.
5277   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_8, buffer));
5278 }
5279 
TestRecursiveBreakpointsGeneric(bool global_evaluate)5280 void TestRecursiveBreakpointsGeneric(bool global_evaluate) {
5281   i::FLAG_debugger_auto_break = true;
5282 
5283   BreakpointsDebuggerThread breakpoints_debugger_thread(global_evaluate);
5284   BreakpointsV8Thread breakpoints_v8_thread;
5285 
5286   // Create a V8 environment
5287   Barriers stack_allocated_breakpoints_barriers;
5288   stack_allocated_breakpoints_barriers.Initialize();
5289   breakpoints_barriers = &stack_allocated_breakpoints_barriers;
5290 
5291   breakpoints_v8_thread.Start();
5292   breakpoints_debugger_thread.Start();
5293 
5294   breakpoints_v8_thread.Join();
5295   breakpoints_debugger_thread.Join();
5296 }
5297 
TEST(RecursiveBreakpoints)5298 TEST(RecursiveBreakpoints) {
5299   TestRecursiveBreakpointsGeneric(false);
5300 }
5301 
TEST(RecursiveBreakpointsGlobal)5302 TEST(RecursiveBreakpointsGlobal) {
5303   TestRecursiveBreakpointsGeneric(true);
5304 }
5305 
5306 
DummyDebugEventListener(v8::DebugEvent event,v8::Handle<v8::Object> exec_state,v8::Handle<v8::Object> event_data,v8::Handle<v8::Value> data)5307 static void DummyDebugEventListener(v8::DebugEvent event,
5308                                     v8::Handle<v8::Object> exec_state,
5309                                     v8::Handle<v8::Object> event_data,
5310                                     v8::Handle<v8::Value> data) {
5311 }
5312 
5313 
TEST(SetDebugEventListenerOnUninitializedVM)5314 TEST(SetDebugEventListenerOnUninitializedVM) {
5315   v8::Debug::SetDebugEventListener(DummyDebugEventListener);
5316 }
5317 
5318 
DummyMessageHandler(const v8::Debug::Message & message)5319 static void DummyMessageHandler(const v8::Debug::Message& message) {
5320 }
5321 
5322 
TEST(SetMessageHandlerOnUninitializedVM)5323 TEST(SetMessageHandlerOnUninitializedVM) {
5324   v8::Debug::SetMessageHandler2(DummyMessageHandler);
5325 }
5326 
5327 
TEST(DebugBreakOnUninitializedVM)5328 TEST(DebugBreakOnUninitializedVM) {
5329   v8::Debug::DebugBreak();
5330 }
5331 
5332 
TEST(SendCommandToUninitializedVM)5333 TEST(SendCommandToUninitializedVM) {
5334   const char* dummy_command = "{}";
5335   uint16_t dummy_buffer[80];
5336   int dummy_length = AsciiToUtf16(dummy_command, dummy_buffer);
5337   v8::Debug::SendCommand(dummy_buffer, dummy_length);
5338 }
5339 
5340 
5341 // Source for a JavaScript function which returns the data parameter of a
5342 // function called in the context of the debugger. If no data parameter is
5343 // passed it throws an exception.
5344 static const char* debugger_call_with_data_source =
5345     "function debugger_call_with_data(exec_state, data) {"
5346     "  if (data) return data;"
5347     "  throw 'No data!'"
5348     "}";
5349 v8::Handle<v8::Function> debugger_call_with_data;
5350 
5351 
5352 // Source for a JavaScript function which returns the data parameter of a
5353 // function called in the context of the debugger. If no data parameter is
5354 // passed it throws an exception.
5355 static const char* debugger_call_with_closure_source =
5356     "var x = 3;"
5357     "(function (exec_state) {"
5358     "  if (exec_state.y) return x - 1;"
5359     "  exec_state.y = x;"
5360     "  return exec_state.y"
5361     "})";
5362 v8::Handle<v8::Function> debugger_call_with_closure;
5363 
5364 // Function to retrieve the number of JavaScript frames by calling a JavaScript
5365 // in the debugger.
CheckFrameCount(const v8::Arguments & args)5366 static v8::Handle<v8::Value> CheckFrameCount(const v8::Arguments& args) {
5367   CHECK(v8::Debug::Call(frame_count)->IsNumber());
5368   CHECK_EQ(args[0]->Int32Value(),
5369            v8::Debug::Call(frame_count)->Int32Value());
5370   return v8::Undefined();
5371 }
5372 
5373 
5374 // Function to retrieve the source line of the top JavaScript frame by calling a
5375 // JavaScript function in the debugger.
CheckSourceLine(const v8::Arguments & args)5376 static v8::Handle<v8::Value> CheckSourceLine(const v8::Arguments& args) {
5377   CHECK(v8::Debug::Call(frame_source_line)->IsNumber());
5378   CHECK_EQ(args[0]->Int32Value(),
5379            v8::Debug::Call(frame_source_line)->Int32Value());
5380   return v8::Undefined();
5381 }
5382 
5383 
5384 // Function to test passing an additional parameter to a JavaScript function
5385 // called in the debugger. It also tests that functions called in the debugger
5386 // can throw exceptions.
CheckDataParameter(const v8::Arguments & args)5387 static v8::Handle<v8::Value> CheckDataParameter(const v8::Arguments& args) {
5388   v8::Handle<v8::String> data = v8::String::New("Test");
5389   CHECK(v8::Debug::Call(debugger_call_with_data, data)->IsString());
5390 
5391   CHECK(v8::Debug::Call(debugger_call_with_data).IsEmpty());
5392   CHECK(v8::Debug::Call(debugger_call_with_data).IsEmpty());
5393 
5394   v8::TryCatch catcher;
5395   v8::Debug::Call(debugger_call_with_data);
5396   CHECK(catcher.HasCaught());
5397   CHECK(catcher.Exception()->IsString());
5398 
5399   return v8::Undefined();
5400 }
5401 
5402 
5403 // Function to test using a JavaScript with closure in the debugger.
CheckClosure(const v8::Arguments & args)5404 static v8::Handle<v8::Value> CheckClosure(const v8::Arguments& args) {
5405   CHECK(v8::Debug::Call(debugger_call_with_closure)->IsNumber());
5406   CHECK_EQ(3, v8::Debug::Call(debugger_call_with_closure)->Int32Value());
5407   return v8::Undefined();
5408 }
5409 
5410 
5411 // Test functions called through the debugger.
TEST(CallFunctionInDebugger)5412 TEST(CallFunctionInDebugger) {
5413   // Create and enter a context with the functions CheckFrameCount,
5414   // CheckSourceLine and CheckDataParameter installed.
5415   v8::HandleScope scope;
5416   v8::Handle<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
5417   global_template->Set(v8::String::New("CheckFrameCount"),
5418                        v8::FunctionTemplate::New(CheckFrameCount));
5419   global_template->Set(v8::String::New("CheckSourceLine"),
5420                        v8::FunctionTemplate::New(CheckSourceLine));
5421   global_template->Set(v8::String::New("CheckDataParameter"),
5422                        v8::FunctionTemplate::New(CheckDataParameter));
5423   global_template->Set(v8::String::New("CheckClosure"),
5424                        v8::FunctionTemplate::New(CheckClosure));
5425   v8::Handle<v8::Context> context = v8::Context::New(NULL, global_template);
5426   v8::Context::Scope context_scope(context);
5427 
5428   // Compile a function for checking the number of JavaScript frames.
5429   v8::Script::Compile(v8::String::New(frame_count_source))->Run();
5430   frame_count = v8::Local<v8::Function>::Cast(
5431       context->Global()->Get(v8::String::New("frame_count")));
5432 
5433   // Compile a function for returning the source line for the top frame.
5434   v8::Script::Compile(v8::String::New(frame_source_line_source))->Run();
5435   frame_source_line = v8::Local<v8::Function>::Cast(
5436       context->Global()->Get(v8::String::New("frame_source_line")));
5437 
5438   // Compile a function returning the data parameter.
5439   v8::Script::Compile(v8::String::New(debugger_call_with_data_source))->Run();
5440   debugger_call_with_data = v8::Local<v8::Function>::Cast(
5441       context->Global()->Get(v8::String::New("debugger_call_with_data")));
5442 
5443   // Compile a function capturing closure.
5444   debugger_call_with_closure = v8::Local<v8::Function>::Cast(
5445       v8::Script::Compile(
5446           v8::String::New(debugger_call_with_closure_source))->Run());
5447 
5448   // Calling a function through the debugger returns 0 frames if there are
5449   // no JavaScript frames.
5450   CHECK_EQ(v8::Integer::New(0), v8::Debug::Call(frame_count));
5451 
5452   // Test that the number of frames can be retrieved.
5453   v8::Script::Compile(v8::String::New("CheckFrameCount(1)"))->Run();
5454   v8::Script::Compile(v8::String::New("function f() {"
5455                                       "  CheckFrameCount(2);"
5456                                       "}; f()"))->Run();
5457 
5458   // Test that the source line can be retrieved.
5459   v8::Script::Compile(v8::String::New("CheckSourceLine(0)"))->Run();
5460   v8::Script::Compile(v8::String::New("function f() {\n"
5461                                       "  CheckSourceLine(1)\n"
5462                                       "  CheckSourceLine(2)\n"
5463                                       "  CheckSourceLine(3)\n"
5464                                       "}; f()"))->Run();
5465 
5466   // Test that a parameter can be passed to a function called in the debugger.
5467   v8::Script::Compile(v8::String::New("CheckDataParameter()"))->Run();
5468 
5469   // Test that a function with closure can be run in the debugger.
5470   v8::Script::Compile(v8::String::New("CheckClosure()"))->Run();
5471 
5472 
5473   // Test that the source line is correct when there is a line offset.
5474   v8::ScriptOrigin origin(v8::String::New("test"),
5475                           v8::Integer::New(7));
5476   v8::Script::Compile(v8::String::New("CheckSourceLine(7)"), &origin)->Run();
5477   v8::Script::Compile(v8::String::New("function f() {\n"
5478                                       "  CheckSourceLine(8)\n"
5479                                       "  CheckSourceLine(9)\n"
5480                                       "  CheckSourceLine(10)\n"
5481                                       "}; f()"), &origin)->Run();
5482 }
5483 
5484 
5485 // Debugger message handler which counts the number of breaks.
5486 static void SendContinueCommand();
MessageHandlerBreakPointHitCount(const v8::Debug::Message & message)5487 static void MessageHandlerBreakPointHitCount(
5488     const v8::Debug::Message& message) {
5489   if (message.IsEvent() && message.GetEvent() == v8::Break) {
5490     // Count the number of breaks.
5491     break_point_hit_count++;
5492 
5493     SendContinueCommand();
5494   }
5495 }
5496 
5497 
5498 // Test that clearing the debug event listener actually clears all break points
5499 // and related information.
TEST(DebuggerUnload)5500 TEST(DebuggerUnload) {
5501   DebugLocalContext env;
5502 
5503   // Check debugger is unloaded before it is used.
5504   CheckDebuggerUnloaded();
5505 
5506   // Set a debug event listener.
5507   break_point_hit_count = 0;
5508   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
5509                                    v8::Undefined());
5510   {
5511     v8::HandleScope scope;
5512     // Create a couple of functions for the test.
5513     v8::Local<v8::Function> foo =
5514         CompileFunction(&env, "function foo(){x=1}", "foo");
5515     v8::Local<v8::Function> bar =
5516         CompileFunction(&env, "function bar(){y=2}", "bar");
5517 
5518     // Set some break points.
5519     SetBreakPoint(foo, 0);
5520     SetBreakPoint(foo, 4);
5521     SetBreakPoint(bar, 0);
5522     SetBreakPoint(bar, 4);
5523 
5524     // Make sure that the break points are there.
5525     break_point_hit_count = 0;
5526     foo->Call(env->Global(), 0, NULL);
5527     CHECK_EQ(2, break_point_hit_count);
5528     bar->Call(env->Global(), 0, NULL);
5529     CHECK_EQ(4, break_point_hit_count);
5530   }
5531 
5532   // Remove the debug event listener without clearing breakpoints. Do this
5533   // outside a handle scope.
5534   v8::Debug::SetDebugEventListener(NULL);
5535   CheckDebuggerUnloaded(true);
5536 
5537   // Now set a debug message handler.
5538   break_point_hit_count = 0;
5539   v8::Debug::SetMessageHandler2(MessageHandlerBreakPointHitCount);
5540   {
5541     v8::HandleScope scope;
5542 
5543     // Get the test functions again.
5544     v8::Local<v8::Function> foo(v8::Local<v8::Function>::Cast(
5545         env->Global()->Get(v8::String::New("foo"))));
5546 
5547     foo->Call(env->Global(), 0, NULL);
5548     CHECK_EQ(0, break_point_hit_count);
5549 
5550     // Set break points and run again.
5551     SetBreakPoint(foo, 0);
5552     SetBreakPoint(foo, 4);
5553     foo->Call(env->Global(), 0, NULL);
5554     CHECK_EQ(2, break_point_hit_count);
5555   }
5556 
5557   // Remove the debug message handler without clearing breakpoints. Do this
5558   // outside a handle scope.
5559   v8::Debug::SetMessageHandler2(NULL);
5560   CheckDebuggerUnloaded(true);
5561 }
5562 
5563 
5564 // Sends continue command to the debugger.
SendContinueCommand()5565 static void SendContinueCommand() {
5566   const int kBufferSize = 1000;
5567   uint16_t buffer[kBufferSize];
5568   const char* command_continue =
5569     "{\"seq\":0,"
5570      "\"type\":\"request\","
5571      "\"command\":\"continue\"}";
5572 
5573   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_continue, buffer));
5574 }
5575 
5576 
5577 // Debugger message handler which counts the number of times it is called.
5578 static int message_handler_hit_count = 0;
MessageHandlerHitCount(const v8::Debug::Message & message)5579 static void MessageHandlerHitCount(const v8::Debug::Message& message) {
5580   message_handler_hit_count++;
5581 
5582   static char print_buffer[1000];
5583   v8::String::Value json(message.GetJSON());
5584   Utf16ToAscii(*json, json.length(), print_buffer);
5585   if (IsExceptionEventMessage(print_buffer)) {
5586     // Send a continue command for exception events.
5587     SendContinueCommand();
5588   }
5589 }
5590 
5591 
5592 // Test clearing the debug message handler.
TEST(DebuggerClearMessageHandler)5593 TEST(DebuggerClearMessageHandler) {
5594   v8::HandleScope scope;
5595   DebugLocalContext env;
5596 
5597   // Check debugger is unloaded before it is used.
5598   CheckDebuggerUnloaded();
5599 
5600   // Set a debug message handler.
5601   v8::Debug::SetMessageHandler2(MessageHandlerHitCount);
5602 
5603   // Run code to throw a unhandled exception. This should end up in the message
5604   // handler.
5605   CompileRun("throw 1");
5606 
5607   // The message handler should be called.
5608   CHECK_GT(message_handler_hit_count, 0);
5609 
5610   // Clear debug message handler.
5611   message_handler_hit_count = 0;
5612   v8::Debug::SetMessageHandler(NULL);
5613 
5614   // Run code to throw a unhandled exception. This should end up in the message
5615   // handler.
5616   CompileRun("throw 1");
5617 
5618   // The message handler should not be called more.
5619   CHECK_EQ(0, message_handler_hit_count);
5620 
5621   CheckDebuggerUnloaded(true);
5622 }
5623 
5624 
5625 // Debugger message handler which clears the message handler while active.
MessageHandlerClearingMessageHandler(const v8::Debug::Message & message)5626 static void MessageHandlerClearingMessageHandler(
5627     const v8::Debug::Message& message) {
5628   message_handler_hit_count++;
5629 
5630   // Clear debug message handler.
5631   v8::Debug::SetMessageHandler(NULL);
5632 }
5633 
5634 
5635 // Test clearing the debug message handler while processing a debug event.
TEST(DebuggerClearMessageHandlerWhileActive)5636 TEST(DebuggerClearMessageHandlerWhileActive) {
5637   v8::HandleScope scope;
5638   DebugLocalContext env;
5639 
5640   // Check debugger is unloaded before it is used.
5641   CheckDebuggerUnloaded();
5642 
5643   // Set a debug message handler.
5644   v8::Debug::SetMessageHandler2(MessageHandlerClearingMessageHandler);
5645 
5646   // Run code to throw a unhandled exception. This should end up in the message
5647   // handler.
5648   CompileRun("throw 1");
5649 
5650   // The message handler should be called.
5651   CHECK_EQ(1, message_handler_hit_count);
5652 
5653   CheckDebuggerUnloaded(true);
5654 }
5655 
5656 
5657 /* Test DebuggerHostDispatch */
5658 /* In this test, the debugger waits for a command on a breakpoint
5659  * and is dispatching host commands while in the infinite loop.
5660  */
5661 
5662 class HostDispatchV8Thread : public v8::internal::Thread {
5663  public:
HostDispatchV8Thread()5664   HostDispatchV8Thread() : Thread("HostDispatchV8Thread") { }
5665   void Run();
5666 };
5667 
5668 class HostDispatchDebuggerThread : public v8::internal::Thread {
5669  public:
HostDispatchDebuggerThread()5670   HostDispatchDebuggerThread() : Thread("HostDispatchDebuggerThread") { }
5671   void Run();
5672 };
5673 
5674 Barriers* host_dispatch_barriers;
5675 
HostDispatchMessageHandler(const v8::Debug::Message & message)5676 static void HostDispatchMessageHandler(const v8::Debug::Message& message) {
5677   static char print_buffer[1000];
5678   v8::String::Value json(message.GetJSON());
5679   Utf16ToAscii(*json, json.length(), print_buffer);
5680 }
5681 
5682 
HostDispatchDispatchHandler()5683 static void HostDispatchDispatchHandler() {
5684   host_dispatch_barriers->semaphore_1->Signal();
5685 }
5686 
5687 
Run()5688 void HostDispatchV8Thread::Run() {
5689   const char* source_1 = "var y_global = 3;\n"
5690     "function cat( new_value ) {\n"
5691     "  var x = new_value;\n"
5692     "  y_global = 4;\n"
5693     "  x = 3 * x + 1;\n"
5694     "  y_global = 5;\n"
5695     "  return x;\n"
5696     "}\n"
5697     "\n";
5698   const char* source_2 = "cat(17);\n";
5699 
5700   v8::V8::Initialize();
5701   v8::HandleScope scope;
5702   DebugLocalContext env;
5703 
5704   // Set up message and host dispatch handlers.
5705   v8::Debug::SetMessageHandler2(HostDispatchMessageHandler);
5706   v8::Debug::SetHostDispatchHandler(HostDispatchDispatchHandler, 10 /* ms */);
5707 
5708   CompileRun(source_1);
5709   host_dispatch_barriers->barrier_1.Wait();
5710   host_dispatch_barriers->barrier_2.Wait();
5711   CompileRun(source_2);
5712 }
5713 
5714 
Run()5715 void HostDispatchDebuggerThread::Run() {
5716   const int kBufSize = 1000;
5717   uint16_t buffer[kBufSize];
5718 
5719   const char* command_1 = "{\"seq\":101,"
5720       "\"type\":\"request\","
5721       "\"command\":\"setbreakpoint\","
5722       "\"arguments\":{\"type\":\"function\",\"target\":\"cat\",\"line\":3}}";
5723   const char* command_2 = "{\"seq\":102,"
5724       "\"type\":\"request\","
5725       "\"command\":\"continue\"}";
5726 
5727   // v8 thread initializes, runs source_1
5728   host_dispatch_barriers->barrier_1.Wait();
5729   // 1: Set breakpoint in cat().
5730   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_1, buffer));
5731 
5732   host_dispatch_barriers->barrier_2.Wait();
5733   // v8 thread starts compiling source_2.
5734   // Break happens, to run queued commands and host dispatches.
5735   // Wait for host dispatch to be processed.
5736   host_dispatch_barriers->semaphore_1->Wait();
5737   // 2: Continue evaluation
5738   v8::Debug::SendCommand(buffer, AsciiToUtf16(command_2, buffer));
5739 }
5740 
5741 
TEST(DebuggerHostDispatch)5742 TEST(DebuggerHostDispatch) {
5743   HostDispatchDebuggerThread host_dispatch_debugger_thread;
5744   HostDispatchV8Thread host_dispatch_v8_thread;
5745   i::FLAG_debugger_auto_break = true;
5746 
5747   // Create a V8 environment
5748   Barriers stack_allocated_host_dispatch_barriers;
5749   stack_allocated_host_dispatch_barriers.Initialize();
5750   host_dispatch_barriers = &stack_allocated_host_dispatch_barriers;
5751 
5752   host_dispatch_v8_thread.Start();
5753   host_dispatch_debugger_thread.Start();
5754 
5755   host_dispatch_v8_thread.Join();
5756   host_dispatch_debugger_thread.Join();
5757 }
5758 
5759 
5760 /* Test DebugMessageDispatch */
5761 /* In this test, the V8 thread waits for a message from the debug thread.
5762  * The DebugMessageDispatchHandler is executed from the debugger thread
5763  * which signals the V8 thread to wake up.
5764  */
5765 
5766 class DebugMessageDispatchV8Thread : public v8::internal::Thread {
5767  public:
DebugMessageDispatchV8Thread()5768   DebugMessageDispatchV8Thread() : Thread("DebugMessageDispatchV8Thread") { }
5769   void Run();
5770 };
5771 
5772 class DebugMessageDispatchDebuggerThread : public v8::internal::Thread {
5773  public:
DebugMessageDispatchDebuggerThread()5774   DebugMessageDispatchDebuggerThread()
5775       : Thread("DebugMessageDispatchDebuggerThread") { }
5776   void Run();
5777 };
5778 
5779 Barriers* debug_message_dispatch_barriers;
5780 
5781 
DebugMessageHandler()5782 static void DebugMessageHandler() {
5783   debug_message_dispatch_barriers->semaphore_1->Signal();
5784 }
5785 
5786 
Run()5787 void DebugMessageDispatchV8Thread::Run() {
5788   v8::V8::Initialize();
5789   v8::HandleScope scope;
5790   DebugLocalContext env;
5791 
5792   // Set up debug message dispatch handler.
5793   v8::Debug::SetDebugMessageDispatchHandler(DebugMessageHandler);
5794 
5795   CompileRun("var y = 1 + 2;\n");
5796   debug_message_dispatch_barriers->barrier_1.Wait();
5797   debug_message_dispatch_barriers->semaphore_1->Wait();
5798   debug_message_dispatch_barriers->barrier_2.Wait();
5799 }
5800 
5801 
Run()5802 void DebugMessageDispatchDebuggerThread::Run() {
5803   debug_message_dispatch_barriers->barrier_1.Wait();
5804   SendContinueCommand();
5805   debug_message_dispatch_barriers->barrier_2.Wait();
5806 }
5807 
5808 
TEST(DebuggerDebugMessageDispatch)5809 TEST(DebuggerDebugMessageDispatch) {
5810   DebugMessageDispatchDebuggerThread debug_message_dispatch_debugger_thread;
5811   DebugMessageDispatchV8Thread debug_message_dispatch_v8_thread;
5812 
5813   i::FLAG_debugger_auto_break = true;
5814 
5815   // Create a V8 environment
5816   Barriers stack_allocated_debug_message_dispatch_barriers;
5817   stack_allocated_debug_message_dispatch_barriers.Initialize();
5818   debug_message_dispatch_barriers =
5819       &stack_allocated_debug_message_dispatch_barriers;
5820 
5821   debug_message_dispatch_v8_thread.Start();
5822   debug_message_dispatch_debugger_thread.Start();
5823 
5824   debug_message_dispatch_v8_thread.Join();
5825   debug_message_dispatch_debugger_thread.Join();
5826 }
5827 
5828 
TEST(DebuggerAgent)5829 TEST(DebuggerAgent) {
5830   v8::V8::Initialize();
5831   i::Debugger* debugger = i::Isolate::Current()->debugger();
5832   // Make sure these ports is not used by other tests to allow tests to run in
5833   // parallel.
5834   const int kPort1 = 5858;
5835   const int kPort2 = 5857;
5836   const int kPort3 = 5856;
5837 
5838   // Make a string with the port2 number.
5839   const int kPortBufferLen = 6;
5840   char port2_str[kPortBufferLen];
5841   OS::SNPrintF(i::Vector<char>(port2_str, kPortBufferLen), "%d", kPort2);
5842 
5843   bool ok;
5844 
5845   // Initialize the socket library.
5846   i::Socket::SetUp();
5847 
5848   // Test starting and stopping the agent without any client connection.
5849   debugger->StartAgent("test", kPort1);
5850   debugger->StopAgent();
5851   // Test starting the agent, connecting a client and shutting down the agent
5852   // with the client connected.
5853   ok = debugger->StartAgent("test", kPort2);
5854   CHECK(ok);
5855   debugger->WaitForAgent();
5856   i::Socket* client = i::OS::CreateSocket();
5857   ok = client->Connect("localhost", port2_str);
5858   CHECK(ok);
5859   // It is important to wait for a message from the agent. Otherwise,
5860   // we can close the server socket during "accept" syscall, making it failing
5861   // (at least on Linux), and the test will work incorrectly.
5862   char buf;
5863   ok = client->Receive(&buf, 1) == 1;
5864   CHECK(ok);
5865   debugger->StopAgent();
5866   delete client;
5867 
5868   // Test starting and stopping the agent with the required port already
5869   // occoupied.
5870   i::Socket* server = i::OS::CreateSocket();
5871   server->Bind(kPort3);
5872 
5873   debugger->StartAgent("test", kPort3);
5874   debugger->StopAgent();
5875 
5876   delete server;
5877 }
5878 
5879 
5880 class DebuggerAgentProtocolServerThread : public i::Thread {
5881  public:
DebuggerAgentProtocolServerThread(int port)5882   explicit DebuggerAgentProtocolServerThread(int port)
5883       : Thread("DebuggerAgentProtocolServerThread"),
5884         port_(port),
5885         server_(NULL),
5886         client_(NULL),
5887         listening_(OS::CreateSemaphore(0)) {
5888   }
~DebuggerAgentProtocolServerThread()5889   ~DebuggerAgentProtocolServerThread() {
5890     // Close both sockets.
5891     delete client_;
5892     delete server_;
5893     delete listening_;
5894   }
5895 
5896   void Run();
WaitForListening()5897   void WaitForListening() { listening_->Wait(); }
body()5898   char* body() { return *body_; }
5899 
5900  private:
5901   int port_;
5902   i::SmartArrayPointer<char> body_;
5903   i::Socket* server_;  // Server socket used for bind/accept.
5904   i::Socket* client_;  // Single client connection used by the test.
5905   i::Semaphore* listening_;  // Signalled when the server is in listen mode.
5906 };
5907 
5908 
Run()5909 void DebuggerAgentProtocolServerThread::Run() {
5910   bool ok;
5911 
5912   // Create the server socket and bind it to the requested port.
5913   server_ = i::OS::CreateSocket();
5914   CHECK(server_ != NULL);
5915   ok = server_->Bind(port_);
5916   CHECK(ok);
5917 
5918   // Listen for new connections.
5919   ok = server_->Listen(1);
5920   CHECK(ok);
5921   listening_->Signal();
5922 
5923   // Accept a connection.
5924   client_ = server_->Accept();
5925   CHECK(client_ != NULL);
5926 
5927   // Receive a debugger agent protocol message.
5928   i::DebuggerAgentUtil::ReceiveMessage(client_);
5929 }
5930 
5931 
TEST(DebuggerAgentProtocolOverflowHeader)5932 TEST(DebuggerAgentProtocolOverflowHeader) {
5933   // Make sure this port is not used by other tests to allow tests to run in
5934   // parallel.
5935   const int kPort = 5860;
5936   static const char* kLocalhost = "localhost";
5937 
5938   // Make a string with the port number.
5939   const int kPortBufferLen = 6;
5940   char port_str[kPortBufferLen];
5941   OS::SNPrintF(i::Vector<char>(port_str, kPortBufferLen), "%d", kPort);
5942 
5943   // Initialize the socket library.
5944   i::Socket::SetUp();
5945 
5946   // Create a socket server to receive a debugger agent message.
5947   DebuggerAgentProtocolServerThread* server =
5948       new DebuggerAgentProtocolServerThread(kPort);
5949   server->Start();
5950   server->WaitForListening();
5951 
5952   // Connect.
5953   i::Socket* client = i::OS::CreateSocket();
5954   CHECK(client != NULL);
5955   bool ok = client->Connect(kLocalhost, port_str);
5956   CHECK(ok);
5957 
5958   // Send headers which overflow the receive buffer.
5959   static const int kBufferSize = 1000;
5960   char buffer[kBufferSize];
5961 
5962   // Long key and short value: XXXX....XXXX:0\r\n.
5963   for (int i = 0; i < kBufferSize - 4; i++) {
5964     buffer[i] = 'X';
5965   }
5966   buffer[kBufferSize - 4] = ':';
5967   buffer[kBufferSize - 3] = '0';
5968   buffer[kBufferSize - 2] = '\r';
5969   buffer[kBufferSize - 1] = '\n';
5970   client->Send(buffer, kBufferSize);
5971 
5972   // Short key and long value: X:XXXX....XXXX\r\n.
5973   buffer[0] = 'X';
5974   buffer[1] = ':';
5975   for (int i = 2; i < kBufferSize - 2; i++) {
5976     buffer[i] = 'X';
5977   }
5978   buffer[kBufferSize - 2] = '\r';
5979   buffer[kBufferSize - 1] = '\n';
5980   client->Send(buffer, kBufferSize);
5981 
5982   // Add empty body to request.
5983   const char* content_length_zero_header = "Content-Length:0\r\n";
5984   client->Send(content_length_zero_header,
5985                StrLength(content_length_zero_header));
5986   client->Send("\r\n", 2);
5987 
5988   // Wait until data is received.
5989   server->Join();
5990 
5991   // Check for empty body.
5992   CHECK(server->body() == NULL);
5993 
5994   // Close the client before the server to avoid TIME_WAIT issues.
5995   client->Shutdown();
5996   delete client;
5997   delete server;
5998 }
5999 
6000 
6001 // Test for issue http://code.google.com/p/v8/issues/detail?id=289.
6002 // Make sure that DebugGetLoadedScripts doesn't return scripts
6003 // with disposed external source.
6004 class EmptyExternalStringResource : public v8::String::ExternalStringResource {
6005  public:
EmptyExternalStringResource()6006   EmptyExternalStringResource() { empty_[0] = 0; }
~EmptyExternalStringResource()6007   virtual ~EmptyExternalStringResource() {}
length() const6008   virtual size_t length() const { return empty_.length(); }
data() const6009   virtual const uint16_t* data() const { return empty_.start(); }
6010  private:
6011   ::v8::internal::EmbeddedVector<uint16_t, 1> empty_;
6012 };
6013 
6014 
TEST(DebugGetLoadedScripts)6015 TEST(DebugGetLoadedScripts) {
6016   v8::HandleScope scope;
6017   DebugLocalContext env;
6018   env.ExposeDebug();
6019 
6020   EmptyExternalStringResource source_ext_str;
6021   v8::Local<v8::String> source = v8::String::NewExternal(&source_ext_str);
6022   v8::Handle<v8::Script> evil_script(v8::Script::Compile(source));
6023   // "use" evil_script to make the compiler happy.
6024   (void) evil_script;
6025   Handle<i::ExternalTwoByteString> i_source(
6026       i::ExternalTwoByteString::cast(*v8::Utils::OpenHandle(*source)));
6027   // This situation can happen if source was an external string disposed
6028   // by its owner.
6029   i_source->set_resource(0);
6030 
6031   bool allow_natives_syntax = i::FLAG_allow_natives_syntax;
6032   i::FLAG_allow_natives_syntax = true;
6033   CompileRun(
6034       "var scripts = %DebugGetLoadedScripts();"
6035       "var count = scripts.length;"
6036       "for (var i = 0; i < count; ++i) {"
6037       "  scripts[i].line_ends;"
6038       "}");
6039   // Must not crash while accessing line_ends.
6040   i::FLAG_allow_natives_syntax = allow_natives_syntax;
6041 
6042   // Some scripts are retrieved - at least the number of native scripts.
6043   CHECK_GT((*env)->Global()->Get(v8::String::New("count"))->Int32Value(), 8);
6044 }
6045 
6046 
6047 // Test script break points set on lines.
TEST(ScriptNameAndData)6048 TEST(ScriptNameAndData) {
6049   v8::HandleScope scope;
6050   DebugLocalContext env;
6051   env.ExposeDebug();
6052 
6053   // Create functions for retrieving script name and data for the function on
6054   // the top frame when hitting a break point.
6055   frame_script_name = CompileFunction(&env,
6056                                       frame_script_name_source,
6057                                       "frame_script_name");
6058   frame_script_data = CompileFunction(&env,
6059                                       frame_script_data_source,
6060                                       "frame_script_data");
6061   compiled_script_data = CompileFunction(&env,
6062                                          compiled_script_data_source,
6063                                          "compiled_script_data");
6064 
6065   v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
6066                                    v8::Undefined());
6067 
6068   // Test function source.
6069   v8::Local<v8::String> script = v8::String::New(
6070     "function f() {\n"
6071     "  debugger;\n"
6072     "}\n");
6073 
6074   v8::ScriptOrigin origin1 = v8::ScriptOrigin(v8::String::New("name"));
6075   v8::Handle<v8::Script> script1 = v8::Script::Compile(script, &origin1);
6076   script1->SetData(v8::String::New("data"));
6077   script1->Run();
6078   v8::Local<v8::Function> f;
6079   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
6080 
6081   f->Call(env->Global(), 0, NULL);
6082   CHECK_EQ(1, break_point_hit_count);
6083   CHECK_EQ("name", last_script_name_hit);
6084   CHECK_EQ("data", last_script_data_hit);
6085 
6086   // Compile the same script again without setting data. As the compilation
6087   // cache is disabled when debugging expect the data to be missing.
6088   v8::Script::Compile(script, &origin1)->Run();
6089   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
6090   f->Call(env->Global(), 0, NULL);
6091   CHECK_EQ(2, break_point_hit_count);
6092   CHECK_EQ("name", last_script_name_hit);
6093   CHECK_EQ("", last_script_data_hit);  // Undefined results in empty string.
6094 
6095   v8::Local<v8::String> data_obj_source = v8::String::New(
6096     "({ a: 'abc',\n"
6097     "  b: 123,\n"
6098     "  toString: function() { return this.a + ' ' + this.b; }\n"
6099     "})\n");
6100   v8::Local<v8::Value> data_obj = v8::Script::Compile(data_obj_source)->Run();
6101   v8::ScriptOrigin origin2 = v8::ScriptOrigin(v8::String::New("new name"));
6102   v8::Handle<v8::Script> script2 = v8::Script::Compile(script, &origin2);
6103   script2->Run();
6104   script2->SetData(data_obj->ToString());
6105   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
6106   f->Call(env->Global(), 0, NULL);
6107   CHECK_EQ(3, break_point_hit_count);
6108   CHECK_EQ("new name", last_script_name_hit);
6109   CHECK_EQ("abc 123", last_script_data_hit);
6110 
6111   v8::Handle<v8::Script> script3 =
6112       v8::Script::Compile(script, &origin2, NULL,
6113                           v8::String::New("in compile"));
6114   CHECK_EQ("in compile", last_script_data_hit);
6115   script3->Run();
6116   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
6117   f->Call(env->Global(), 0, NULL);
6118   CHECK_EQ(4, break_point_hit_count);
6119   CHECK_EQ("in compile", last_script_data_hit);
6120 }
6121 
6122 
6123 static v8::Persistent<v8::Context> expected_context;
6124 static v8::Handle<v8::Value> expected_context_data;
6125 
6126 
6127 // Check that the expected context is the one generating the debug event.
ContextCheckMessageHandler(const v8::Debug::Message & message)6128 static void ContextCheckMessageHandler(const v8::Debug::Message& message) {
6129   CHECK(message.GetEventContext() == expected_context);
6130   CHECK(message.GetEventContext()->GetData()->StrictEquals(
6131       expected_context_data));
6132   message_handler_hit_count++;
6133 
6134   static char print_buffer[1000];
6135   v8::String::Value json(message.GetJSON());
6136   Utf16ToAscii(*json, json.length(), print_buffer);
6137 
6138   // Send a continue command for break events.
6139   if (IsBreakEventMessage(print_buffer)) {
6140     SendContinueCommand();
6141   }
6142 }
6143 
6144 
6145 // Test which creates two contexts and sets different embedder data on each.
6146 // Checks that this data is set correctly and that when the debug message
6147 // handler is called the expected context is the one active.
TEST(ContextData)6148 TEST(ContextData) {
6149   v8::HandleScope scope;
6150 
6151   v8::Debug::SetMessageHandler2(ContextCheckMessageHandler);
6152 
6153   // Create two contexts.
6154   v8::Persistent<v8::Context> context_1;
6155   v8::Persistent<v8::Context> context_2;
6156   v8::Handle<v8::ObjectTemplate> global_template =
6157       v8::Handle<v8::ObjectTemplate>();
6158   v8::Handle<v8::Value> global_object = v8::Handle<v8::Value>();
6159   context_1 = v8::Context::New(NULL, global_template, global_object);
6160   context_2 = v8::Context::New(NULL, global_template, global_object);
6161 
6162   // Default data value is undefined.
6163   CHECK(context_1->GetData()->IsUndefined());
6164   CHECK(context_2->GetData()->IsUndefined());
6165 
6166   // Set and check different data values.
6167   v8::Handle<v8::String> data_1 = v8::String::New("1");
6168   v8::Handle<v8::String> data_2 = v8::String::New("2");
6169   context_1->SetData(data_1);
6170   context_2->SetData(data_2);
6171   CHECK(context_1->GetData()->StrictEquals(data_1));
6172   CHECK(context_2->GetData()->StrictEquals(data_2));
6173 
6174   // Simple test function which causes a break.
6175   const char* source = "function f() { debugger; }";
6176 
6177   // Enter and run function in the first context.
6178   {
6179     v8::Context::Scope context_scope(context_1);
6180     expected_context = context_1;
6181     expected_context_data = data_1;
6182     v8::Local<v8::Function> f = CompileFunction(source, "f");
6183     f->Call(context_1->Global(), 0, NULL);
6184   }
6185 
6186 
6187   // Enter and run function in the second context.
6188   {
6189     v8::Context::Scope context_scope(context_2);
6190     expected_context = context_2;
6191     expected_context_data = data_2;
6192     v8::Local<v8::Function> f = CompileFunction(source, "f");
6193     f->Call(context_2->Global(), 0, NULL);
6194   }
6195 
6196   // Two times compile event and two times break event.
6197   CHECK_GT(message_handler_hit_count, 4);
6198 
6199   v8::Debug::SetMessageHandler2(NULL);
6200   CheckDebuggerUnloaded();
6201 }
6202 
6203 
6204 // Debug message handler which issues a debug break when it hits a break event.
6205 static int message_handler_break_hit_count = 0;
DebugBreakMessageHandler(const v8::Debug::Message & message)6206 static void DebugBreakMessageHandler(const v8::Debug::Message& message) {
6207   // Schedule a debug break for break events.
6208   if (message.IsEvent() && message.GetEvent() == v8::Break) {
6209     message_handler_break_hit_count++;
6210     if (message_handler_break_hit_count == 1) {
6211       v8::Debug::DebugBreak();
6212     }
6213   }
6214 
6215   // Issue a continue command if this event will not cause the VM to start
6216   // running.
6217   if (!message.WillStartRunning()) {
6218     SendContinueCommand();
6219   }
6220 }
6221 
6222 
6223 // Test that a debug break can be scheduled while in a message handler.
TEST(DebugBreakInMessageHandler)6224 TEST(DebugBreakInMessageHandler) {
6225   v8::HandleScope scope;
6226   DebugLocalContext env;
6227 
6228   v8::Debug::SetMessageHandler2(DebugBreakMessageHandler);
6229 
6230   // Test functions.
6231   const char* script = "function f() { debugger; g(); } function g() { }";
6232   CompileRun(script);
6233   v8::Local<v8::Function> f =
6234       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
6235   v8::Local<v8::Function> g =
6236       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("g")));
6237 
6238   // Call f then g. The debugger statement in f will casue a break which will
6239   // cause another break.
6240   f->Call(env->Global(), 0, NULL);
6241   CHECK_EQ(2, message_handler_break_hit_count);
6242   // Calling g will not cause any additional breaks.
6243   g->Call(env->Global(), 0, NULL);
6244   CHECK_EQ(2, message_handler_break_hit_count);
6245 }
6246 
6247 
6248 #ifndef V8_INTERPRETED_REGEXP
6249 // Debug event handler which gets the function on the top frame and schedules a
6250 // break a number of times.
DebugEventDebugBreak(v8::DebugEvent event,v8::Handle<v8::Object> exec_state,v8::Handle<v8::Object> event_data,v8::Handle<v8::Value> data)6251 static void DebugEventDebugBreak(
6252     v8::DebugEvent event,
6253     v8::Handle<v8::Object> exec_state,
6254     v8::Handle<v8::Object> event_data,
6255     v8::Handle<v8::Value> data) {
6256 
6257   if (event == v8::Break) {
6258     break_point_hit_count++;
6259 
6260     // Get the name of the top frame function.
6261     if (!frame_function_name.IsEmpty()) {
6262       // Get the name of the function.
6263       const int argc = 2;
6264       v8::Handle<v8::Value> argv[argc] = { exec_state, v8::Integer::New(0) };
6265       v8::Handle<v8::Value> result = frame_function_name->Call(exec_state,
6266                                                                argc, argv);
6267       if (result->IsUndefined()) {
6268         last_function_hit[0] = '\0';
6269       } else {
6270         CHECK(result->IsString());
6271         v8::Handle<v8::String> function_name(result->ToString());
6272         function_name->WriteAscii(last_function_hit);
6273       }
6274     }
6275 
6276     // Keep forcing breaks.
6277     if (break_point_hit_count < 20) {
6278       v8::Debug::DebugBreak();
6279     }
6280   }
6281 }
6282 
6283 
TEST(RegExpDebugBreak)6284 TEST(RegExpDebugBreak) {
6285   // This test only applies to native regexps.
6286   v8::HandleScope scope;
6287   DebugLocalContext env;
6288 
6289   // Create a function for checking the function when hitting a break point.
6290   frame_function_name = CompileFunction(&env,
6291                                         frame_function_name_source,
6292                                         "frame_function_name");
6293 
6294   // Test RegExp which matches white spaces and comments at the begining of a
6295   // source line.
6296   const char* script =
6297     "var sourceLineBeginningSkip = /^(?:[ \\v\\h]*(?:\\/\\*.*?\\*\\/)*)*/;\n"
6298     "function f(s) { return s.match(sourceLineBeginningSkip)[0].length; }";
6299 
6300   v8::Local<v8::Function> f = CompileFunction(script, "f");
6301   const int argc = 1;
6302   v8::Handle<v8::Value> argv[argc] = { v8::String::New("  /* xxx */ a=0;") };
6303   v8::Local<v8::Value> result = f->Call(env->Global(), argc, argv);
6304   CHECK_EQ(12, result->Int32Value());
6305 
6306   v8::Debug::SetDebugEventListener(DebugEventDebugBreak);
6307   v8::Debug::DebugBreak();
6308   result = f->Call(env->Global(), argc, argv);
6309 
6310   // Check that there was only one break event. Matching RegExp should not
6311   // cause Break events.
6312   CHECK_EQ(1, break_point_hit_count);
6313   CHECK_EQ("f", last_function_hit);
6314 }
6315 #endif  // V8_INTERPRETED_REGEXP
6316 
6317 
6318 // Common part of EvalContextData and NestedBreakEventContextData tests.
ExecuteScriptForContextCheck()6319 static void ExecuteScriptForContextCheck() {
6320   // Create a context.
6321   v8::Persistent<v8::Context> context_1;
6322   v8::Handle<v8::ObjectTemplate> global_template =
6323       v8::Handle<v8::ObjectTemplate>();
6324   context_1 = v8::Context::New(NULL, global_template);
6325 
6326   // Default data value is undefined.
6327   CHECK(context_1->GetData()->IsUndefined());
6328 
6329   // Set and check a data value.
6330   v8::Handle<v8::String> data_1 = v8::String::New("1");
6331   context_1->SetData(data_1);
6332   CHECK(context_1->GetData()->StrictEquals(data_1));
6333 
6334   // Simple test function with eval that causes a break.
6335   const char* source = "function f() { eval('debugger;'); }";
6336 
6337   // Enter and run function in the context.
6338   {
6339     v8::Context::Scope context_scope(context_1);
6340     expected_context = context_1;
6341     expected_context_data = data_1;
6342     v8::Local<v8::Function> f = CompileFunction(source, "f");
6343     f->Call(context_1->Global(), 0, NULL);
6344   }
6345 }
6346 
6347 
6348 // Test which creates a context and sets embedder data on it. Checks that this
6349 // data is set correctly and that when the debug message handler is called for
6350 // break event in an eval statement the expected context is the one returned by
6351 // Message.GetEventContext.
TEST(EvalContextData)6352 TEST(EvalContextData) {
6353   v8::HandleScope scope;
6354   v8::Debug::SetMessageHandler2(ContextCheckMessageHandler);
6355 
6356   ExecuteScriptForContextCheck();
6357 
6358   // One time compile event and one time break event.
6359   CHECK_GT(message_handler_hit_count, 2);
6360   v8::Debug::SetMessageHandler2(NULL);
6361   CheckDebuggerUnloaded();
6362 }
6363 
6364 
6365 static bool sent_eval = false;
6366 static int break_count = 0;
6367 static int continue_command_send_count = 0;
6368 // Check that the expected context is the one generating the debug event
6369 // including the case of nested break event.
DebugEvalContextCheckMessageHandler(const v8::Debug::Message & message)6370 static void DebugEvalContextCheckMessageHandler(
6371     const v8::Debug::Message& message) {
6372   CHECK(message.GetEventContext() == expected_context);
6373   CHECK(message.GetEventContext()->GetData()->StrictEquals(
6374       expected_context_data));
6375   message_handler_hit_count++;
6376 
6377   static char print_buffer[1000];
6378   v8::String::Value json(message.GetJSON());
6379   Utf16ToAscii(*json, json.length(), print_buffer);
6380 
6381   if (IsBreakEventMessage(print_buffer)) {
6382     break_count++;
6383     if (!sent_eval) {
6384       sent_eval = true;
6385 
6386       const int kBufferSize = 1000;
6387       uint16_t buffer[kBufferSize];
6388       const char* eval_command =
6389           "{\"seq\":0,"
6390           "\"type\":\"request\","
6391           "\"command\":\"evaluate\","
6392           "\"arguments\":{\"expression\":\"debugger;\","
6393           "\"global\":true,\"disable_break\":false}}";
6394 
6395       // Send evaluate command.
6396       v8::Debug::SendCommand(buffer, AsciiToUtf16(eval_command, buffer));
6397       return;
6398     } else {
6399       // It's a break event caused by the evaluation request above.
6400       SendContinueCommand();
6401       continue_command_send_count++;
6402     }
6403   } else if (IsEvaluateResponseMessage(print_buffer) &&
6404       continue_command_send_count < 2) {
6405     // Response to the evaluation request. We're still on the breakpoint so
6406     // send continue.
6407     SendContinueCommand();
6408     continue_command_send_count++;
6409   }
6410 }
6411 
6412 
6413 // Tests that context returned for break event is correct when the event occurs
6414 // in 'evaluate' debugger request.
TEST(NestedBreakEventContextData)6415 TEST(NestedBreakEventContextData) {
6416   v8::HandleScope scope;
6417   break_count = 0;
6418   message_handler_hit_count = 0;
6419   v8::Debug::SetMessageHandler2(DebugEvalContextCheckMessageHandler);
6420 
6421   ExecuteScriptForContextCheck();
6422 
6423   // One time compile event and two times break event.
6424   CHECK_GT(message_handler_hit_count, 3);
6425 
6426   // One break from the source and another from the evaluate request.
6427   CHECK_EQ(break_count, 2);
6428   v8::Debug::SetMessageHandler2(NULL);
6429   CheckDebuggerUnloaded();
6430 }
6431 
6432 
6433 // Debug event listener which counts the script collected events.
6434 int script_collected_count = 0;
DebugEventScriptCollectedEvent(v8::DebugEvent event,v8::Handle<v8::Object> exec_state,v8::Handle<v8::Object> event_data,v8::Handle<v8::Value> data)6435 static void DebugEventScriptCollectedEvent(v8::DebugEvent event,
6436                                            v8::Handle<v8::Object> exec_state,
6437                                            v8::Handle<v8::Object> event_data,
6438                                            v8::Handle<v8::Value> data) {
6439   // Count the number of breaks.
6440   if (event == v8::ScriptCollected) {
6441     script_collected_count++;
6442   }
6443 }
6444 
6445 
6446 // Test that scripts collected are reported through the debug event listener.
TEST(ScriptCollectedEvent)6447 TEST(ScriptCollectedEvent) {
6448   v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
6449   break_point_hit_count = 0;
6450   script_collected_count = 0;
6451   v8::HandleScope scope;
6452   DebugLocalContext env;
6453 
6454   // Request the loaded scripts to initialize the debugger script cache.
6455   debug->GetLoadedScripts();
6456 
6457   // Do garbage collection to ensure that only the script in this test will be
6458   // collected afterwards.
6459   HEAP->CollectAllGarbage(Heap::kNoGCFlags);
6460 
6461   script_collected_count = 0;
6462   v8::Debug::SetDebugEventListener(DebugEventScriptCollectedEvent,
6463                                    v8::Undefined());
6464   {
6465     v8::Script::Compile(v8::String::New("eval('a=1')"))->Run();
6466     v8::Script::Compile(v8::String::New("eval('a=2')"))->Run();
6467   }
6468 
6469   // Do garbage collection to collect the script above which is no longer
6470   // referenced.
6471   HEAP->CollectAllGarbage(Heap::kNoGCFlags);
6472 
6473   CHECK_EQ(2, script_collected_count);
6474 
6475   v8::Debug::SetDebugEventListener(NULL);
6476   CheckDebuggerUnloaded();
6477 }
6478 
6479 
6480 // Debug event listener which counts the script collected events.
6481 int script_collected_message_count = 0;
ScriptCollectedMessageHandler(const v8::Debug::Message & message)6482 static void ScriptCollectedMessageHandler(const v8::Debug::Message& message) {
6483   // Count the number of scripts collected.
6484   if (message.IsEvent() && message.GetEvent() == v8::ScriptCollected) {
6485     script_collected_message_count++;
6486     v8::Handle<v8::Context> context = message.GetEventContext();
6487     CHECK(context.IsEmpty());
6488   }
6489 }
6490 
6491 
6492 // Test that GetEventContext doesn't fail and return empty handle for
6493 // ScriptCollected events.
TEST(ScriptCollectedEventContext)6494 TEST(ScriptCollectedEventContext) {
6495   v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
6496   script_collected_message_count = 0;
6497   v8::HandleScope scope;
6498 
6499   { // Scope for the DebugLocalContext.
6500     DebugLocalContext env;
6501 
6502     // Request the loaded scripts to initialize the debugger script cache.
6503     debug->GetLoadedScripts();
6504 
6505     // Do garbage collection to ensure that only the script in this test will be
6506     // collected afterwards.
6507     HEAP->CollectAllGarbage(Heap::kNoGCFlags);
6508 
6509     v8::Debug::SetMessageHandler2(ScriptCollectedMessageHandler);
6510     {
6511       v8::Script::Compile(v8::String::New("eval('a=1')"))->Run();
6512       v8::Script::Compile(v8::String::New("eval('a=2')"))->Run();
6513     }
6514   }
6515 
6516   // Do garbage collection to collect the script above which is no longer
6517   // referenced.
6518   HEAP->CollectAllGarbage(Heap::kNoGCFlags);
6519 
6520   CHECK_EQ(2, script_collected_message_count);
6521 
6522   v8::Debug::SetMessageHandler2(NULL);
6523 }
6524 
6525 
6526 // Debug event listener which counts the after compile events.
6527 int after_compile_message_count = 0;
AfterCompileMessageHandler(const v8::Debug::Message & message)6528 static void AfterCompileMessageHandler(const v8::Debug::Message& message) {
6529   // Count the number of scripts collected.
6530   if (message.IsEvent()) {
6531     if (message.GetEvent() == v8::AfterCompile) {
6532       after_compile_message_count++;
6533     } else if (message.GetEvent() == v8::Break) {
6534       SendContinueCommand();
6535     }
6536   }
6537 }
6538 
6539 
6540 // Tests that after compile event is sent as many times as there are scripts
6541 // compiled.
TEST(AfterCompileMessageWhenMessageHandlerIsReset)6542 TEST(AfterCompileMessageWhenMessageHandlerIsReset) {
6543   v8::HandleScope scope;
6544   DebugLocalContext env;
6545   after_compile_message_count = 0;
6546   const char* script = "var a=1";
6547 
6548   v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
6549   v8::Script::Compile(v8::String::New(script))->Run();
6550   v8::Debug::SetMessageHandler2(NULL);
6551 
6552   v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
6553   v8::Debug::DebugBreak();
6554   v8::Script::Compile(v8::String::New(script))->Run();
6555 
6556   // Setting listener to NULL should cause debugger unload.
6557   v8::Debug::SetMessageHandler2(NULL);
6558   CheckDebuggerUnloaded();
6559 
6560   // Compilation cache should be disabled when debugger is active.
6561   CHECK_EQ(2, after_compile_message_count);
6562 }
6563 
6564 
6565 // Tests that break event is sent when message handler is reset.
TEST(BreakMessageWhenMessageHandlerIsReset)6566 TEST(BreakMessageWhenMessageHandlerIsReset) {
6567   v8::HandleScope scope;
6568   DebugLocalContext env;
6569   after_compile_message_count = 0;
6570   const char* script = "function f() {};";
6571 
6572   v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
6573   v8::Script::Compile(v8::String::New(script))->Run();
6574   v8::Debug::SetMessageHandler2(NULL);
6575 
6576   v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
6577   v8::Debug::DebugBreak();
6578   v8::Local<v8::Function> f =
6579       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
6580   f->Call(env->Global(), 0, NULL);
6581 
6582   // Setting message handler to NULL should cause debugger unload.
6583   v8::Debug::SetMessageHandler2(NULL);
6584   CheckDebuggerUnloaded();
6585 
6586   // Compilation cache should be disabled when debugger is active.
6587   CHECK_EQ(1, after_compile_message_count);
6588 }
6589 
6590 
6591 static int exception_event_count = 0;
ExceptionMessageHandler(const v8::Debug::Message & message)6592 static void ExceptionMessageHandler(const v8::Debug::Message& message) {
6593   if (message.IsEvent() && message.GetEvent() == v8::Exception) {
6594     exception_event_count++;
6595     SendContinueCommand();
6596   }
6597 }
6598 
6599 
6600 // Tests that exception event is sent when message handler is reset.
TEST(ExceptionMessageWhenMessageHandlerIsReset)6601 TEST(ExceptionMessageWhenMessageHandlerIsReset) {
6602   v8::HandleScope scope;
6603   DebugLocalContext env;
6604 
6605   // For this test, we want to break on uncaught exceptions:
6606   ChangeBreakOnException(false, true);
6607 
6608   exception_event_count = 0;
6609   const char* script = "function f() {throw new Error()};";
6610 
6611   v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
6612   v8::Script::Compile(v8::String::New(script))->Run();
6613   v8::Debug::SetMessageHandler2(NULL);
6614 
6615   v8::Debug::SetMessageHandler2(ExceptionMessageHandler);
6616   v8::Local<v8::Function> f =
6617       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
6618   f->Call(env->Global(), 0, NULL);
6619 
6620   // Setting message handler to NULL should cause debugger unload.
6621   v8::Debug::SetMessageHandler2(NULL);
6622   CheckDebuggerUnloaded();
6623 
6624   CHECK_EQ(1, exception_event_count);
6625 }
6626 
6627 
6628 // Tests after compile event is sent when there are some provisional
6629 // breakpoints out of the scripts lines range.
TEST(ProvisionalBreakpointOnLineOutOfRange)6630 TEST(ProvisionalBreakpointOnLineOutOfRange) {
6631   v8::HandleScope scope;
6632   DebugLocalContext env;
6633   env.ExposeDebug();
6634   const char* script = "function f() {};";
6635   const char* resource_name = "test_resource";
6636 
6637   // Set a couple of provisional breakpoint on lines out of the script lines
6638   // range.
6639   int sbp1 = SetScriptBreakPointByNameFromJS(resource_name, 3,
6640                                              -1 /* no column */);
6641   int sbp2 = SetScriptBreakPointByNameFromJS(resource_name, 5, 5);
6642 
6643   after_compile_message_count = 0;
6644   v8::Debug::SetMessageHandler2(AfterCompileMessageHandler);
6645 
6646   v8::ScriptOrigin origin(
6647       v8::String::New(resource_name),
6648       v8::Integer::New(10),
6649       v8::Integer::New(1));
6650   // Compile a script whose first line number is greater than the breakpoints'
6651   // lines.
6652   v8::Script::Compile(v8::String::New(script), &origin)->Run();
6653 
6654   // If the script is compiled successfully there is exactly one after compile
6655   // event. In case of an exception in debugger code after compile event is not
6656   // sent.
6657   CHECK_EQ(1, after_compile_message_count);
6658 
6659   ClearBreakPointFromJS(sbp1);
6660   ClearBreakPointFromJS(sbp2);
6661   v8::Debug::SetMessageHandler2(NULL);
6662 }
6663 
6664 
BreakMessageHandler(const v8::Debug::Message & message)6665 static void BreakMessageHandler(const v8::Debug::Message& message) {
6666   i::Isolate* isolate = i::Isolate::Current();
6667   if (message.IsEvent() && message.GetEvent() == v8::Break) {
6668     // Count the number of breaks.
6669     break_point_hit_count++;
6670 
6671     v8::HandleScope scope;
6672     message.GetJSON();
6673 
6674     SendContinueCommand();
6675   } else if (message.IsEvent() && message.GetEvent() == v8::AfterCompile) {
6676     v8::HandleScope scope;
6677 
6678     bool is_debug_break = isolate->stack_guard()->IsDebugBreak();
6679     // Force DebugBreak flag while serializer is working.
6680     isolate->stack_guard()->DebugBreak();
6681 
6682     // Force serialization to trigger some internal JS execution.
6683     message.GetJSON();
6684 
6685     // Restore previous state.
6686     if (is_debug_break) {
6687       isolate->stack_guard()->DebugBreak();
6688     } else {
6689       isolate->stack_guard()->Continue(i::DEBUGBREAK);
6690     }
6691   }
6692 }
6693 
6694 
6695 // Test that if DebugBreak is forced it is ignored when code from
6696 // debug-delay.js is executed.
TEST(NoDebugBreakInAfterCompileMessageHandler)6697 TEST(NoDebugBreakInAfterCompileMessageHandler) {
6698   v8::HandleScope scope;
6699   DebugLocalContext env;
6700 
6701   // Register a debug event listener which sets the break flag and counts.
6702   v8::Debug::SetMessageHandler2(BreakMessageHandler);
6703 
6704   // Set the debug break flag.
6705   v8::Debug::DebugBreak();
6706 
6707   // Create a function for testing stepping.
6708   const char* src = "function f() { eval('var x = 10;'); } ";
6709   v8::Local<v8::Function> f = CompileFunction(&env, src, "f");
6710 
6711   // There should be only one break event.
6712   CHECK_EQ(1, break_point_hit_count);
6713 
6714   // Set the debug break flag again.
6715   v8::Debug::DebugBreak();
6716   f->Call(env->Global(), 0, NULL);
6717   // There should be one more break event when the script is evaluated in 'f'.
6718   CHECK_EQ(2, break_point_hit_count);
6719 
6720   // Get rid of the debug message handler.
6721   v8::Debug::SetMessageHandler2(NULL);
6722   CheckDebuggerUnloaded();
6723 }
6724 
6725 
6726 static int counting_message_handler_counter;
6727 
CountingMessageHandler(const v8::Debug::Message & message)6728 static void CountingMessageHandler(const v8::Debug::Message& message) {
6729   counting_message_handler_counter++;
6730 }
6731 
6732 // Test that debug messages get processed when ProcessDebugMessages is called.
TEST(ProcessDebugMessages)6733 TEST(ProcessDebugMessages) {
6734   v8::HandleScope scope;
6735   DebugLocalContext env;
6736 
6737   counting_message_handler_counter = 0;
6738 
6739   v8::Debug::SetMessageHandler2(CountingMessageHandler);
6740 
6741   const int kBufferSize = 1000;
6742   uint16_t buffer[kBufferSize];
6743   const char* scripts_command =
6744     "{\"seq\":0,"
6745      "\"type\":\"request\","
6746      "\"command\":\"scripts\"}";
6747 
6748   // Send scripts command.
6749   v8::Debug::SendCommand(buffer, AsciiToUtf16(scripts_command, buffer));
6750 
6751   CHECK_EQ(0, counting_message_handler_counter);
6752   v8::Debug::ProcessDebugMessages();
6753   // At least one message should come
6754   CHECK_GE(counting_message_handler_counter, 1);
6755 
6756   counting_message_handler_counter = 0;
6757 
6758   v8::Debug::SendCommand(buffer, AsciiToUtf16(scripts_command, buffer));
6759   v8::Debug::SendCommand(buffer, AsciiToUtf16(scripts_command, buffer));
6760   CHECK_EQ(0, counting_message_handler_counter);
6761   v8::Debug::ProcessDebugMessages();
6762   // At least two messages should come
6763   CHECK_GE(counting_message_handler_counter, 2);
6764 
6765   // Get rid of the debug message handler.
6766   v8::Debug::SetMessageHandler2(NULL);
6767   CheckDebuggerUnloaded();
6768 }
6769 
6770 
6771 struct BacktraceData {
6772   static int frame_counter;
MessageHandlerBacktraceData6773   static void MessageHandler(const v8::Debug::Message& message) {
6774     char print_buffer[1000];
6775     v8::String::Value json(message.GetJSON());
6776     Utf16ToAscii(*json, json.length(), print_buffer, 1000);
6777 
6778     if (strstr(print_buffer, "backtrace") == NULL) {
6779       return;
6780     }
6781     frame_counter = GetTotalFramesInt(print_buffer);
6782   }
6783 };
6784 
6785 int BacktraceData::frame_counter;
6786 
6787 
6788 // Test that debug messages get processed when ProcessDebugMessages is called.
TEST(Backtrace)6789 TEST(Backtrace) {
6790   v8::HandleScope scope;
6791   DebugLocalContext env;
6792 
6793   v8::Debug::SetMessageHandler2(BacktraceData::MessageHandler);
6794 
6795   const int kBufferSize = 1000;
6796   uint16_t buffer[kBufferSize];
6797   const char* scripts_command =
6798     "{\"seq\":0,"
6799      "\"type\":\"request\","
6800      "\"command\":\"backtrace\"}";
6801 
6802   // Check backtrace from ProcessDebugMessages.
6803   BacktraceData::frame_counter = -10;
6804   v8::Debug::SendCommand(buffer, AsciiToUtf16(scripts_command, buffer));
6805   v8::Debug::ProcessDebugMessages();
6806   CHECK_EQ(BacktraceData::frame_counter, 0);
6807 
6808   v8::Handle<v8::String> void0 = v8::String::New("void(0)");
6809   v8::Handle<v8::Script> script = v8::Script::Compile(void0, void0);
6810 
6811   // Check backtrace from "void(0)" script.
6812   BacktraceData::frame_counter = -10;
6813   v8::Debug::SendCommand(buffer, AsciiToUtf16(scripts_command, buffer));
6814   script->Run();
6815   CHECK_EQ(BacktraceData::frame_counter, 1);
6816 
6817   // Get rid of the debug message handler.
6818   v8::Debug::SetMessageHandler2(NULL);
6819   CheckDebuggerUnloaded();
6820 }
6821 
6822 
TEST(GetMirror)6823 TEST(GetMirror) {
6824   v8::HandleScope scope;
6825   DebugLocalContext env;
6826   v8::Handle<v8::Value> obj = v8::Debug::GetMirror(v8::String::New("hodja"));
6827   v8::Handle<v8::Function> run_test = v8::Handle<v8::Function>::Cast(
6828       v8::Script::New(
6829           v8::String::New(
6830               "function runTest(mirror) {"
6831               "  return mirror.isString() && (mirror.length() == 5);"
6832               "}"
6833               ""
6834               "runTest;"))->Run());
6835   v8::Handle<v8::Value> result = run_test->Call(env->Global(), 1, &obj);
6836   CHECK(result->IsTrue());
6837 }
6838 
6839 
6840 // Test that the debug break flag works with function.apply.
TEST(DebugBreakFunctionApply)6841 TEST(DebugBreakFunctionApply) {
6842   v8::HandleScope scope;
6843   DebugLocalContext env;
6844 
6845   // Create a function for testing breaking in apply.
6846   v8::Local<v8::Function> foo = CompileFunction(
6847       &env,
6848       "function baz(x) { }"
6849       "function bar(x) { baz(); }"
6850       "function foo(){ bar.apply(this, [1]); }",
6851       "foo");
6852 
6853   // Register a debug event listener which steps and counts.
6854   v8::Debug::SetDebugEventListener(DebugEventBreakMax);
6855 
6856   // Set the debug break flag before calling the code using function.apply.
6857   v8::Debug::DebugBreak();
6858 
6859   // Limit the number of debug breaks. This is a regression test for issue 493
6860   // where this test would enter an infinite loop.
6861   break_point_hit_count = 0;
6862   max_break_point_hit_count = 10000;  // 10000 => infinite loop.
6863   foo->Call(env->Global(), 0, NULL);
6864 
6865   // When keeping the debug break several break will happen.
6866   CHECK_GT(break_point_hit_count, 1);
6867 
6868   v8::Debug::SetDebugEventListener(NULL);
6869   CheckDebuggerUnloaded();
6870 }
6871 
6872 
6873 v8::Handle<v8::Context> debugee_context;
6874 v8::Handle<v8::Context> debugger_context;
6875 
6876 
6877 // Property getter that checks that current and calling contexts
6878 // are both the debugee contexts.
NamedGetterWithCallingContextCheck(v8::Local<v8::String> name,const v8::AccessorInfo & info)6879 static v8::Handle<v8::Value> NamedGetterWithCallingContextCheck(
6880     v8::Local<v8::String> name,
6881     const v8::AccessorInfo& info) {
6882   CHECK_EQ(0, strcmp(*v8::String::AsciiValue(name), "a"));
6883   v8::Handle<v8::Context> current = v8::Context::GetCurrent();
6884   CHECK(current == debugee_context);
6885   CHECK(current != debugger_context);
6886   v8::Handle<v8::Context> calling = v8::Context::GetCalling();
6887   CHECK(calling == debugee_context);
6888   CHECK(calling != debugger_context);
6889   return v8::Int32::New(1);
6890 }
6891 
6892 
6893 // Debug event listener that checks if the first argument of a function is
6894 // an object with property 'a' == 1. If the property has custom accessor
6895 // this handler will eventually invoke it.
DebugEventGetAtgumentPropertyValue(v8::DebugEvent event,v8::Handle<v8::Object> exec_state,v8::Handle<v8::Object> event_data,v8::Handle<v8::Value> data)6896 static void DebugEventGetAtgumentPropertyValue(
6897     v8::DebugEvent event,
6898     v8::Handle<v8::Object> exec_state,
6899     v8::Handle<v8::Object> event_data,
6900     v8::Handle<v8::Value> data) {
6901   if (event == v8::Break) {
6902     break_point_hit_count++;
6903     CHECK(debugger_context == v8::Context::GetCurrent());
6904     v8::Handle<v8::Function> func(v8::Function::Cast(*CompileRun(
6905         "(function(exec_state) {\n"
6906         "    return (exec_state.frame(0).argumentValue(0).property('a').\n"
6907         "            value().value() == 1);\n"
6908         "})")));
6909     const int argc = 1;
6910     v8::Handle<v8::Value> argv[argc] = { exec_state };
6911     v8::Handle<v8::Value> result = func->Call(exec_state, argc, argv);
6912     CHECK(result->IsTrue());
6913   }
6914 }
6915 
6916 
TEST(CallingContextIsNotDebugContext)6917 TEST(CallingContextIsNotDebugContext) {
6918   v8::internal::Debug* debug = v8::internal::Isolate::Current()->debug();
6919   // Create and enter a debugee context.
6920   v8::HandleScope scope;
6921   DebugLocalContext env;
6922   env.ExposeDebug();
6923 
6924   // Save handles to the debugger and debugee contexts to be used in
6925   // NamedGetterWithCallingContextCheck.
6926   debugee_context = v8::Local<v8::Context>(*env);
6927   debugger_context = v8::Utils::ToLocal(debug->debug_context());
6928 
6929   // Create object with 'a' property accessor.
6930   v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New();
6931   named->SetAccessor(v8::String::New("a"),
6932                      NamedGetterWithCallingContextCheck);
6933   env->Global()->Set(v8::String::New("obj"),
6934                      named->NewInstance());
6935 
6936   // Register the debug event listener
6937   v8::Debug::SetDebugEventListener(DebugEventGetAtgumentPropertyValue);
6938 
6939   // Create a function that invokes debugger.
6940   v8::Local<v8::Function> foo = CompileFunction(
6941       &env,
6942       "function bar(x) { debugger; }"
6943       "function foo(){ bar(obj); }",
6944       "foo");
6945 
6946   break_point_hit_count = 0;
6947   foo->Call(env->Global(), 0, NULL);
6948   CHECK_EQ(1, break_point_hit_count);
6949 
6950   v8::Debug::SetDebugEventListener(NULL);
6951   debugee_context = v8::Handle<v8::Context>();
6952   debugger_context = v8::Handle<v8::Context>();
6953   CheckDebuggerUnloaded();
6954 }
6955 
6956 
TEST(DebugContextIsPreservedBetweenAccesses)6957 TEST(DebugContextIsPreservedBetweenAccesses) {
6958   v8::HandleScope scope;
6959   v8::Local<v8::Context> context1 = v8::Debug::GetDebugContext();
6960   v8::Local<v8::Context> context2 = v8::Debug::GetDebugContext();
6961   CHECK_EQ(*context1, *context2);
6962 }
6963 
6964 
6965 static v8::Handle<v8::Value> expected_callback_data;
DebugEventContextChecker(const v8::Debug::EventDetails & details)6966 static void DebugEventContextChecker(const v8::Debug::EventDetails& details) {
6967   CHECK(details.GetEventContext() == expected_context);
6968   CHECK_EQ(expected_callback_data, details.GetCallbackData());
6969 }
6970 
6971 // Check that event details contain context where debug event occured.
TEST(DebugEventContext)6972 TEST(DebugEventContext) {
6973   v8::HandleScope scope;
6974   expected_callback_data = v8::Int32::New(2010);
6975   v8::Debug::SetDebugEventListener2(DebugEventContextChecker,
6976                                     expected_callback_data);
6977   expected_context = v8::Context::New();
6978   v8::Context::Scope context_scope(expected_context);
6979   v8::Script::Compile(v8::String::New("(function(){debugger;})();"))->Run();
6980   expected_context.Dispose();
6981   expected_context.Clear();
6982   v8::Debug::SetDebugEventListener(NULL);
6983   expected_context_data = v8::Handle<v8::Value>();
6984   CheckDebuggerUnloaded();
6985 }
6986 
6987 
6988 static void* expected_break_data;
6989 static bool was_debug_break_called;
6990 static bool was_debug_event_called;
DebugEventBreakDataChecker(const v8::Debug::EventDetails & details)6991 static void DebugEventBreakDataChecker(const v8::Debug::EventDetails& details) {
6992   if (details.GetEvent() == v8::BreakForCommand) {
6993     CHECK_EQ(expected_break_data, details.GetClientData());
6994     was_debug_event_called = true;
6995   } else if (details.GetEvent() == v8::Break) {
6996     was_debug_break_called = true;
6997   }
6998 }
6999 
7000 
7001 // Check that event details contain context where debug event occured.
TEST(DebugEventBreakData)7002 TEST(DebugEventBreakData) {
7003   v8::HandleScope scope;
7004   DebugLocalContext env;
7005   v8::Debug::SetDebugEventListener2(DebugEventBreakDataChecker);
7006 
7007   TestClientData::constructor_call_counter = 0;
7008   TestClientData::destructor_call_counter = 0;
7009 
7010   expected_break_data = NULL;
7011   was_debug_event_called = false;
7012   was_debug_break_called = false;
7013   v8::Debug::DebugBreakForCommand();
7014   v8::Script::Compile(v8::String::New("(function(x){return x;})(1);"))->Run();
7015   CHECK(was_debug_event_called);
7016   CHECK(!was_debug_break_called);
7017 
7018   TestClientData* data1 = new TestClientData();
7019   expected_break_data = data1;
7020   was_debug_event_called = false;
7021   was_debug_break_called = false;
7022   v8::Debug::DebugBreakForCommand(data1);
7023   v8::Script::Compile(v8::String::New("(function(x){return x+1;})(1);"))->Run();
7024   CHECK(was_debug_event_called);
7025   CHECK(!was_debug_break_called);
7026 
7027   expected_break_data = NULL;
7028   was_debug_event_called = false;
7029   was_debug_break_called = false;
7030   v8::Debug::DebugBreak();
7031   v8::Script::Compile(v8::String::New("(function(x){return x+2;})(1);"))->Run();
7032   CHECK(!was_debug_event_called);
7033   CHECK(was_debug_break_called);
7034 
7035   TestClientData* data2 = new TestClientData();
7036   expected_break_data = data2;
7037   was_debug_event_called = false;
7038   was_debug_break_called = false;
7039   v8::Debug::DebugBreak();
7040   v8::Debug::DebugBreakForCommand(data2);
7041   v8::Script::Compile(v8::String::New("(function(x){return x+3;})(1);"))->Run();
7042   CHECK(was_debug_event_called);
7043   CHECK(was_debug_break_called);
7044 
7045   CHECK_EQ(2, TestClientData::constructor_call_counter);
7046   CHECK_EQ(TestClientData::constructor_call_counter,
7047            TestClientData::destructor_call_counter);
7048 
7049   v8::Debug::SetDebugEventListener(NULL);
7050   CheckDebuggerUnloaded();
7051 }
7052 
7053 static bool debug_event_break_deoptimize_done = false;
7054 
DebugEventBreakDeoptimize(v8::DebugEvent event,v8::Handle<v8::Object> exec_state,v8::Handle<v8::Object> event_data,v8::Handle<v8::Value> data)7055 static void DebugEventBreakDeoptimize(v8::DebugEvent event,
7056                                       v8::Handle<v8::Object> exec_state,
7057                                       v8::Handle<v8::Object> event_data,
7058                                       v8::Handle<v8::Value> data) {
7059   if (event == v8::Break) {
7060     if (!frame_function_name.IsEmpty()) {
7061       // Get the name of the function.
7062       const int argc = 2;
7063       v8::Handle<v8::Value> argv[argc] = { exec_state, v8::Integer::New(0) };
7064       v8::Handle<v8::Value> result =
7065           frame_function_name->Call(exec_state, argc, argv);
7066       if (!result->IsUndefined()) {
7067         char fn[80];
7068         CHECK(result->IsString());
7069         v8::Handle<v8::String> function_name(result->ToString());
7070         function_name->WriteAscii(fn);
7071         if (strcmp(fn, "bar") == 0) {
7072           i::Deoptimizer::DeoptimizeAll();
7073           debug_event_break_deoptimize_done = true;
7074         }
7075       }
7076     }
7077 
7078     v8::Debug::DebugBreak();
7079   }
7080 }
7081 
7082 
7083 // Test deoptimization when execution is broken using the debug break stack
7084 // check interrupt.
TEST(DeoptimizeDuringDebugBreak)7085 TEST(DeoptimizeDuringDebugBreak) {
7086   v8::HandleScope scope;
7087   DebugLocalContext env;
7088   env.ExposeDebug();
7089 
7090   // Create a function for checking the function when hitting a break point.
7091   frame_function_name = CompileFunction(&env,
7092                                         frame_function_name_source,
7093                                         "frame_function_name");
7094 
7095 
7096   // Set a debug event listener which will keep interrupting execution until
7097   // debug break. When inside function bar it will deoptimize all functions.
7098   // This tests lazy deoptimization bailout for the stack check, as the first
7099   // time in function bar when using debug break and no break points will be at
7100   // the initial stack check.
7101   v8::Debug::SetDebugEventListener(DebugEventBreakDeoptimize,
7102                                    v8::Undefined());
7103 
7104   // Compile and run function bar which will optimize it for some flag settings.
7105   v8::Script::Compile(v8::String::New("function bar(){}; bar()"))->Run();
7106 
7107   // Set debug break and call bar again.
7108   v8::Debug::DebugBreak();
7109   v8::Script::Compile(v8::String::New("bar()"))->Run();
7110 
7111   CHECK(debug_event_break_deoptimize_done);
7112 
7113   v8::Debug::SetDebugEventListener(NULL);
7114 }
7115 
7116 
DebugEventBreakWithOptimizedStack(v8::DebugEvent event,v8::Handle<v8::Object> exec_state,v8::Handle<v8::Object> event_data,v8::Handle<v8::Value> data)7117 static void DebugEventBreakWithOptimizedStack(v8::DebugEvent event,
7118                                               v8::Handle<v8::Object> exec_state,
7119                                               v8::Handle<v8::Object> event_data,
7120                                               v8::Handle<v8::Value> data) {
7121   if (event == v8::Break) {
7122     if (!frame_function_name.IsEmpty()) {
7123       for (int i = 0; i < 2; i++) {
7124         const int argc = 2;
7125         v8::Handle<v8::Value> argv[argc] = { exec_state, v8::Integer::New(i) };
7126         // Get the name of the function in frame i.
7127         v8::Handle<v8::Value> result =
7128             frame_function_name->Call(exec_state, argc, argv);
7129         CHECK(result->IsString());
7130         v8::Handle<v8::String> function_name(result->ToString());
7131         CHECK(function_name->Equals(v8::String::New("loop")));
7132         // Get the name of the first argument in frame i.
7133         result = frame_argument_name->Call(exec_state, argc, argv);
7134         CHECK(result->IsString());
7135         v8::Handle<v8::String> argument_name(result->ToString());
7136         CHECK(argument_name->Equals(v8::String::New("count")));
7137         // Get the value of the first argument in frame i. If the
7138         // funtion is optimized the value will be undefined, otherwise
7139         // the value will be '1 - i'.
7140         //
7141         // TODO(3141533): We should be able to get the real value for
7142         // optimized frames.
7143         result = frame_argument_value->Call(exec_state, argc, argv);
7144         CHECK(result->IsUndefined() || (result->Int32Value() == 1 - i));
7145         // Get the name of the first local variable.
7146         result = frame_local_name->Call(exec_state, argc, argv);
7147         CHECK(result->IsString());
7148         v8::Handle<v8::String> local_name(result->ToString());
7149         CHECK(local_name->Equals(v8::String::New("local")));
7150         // Get the value of the first local variable. If the function
7151         // is optimized the value will be undefined, otherwise it will
7152         // be 42.
7153         //
7154         // TODO(3141533): We should be able to get the real value for
7155         // optimized frames.
7156         result = frame_local_value->Call(exec_state, argc, argv);
7157         CHECK(result->IsUndefined() || (result->Int32Value() == 42));
7158       }
7159     }
7160   }
7161 }
7162 
7163 
ScheduleBreak(const v8::Arguments & args)7164 static v8::Handle<v8::Value> ScheduleBreak(const v8::Arguments& args) {
7165   v8::Debug::SetDebugEventListener(DebugEventBreakWithOptimizedStack,
7166                                    v8::Undefined());
7167   v8::Debug::DebugBreak();
7168   return v8::Undefined();
7169 }
7170 
7171 
TEST(DebugBreakStackInspection)7172 TEST(DebugBreakStackInspection) {
7173   v8::HandleScope scope;
7174   DebugLocalContext env;
7175 
7176   frame_function_name =
7177       CompileFunction(&env, frame_function_name_source, "frame_function_name");
7178   frame_argument_name =
7179       CompileFunction(&env, frame_argument_name_source, "frame_argument_name");
7180   frame_argument_value = CompileFunction(&env,
7181                                          frame_argument_value_source,
7182                                          "frame_argument_value");
7183   frame_local_name =
7184       CompileFunction(&env, frame_local_name_source, "frame_local_name");
7185   frame_local_value =
7186       CompileFunction(&env, frame_local_value_source, "frame_local_value");
7187 
7188   v8::Handle<v8::FunctionTemplate> schedule_break_template =
7189       v8::FunctionTemplate::New(ScheduleBreak);
7190   v8::Handle<v8::Function> schedule_break =
7191       schedule_break_template->GetFunction();
7192   env->Global()->Set(v8_str("scheduleBreak"), schedule_break);
7193 
7194   const char* src =
7195       "function loop(count) {"
7196       "  var local = 42;"
7197       "  if (count < 1) { scheduleBreak(); loop(count + 1); }"
7198       "}"
7199       "loop(0);";
7200   v8::Script::Compile(v8::String::New(src))->Run();
7201 }
7202 
7203 
7204 // Test that setting the terminate execution flag during debug break processing.
TestDebugBreakInLoop(const char * loop_head,const char ** loop_bodies,const char * loop_tail)7205 static void TestDebugBreakInLoop(const char* loop_head,
7206                                  const char** loop_bodies,
7207                                  const char* loop_tail) {
7208   // Receive 100 breaks for each test and then terminate JavaScript execution.
7209   static const int kBreaksPerTest = 100;
7210 
7211   for (int i = 0; loop_bodies[i] != NULL; i++) {
7212     // Perform a lazy deoptimization after various numbers of breaks
7213     // have been hit.
7214     for (int j = 0; j < 11; j++) {
7215       break_point_hit_count_deoptimize = j;
7216       if (j == 10) {
7217         break_point_hit_count_deoptimize = kBreaksPerTest;
7218       }
7219 
7220       break_point_hit_count = 0;
7221       max_break_point_hit_count = kBreaksPerTest;
7222       terminate_after_max_break_point_hit = true;
7223 
7224       EmbeddedVector<char, 1024> buffer;
7225       OS::SNPrintF(buffer,
7226                    "function f() {%s%s%s}",
7227                    loop_head, loop_bodies[i], loop_tail);
7228 
7229       // Function with infinite loop.
7230       CompileRun(buffer.start());
7231 
7232       // Set the debug break to enter the debugger as soon as possible.
7233       v8::Debug::DebugBreak();
7234 
7235       // Call function with infinite loop.
7236       CompileRun("f();");
7237       CHECK_EQ(kBreaksPerTest, break_point_hit_count);
7238 
7239       CHECK(!v8::V8::IsExecutionTerminating());
7240     }
7241   }
7242 }
7243 
7244 
TEST(DebugBreakLoop)7245 TEST(DebugBreakLoop) {
7246   v8::HandleScope scope;
7247   DebugLocalContext env;
7248 
7249   // Register a debug event listener which sets the break flag and counts.
7250   v8::Debug::SetDebugEventListener(DebugEventBreakMax);
7251 
7252   // Create a function for getting the frame count when hitting the break.
7253   frame_count = CompileFunction(&env, frame_count_source, "frame_count");
7254 
7255   CompileRun("var a = 1;");
7256   CompileRun("function g() { }");
7257   CompileRun("function h() { }");
7258 
7259   const char* loop_bodies[] = {
7260       "",
7261       "g()",
7262       "if (a == 0) { g() }",
7263       "if (a == 1) { g() }",
7264       "if (a == 0) { g() } else { h() }",
7265       "if (a == 0) { continue }",
7266       "if (a == 1) { continue }",
7267       "switch (a) { case 1: g(); }",
7268       "switch (a) { case 1: continue; }",
7269       "switch (a) { case 1: g(); break; default: h() }",
7270       "switch (a) { case 1: continue; break; default: h() }",
7271       NULL
7272   };
7273 
7274   TestDebugBreakInLoop("while (true) {", loop_bodies, "}");
7275   TestDebugBreakInLoop("while (a == 1) {", loop_bodies, "}");
7276 
7277   TestDebugBreakInLoop("do {", loop_bodies, "} while (true)");
7278   TestDebugBreakInLoop("do {", loop_bodies, "} while (a == 1)");
7279 
7280   TestDebugBreakInLoop("for (;;) {", loop_bodies, "}");
7281   TestDebugBreakInLoop("for (;a == 1;) {", loop_bodies, "}");
7282 
7283   // Get rid of the debug event listener.
7284   v8::Debug::SetDebugEventListener(NULL);
7285   CheckDebuggerUnloaded();
7286 }
7287 
7288 
7289 v8::Local<v8::Script> inline_script;
7290 
DebugBreakInlineListener(v8::DebugEvent event,v8::Handle<v8::Object> exec_state,v8::Handle<v8::Object> event_data,v8::Handle<v8::Value> data)7291 static void DebugBreakInlineListener(v8::DebugEvent event,
7292                                      v8::Handle<v8::Object> exec_state,
7293                                      v8::Handle<v8::Object> event_data,
7294                                      v8::Handle<v8::Value> data) {
7295   if (event != v8::Break) return;
7296 
7297   int expected_frame_count = 4;
7298   int expected_line_number[] = {1, 4, 7, 12};
7299 
7300   i::Handle<i::Object> compiled_script = v8::Utils::OpenHandle(*inline_script);
7301   i::Handle<i::Script> source_script = i::Handle<i::Script>(i::Script::cast(
7302       i::JSFunction::cast(*compiled_script)->shared()->script()));
7303 
7304   int break_id = v8::internal::Isolate::Current()->debug()->break_id();
7305   char script[128];
7306   i::Vector<char> script_vector(script, sizeof(script));
7307   OS::SNPrintF(script_vector, "%%GetFrameCount(%d)", break_id);
7308   v8::Local<v8::Value> result = CompileRun(script);
7309 
7310   int frame_count = result->Int32Value();
7311   CHECK_EQ(expected_frame_count, frame_count);
7312 
7313   for (int i = 0; i < frame_count; i++) {
7314     // The 5. element in the returned array of GetFrameDetails contains the
7315     // source position of that frame.
7316     OS::SNPrintF(script_vector, "%%GetFrameDetails(%d, %d)[5]", break_id, i);
7317     v8::Local<v8::Value> result = CompileRun(script);
7318     CHECK_EQ(expected_line_number[i],
7319              i::GetScriptLineNumber(source_script, result->Int32Value()));
7320   }
7321   v8::Debug::SetDebugEventListener(NULL);
7322   v8::V8::TerminateExecution();
7323 }
7324 
7325 
TEST(DebugBreakInline)7326 TEST(DebugBreakInline) {
7327   i::FLAG_allow_natives_syntax = true;
7328   v8::HandleScope scope;
7329   DebugLocalContext env;
7330   const char* source =
7331       "function debug(b) {             \n"
7332       "  if (b) debugger;              \n"
7333       "}                               \n"
7334       "function f(b) {                 \n"
7335       "  debug(b)                      \n"
7336       "};                              \n"
7337       "function g(b) {                 \n"
7338       "  f(b);                         \n"
7339       "};                              \n"
7340       "g(false);                       \n"
7341       "g(false);                       \n"
7342       "%OptimizeFunctionOnNextCall(g); \n"
7343       "g(true);";
7344   v8::Debug::SetDebugEventListener(DebugBreakInlineListener);
7345   inline_script = v8::Script::Compile(v8::String::New(source));
7346   inline_script->Run();
7347 }
7348 
7349 
7350 #endif  // ENABLE_DEBUGGER_SUPPORT
7351