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#include <stdlib.h>
29
30#include "src/v8.h"
31
32#include "src/api.h"
33#include "src/base/platform/condition-variable.h"
34#include "src/base/platform/platform.h"
35#include "src/compilation-cache.h"
36#include "src/debug.h"
37#include "src/deoptimizer.h"
38#include "src/frames.h"
39#include "src/utils.h"
40#include "test/cctest/cctest.h"
41
42
43using ::v8::base::Mutex;
44using ::v8::base::LockGuard;
45using ::v8::base::ConditionVariable;
46using ::v8::base::OS;
47using ::v8::base::Semaphore;
48using ::v8::internal::EmbeddedVector;
49using ::v8::internal::Object;
50using ::v8::internal::Handle;
51using ::v8::internal::Heap;
52using ::v8::internal::JSGlobalProxy;
53using ::v8::internal::Code;
54using ::v8::internal::Debug;
55using ::v8::internal::Debugger;
56using ::v8::internal::CommandMessage;
57using ::v8::internal::CommandMessageQueue;
58using ::v8::internal::StackFrame;
59using ::v8::internal::StepAction;
60using ::v8::internal::StepIn;  // From StepAction enum
61using ::v8::internal::StepNext;  // From StepAction enum
62using ::v8::internal::StepOut;  // From StepAction enum
63using ::v8::internal::Vector;
64using ::v8::internal::StrLength;
65
66// Size of temp buffer for formatting small strings.
67#define SMALL_STRING_BUFFER_SIZE 80
68
69// --- H e l p e r   C l a s s e s
70
71
72// Helper class for creating a V8 enviromnent for running tests
73class DebugLocalContext {
74 public:
75  inline DebugLocalContext(
76      v8::Isolate* isolate, v8::ExtensionConfiguration* extensions = 0,
77      v8::Handle<v8::ObjectTemplate> global_template =
78          v8::Handle<v8::ObjectTemplate>(),
79      v8::Handle<v8::Value> global_object = v8::Handle<v8::Value>())
80      : scope_(isolate),
81        context_(v8::Context::New(isolate, extensions, global_template,
82                                  global_object)) {
83    context_->Enter();
84  }
85  inline DebugLocalContext(
86      v8::ExtensionConfiguration* extensions = 0,
87      v8::Handle<v8::ObjectTemplate> global_template =
88          v8::Handle<v8::ObjectTemplate>(),
89      v8::Handle<v8::Value> global_object = v8::Handle<v8::Value>())
90      : scope_(CcTest::isolate()),
91        context_(v8::Context::New(CcTest::isolate(), extensions,
92                                  global_template, global_object)) {
93    context_->Enter();
94  }
95  inline ~DebugLocalContext() {
96    context_->Exit();
97  }
98  inline v8::Local<v8::Context> context() { return context_; }
99  inline v8::Context* operator->() { return *context_; }
100  inline v8::Context* operator*() { return *context_; }
101  inline v8::Isolate* GetIsolate() { return context_->GetIsolate(); }
102  inline bool IsReady() { return !context_.IsEmpty(); }
103  void ExposeDebug() {
104    v8::internal::Isolate* isolate =
105        reinterpret_cast<v8::internal::Isolate*>(context_->GetIsolate());
106    v8::internal::Factory* factory = isolate->factory();
107    // Expose the debug context global object in the global object for testing.
108    CHECK(isolate->debug()->Load());
109    Handle<v8::internal::Context> debug_context =
110        isolate->debug()->debug_context();
111    debug_context->set_security_token(
112        v8::Utils::OpenHandle(*context_)->security_token());
113
114    Handle<JSGlobalProxy> global(Handle<JSGlobalProxy>::cast(
115        v8::Utils::OpenHandle(*context_->Global())));
116    Handle<v8::internal::String> debug_string =
117        factory->InternalizeOneByteString(STATIC_CHAR_VECTOR("debug"));
118    v8::internal::Runtime::DefineObjectProperty(global, debug_string,
119        handle(debug_context->global_proxy(), isolate), DONT_ENUM).Check();
120  }
121
122 private:
123  v8::HandleScope scope_;
124  v8::Local<v8::Context> context_;
125};
126
127
128// --- H e l p e r   F u n c t i o n s
129
130
131// Compile and run the supplied source and return the fequested function.
132static v8::Local<v8::Function> CompileFunction(DebugLocalContext* env,
133                                               const char* source,
134                                               const char* function_name) {
135  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), source))
136      ->Run();
137  return v8::Local<v8::Function>::Cast((*env)->Global()->Get(
138      v8::String::NewFromUtf8(env->GetIsolate(), function_name)));
139}
140
141
142// Compile and run the supplied source and return the requested function.
143static v8::Local<v8::Function> CompileFunction(v8::Isolate* isolate,
144                                               const char* source,
145                                               const char* function_name) {
146  v8::Script::Compile(v8::String::NewFromUtf8(isolate, source))->Run();
147  v8::Local<v8::Object> global = isolate->GetCurrentContext()->Global();
148  return v8::Local<v8::Function>::Cast(
149      global->Get(v8::String::NewFromUtf8(isolate, function_name)));
150}
151
152
153// Is there any debug info for the function?
154static bool HasDebugInfo(v8::Handle<v8::Function> fun) {
155  Handle<v8::internal::JSFunction> f = v8::Utils::OpenHandle(*fun);
156  Handle<v8::internal::SharedFunctionInfo> shared(f->shared());
157  return Debug::HasDebugInfo(shared);
158}
159
160
161// Set a break point in a function and return the associated break point
162// number.
163static int SetBreakPoint(Handle<v8::internal::JSFunction> fun, int position) {
164  static int break_point = 0;
165  v8::internal::Isolate* isolate = fun->GetIsolate();
166  v8::internal::Debug* debug = isolate->debug();
167  debug->SetBreakPoint(
168      fun,
169      Handle<Object>(v8::internal::Smi::FromInt(++break_point), isolate),
170      &position);
171  return break_point;
172}
173
174
175// Set a break point in a function and return the associated break point
176// number.
177static int SetBreakPoint(v8::Handle<v8::Function> fun, int position) {
178  return SetBreakPoint(v8::Utils::OpenHandle(*fun), position);
179}
180
181
182// Set a break point in a function using the Debug object and return the
183// associated break point number.
184static int SetBreakPointFromJS(v8::Isolate* isolate,
185                               const char* function_name,
186                               int line, int position) {
187  EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
188  SNPrintF(buffer,
189           "debug.Debug.setBreakPoint(%s,%d,%d)",
190           function_name, line, position);
191  buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
192  v8::Handle<v8::String> str = v8::String::NewFromUtf8(isolate, buffer.start());
193  return v8::Script::Compile(str)->Run()->Int32Value();
194}
195
196
197// Set a break point in a script identified by id using the global Debug object.
198static int SetScriptBreakPointByIdFromJS(v8::Isolate* isolate, int script_id,
199                                         int line, int column) {
200  EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
201  if (column >= 0) {
202    // Column specified set script break point on precise location.
203    SNPrintF(buffer,
204             "debug.Debug.setScriptBreakPointById(%d,%d,%d)",
205             script_id, line, column);
206  } else {
207    // Column not specified set script break point on line.
208    SNPrintF(buffer,
209             "debug.Debug.setScriptBreakPointById(%d,%d)",
210             script_id, line);
211  }
212  buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
213  {
214    v8::TryCatch try_catch;
215    v8::Handle<v8::String> str =
216        v8::String::NewFromUtf8(isolate, buffer.start());
217    v8::Handle<v8::Value> value = v8::Script::Compile(str)->Run();
218    CHECK(!try_catch.HasCaught());
219    return value->Int32Value();
220  }
221}
222
223
224// Set a break point in a script identified by name using the global Debug
225// object.
226static int SetScriptBreakPointByNameFromJS(v8::Isolate* isolate,
227                                           const char* script_name, int line,
228                                           int column) {
229  EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
230  if (column >= 0) {
231    // Column specified set script break point on precise location.
232    SNPrintF(buffer,
233             "debug.Debug.setScriptBreakPointByName(\"%s\",%d,%d)",
234             script_name, line, column);
235  } else {
236    // Column not specified set script break point on line.
237    SNPrintF(buffer,
238             "debug.Debug.setScriptBreakPointByName(\"%s\",%d)",
239             script_name, line);
240  }
241  buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
242  {
243    v8::TryCatch try_catch;
244    v8::Handle<v8::String> str =
245        v8::String::NewFromUtf8(isolate, buffer.start());
246    v8::Handle<v8::Value> value = v8::Script::Compile(str)->Run();
247    CHECK(!try_catch.HasCaught());
248    return value->Int32Value();
249  }
250}
251
252
253// Clear a break point.
254static void ClearBreakPoint(int break_point) {
255  v8::internal::Isolate* isolate = CcTest::i_isolate();
256  v8::internal::Debug* debug = isolate->debug();
257  debug->ClearBreakPoint(
258      Handle<Object>(v8::internal::Smi::FromInt(break_point), isolate));
259}
260
261
262// Clear a break point using the global Debug object.
263static void ClearBreakPointFromJS(v8::Isolate* isolate,
264                                  int break_point_number) {
265  EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
266  SNPrintF(buffer,
267           "debug.Debug.clearBreakPoint(%d)",
268           break_point_number);
269  buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
270  v8::Script::Compile(v8::String::NewFromUtf8(isolate, buffer.start()))->Run();
271}
272
273
274static void EnableScriptBreakPointFromJS(v8::Isolate* isolate,
275                                         int break_point_number) {
276  EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
277  SNPrintF(buffer,
278           "debug.Debug.enableScriptBreakPoint(%d)",
279           break_point_number);
280  buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
281  v8::Script::Compile(v8::String::NewFromUtf8(isolate, buffer.start()))->Run();
282}
283
284
285static void DisableScriptBreakPointFromJS(v8::Isolate* isolate,
286                                          int break_point_number) {
287  EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
288  SNPrintF(buffer,
289           "debug.Debug.disableScriptBreakPoint(%d)",
290           break_point_number);
291  buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
292  v8::Script::Compile(v8::String::NewFromUtf8(isolate, buffer.start()))->Run();
293}
294
295
296static void ChangeScriptBreakPointConditionFromJS(v8::Isolate* isolate,
297                                                  int break_point_number,
298                                                  const char* condition) {
299  EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
300  SNPrintF(buffer,
301           "debug.Debug.changeScriptBreakPointCondition(%d, \"%s\")",
302           break_point_number, condition);
303  buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
304  v8::Script::Compile(v8::String::NewFromUtf8(isolate, buffer.start()))->Run();
305}
306
307
308static void ChangeScriptBreakPointIgnoreCountFromJS(v8::Isolate* isolate,
309                                                    int break_point_number,
310                                                    int ignoreCount) {
311  EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
312  SNPrintF(buffer,
313           "debug.Debug.changeScriptBreakPointIgnoreCount(%d, %d)",
314           break_point_number, ignoreCount);
315  buffer[SMALL_STRING_BUFFER_SIZE - 1] = '\0';
316  v8::Script::Compile(v8::String::NewFromUtf8(isolate, buffer.start()))->Run();
317}
318
319
320// Change break on exception.
321static void ChangeBreakOnException(bool caught, bool uncaught) {
322  v8::internal::Debug* debug = CcTest::i_isolate()->debug();
323  debug->ChangeBreakOnException(v8::internal::BreakException, caught);
324  debug->ChangeBreakOnException(v8::internal::BreakUncaughtException, uncaught);
325}
326
327
328// Change break on exception using the global Debug object.
329static void ChangeBreakOnExceptionFromJS(v8::Isolate* isolate, bool caught,
330                                         bool uncaught) {
331  if (caught) {
332    v8::Script::Compile(
333        v8::String::NewFromUtf8(isolate, "debug.Debug.setBreakOnException()"))
334        ->Run();
335  } else {
336    v8::Script::Compile(
337        v8::String::NewFromUtf8(isolate, "debug.Debug.clearBreakOnException()"))
338        ->Run();
339  }
340  if (uncaught) {
341    v8::Script::Compile(
342        v8::String::NewFromUtf8(
343            isolate, "debug.Debug.setBreakOnUncaughtException()"))->Run();
344  } else {
345    v8::Script::Compile(
346        v8::String::NewFromUtf8(
347            isolate, "debug.Debug.clearBreakOnUncaughtException()"))->Run();
348  }
349}
350
351
352// Prepare to step to next break location.
353static void PrepareStep(StepAction step_action) {
354  v8::internal::Debug* debug = CcTest::i_isolate()->debug();
355  debug->PrepareStep(step_action, 1, StackFrame::NO_ID);
356}
357
358
359// This function is in namespace v8::internal to be friend with class
360// v8::internal::Debug.
361namespace v8 {
362namespace internal {
363
364// Collect the currently debugged functions.
365Handle<FixedArray> GetDebuggedFunctions() {
366  Debug* debug = CcTest::i_isolate()->debug();
367
368  v8::internal::DebugInfoListNode* node = debug->debug_info_list_;
369
370  // Find the number of debugged functions.
371  int count = 0;
372  while (node) {
373    count++;
374    node = node->next();
375  }
376
377  // Allocate array for the debugged functions
378  Handle<FixedArray> debugged_functions =
379      CcTest::i_isolate()->factory()->NewFixedArray(count);
380
381  // Run through the debug info objects and collect all functions.
382  count = 0;
383  while (node) {
384    debugged_functions->set(count++, *node->debug_info());
385    node = node->next();
386  }
387
388  return debugged_functions;
389}
390
391
392// Check that the debugger has been fully unloaded.
393void CheckDebuggerUnloaded(bool check_functions) {
394  // Check that the debugger context is cleared and that there is no debug
395  // information stored for the debugger.
396  CHECK(CcTest::i_isolate()->debug()->debug_context().is_null());
397  CHECK_EQ(NULL, CcTest::i_isolate()->debug()->debug_info_list_);
398
399  // Collect garbage to ensure weak handles are cleared.
400  CcTest::heap()->CollectAllGarbage(Heap::kNoGCFlags);
401  CcTest::heap()->CollectAllGarbage(Heap::kMakeHeapIterableMask);
402
403  // Iterate the head and check that there are no debugger related objects left.
404  HeapIterator iterator(CcTest::heap());
405  for (HeapObject* obj = iterator.next(); obj != NULL; obj = iterator.next()) {
406    CHECK(!obj->IsDebugInfo());
407    CHECK(!obj->IsBreakPointInfo());
408
409    // If deep check of functions is requested check that no debug break code
410    // is left in all functions.
411    if (check_functions) {
412      if (obj->IsJSFunction()) {
413        JSFunction* fun = JSFunction::cast(obj);
414        for (RelocIterator it(fun->shared()->code()); !it.done(); it.next()) {
415          RelocInfo::Mode rmode = it.rinfo()->rmode();
416          if (RelocInfo::IsCodeTarget(rmode)) {
417            CHECK(!Debug::IsDebugBreak(it.rinfo()->target_address()));
418          } else if (RelocInfo::IsJSReturn(rmode)) {
419            CHECK(!Debug::IsDebugBreakAtReturn(it.rinfo()));
420          }
421        }
422      }
423    }
424  }
425}
426
427
428} }  // namespace v8::internal
429
430
431// Check that the debugger has been fully unloaded.
432static void CheckDebuggerUnloaded(bool check_functions = false) {
433  // Let debugger to unload itself synchronously
434  v8::Debug::ProcessDebugMessages();
435
436  v8::internal::CheckDebuggerUnloaded(check_functions);
437}
438
439
440// Inherit from BreakLocationIterator to get access to protected parts for
441// testing.
442class TestBreakLocationIterator: public v8::internal::BreakLocationIterator {
443 public:
444  explicit TestBreakLocationIterator(Handle<v8::internal::DebugInfo> debug_info)
445    : BreakLocationIterator(debug_info, v8::internal::SOURCE_BREAK_LOCATIONS) {}
446  v8::internal::RelocIterator* it() { return reloc_iterator_; }
447  v8::internal::RelocIterator* it_original() {
448    return reloc_iterator_original_;
449  }
450};
451
452
453// Compile a function, set a break point and check that the call at the break
454// location in the code is the expected debug_break function.
455void CheckDebugBreakFunction(DebugLocalContext* env,
456                             const char* source, const char* name,
457                             int position, v8::internal::RelocInfo::Mode mode,
458                             Code* debug_break) {
459  v8::internal::Debug* debug = CcTest::i_isolate()->debug();
460
461  // Create function and set the break point.
462  Handle<v8::internal::JSFunction> fun = v8::Utils::OpenHandle(
463      *CompileFunction(env, source, name));
464  int bp = SetBreakPoint(fun, position);
465
466  // Check that the debug break function is as expected.
467  Handle<v8::internal::SharedFunctionInfo> shared(fun->shared());
468  CHECK(Debug::HasDebugInfo(shared));
469  TestBreakLocationIterator it1(Debug::GetDebugInfo(shared));
470  it1.FindBreakLocationFromPosition(position, v8::internal::STATEMENT_ALIGNED);
471  v8::internal::RelocInfo::Mode actual_mode = it1.it()->rinfo()->rmode();
472  if (actual_mode == v8::internal::RelocInfo::CODE_TARGET_WITH_ID) {
473    actual_mode = v8::internal::RelocInfo::CODE_TARGET;
474  }
475  CHECK_EQ(mode, actual_mode);
476  if (mode != v8::internal::RelocInfo::JS_RETURN) {
477    CHECK_EQ(debug_break,
478        Code::GetCodeFromTargetAddress(it1.it()->rinfo()->target_address()));
479  } else {
480    CHECK(Debug::IsDebugBreakAtReturn(it1.it()->rinfo()));
481  }
482
483  // Clear the break point and check that the debug break function is no longer
484  // there
485  ClearBreakPoint(bp);
486  CHECK(!debug->HasDebugInfo(shared));
487  CHECK(debug->EnsureDebugInfo(shared, fun));
488  TestBreakLocationIterator it2(Debug::GetDebugInfo(shared));
489  it2.FindBreakLocationFromPosition(position, v8::internal::STATEMENT_ALIGNED);
490  actual_mode = it2.it()->rinfo()->rmode();
491  if (actual_mode == v8::internal::RelocInfo::CODE_TARGET_WITH_ID) {
492    actual_mode = v8::internal::RelocInfo::CODE_TARGET;
493  }
494  CHECK_EQ(mode, actual_mode);
495  if (mode == v8::internal::RelocInfo::JS_RETURN) {
496    CHECK(!Debug::IsDebugBreakAtReturn(it2.it()->rinfo()));
497  }
498}
499
500
501// --- D e b u g   E v e n t   H a n d l e r s
502// ---
503// --- The different tests uses a number of debug event handlers.
504// ---
505
506
507// Source for the JavaScript function which picks out the function
508// name of a frame.
509const char* frame_function_name_source =
510    "function frame_function_name(exec_state, frame_number) {"
511    "  return exec_state.frame(frame_number).func().name();"
512    "}";
513v8::Local<v8::Function> frame_function_name;
514
515
516// Source for the JavaScript function which pick out the name of the
517// first argument of a frame.
518const char* frame_argument_name_source =
519    "function frame_argument_name(exec_state, frame_number) {"
520    "  return exec_state.frame(frame_number).argumentName(0);"
521    "}";
522v8::Local<v8::Function> frame_argument_name;
523
524
525// Source for the JavaScript function which pick out the value of the
526// first argument of a frame.
527const char* frame_argument_value_source =
528    "function frame_argument_value(exec_state, frame_number) {"
529    "  return exec_state.frame(frame_number).argumentValue(0).value_;"
530    "}";
531v8::Local<v8::Function> frame_argument_value;
532
533
534// Source for the JavaScript function which pick out the name of the
535// first argument of a frame.
536const char* frame_local_name_source =
537    "function frame_local_name(exec_state, frame_number) {"
538    "  return exec_state.frame(frame_number).localName(0);"
539    "}";
540v8::Local<v8::Function> frame_local_name;
541
542
543// Source for the JavaScript function which pick out the value of the
544// first argument of a frame.
545const char* frame_local_value_source =
546    "function frame_local_value(exec_state, frame_number) {"
547    "  return exec_state.frame(frame_number).localValue(0).value_;"
548    "}";
549v8::Local<v8::Function> frame_local_value;
550
551
552// Source for the JavaScript function which picks out the source line for the
553// top frame.
554const char* frame_source_line_source =
555    "function frame_source_line(exec_state) {"
556    "  return exec_state.frame(0).sourceLine();"
557    "}";
558v8::Local<v8::Function> frame_source_line;
559
560
561// Source for the JavaScript function which picks out the source column for the
562// top frame.
563const char* frame_source_column_source =
564    "function frame_source_column(exec_state) {"
565    "  return exec_state.frame(0).sourceColumn();"
566    "}";
567v8::Local<v8::Function> frame_source_column;
568
569
570// Source for the JavaScript function which picks out the script name for the
571// top frame.
572const char* frame_script_name_source =
573    "function frame_script_name(exec_state) {"
574    "  return exec_state.frame(0).func().script().name();"
575    "}";
576v8::Local<v8::Function> frame_script_name;
577
578
579// Source for the JavaScript function which returns the number of frames.
580static const char* frame_count_source =
581    "function frame_count(exec_state) {"
582    "  return exec_state.frameCount();"
583    "}";
584v8::Handle<v8::Function> frame_count;
585
586
587// Global variable to store the last function hit - used by some tests.
588char last_function_hit[80];
589
590// Global variable to store the name for last script hit - used by some tests.
591char last_script_name_hit[80];
592
593// Global variables to store the last source position - used by some tests.
594int last_source_line = -1;
595int last_source_column = -1;
596
597// Debug event handler which counts the break points which have been hit.
598int break_point_hit_count = 0;
599int break_point_hit_count_deoptimize = 0;
600static void DebugEventBreakPointHitCount(
601    const v8::Debug::EventDetails& event_details) {
602  v8::DebugEvent event = event_details.GetEvent();
603  v8::Handle<v8::Object> exec_state = event_details.GetExecutionState();
604  v8::internal::Isolate* isolate = CcTest::i_isolate();
605  Debug* debug = isolate->debug();
606  // When hitting a debug event listener there must be a break set.
607  CHECK_NE(debug->break_id(), 0);
608
609  // Count the number of breaks.
610  if (event == v8::Break) {
611    break_point_hit_count++;
612    if (!frame_function_name.IsEmpty()) {
613      // Get the name of the function.
614      const int argc = 2;
615      v8::Handle<v8::Value> argv[argc] = {
616        exec_state, v8::Integer::New(CcTest::isolate(), 0)
617      };
618      v8::Handle<v8::Value> result = frame_function_name->Call(exec_state,
619                                                               argc, argv);
620      if (result->IsUndefined()) {
621        last_function_hit[0] = '\0';
622      } else {
623        CHECK(result->IsString());
624        v8::Handle<v8::String> function_name(result->ToString());
625        function_name->WriteUtf8(last_function_hit);
626      }
627    }
628
629    if (!frame_source_line.IsEmpty()) {
630      // Get the source line.
631      const int argc = 1;
632      v8::Handle<v8::Value> argv[argc] = { exec_state };
633      v8::Handle<v8::Value> result = frame_source_line->Call(exec_state,
634                                                             argc, argv);
635      CHECK(result->IsNumber());
636      last_source_line = result->Int32Value();
637    }
638
639    if (!frame_source_column.IsEmpty()) {
640      // Get the source column.
641      const int argc = 1;
642      v8::Handle<v8::Value> argv[argc] = { exec_state };
643      v8::Handle<v8::Value> result = frame_source_column->Call(exec_state,
644                                                               argc, argv);
645      CHECK(result->IsNumber());
646      last_source_column = result->Int32Value();
647    }
648
649    if (!frame_script_name.IsEmpty()) {
650      // Get the script name of the function script.
651      const int argc = 1;
652      v8::Handle<v8::Value> argv[argc] = { exec_state };
653      v8::Handle<v8::Value> result = frame_script_name->Call(exec_state,
654                                                             argc, argv);
655      if (result->IsUndefined()) {
656        last_script_name_hit[0] = '\0';
657      } else {
658        CHECK(result->IsString());
659        v8::Handle<v8::String> script_name(result->ToString());
660        script_name->WriteUtf8(last_script_name_hit);
661      }
662    }
663
664    // Perform a full deoptimization when the specified number of
665    // breaks have been hit.
666    if (break_point_hit_count == break_point_hit_count_deoptimize) {
667      i::Deoptimizer::DeoptimizeAll(isolate);
668    }
669  }
670}
671
672
673// Debug event handler which counts a number of events and collects the stack
674// height if there is a function compiled for that.
675int exception_hit_count = 0;
676int uncaught_exception_hit_count = 0;
677int last_js_stack_height = -1;
678v8::Handle<v8::Function> debug_event_listener_callback;
679int debug_event_listener_callback_result;
680
681static void DebugEventCounterClear() {
682  break_point_hit_count = 0;
683  exception_hit_count = 0;
684  uncaught_exception_hit_count = 0;
685}
686
687static void DebugEventCounter(
688    const v8::Debug::EventDetails& event_details) {
689  v8::DebugEvent event = event_details.GetEvent();
690  v8::Handle<v8::Object> exec_state = event_details.GetExecutionState();
691  v8::Handle<v8::Object> event_data = event_details.GetEventData();
692  v8::internal::Debug* debug = CcTest::i_isolate()->debug();
693
694  // When hitting a debug event listener there must be a break set.
695  CHECK_NE(debug->break_id(), 0);
696
697  // Count the number of breaks.
698  if (event == v8::Break) {
699    break_point_hit_count++;
700  } else if (event == v8::Exception) {
701    exception_hit_count++;
702
703    // Check whether the exception was uncaught.
704    v8::Local<v8::String> fun_name =
705        v8::String::NewFromUtf8(CcTest::isolate(), "uncaught");
706    v8::Local<v8::Function> fun =
707        v8::Local<v8::Function>::Cast(event_data->Get(fun_name));
708    v8::Local<v8::Value> result = fun->Call(event_data, 0, NULL);
709    if (result->IsTrue()) {
710      uncaught_exception_hit_count++;
711    }
712  }
713
714  // Collect the JavsScript stack height if the function frame_count is
715  // compiled.
716  if (!frame_count.IsEmpty()) {
717    static const int kArgc = 1;
718    v8::Handle<v8::Value> argv[kArgc] = { exec_state };
719    // Using exec_state as receiver is just to have a receiver.
720    v8::Handle<v8::Value> result = frame_count->Call(exec_state, kArgc, argv);
721    last_js_stack_height = result->Int32Value();
722  }
723
724  // Run callback from DebugEventListener and check the result.
725  if (!debug_event_listener_callback.IsEmpty()) {
726    v8::Handle<v8::Value> result =
727        debug_event_listener_callback->Call(event_data, 0, NULL);
728    CHECK(!result.IsEmpty());
729    CHECK_EQ(debug_event_listener_callback_result, result->Int32Value());
730  }
731}
732
733
734// Debug event handler which evaluates a number of expressions when a break
735// point is hit. Each evaluated expression is compared with an expected value.
736// For this debug event handler to work the following two global varaibles
737// must be initialized.
738//   checks: An array of expressions and expected results
739//   evaluate_check_function: A JavaScript function (see below)
740
741// Structure for holding checks to do.
742struct EvaluateCheck {
743  const char* expr;  // An expression to evaluate when a break point is hit.
744  v8::Handle<v8::Value> expected;  // The expected result.
745};
746
747
748// Array of checks to do.
749struct EvaluateCheck* checks = NULL;
750// Source for The JavaScript function which can do the evaluation when a break
751// point is hit.
752const char* evaluate_check_source =
753    "function evaluate_check(exec_state, expr, expected) {"
754    "  return exec_state.frame(0).evaluate(expr).value() === expected;"
755    "}";
756v8::Local<v8::Function> evaluate_check_function;
757
758// The actual debug event described by the longer comment above.
759static void DebugEventEvaluate(
760    const v8::Debug::EventDetails& event_details) {
761  v8::DebugEvent event = event_details.GetEvent();
762  v8::Handle<v8::Object> exec_state = event_details.GetExecutionState();
763  v8::internal::Debug* debug = CcTest::i_isolate()->debug();
764  // When hitting a debug event listener there must be a break set.
765  CHECK_NE(debug->break_id(), 0);
766
767  if (event == v8::Break) {
768    break_point_hit_count++;
769    for (int i = 0; checks[i].expr != NULL; i++) {
770      const int argc = 3;
771      v8::Handle<v8::Value> argv[argc] = {
772          exec_state,
773          v8::String::NewFromUtf8(CcTest::isolate(), checks[i].expr),
774          checks[i].expected};
775      v8::Handle<v8::Value> result =
776          evaluate_check_function->Call(exec_state, argc, argv);
777      if (!result->IsTrue()) {
778        v8::String::Utf8Value utf8(checks[i].expected->ToString());
779        V8_Fatal(__FILE__, __LINE__, "%s != %s", checks[i].expr, *utf8);
780      }
781    }
782  }
783}
784
785
786// This debug event listener removes a breakpoint in a function
787int debug_event_remove_break_point = 0;
788static void DebugEventRemoveBreakPoint(
789    const v8::Debug::EventDetails& event_details) {
790  v8::DebugEvent event = event_details.GetEvent();
791  v8::Handle<v8::Value> data = event_details.GetCallbackData();
792  v8::internal::Debug* debug = CcTest::i_isolate()->debug();
793  // When hitting a debug event listener there must be a break set.
794  CHECK_NE(debug->break_id(), 0);
795
796  if (event == v8::Break) {
797    break_point_hit_count++;
798    CHECK(data->IsFunction());
799    ClearBreakPoint(debug_event_remove_break_point);
800  }
801}
802
803
804// Debug event handler which counts break points hit and performs a step
805// afterwards.
806StepAction step_action = StepIn;  // Step action to perform when stepping.
807static void DebugEventStep(
808    const v8::Debug::EventDetails& event_details) {
809  v8::DebugEvent event = event_details.GetEvent();
810  v8::internal::Debug* debug = CcTest::i_isolate()->debug();
811  // When hitting a debug event listener there must be a break set.
812  CHECK_NE(debug->break_id(), 0);
813
814  if (event == v8::Break) {
815    break_point_hit_count++;
816    PrepareStep(step_action);
817  }
818}
819
820
821// Debug event handler which counts break points hit and performs a step
822// afterwards. For each call the expected function is checked.
823// For this debug event handler to work the following two global varaibles
824// must be initialized.
825//   expected_step_sequence: An array of the expected function call sequence.
826//   frame_function_name: A JavaScript function (see below).
827
828// String containing the expected function call sequence. Note: this only works
829// if functions have name length of one.
830const char* expected_step_sequence = NULL;
831
832// The actual debug event described by the longer comment above.
833static void DebugEventStepSequence(
834    const v8::Debug::EventDetails& event_details) {
835  v8::DebugEvent event = event_details.GetEvent();
836  v8::Handle<v8::Object> exec_state = event_details.GetExecutionState();
837  v8::internal::Debug* debug = CcTest::i_isolate()->debug();
838  // When hitting a debug event listener there must be a break set.
839  CHECK_NE(debug->break_id(), 0);
840
841  if (event == v8::Break || event == v8::Exception) {
842    // Check that the current function is the expected.
843    CHECK(break_point_hit_count <
844          StrLength(expected_step_sequence));
845    const int argc = 2;
846    v8::Handle<v8::Value> argv[argc] = {
847      exec_state, v8::Integer::New(CcTest::isolate(), 0)
848    };
849    v8::Handle<v8::Value> result = frame_function_name->Call(exec_state,
850                                                             argc, argv);
851    CHECK(result->IsString());
852    v8::String::Utf8Value function_name(result->ToString());
853    CHECK_EQ(1, StrLength(*function_name));
854    CHECK_EQ((*function_name)[0],
855              expected_step_sequence[break_point_hit_count]);
856
857    // Perform step.
858    break_point_hit_count++;
859    PrepareStep(step_action);
860  }
861}
862
863
864// Debug event handler which performs a garbage collection.
865static void DebugEventBreakPointCollectGarbage(
866    const v8::Debug::EventDetails& event_details) {
867  v8::DebugEvent event = event_details.GetEvent();
868  v8::internal::Debug* debug = CcTest::i_isolate()->debug();
869  // When hitting a debug event listener there must be a break set.
870  CHECK_NE(debug->break_id(), 0);
871
872  // Perform a garbage collection when break point is hit and continue. Based
873  // on the number of break points hit either scavenge or mark compact
874  // collector is used.
875  if (event == v8::Break) {
876    break_point_hit_count++;
877    if (break_point_hit_count % 2 == 0) {
878      // Scavenge.
879      CcTest::heap()->CollectGarbage(v8::internal::NEW_SPACE);
880    } else {
881      // Mark sweep compact.
882      CcTest::heap()->CollectAllGarbage(Heap::kNoGCFlags);
883    }
884  }
885}
886
887
888// Debug event handler which re-issues a debug break and calls the garbage
889// collector to have the heap verified.
890static void DebugEventBreak(
891    const v8::Debug::EventDetails& event_details) {
892  v8::DebugEvent event = event_details.GetEvent();
893  v8::internal::Debug* debug = CcTest::i_isolate()->debug();
894  // When hitting a debug event listener there must be a break set.
895  CHECK_NE(debug->break_id(), 0);
896
897  if (event == v8::Break) {
898    // Count the number of breaks.
899    break_point_hit_count++;
900
901    // Run the garbage collector to enforce heap verification if option
902    // --verify-heap is set.
903    CcTest::heap()->CollectGarbage(v8::internal::NEW_SPACE);
904
905    // Set the break flag again to come back here as soon as possible.
906    v8::Debug::DebugBreak(CcTest::isolate());
907  }
908}
909
910
911// Debug event handler which re-issues a debug break until a limit has been
912// reached.
913int max_break_point_hit_count = 0;
914bool terminate_after_max_break_point_hit = false;
915static void DebugEventBreakMax(
916    const v8::Debug::EventDetails& event_details) {
917  v8::DebugEvent event = event_details.GetEvent();
918  v8::Handle<v8::Object> exec_state = event_details.GetExecutionState();
919  v8::Isolate* v8_isolate = CcTest::isolate();
920  v8::internal::Isolate* isolate = CcTest::i_isolate();
921  v8::internal::Debug* debug = isolate->debug();
922  // When hitting a debug event listener there must be a break set.
923  CHECK_NE(debug->break_id(), 0);
924
925  if (event == v8::Break) {
926    if (break_point_hit_count < max_break_point_hit_count) {
927      // Count the number of breaks.
928      break_point_hit_count++;
929
930      // Collect the JavsScript stack height if the function frame_count is
931      // compiled.
932      if (!frame_count.IsEmpty()) {
933        static const int kArgc = 1;
934        v8::Handle<v8::Value> argv[kArgc] = { exec_state };
935        // Using exec_state as receiver is just to have a receiver.
936        v8::Handle<v8::Value> result =
937            frame_count->Call(exec_state, kArgc, argv);
938        last_js_stack_height = result->Int32Value();
939      }
940
941      // Set the break flag again to come back here as soon as possible.
942      v8::Debug::DebugBreak(v8_isolate);
943
944    } else if (terminate_after_max_break_point_hit) {
945      // Terminate execution after the last break if requested.
946      v8::V8::TerminateExecution(v8_isolate);
947    }
948
949    // Perform a full deoptimization when the specified number of
950    // breaks have been hit.
951    if (break_point_hit_count == break_point_hit_count_deoptimize) {
952      i::Deoptimizer::DeoptimizeAll(isolate);
953    }
954  }
955}
956
957
958// --- M e s s a g e   C a l l b a c k
959
960
961// Message callback which counts the number of messages.
962int message_callback_count = 0;
963
964static void MessageCallbackCountClear() {
965  message_callback_count = 0;
966}
967
968static void MessageCallbackCount(v8::Handle<v8::Message> message,
969                                 v8::Handle<v8::Value> data) {
970  message_callback_count++;
971}
972
973
974// --- T h e   A c t u a l   T e s t s
975
976
977// Test that the debug break function is the expected one for different kinds
978// of break locations.
979TEST(DebugStub) {
980  using ::v8::internal::Builtins;
981  using ::v8::internal::Isolate;
982  DebugLocalContext env;
983  v8::HandleScope scope(env->GetIsolate());
984
985  CheckDebugBreakFunction(&env,
986                          "function f1(){}", "f1",
987                          0,
988                          v8::internal::RelocInfo::JS_RETURN,
989                          NULL);
990  CheckDebugBreakFunction(&env,
991                          "function f2(){x=1;}", "f2",
992                          0,
993                          v8::internal::RelocInfo::CODE_TARGET,
994                          CcTest::i_isolate()->builtins()->builtin(
995                              Builtins::kStoreIC_DebugBreak));
996  CheckDebugBreakFunction(&env,
997                          "function f3(){var a=x;}", "f3",
998                          0,
999                          v8::internal::RelocInfo::CODE_TARGET,
1000                          CcTest::i_isolate()->builtins()->builtin(
1001                              Builtins::kLoadIC_DebugBreak));
1002
1003// TODO(1240753): Make the test architecture independent or split
1004// parts of the debugger into architecture dependent files. This
1005// part currently disabled as it is not portable between IA32/ARM.
1006// Currently on ICs for keyed store/load on ARM.
1007#if !defined (__arm__) && !defined(__thumb__)
1008  CheckDebugBreakFunction(
1009      &env,
1010      "function f4(){var index='propertyName'; var a={}; a[index] = 'x';}",
1011      "f4",
1012      0,
1013      v8::internal::RelocInfo::CODE_TARGET,
1014      CcTest::i_isolate()->builtins()->builtin(
1015          Builtins::kKeyedStoreIC_DebugBreak));
1016  CheckDebugBreakFunction(
1017      &env,
1018      "function f5(){var index='propertyName'; var a={}; return a[index];}",
1019      "f5",
1020      0,
1021      v8::internal::RelocInfo::CODE_TARGET,
1022      CcTest::i_isolate()->builtins()->builtin(
1023          Builtins::kKeyedLoadIC_DebugBreak));
1024#endif
1025
1026  CheckDebugBreakFunction(
1027      &env,
1028      "function f6(a){return a==null;}",
1029      "f6",
1030      0,
1031      v8::internal::RelocInfo::CODE_TARGET,
1032      CcTest::i_isolate()->builtins()->builtin(
1033          Builtins::kCompareNilIC_DebugBreak));
1034
1035  // Check the debug break code stubs for call ICs with different number of
1036  // parameters.
1037  // TODO(verwaest): XXX update test.
1038  // Handle<Code> debug_break_0 = v8::internal::ComputeCallDebugBreak(0);
1039  // Handle<Code> debug_break_1 = v8::internal::ComputeCallDebugBreak(1);
1040  // Handle<Code> debug_break_4 = v8::internal::ComputeCallDebugBreak(4);
1041
1042  // CheckDebugBreakFunction(&env,
1043  //                         "function f4_0(){x();}", "f4_0",
1044  //                         0,
1045  //                         v8::internal::RelocInfo::CODE_TARGET,
1046  //                         *debug_break_0);
1047
1048  // CheckDebugBreakFunction(&env,
1049  //                         "function f4_1(){x(1);}", "f4_1",
1050  //                         0,
1051  //                         v8::internal::RelocInfo::CODE_TARGET,
1052  //                         *debug_break_1);
1053
1054  // CheckDebugBreakFunction(&env,
1055  //                         "function f4_4(){x(1,2,3,4);}", "f4_4",
1056  //                         0,
1057  //                         v8::internal::RelocInfo::CODE_TARGET,
1058  //                         *debug_break_4);
1059}
1060
1061
1062// Test that the debug info in the VM is in sync with the functions being
1063// debugged.
1064TEST(DebugInfo) {
1065  DebugLocalContext env;
1066  v8::HandleScope scope(env->GetIsolate());
1067  // Create a couple of functions for the test.
1068  v8::Local<v8::Function> foo =
1069      CompileFunction(&env, "function foo(){}", "foo");
1070  v8::Local<v8::Function> bar =
1071      CompileFunction(&env, "function bar(){}", "bar");
1072  // Initially no functions are debugged.
1073  CHECK_EQ(0, v8::internal::GetDebuggedFunctions()->length());
1074  CHECK(!HasDebugInfo(foo));
1075  CHECK(!HasDebugInfo(bar));
1076  // One function (foo) is debugged.
1077  int bp1 = SetBreakPoint(foo, 0);
1078  CHECK_EQ(1, v8::internal::GetDebuggedFunctions()->length());
1079  CHECK(HasDebugInfo(foo));
1080  CHECK(!HasDebugInfo(bar));
1081  // Two functions are debugged.
1082  int bp2 = SetBreakPoint(bar, 0);
1083  CHECK_EQ(2, v8::internal::GetDebuggedFunctions()->length());
1084  CHECK(HasDebugInfo(foo));
1085  CHECK(HasDebugInfo(bar));
1086  // One function (bar) is debugged.
1087  ClearBreakPoint(bp1);
1088  CHECK_EQ(1, v8::internal::GetDebuggedFunctions()->length());
1089  CHECK(!HasDebugInfo(foo));
1090  CHECK(HasDebugInfo(bar));
1091  // No functions are debugged.
1092  ClearBreakPoint(bp2);
1093  CHECK_EQ(0, v8::internal::GetDebuggedFunctions()->length());
1094  CHECK(!HasDebugInfo(foo));
1095  CHECK(!HasDebugInfo(bar));
1096}
1097
1098
1099// Test that a break point can be set at an IC store location.
1100TEST(BreakPointICStore) {
1101  break_point_hit_count = 0;
1102  DebugLocalContext env;
1103  v8::HandleScope scope(env->GetIsolate());
1104
1105  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
1106  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
1107                                              "function foo(){bar=0;}"))->Run();
1108  v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
1109      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo")));
1110
1111  // Run without breakpoints.
1112  foo->Call(env->Global(), 0, NULL);
1113  CHECK_EQ(0, break_point_hit_count);
1114
1115  // Run with breakpoint
1116  int bp = SetBreakPoint(foo, 0);
1117  foo->Call(env->Global(), 0, NULL);
1118  CHECK_EQ(1, break_point_hit_count);
1119  foo->Call(env->Global(), 0, NULL);
1120  CHECK_EQ(2, break_point_hit_count);
1121
1122  // Run without breakpoints.
1123  ClearBreakPoint(bp);
1124  foo->Call(env->Global(), 0, NULL);
1125  CHECK_EQ(2, break_point_hit_count);
1126
1127  v8::Debug::SetDebugEventListener(NULL);
1128  CheckDebuggerUnloaded();
1129}
1130
1131
1132// Test that a break point can be set at an IC load location.
1133TEST(BreakPointICLoad) {
1134  break_point_hit_count = 0;
1135  DebugLocalContext env;
1136  v8::HandleScope scope(env->GetIsolate());
1137  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
1138  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), "bar=1"))
1139      ->Run();
1140  v8::Script::Compile(
1141      v8::String::NewFromUtf8(env->GetIsolate(), "function foo(){var x=bar;}"))
1142      ->Run();
1143  v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
1144      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo")));
1145
1146  // Run without breakpoints.
1147  foo->Call(env->Global(), 0, NULL);
1148  CHECK_EQ(0, break_point_hit_count);
1149
1150  // Run with breakpoint.
1151  int bp = SetBreakPoint(foo, 0);
1152  foo->Call(env->Global(), 0, NULL);
1153  CHECK_EQ(1, break_point_hit_count);
1154  foo->Call(env->Global(), 0, NULL);
1155  CHECK_EQ(2, break_point_hit_count);
1156
1157  // Run without breakpoints.
1158  ClearBreakPoint(bp);
1159  foo->Call(env->Global(), 0, NULL);
1160  CHECK_EQ(2, break_point_hit_count);
1161
1162  v8::Debug::SetDebugEventListener(NULL);
1163  CheckDebuggerUnloaded();
1164}
1165
1166
1167// Test that a break point can be set at an IC call location.
1168TEST(BreakPointICCall) {
1169  break_point_hit_count = 0;
1170  DebugLocalContext env;
1171  v8::HandleScope scope(env->GetIsolate());
1172  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
1173  v8::Script::Compile(
1174      v8::String::NewFromUtf8(env->GetIsolate(), "function bar(){}"))->Run();
1175  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
1176                                              "function foo(){bar();}"))->Run();
1177  v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
1178      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo")));
1179
1180  // Run without breakpoints.
1181  foo->Call(env->Global(), 0, NULL);
1182  CHECK_EQ(0, break_point_hit_count);
1183
1184  // Run with breakpoint
1185  int bp = SetBreakPoint(foo, 0);
1186  foo->Call(env->Global(), 0, NULL);
1187  CHECK_EQ(1, break_point_hit_count);
1188  foo->Call(env->Global(), 0, NULL);
1189  CHECK_EQ(2, break_point_hit_count);
1190
1191  // Run without breakpoints.
1192  ClearBreakPoint(bp);
1193  foo->Call(env->Global(), 0, NULL);
1194  CHECK_EQ(2, break_point_hit_count);
1195
1196  v8::Debug::SetDebugEventListener(NULL);
1197  CheckDebuggerUnloaded();
1198}
1199
1200
1201// Test that a break point can be set at an IC call location and survive a GC.
1202TEST(BreakPointICCallWithGC) {
1203  break_point_hit_count = 0;
1204  DebugLocalContext env;
1205  v8::HandleScope scope(env->GetIsolate());
1206  v8::Debug::SetDebugEventListener(DebugEventBreakPointCollectGarbage);
1207  v8::Script::Compile(
1208      v8::String::NewFromUtf8(env->GetIsolate(), "function bar(){return 1;}"))
1209      ->Run();
1210  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
1211                                              "function foo(){return bar();}"))
1212      ->Run();
1213  v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
1214      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo")));
1215
1216  // Run without breakpoints.
1217  CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
1218  CHECK_EQ(0, break_point_hit_count);
1219
1220  // Run with breakpoint.
1221  int bp = SetBreakPoint(foo, 0);
1222  CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
1223  CHECK_EQ(1, break_point_hit_count);
1224  CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
1225  CHECK_EQ(2, break_point_hit_count);
1226
1227  // Run without breakpoints.
1228  ClearBreakPoint(bp);
1229  foo->Call(env->Global(), 0, NULL);
1230  CHECK_EQ(2, break_point_hit_count);
1231
1232  v8::Debug::SetDebugEventListener(NULL);
1233  CheckDebuggerUnloaded();
1234}
1235
1236
1237// Test that a break point can be set at an IC call location and survive a GC.
1238TEST(BreakPointConstructCallWithGC) {
1239  break_point_hit_count = 0;
1240  DebugLocalContext env;
1241  v8::HandleScope scope(env->GetIsolate());
1242  v8::Debug::SetDebugEventListener(DebugEventBreakPointCollectGarbage);
1243  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
1244                                              "function bar(){ this.x = 1;}"))
1245      ->Run();
1246  v8::Script::Compile(
1247      v8::String::NewFromUtf8(env->GetIsolate(),
1248                              "function foo(){return new bar(1).x;}"))->Run();
1249  v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
1250      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo")));
1251
1252  // Run without breakpoints.
1253  CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
1254  CHECK_EQ(0, break_point_hit_count);
1255
1256  // Run with breakpoint.
1257  int bp = SetBreakPoint(foo, 0);
1258  CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
1259  CHECK_EQ(1, break_point_hit_count);
1260  CHECK_EQ(1, foo->Call(env->Global(), 0, NULL)->Int32Value());
1261  CHECK_EQ(2, break_point_hit_count);
1262
1263  // Run without breakpoints.
1264  ClearBreakPoint(bp);
1265  foo->Call(env->Global(), 0, NULL);
1266  CHECK_EQ(2, break_point_hit_count);
1267
1268  v8::Debug::SetDebugEventListener(NULL);
1269  CheckDebuggerUnloaded();
1270}
1271
1272
1273// Test that a break point can be set at a return store location.
1274TEST(BreakPointReturn) {
1275  break_point_hit_count = 0;
1276  DebugLocalContext env;
1277  v8::HandleScope scope(env->GetIsolate());
1278
1279  // Create a functions for checking the source line and column when hitting
1280  // a break point.
1281  frame_source_line = CompileFunction(&env,
1282                                      frame_source_line_source,
1283                                      "frame_source_line");
1284  frame_source_column = CompileFunction(&env,
1285                                        frame_source_column_source,
1286                                        "frame_source_column");
1287
1288
1289  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
1290  v8::Script::Compile(
1291      v8::String::NewFromUtf8(env->GetIsolate(), "function foo(){}"))->Run();
1292  v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
1293      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo")));
1294
1295  // Run without breakpoints.
1296  foo->Call(env->Global(), 0, NULL);
1297  CHECK_EQ(0, break_point_hit_count);
1298
1299  // Run with breakpoint
1300  int bp = SetBreakPoint(foo, 0);
1301  foo->Call(env->Global(), 0, NULL);
1302  CHECK_EQ(1, break_point_hit_count);
1303  CHECK_EQ(0, last_source_line);
1304  CHECK_EQ(15, last_source_column);
1305  foo->Call(env->Global(), 0, NULL);
1306  CHECK_EQ(2, break_point_hit_count);
1307  CHECK_EQ(0, last_source_line);
1308  CHECK_EQ(15, last_source_column);
1309
1310  // Run without breakpoints.
1311  ClearBreakPoint(bp);
1312  foo->Call(env->Global(), 0, NULL);
1313  CHECK_EQ(2, break_point_hit_count);
1314
1315  v8::Debug::SetDebugEventListener(NULL);
1316  CheckDebuggerUnloaded();
1317}
1318
1319
1320static void CallWithBreakPoints(v8::Local<v8::Object> recv,
1321                                v8::Local<v8::Function> f,
1322                                int break_point_count,
1323                                int call_count) {
1324  break_point_hit_count = 0;
1325  for (int i = 0; i < call_count; i++) {
1326    f->Call(recv, 0, NULL);
1327    CHECK_EQ((i + 1) * break_point_count, break_point_hit_count);
1328  }
1329}
1330
1331
1332// Test GC during break point processing.
1333TEST(GCDuringBreakPointProcessing) {
1334  break_point_hit_count = 0;
1335  DebugLocalContext env;
1336  v8::HandleScope scope(env->GetIsolate());
1337
1338  v8::Debug::SetDebugEventListener(DebugEventBreakPointCollectGarbage);
1339  v8::Local<v8::Function> foo;
1340
1341  // Test IC store break point with garbage collection.
1342  foo = CompileFunction(&env, "function foo(){bar=0;}", "foo");
1343  SetBreakPoint(foo, 0);
1344  CallWithBreakPoints(env->Global(), foo, 1, 10);
1345
1346  // Test IC load break point with garbage collection.
1347  foo = CompileFunction(&env, "bar=1;function foo(){var x=bar;}", "foo");
1348  SetBreakPoint(foo, 0);
1349  CallWithBreakPoints(env->Global(), foo, 1, 10);
1350
1351  // Test IC call break point with garbage collection.
1352  foo = CompileFunction(&env, "function bar(){};function foo(){bar();}", "foo");
1353  SetBreakPoint(foo, 0);
1354  CallWithBreakPoints(env->Global(), foo, 1, 10);
1355
1356  // Test return break point with garbage collection.
1357  foo = CompileFunction(&env, "function foo(){}", "foo");
1358  SetBreakPoint(foo, 0);
1359  CallWithBreakPoints(env->Global(), foo, 1, 25);
1360
1361  // Test debug break slot break point with garbage collection.
1362  foo = CompileFunction(&env, "function foo(){var a;}", "foo");
1363  SetBreakPoint(foo, 0);
1364  CallWithBreakPoints(env->Global(), foo, 1, 25);
1365
1366  v8::Debug::SetDebugEventListener(NULL);
1367  CheckDebuggerUnloaded();
1368}
1369
1370
1371// Call the function three times with different garbage collections in between
1372// and make sure that the break point survives.
1373static void CallAndGC(v8::Local<v8::Object> recv,
1374                      v8::Local<v8::Function> f) {
1375  break_point_hit_count = 0;
1376
1377  for (int i = 0; i < 3; i++) {
1378    // Call function.
1379    f->Call(recv, 0, NULL);
1380    CHECK_EQ(1 + i * 3, break_point_hit_count);
1381
1382    // Scavenge and call function.
1383    CcTest::heap()->CollectGarbage(v8::internal::NEW_SPACE);
1384    f->Call(recv, 0, NULL);
1385    CHECK_EQ(2 + i * 3, break_point_hit_count);
1386
1387    // Mark sweep (and perhaps compact) and call function.
1388    CcTest::heap()->CollectAllGarbage(Heap::kNoGCFlags);
1389    f->Call(recv, 0, NULL);
1390    CHECK_EQ(3 + i * 3, break_point_hit_count);
1391  }
1392}
1393
1394
1395// Test that a break point can be set at a return store location.
1396TEST(BreakPointSurviveGC) {
1397  break_point_hit_count = 0;
1398  DebugLocalContext env;
1399  v8::HandleScope scope(env->GetIsolate());
1400
1401  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
1402  v8::Local<v8::Function> foo;
1403
1404  // Test IC store break point with garbage collection.
1405  {
1406    CompileFunction(&env, "function foo(){}", "foo");
1407    foo = CompileFunction(&env, "function foo(){bar=0;}", "foo");
1408    SetBreakPoint(foo, 0);
1409  }
1410  CallAndGC(env->Global(), foo);
1411
1412  // Test IC load break point with garbage collection.
1413  {
1414    CompileFunction(&env, "function foo(){}", "foo");
1415    foo = CompileFunction(&env, "bar=1;function foo(){var x=bar;}", "foo");
1416    SetBreakPoint(foo, 0);
1417  }
1418  CallAndGC(env->Global(), foo);
1419
1420  // Test IC call break point with garbage collection.
1421  {
1422    CompileFunction(&env, "function foo(){}", "foo");
1423    foo = CompileFunction(&env,
1424                          "function bar(){};function foo(){bar();}",
1425                          "foo");
1426    SetBreakPoint(foo, 0);
1427  }
1428  CallAndGC(env->Global(), foo);
1429
1430  // Test return break point with garbage collection.
1431  {
1432    CompileFunction(&env, "function foo(){}", "foo");
1433    foo = CompileFunction(&env, "function foo(){}", "foo");
1434    SetBreakPoint(foo, 0);
1435  }
1436  CallAndGC(env->Global(), foo);
1437
1438  // Test non IC break point with garbage collection.
1439  {
1440    CompileFunction(&env, "function foo(){}", "foo");
1441    foo = CompileFunction(&env, "function foo(){var bar=0;}", "foo");
1442    SetBreakPoint(foo, 0);
1443  }
1444  CallAndGC(env->Global(), foo);
1445
1446
1447  v8::Debug::SetDebugEventListener(NULL);
1448  CheckDebuggerUnloaded();
1449}
1450
1451
1452// Test that break points can be set using the global Debug object.
1453TEST(BreakPointThroughJavaScript) {
1454  break_point_hit_count = 0;
1455  DebugLocalContext env;
1456  v8::HandleScope scope(env->GetIsolate());
1457  env.ExposeDebug();
1458
1459  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
1460  v8::Script::Compile(
1461      v8::String::NewFromUtf8(env->GetIsolate(), "function bar(){}"))->Run();
1462  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(),
1463                                              "function foo(){bar();bar();}"))
1464      ->Run();
1465  //                                               012345678901234567890
1466  //                                                         1         2
1467  // Break points are set at position 3 and 9
1468  v8::Local<v8::Script> foo =
1469      v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), "foo()"));
1470
1471  // Run without breakpoints.
1472  foo->Run();
1473  CHECK_EQ(0, break_point_hit_count);
1474
1475  // Run with one breakpoint
1476  int bp1 = SetBreakPointFromJS(env->GetIsolate(), "foo", 0, 3);
1477  foo->Run();
1478  CHECK_EQ(1, break_point_hit_count);
1479  foo->Run();
1480  CHECK_EQ(2, break_point_hit_count);
1481
1482  // Run with two breakpoints
1483  int bp2 = SetBreakPointFromJS(env->GetIsolate(), "foo", 0, 9);
1484  foo->Run();
1485  CHECK_EQ(4, break_point_hit_count);
1486  foo->Run();
1487  CHECK_EQ(6, break_point_hit_count);
1488
1489  // Run with one breakpoint
1490  ClearBreakPointFromJS(env->GetIsolate(), bp2);
1491  foo->Run();
1492  CHECK_EQ(7, break_point_hit_count);
1493  foo->Run();
1494  CHECK_EQ(8, break_point_hit_count);
1495
1496  // Run without breakpoints.
1497  ClearBreakPointFromJS(env->GetIsolate(), bp1);
1498  foo->Run();
1499  CHECK_EQ(8, break_point_hit_count);
1500
1501  v8::Debug::SetDebugEventListener(NULL);
1502  CheckDebuggerUnloaded();
1503
1504  // Make sure that the break point numbers are consecutive.
1505  CHECK_EQ(1, bp1);
1506  CHECK_EQ(2, bp2);
1507}
1508
1509
1510// Test that break points on scripts identified by name can be set using the
1511// global Debug object.
1512TEST(ScriptBreakPointByNameThroughJavaScript) {
1513  break_point_hit_count = 0;
1514  DebugLocalContext env;
1515  v8::HandleScope scope(env->GetIsolate());
1516  env.ExposeDebug();
1517
1518  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
1519
1520  v8::Local<v8::String> script = v8::String::NewFromUtf8(
1521    env->GetIsolate(),
1522    "function f() {\n"
1523    "  function h() {\n"
1524    "    a = 0;  // line 2\n"
1525    "  }\n"
1526    "  b = 1;  // line 4\n"
1527    "  return h();\n"
1528    "}\n"
1529    "\n"
1530    "function g() {\n"
1531    "  function h() {\n"
1532    "    a = 0;\n"
1533    "  }\n"
1534    "  b = 2;  // line 12\n"
1535    "  h();\n"
1536    "  b = 3;  // line 14\n"
1537    "  f();    // line 15\n"
1538    "}");
1539
1540  // Compile the script and get the two functions.
1541  v8::ScriptOrigin origin =
1542      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "test"));
1543  v8::Script::Compile(script, &origin)->Run();
1544  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
1545      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
1546  v8::Local<v8::Function> g = v8::Local<v8::Function>::Cast(
1547      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "g")));
1548
1549  // Call f and g without break points.
1550  break_point_hit_count = 0;
1551  f->Call(env->Global(), 0, NULL);
1552  CHECK_EQ(0, break_point_hit_count);
1553  g->Call(env->Global(), 0, NULL);
1554  CHECK_EQ(0, break_point_hit_count);
1555
1556  // Call f and g with break point on line 12.
1557  int sbp1 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 12, 0);
1558  break_point_hit_count = 0;
1559  f->Call(env->Global(), 0, NULL);
1560  CHECK_EQ(0, break_point_hit_count);
1561  g->Call(env->Global(), 0, NULL);
1562  CHECK_EQ(1, break_point_hit_count);
1563
1564  // Remove the break point again.
1565  break_point_hit_count = 0;
1566  ClearBreakPointFromJS(env->GetIsolate(), sbp1);
1567  f->Call(env->Global(), 0, NULL);
1568  CHECK_EQ(0, break_point_hit_count);
1569  g->Call(env->Global(), 0, NULL);
1570  CHECK_EQ(0, break_point_hit_count);
1571
1572  // Call f and g with break point on line 2.
1573  int sbp2 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 2, 0);
1574  break_point_hit_count = 0;
1575  f->Call(env->Global(), 0, NULL);
1576  CHECK_EQ(1, break_point_hit_count);
1577  g->Call(env->Global(), 0, NULL);
1578  CHECK_EQ(2, break_point_hit_count);
1579
1580  // Call f and g with break point on line 2, 4, 12, 14 and 15.
1581  int sbp3 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 4, 0);
1582  int sbp4 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 12, 0);
1583  int sbp5 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 14, 0);
1584  int sbp6 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 15, 0);
1585  break_point_hit_count = 0;
1586  f->Call(env->Global(), 0, NULL);
1587  CHECK_EQ(2, break_point_hit_count);
1588  g->Call(env->Global(), 0, NULL);
1589  CHECK_EQ(7, break_point_hit_count);
1590
1591  // Remove all the break points again.
1592  break_point_hit_count = 0;
1593  ClearBreakPointFromJS(env->GetIsolate(), sbp2);
1594  ClearBreakPointFromJS(env->GetIsolate(), sbp3);
1595  ClearBreakPointFromJS(env->GetIsolate(), sbp4);
1596  ClearBreakPointFromJS(env->GetIsolate(), sbp5);
1597  ClearBreakPointFromJS(env->GetIsolate(), sbp6);
1598  f->Call(env->Global(), 0, NULL);
1599  CHECK_EQ(0, break_point_hit_count);
1600  g->Call(env->Global(), 0, NULL);
1601  CHECK_EQ(0, break_point_hit_count);
1602
1603  v8::Debug::SetDebugEventListener(NULL);
1604  CheckDebuggerUnloaded();
1605
1606  // Make sure that the break point numbers are consecutive.
1607  CHECK_EQ(1, sbp1);
1608  CHECK_EQ(2, sbp2);
1609  CHECK_EQ(3, sbp3);
1610  CHECK_EQ(4, sbp4);
1611  CHECK_EQ(5, sbp5);
1612  CHECK_EQ(6, sbp6);
1613}
1614
1615
1616TEST(ScriptBreakPointByIdThroughJavaScript) {
1617  break_point_hit_count = 0;
1618  DebugLocalContext env;
1619  v8::HandleScope scope(env->GetIsolate());
1620  env.ExposeDebug();
1621
1622  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
1623
1624  v8::Local<v8::String> source = v8::String::NewFromUtf8(
1625    env->GetIsolate(),
1626    "function f() {\n"
1627    "  function h() {\n"
1628    "    a = 0;  // line 2\n"
1629    "  }\n"
1630    "  b = 1;  // line 4\n"
1631    "  return h();\n"
1632    "}\n"
1633    "\n"
1634    "function g() {\n"
1635    "  function h() {\n"
1636    "    a = 0;\n"
1637    "  }\n"
1638    "  b = 2;  // line 12\n"
1639    "  h();\n"
1640    "  b = 3;  // line 14\n"
1641    "  f();    // line 15\n"
1642    "}");
1643
1644  // Compile the script and get the two functions.
1645  v8::ScriptOrigin origin =
1646      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "test"));
1647  v8::Local<v8::Script> script = v8::Script::Compile(source, &origin);
1648  script->Run();
1649  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
1650      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
1651  v8::Local<v8::Function> g = v8::Local<v8::Function>::Cast(
1652      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "g")));
1653
1654  // Get the script id knowing that internally it is a 32 integer.
1655  int script_id = script->GetUnboundScript()->GetId();
1656
1657  // Call f and g without break points.
1658  break_point_hit_count = 0;
1659  f->Call(env->Global(), 0, NULL);
1660  CHECK_EQ(0, break_point_hit_count);
1661  g->Call(env->Global(), 0, NULL);
1662  CHECK_EQ(0, break_point_hit_count);
1663
1664  // Call f and g with break point on line 12.
1665  int sbp1 = SetScriptBreakPointByIdFromJS(env->GetIsolate(), script_id, 12, 0);
1666  break_point_hit_count = 0;
1667  f->Call(env->Global(), 0, NULL);
1668  CHECK_EQ(0, break_point_hit_count);
1669  g->Call(env->Global(), 0, NULL);
1670  CHECK_EQ(1, break_point_hit_count);
1671
1672  // Remove the break point again.
1673  break_point_hit_count = 0;
1674  ClearBreakPointFromJS(env->GetIsolate(), sbp1);
1675  f->Call(env->Global(), 0, NULL);
1676  CHECK_EQ(0, break_point_hit_count);
1677  g->Call(env->Global(), 0, NULL);
1678  CHECK_EQ(0, break_point_hit_count);
1679
1680  // Call f and g with break point on line 2.
1681  int sbp2 = SetScriptBreakPointByIdFromJS(env->GetIsolate(), script_id, 2, 0);
1682  break_point_hit_count = 0;
1683  f->Call(env->Global(), 0, NULL);
1684  CHECK_EQ(1, break_point_hit_count);
1685  g->Call(env->Global(), 0, NULL);
1686  CHECK_EQ(2, break_point_hit_count);
1687
1688  // Call f and g with break point on line 2, 4, 12, 14 and 15.
1689  int sbp3 = SetScriptBreakPointByIdFromJS(env->GetIsolate(), script_id, 4, 0);
1690  int sbp4 = SetScriptBreakPointByIdFromJS(env->GetIsolate(), script_id, 12, 0);
1691  int sbp5 = SetScriptBreakPointByIdFromJS(env->GetIsolate(), script_id, 14, 0);
1692  int sbp6 = SetScriptBreakPointByIdFromJS(env->GetIsolate(), script_id, 15, 0);
1693  break_point_hit_count = 0;
1694  f->Call(env->Global(), 0, NULL);
1695  CHECK_EQ(2, break_point_hit_count);
1696  g->Call(env->Global(), 0, NULL);
1697  CHECK_EQ(7, break_point_hit_count);
1698
1699  // Remove all the break points again.
1700  break_point_hit_count = 0;
1701  ClearBreakPointFromJS(env->GetIsolate(), sbp2);
1702  ClearBreakPointFromJS(env->GetIsolate(), sbp3);
1703  ClearBreakPointFromJS(env->GetIsolate(), sbp4);
1704  ClearBreakPointFromJS(env->GetIsolate(), sbp5);
1705  ClearBreakPointFromJS(env->GetIsolate(), sbp6);
1706  f->Call(env->Global(), 0, NULL);
1707  CHECK_EQ(0, break_point_hit_count);
1708  g->Call(env->Global(), 0, NULL);
1709  CHECK_EQ(0, break_point_hit_count);
1710
1711  v8::Debug::SetDebugEventListener(NULL);
1712  CheckDebuggerUnloaded();
1713
1714  // Make sure that the break point numbers are consecutive.
1715  CHECK_EQ(1, sbp1);
1716  CHECK_EQ(2, sbp2);
1717  CHECK_EQ(3, sbp3);
1718  CHECK_EQ(4, sbp4);
1719  CHECK_EQ(5, sbp5);
1720  CHECK_EQ(6, sbp6);
1721}
1722
1723
1724// Test conditional script break points.
1725TEST(EnableDisableScriptBreakPoint) {
1726  break_point_hit_count = 0;
1727  DebugLocalContext env;
1728  v8::HandleScope scope(env->GetIsolate());
1729  env.ExposeDebug();
1730
1731  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
1732
1733  v8::Local<v8::String> script = v8::String::NewFromUtf8(
1734    env->GetIsolate(),
1735    "function f() {\n"
1736    "  a = 0;  // line 1\n"
1737    "};");
1738
1739  // Compile the script and get function f.
1740  v8::ScriptOrigin origin =
1741      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "test"));
1742  v8::Script::Compile(script, &origin)->Run();
1743  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
1744      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
1745
1746  // Set script break point on line 1 (in function f).
1747  int sbp = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 1, 0);
1748
1749  // Call f while enabeling and disabling the script break point.
1750  break_point_hit_count = 0;
1751  f->Call(env->Global(), 0, NULL);
1752  CHECK_EQ(1, break_point_hit_count);
1753
1754  DisableScriptBreakPointFromJS(env->GetIsolate(), sbp);
1755  f->Call(env->Global(), 0, NULL);
1756  CHECK_EQ(1, break_point_hit_count);
1757
1758  EnableScriptBreakPointFromJS(env->GetIsolate(), sbp);
1759  f->Call(env->Global(), 0, NULL);
1760  CHECK_EQ(2, break_point_hit_count);
1761
1762  DisableScriptBreakPointFromJS(env->GetIsolate(), sbp);
1763  f->Call(env->Global(), 0, NULL);
1764  CHECK_EQ(2, break_point_hit_count);
1765
1766  // Reload the script and get f again checking that the disabeling survives.
1767  v8::Script::Compile(script, &origin)->Run();
1768  f = v8::Local<v8::Function>::Cast(
1769      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
1770  f->Call(env->Global(), 0, NULL);
1771  CHECK_EQ(2, break_point_hit_count);
1772
1773  EnableScriptBreakPointFromJS(env->GetIsolate(), sbp);
1774  f->Call(env->Global(), 0, NULL);
1775  CHECK_EQ(3, break_point_hit_count);
1776
1777  v8::Debug::SetDebugEventListener(NULL);
1778  CheckDebuggerUnloaded();
1779}
1780
1781
1782// Test conditional script break points.
1783TEST(ConditionalScriptBreakPoint) {
1784  break_point_hit_count = 0;
1785  DebugLocalContext env;
1786  v8::HandleScope scope(env->GetIsolate());
1787  env.ExposeDebug();
1788
1789  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
1790
1791  v8::Local<v8::String> script = v8::String::NewFromUtf8(
1792    env->GetIsolate(),
1793    "count = 0;\n"
1794    "function f() {\n"
1795    "  g(count++);  // line 2\n"
1796    "};\n"
1797    "function g(x) {\n"
1798    "  var a=x;  // line 5\n"
1799    "};");
1800
1801  // Compile the script and get function f.
1802  v8::ScriptOrigin origin =
1803      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "test"));
1804  v8::Script::Compile(script, &origin)->Run();
1805  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
1806      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
1807
1808  // Set script break point on line 5 (in function g).
1809  int sbp1 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 5, 0);
1810
1811  // Call f with different conditions on the script break point.
1812  break_point_hit_count = 0;
1813  ChangeScriptBreakPointConditionFromJS(env->GetIsolate(), sbp1, "false");
1814  f->Call(env->Global(), 0, NULL);
1815  CHECK_EQ(0, break_point_hit_count);
1816
1817  ChangeScriptBreakPointConditionFromJS(env->GetIsolate(), sbp1, "true");
1818  break_point_hit_count = 0;
1819  f->Call(env->Global(), 0, NULL);
1820  CHECK_EQ(1, break_point_hit_count);
1821
1822  ChangeScriptBreakPointConditionFromJS(env->GetIsolate(), sbp1, "x % 2 == 0");
1823  break_point_hit_count = 0;
1824  for (int i = 0; i < 10; i++) {
1825    f->Call(env->Global(), 0, NULL);
1826  }
1827  CHECK_EQ(5, break_point_hit_count);
1828
1829  // Reload the script and get f again checking that the condition survives.
1830  v8::Script::Compile(script, &origin)->Run();
1831  f = v8::Local<v8::Function>::Cast(
1832      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
1833
1834  break_point_hit_count = 0;
1835  for (int i = 0; i < 10; i++) {
1836    f->Call(env->Global(), 0, NULL);
1837  }
1838  CHECK_EQ(5, break_point_hit_count);
1839
1840  v8::Debug::SetDebugEventListener(NULL);
1841  CheckDebuggerUnloaded();
1842}
1843
1844
1845// Test ignore count on script break points.
1846TEST(ScriptBreakPointIgnoreCount) {
1847  break_point_hit_count = 0;
1848  DebugLocalContext env;
1849  v8::HandleScope scope(env->GetIsolate());
1850  env.ExposeDebug();
1851
1852  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
1853
1854  v8::Local<v8::String> script = v8::String::NewFromUtf8(
1855    env->GetIsolate(),
1856    "function f() {\n"
1857    "  a = 0;  // line 1\n"
1858    "};");
1859
1860  // Compile the script and get function f.
1861  v8::ScriptOrigin origin =
1862      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "test"));
1863  v8::Script::Compile(script, &origin)->Run();
1864  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
1865      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
1866
1867  // Set script break point on line 1 (in function f).
1868  int sbp = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 1, 0);
1869
1870  // Call f with different ignores on the script break point.
1871  break_point_hit_count = 0;
1872  ChangeScriptBreakPointIgnoreCountFromJS(env->GetIsolate(), sbp, 1);
1873  f->Call(env->Global(), 0, NULL);
1874  CHECK_EQ(0, break_point_hit_count);
1875  f->Call(env->Global(), 0, NULL);
1876  CHECK_EQ(1, break_point_hit_count);
1877
1878  ChangeScriptBreakPointIgnoreCountFromJS(env->GetIsolate(), sbp, 5);
1879  break_point_hit_count = 0;
1880  for (int i = 0; i < 10; i++) {
1881    f->Call(env->Global(), 0, NULL);
1882  }
1883  CHECK_EQ(5, break_point_hit_count);
1884
1885  // Reload the script and get f again checking that the ignore survives.
1886  v8::Script::Compile(script, &origin)->Run();
1887  f = v8::Local<v8::Function>::Cast(
1888      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
1889
1890  break_point_hit_count = 0;
1891  for (int i = 0; i < 10; i++) {
1892    f->Call(env->Global(), 0, NULL);
1893  }
1894  CHECK_EQ(5, break_point_hit_count);
1895
1896  v8::Debug::SetDebugEventListener(NULL);
1897  CheckDebuggerUnloaded();
1898}
1899
1900
1901// Test that script break points survive when a script is reloaded.
1902TEST(ScriptBreakPointReload) {
1903  break_point_hit_count = 0;
1904  DebugLocalContext env;
1905  v8::HandleScope scope(env->GetIsolate());
1906  env.ExposeDebug();
1907
1908  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
1909
1910  v8::Local<v8::Function> f;
1911  v8::Local<v8::String> script = v8::String::NewFromUtf8(
1912    env->GetIsolate(),
1913    "function f() {\n"
1914    "  function h() {\n"
1915    "    a = 0;  // line 2\n"
1916    "  }\n"
1917    "  b = 1;  // line 4\n"
1918    "  return h();\n"
1919    "}");
1920
1921  v8::ScriptOrigin origin_1 =
1922      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "1"));
1923  v8::ScriptOrigin origin_2 =
1924      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "2"));
1925
1926  // Set a script break point before the script is loaded.
1927  SetScriptBreakPointByNameFromJS(env->GetIsolate(), "1", 2, 0);
1928
1929  // Compile the script and get the function.
1930  v8::Script::Compile(script, &origin_1)->Run();
1931  f = v8::Local<v8::Function>::Cast(
1932      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
1933
1934  // Call f and check that the script break point is active.
1935  break_point_hit_count = 0;
1936  f->Call(env->Global(), 0, NULL);
1937  CHECK_EQ(1, break_point_hit_count);
1938
1939  // Compile the script again with a different script data and get the
1940  // function.
1941  v8::Script::Compile(script, &origin_2)->Run();
1942  f = v8::Local<v8::Function>::Cast(
1943      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
1944
1945  // Call f and check that no break points are set.
1946  break_point_hit_count = 0;
1947  f->Call(env->Global(), 0, NULL);
1948  CHECK_EQ(0, break_point_hit_count);
1949
1950  // Compile the script again and get the function.
1951  v8::Script::Compile(script, &origin_1)->Run();
1952  f = v8::Local<v8::Function>::Cast(
1953      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
1954
1955  // Call f and check that the script break point is active.
1956  break_point_hit_count = 0;
1957  f->Call(env->Global(), 0, NULL);
1958  CHECK_EQ(1, break_point_hit_count);
1959
1960  v8::Debug::SetDebugEventListener(NULL);
1961  CheckDebuggerUnloaded();
1962}
1963
1964
1965// Test when several scripts has the same script data
1966TEST(ScriptBreakPointMultiple) {
1967  break_point_hit_count = 0;
1968  DebugLocalContext env;
1969  v8::HandleScope scope(env->GetIsolate());
1970  env.ExposeDebug();
1971
1972  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
1973
1974  v8::Local<v8::Function> f;
1975  v8::Local<v8::String> script_f =
1976      v8::String::NewFromUtf8(env->GetIsolate(),
1977                              "function f() {\n"
1978                              "  a = 0;  // line 1\n"
1979                              "}");
1980
1981  v8::Local<v8::Function> g;
1982  v8::Local<v8::String> script_g =
1983      v8::String::NewFromUtf8(env->GetIsolate(),
1984                              "function g() {\n"
1985                              "  b = 0;  // line 1\n"
1986                              "}");
1987
1988  v8::ScriptOrigin origin =
1989      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "test"));
1990
1991  // Set a script break point before the scripts are loaded.
1992  int sbp = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 1, 0);
1993
1994  // Compile the scripts with same script data and get the functions.
1995  v8::Script::Compile(script_f, &origin)->Run();
1996  f = v8::Local<v8::Function>::Cast(
1997      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
1998  v8::Script::Compile(script_g, &origin)->Run();
1999  g = v8::Local<v8::Function>::Cast(
2000      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "g")));
2001
2002  // Call f and g and check that the script break point is active.
2003  break_point_hit_count = 0;
2004  f->Call(env->Global(), 0, NULL);
2005  CHECK_EQ(1, break_point_hit_count);
2006  g->Call(env->Global(), 0, NULL);
2007  CHECK_EQ(2, break_point_hit_count);
2008
2009  // Clear the script break point.
2010  ClearBreakPointFromJS(env->GetIsolate(), sbp);
2011
2012  // Call f and g and check that the script break point is no longer active.
2013  break_point_hit_count = 0;
2014  f->Call(env->Global(), 0, NULL);
2015  CHECK_EQ(0, break_point_hit_count);
2016  g->Call(env->Global(), 0, NULL);
2017  CHECK_EQ(0, break_point_hit_count);
2018
2019  // Set script break point with the scripts loaded.
2020  sbp = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test", 1, 0);
2021
2022  // Call f and g and check that the script break point is active.
2023  break_point_hit_count = 0;
2024  f->Call(env->Global(), 0, NULL);
2025  CHECK_EQ(1, break_point_hit_count);
2026  g->Call(env->Global(), 0, NULL);
2027  CHECK_EQ(2, break_point_hit_count);
2028
2029  v8::Debug::SetDebugEventListener(NULL);
2030  CheckDebuggerUnloaded();
2031}
2032
2033
2034// Test the script origin which has both name and line offset.
2035TEST(ScriptBreakPointLineOffset) {
2036  break_point_hit_count = 0;
2037  DebugLocalContext env;
2038  v8::HandleScope scope(env->GetIsolate());
2039  env.ExposeDebug();
2040
2041  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
2042
2043  v8::Local<v8::Function> f;
2044  v8::Local<v8::String> script = v8::String::NewFromUtf8(
2045      env->GetIsolate(),
2046      "function f() {\n"
2047      "  a = 0;  // line 8 as this script has line offset 7\n"
2048      "  b = 0;  // line 9 as this script has line offset 7\n"
2049      "}");
2050
2051  // Create script origin both name and line offset.
2052  v8::ScriptOrigin origin(
2053      v8::String::NewFromUtf8(env->GetIsolate(), "test.html"),
2054      v8::Integer::New(env->GetIsolate(), 7));
2055
2056  // Set two script break points before the script is loaded.
2057  int sbp1 =
2058      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 8, 0);
2059  int sbp2 =
2060      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 9, 0);
2061
2062  // Compile the script and get the function.
2063  v8::Script::Compile(script, &origin)->Run();
2064  f = v8::Local<v8::Function>::Cast(
2065      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
2066
2067  // Call f and check that the script break point is active.
2068  break_point_hit_count = 0;
2069  f->Call(env->Global(), 0, NULL);
2070  CHECK_EQ(2, break_point_hit_count);
2071
2072  // Clear the script break points.
2073  ClearBreakPointFromJS(env->GetIsolate(), sbp1);
2074  ClearBreakPointFromJS(env->GetIsolate(), sbp2);
2075
2076  // Call f and check that no script break points are active.
2077  break_point_hit_count = 0;
2078  f->Call(env->Global(), 0, NULL);
2079  CHECK_EQ(0, break_point_hit_count);
2080
2081  // Set a script break point with the script loaded.
2082  sbp1 = SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 9, 0);
2083
2084  // Call f and check that the script break point is active.
2085  break_point_hit_count = 0;
2086  f->Call(env->Global(), 0, NULL);
2087  CHECK_EQ(1, break_point_hit_count);
2088
2089  v8::Debug::SetDebugEventListener(NULL);
2090  CheckDebuggerUnloaded();
2091}
2092
2093
2094// Test script break points set on lines.
2095TEST(ScriptBreakPointLine) {
2096  DebugLocalContext env;
2097  v8::HandleScope scope(env->GetIsolate());
2098  env.ExposeDebug();
2099
2100  // Create a function for checking the function when hitting a break point.
2101  frame_function_name = CompileFunction(&env,
2102                                        frame_function_name_source,
2103                                        "frame_function_name");
2104
2105  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
2106
2107  v8::Local<v8::Function> f;
2108  v8::Local<v8::Function> g;
2109  v8::Local<v8::String> script =
2110      v8::String::NewFromUtf8(env->GetIsolate(),
2111                              "a = 0                      // line 0\n"
2112                              "function f() {\n"
2113                              "  a = 1;                   // line 2\n"
2114                              "}\n"
2115                              " a = 2;                    // line 4\n"
2116                              "  /* xx */ function g() {  // line 5\n"
2117                              "    function h() {         // line 6\n"
2118                              "      a = 3;               // line 7\n"
2119                              "    }\n"
2120                              "    h();                   // line 9\n"
2121                              "    a = 4;                 // line 10\n"
2122                              "  }\n"
2123                              " a=5;                      // line 12");
2124
2125  // Set a couple script break point before the script is loaded.
2126  int sbp1 =
2127      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 0, -1);
2128  int sbp2 =
2129      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 1, -1);
2130  int sbp3 =
2131      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 5, -1);
2132
2133  // Compile the script and get the function.
2134  break_point_hit_count = 0;
2135  v8::ScriptOrigin origin(
2136      v8::String::NewFromUtf8(env->GetIsolate(), "test.html"),
2137      v8::Integer::New(env->GetIsolate(), 0));
2138  v8::Script::Compile(script, &origin)->Run();
2139  f = v8::Local<v8::Function>::Cast(
2140      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
2141  g = v8::Local<v8::Function>::Cast(
2142      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "g")));
2143
2144  // Check that a break point was hit when the script was run.
2145  CHECK_EQ(1, break_point_hit_count);
2146  CHECK_EQ(0, StrLength(last_function_hit));
2147
2148  // Call f and check that the script break point.
2149  f->Call(env->Global(), 0, NULL);
2150  CHECK_EQ(2, break_point_hit_count);
2151  CHECK_EQ("f", last_function_hit);
2152
2153  // Call g and check that the script break point.
2154  g->Call(env->Global(), 0, NULL);
2155  CHECK_EQ(3, break_point_hit_count);
2156  CHECK_EQ("g", last_function_hit);
2157
2158  // Clear the script break point on g and set one on h.
2159  ClearBreakPointFromJS(env->GetIsolate(), sbp3);
2160  int sbp4 =
2161      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 6, -1);
2162
2163  // Call g and check that the script break point in h is hit.
2164  g->Call(env->Global(), 0, NULL);
2165  CHECK_EQ(4, break_point_hit_count);
2166  CHECK_EQ("h", last_function_hit);
2167
2168  // Clear break points in f and h. Set a new one in the script between
2169  // functions f and g and test that there is no break points in f and g any
2170  // more.
2171  ClearBreakPointFromJS(env->GetIsolate(), sbp2);
2172  ClearBreakPointFromJS(env->GetIsolate(), sbp4);
2173  int sbp5 =
2174      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 4, -1);
2175  break_point_hit_count = 0;
2176  f->Call(env->Global(), 0, NULL);
2177  g->Call(env->Global(), 0, NULL);
2178  CHECK_EQ(0, break_point_hit_count);
2179
2180  // Reload the script which should hit two break points.
2181  break_point_hit_count = 0;
2182  v8::Script::Compile(script, &origin)->Run();
2183  CHECK_EQ(2, break_point_hit_count);
2184  CHECK_EQ(0, StrLength(last_function_hit));
2185
2186  // Set a break point in the code after the last function decleration.
2187  int sbp6 =
2188      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 12, -1);
2189
2190  // Reload the script which should hit three break points.
2191  break_point_hit_count = 0;
2192  v8::Script::Compile(script, &origin)->Run();
2193  CHECK_EQ(3, break_point_hit_count);
2194  CHECK_EQ(0, StrLength(last_function_hit));
2195
2196  // Clear the last break points, and reload the script which should not hit any
2197  // break points.
2198  ClearBreakPointFromJS(env->GetIsolate(), sbp1);
2199  ClearBreakPointFromJS(env->GetIsolate(), sbp5);
2200  ClearBreakPointFromJS(env->GetIsolate(), sbp6);
2201  break_point_hit_count = 0;
2202  v8::Script::Compile(script, &origin)->Run();
2203  CHECK_EQ(0, break_point_hit_count);
2204
2205  v8::Debug::SetDebugEventListener(NULL);
2206  CheckDebuggerUnloaded();
2207}
2208
2209
2210// Test top level script break points set on lines.
2211TEST(ScriptBreakPointLineTopLevel) {
2212  DebugLocalContext env;
2213  v8::HandleScope scope(env->GetIsolate());
2214  env.ExposeDebug();
2215
2216  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
2217
2218  v8::Local<v8::String> script =
2219      v8::String::NewFromUtf8(env->GetIsolate(),
2220                              "function f() {\n"
2221                              "  a = 1;                   // line 1\n"
2222                              "}\n"
2223                              "a = 2;                     // line 3\n");
2224  v8::Local<v8::Function> f;
2225  {
2226    v8::HandleScope scope(env->GetIsolate());
2227    CompileRunWithOrigin(script, "test.html");
2228  }
2229  f = v8::Local<v8::Function>::Cast(
2230      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
2231
2232  CcTest::heap()->CollectAllGarbage(Heap::kNoGCFlags);
2233
2234  SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 3, -1);
2235
2236  // Call f and check that there was no break points.
2237  break_point_hit_count = 0;
2238  f->Call(env->Global(), 0, NULL);
2239  CHECK_EQ(0, break_point_hit_count);
2240
2241  // Recompile and run script and check that break point was hit.
2242  break_point_hit_count = 0;
2243  CompileRunWithOrigin(script, "test.html");
2244  CHECK_EQ(1, break_point_hit_count);
2245
2246  // Call f and check that there are still no break points.
2247  break_point_hit_count = 0;
2248  f = v8::Local<v8::Function>::Cast(
2249      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
2250  CHECK_EQ(0, break_point_hit_count);
2251
2252  v8::Debug::SetDebugEventListener(NULL);
2253  CheckDebuggerUnloaded();
2254}
2255
2256
2257// Test that it is possible to add and remove break points in a top level
2258// function which has no references but has not been collected yet.
2259TEST(ScriptBreakPointTopLevelCrash) {
2260  DebugLocalContext env;
2261  v8::HandleScope scope(env->GetIsolate());
2262  env.ExposeDebug();
2263
2264  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
2265
2266  v8::Local<v8::String> script_source =
2267      v8::String::NewFromUtf8(env->GetIsolate(),
2268                              "function f() {\n"
2269                              "  return 0;\n"
2270                              "}\n"
2271                              "f()");
2272
2273  int sbp1 =
2274      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 3, -1);
2275  {
2276    v8::HandleScope scope(env->GetIsolate());
2277    break_point_hit_count = 0;
2278    CompileRunWithOrigin(script_source, "test.html");
2279    CHECK_EQ(1, break_point_hit_count);
2280  }
2281
2282  int sbp2 =
2283      SetScriptBreakPointByNameFromJS(env->GetIsolate(), "test.html", 3, -1);
2284  ClearBreakPointFromJS(env->GetIsolate(), sbp1);
2285  ClearBreakPointFromJS(env->GetIsolate(), sbp2);
2286
2287  v8::Debug::SetDebugEventListener(NULL);
2288  CheckDebuggerUnloaded();
2289}
2290
2291
2292// Test that it is possible to remove the last break point for a function
2293// inside the break handling of that break point.
2294TEST(RemoveBreakPointInBreak) {
2295  DebugLocalContext env;
2296  v8::HandleScope scope(env->GetIsolate());
2297
2298  v8::Local<v8::Function> foo =
2299      CompileFunction(&env, "function foo(){a=1;}", "foo");
2300  debug_event_remove_break_point = SetBreakPoint(foo, 0);
2301
2302  // Register the debug event listener pasing the function
2303  v8::Debug::SetDebugEventListener(DebugEventRemoveBreakPoint, foo);
2304
2305  break_point_hit_count = 0;
2306  foo->Call(env->Global(), 0, NULL);
2307  CHECK_EQ(1, break_point_hit_count);
2308
2309  break_point_hit_count = 0;
2310  foo->Call(env->Global(), 0, NULL);
2311  CHECK_EQ(0, break_point_hit_count);
2312
2313  v8::Debug::SetDebugEventListener(NULL);
2314  CheckDebuggerUnloaded();
2315}
2316
2317
2318// Test that the debugger statement causes a break.
2319TEST(DebuggerStatement) {
2320  break_point_hit_count = 0;
2321  DebugLocalContext env;
2322  v8::HandleScope scope(env->GetIsolate());
2323  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
2324  v8::Script::Compile(
2325      v8::String::NewFromUtf8(env->GetIsolate(), "function bar(){debugger}"))
2326      ->Run();
2327  v8::Script::Compile(
2328      v8::String::NewFromUtf8(env->GetIsolate(),
2329                              "function foo(){debugger;debugger;}"))->Run();
2330  v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
2331      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo")));
2332  v8::Local<v8::Function> bar = v8::Local<v8::Function>::Cast(
2333      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "bar")));
2334
2335  // Run function with debugger statement
2336  bar->Call(env->Global(), 0, NULL);
2337  CHECK_EQ(1, break_point_hit_count);
2338
2339  // Run function with two debugger statement
2340  foo->Call(env->Global(), 0, NULL);
2341  CHECK_EQ(3, break_point_hit_count);
2342
2343  v8::Debug::SetDebugEventListener(NULL);
2344  CheckDebuggerUnloaded();
2345}
2346
2347
2348// Test setting a breakpoint on the debugger statement.
2349TEST(DebuggerStatementBreakpoint) {
2350    break_point_hit_count = 0;
2351    DebugLocalContext env;
2352    v8::HandleScope scope(env->GetIsolate());
2353    v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
2354    v8::Script::Compile(
2355        v8::String::NewFromUtf8(env->GetIsolate(), "function foo(){debugger;}"))
2356        ->Run();
2357    v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
2358        env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "foo")));
2359
2360    // The debugger statement triggers breakpint hit
2361    foo->Call(env->Global(), 0, NULL);
2362    CHECK_EQ(1, break_point_hit_count);
2363
2364    int bp = SetBreakPoint(foo, 0);
2365
2366    // Set breakpoint does not duplicate hits
2367    foo->Call(env->Global(), 0, NULL);
2368    CHECK_EQ(2, break_point_hit_count);
2369
2370    ClearBreakPoint(bp);
2371    v8::Debug::SetDebugEventListener(NULL);
2372    CheckDebuggerUnloaded();
2373}
2374
2375
2376// Test that the evaluation of expressions when a break point is hit generates
2377// the correct results.
2378TEST(DebugEvaluate) {
2379  DebugLocalContext env;
2380  v8::Isolate* isolate = env->GetIsolate();
2381  v8::HandleScope scope(isolate);
2382  env.ExposeDebug();
2383
2384  // Create a function for checking the evaluation when hitting a break point.
2385  evaluate_check_function = CompileFunction(&env,
2386                                            evaluate_check_source,
2387                                            "evaluate_check");
2388  // Register the debug event listener
2389  v8::Debug::SetDebugEventListener(DebugEventEvaluate);
2390
2391  // Different expected vaules of x and a when in a break point (u = undefined,
2392  // d = Hello, world!).
2393  struct EvaluateCheck checks_uu[] = {
2394    {"x", v8::Undefined(isolate)},
2395    {"a", v8::Undefined(isolate)},
2396    {NULL, v8::Handle<v8::Value>()}
2397  };
2398  struct EvaluateCheck checks_hu[] = {
2399    {"x", v8::String::NewFromUtf8(env->GetIsolate(), "Hello, world!")},
2400    {"a", v8::Undefined(isolate)},
2401    {NULL, v8::Handle<v8::Value>()}
2402  };
2403  struct EvaluateCheck checks_hh[] = {
2404    {"x", v8::String::NewFromUtf8(env->GetIsolate(), "Hello, world!")},
2405    {"a", v8::String::NewFromUtf8(env->GetIsolate(), "Hello, world!")},
2406    {NULL, v8::Handle<v8::Value>()}
2407  };
2408
2409  // Simple test function. The "y=0" is in the function foo to provide a break
2410  // location. For "y=0" the "y" is at position 15 in the foo function
2411  // therefore setting breakpoint at position 15 will break at "y=0" and
2412  // setting it higher will break after.
2413  v8::Local<v8::Function> foo = CompileFunction(&env,
2414    "function foo(x) {"
2415    "  var a;"
2416    "  y=0;"  // To ensure break location 1.
2417    "  a=x;"
2418    "  y=0;"  // To ensure break location 2.
2419    "}",
2420    "foo");
2421  const int foo_break_position_1 = 15;
2422  const int foo_break_position_2 = 29;
2423
2424  // Arguments with one parameter "Hello, world!"
2425  v8::Handle<v8::Value> argv_foo[1] = {
2426      v8::String::NewFromUtf8(env->GetIsolate(), "Hello, world!")};
2427
2428  // Call foo with breakpoint set before a=x and undefined as parameter.
2429  int bp = SetBreakPoint(foo, foo_break_position_1);
2430  checks = checks_uu;
2431  foo->Call(env->Global(), 0, NULL);
2432
2433  // Call foo with breakpoint set before a=x and parameter "Hello, world!".
2434  checks = checks_hu;
2435  foo->Call(env->Global(), 1, argv_foo);
2436
2437  // Call foo with breakpoint set after a=x and parameter "Hello, world!".
2438  ClearBreakPoint(bp);
2439  SetBreakPoint(foo, foo_break_position_2);
2440  checks = checks_hh;
2441  foo->Call(env->Global(), 1, argv_foo);
2442
2443  // Test that overriding Object.prototype will not interfere into evaluation
2444  // on call frame.
2445  v8::Local<v8::Function> zoo =
2446      CompileFunction(&env,
2447                      "x = undefined;"
2448                      "function zoo(t) {"
2449                      "  var a=x;"
2450                      "  Object.prototype.x = 42;"
2451                      "  x=t;"
2452                      "  y=0;"  // To ensure break location.
2453                      "  delete Object.prototype.x;"
2454                      "  x=a;"
2455                      "}",
2456                      "zoo");
2457  const int zoo_break_position = 50;
2458
2459  // Arguments with one parameter "Hello, world!"
2460  v8::Handle<v8::Value> argv_zoo[1] = {
2461      v8::String::NewFromUtf8(env->GetIsolate(), "Hello, world!")};
2462
2463  // Call zoo with breakpoint set at y=0.
2464  DebugEventCounterClear();
2465  bp = SetBreakPoint(zoo, zoo_break_position);
2466  checks = checks_hu;
2467  zoo->Call(env->Global(), 1, argv_zoo);
2468  CHECK_EQ(1, break_point_hit_count);
2469  ClearBreakPoint(bp);
2470
2471  // Test function with an inner function. The "y=0" is in function barbar
2472  // to provide a break location. For "y=0" the "y" is at position 8 in the
2473  // barbar function therefore setting breakpoint at position 8 will break at
2474  // "y=0" and setting it higher will break after.
2475  v8::Local<v8::Function> bar = CompileFunction(&env,
2476    "y = 0;"
2477    "x = 'Goodbye, world!';"
2478    "function bar(x, b) {"
2479    "  var a;"
2480    "  function barbar() {"
2481    "    y=0; /* To ensure break location.*/"
2482    "    a=x;"
2483    "  };"
2484    "  debug.Debug.clearAllBreakPoints();"
2485    "  barbar();"
2486    "  y=0;a=x;"
2487    "}",
2488    "bar");
2489  const int barbar_break_position = 8;
2490
2491  // Call bar setting breakpoint before a=x in barbar and undefined as
2492  // parameter.
2493  checks = checks_uu;
2494  v8::Handle<v8::Value> argv_bar_1[2] = {
2495    v8::Undefined(isolate),
2496    v8::Number::New(isolate, barbar_break_position)
2497  };
2498  bar->Call(env->Global(), 2, argv_bar_1);
2499
2500  // Call bar setting breakpoint before a=x in barbar and parameter
2501  // "Hello, world!".
2502  checks = checks_hu;
2503  v8::Handle<v8::Value> argv_bar_2[2] = {
2504    v8::String::NewFromUtf8(env->GetIsolate(), "Hello, world!"),
2505    v8::Number::New(env->GetIsolate(), barbar_break_position)
2506  };
2507  bar->Call(env->Global(), 2, argv_bar_2);
2508
2509  // Call bar setting breakpoint after a=x in barbar and parameter
2510  // "Hello, world!".
2511  checks = checks_hh;
2512  v8::Handle<v8::Value> argv_bar_3[2] = {
2513    v8::String::NewFromUtf8(env->GetIsolate(), "Hello, world!"),
2514    v8::Number::New(env->GetIsolate(), barbar_break_position + 1)
2515  };
2516  bar->Call(env->Global(), 2, argv_bar_3);
2517
2518  v8::Debug::SetDebugEventListener(NULL);
2519  CheckDebuggerUnloaded();
2520}
2521
2522
2523int debugEventCount = 0;
2524static void CheckDebugEvent(const v8::Debug::EventDetails& eventDetails) {
2525  if (eventDetails.GetEvent() == v8::Break) ++debugEventCount;
2526}
2527
2528
2529// Test that the conditional breakpoints work event if code generation from
2530// strings is prohibited in the debugee context.
2531TEST(ConditionalBreakpointWithCodeGenerationDisallowed) {
2532  DebugLocalContext env;
2533  v8::HandleScope scope(env->GetIsolate());
2534  env.ExposeDebug();
2535
2536  v8::Debug::SetDebugEventListener(CheckDebugEvent);
2537
2538  v8::Local<v8::Function> foo = CompileFunction(&env,
2539    "function foo(x) {\n"
2540    "  var s = 'String value2';\n"
2541    "  return s + x;\n"
2542    "}",
2543    "foo");
2544
2545  // Set conditional breakpoint with condition 'true'.
2546  CompileRun("debug.Debug.setBreakPoint(foo, 2, 0, 'true')");
2547
2548  debugEventCount = 0;
2549  env->AllowCodeGenerationFromStrings(false);
2550  foo->Call(env->Global(), 0, NULL);
2551  CHECK_EQ(1, debugEventCount);
2552
2553  v8::Debug::SetDebugEventListener(NULL);
2554  CheckDebuggerUnloaded();
2555}
2556
2557
2558bool checkedDebugEvals = true;
2559v8::Handle<v8::Function> checkGlobalEvalFunction;
2560v8::Handle<v8::Function> checkFrameEvalFunction;
2561static void CheckDebugEval(const v8::Debug::EventDetails& eventDetails) {
2562  if (eventDetails.GetEvent() == v8::Break) {
2563    ++debugEventCount;
2564    v8::HandleScope handleScope(CcTest::isolate());
2565
2566    v8::Handle<v8::Value> args[] = { eventDetails.GetExecutionState() };
2567    CHECK(checkGlobalEvalFunction->Call(
2568        eventDetails.GetEventContext()->Global(), 1, args)->IsTrue());
2569    CHECK(checkFrameEvalFunction->Call(
2570        eventDetails.GetEventContext()->Global(), 1, args)->IsTrue());
2571  }
2572}
2573
2574
2575// Test that the evaluation of expressions when a break point is hit generates
2576// the correct results in case code generation from strings is disallowed in the
2577// debugee context.
2578TEST(DebugEvaluateWithCodeGenerationDisallowed) {
2579  DebugLocalContext env;
2580  v8::HandleScope scope(env->GetIsolate());
2581  env.ExposeDebug();
2582
2583  v8::Debug::SetDebugEventListener(CheckDebugEval);
2584
2585  v8::Local<v8::Function> foo = CompileFunction(&env,
2586    "var global = 'Global';\n"
2587    "function foo(x) {\n"
2588    "  var local = 'Local';\n"
2589    "  debugger;\n"
2590    "  return local + x;\n"
2591    "}",
2592    "foo");
2593  checkGlobalEvalFunction = CompileFunction(&env,
2594    "function checkGlobalEval(exec_state) {\n"
2595    "  return exec_state.evaluateGlobal('global').value() === 'Global';\n"
2596    "}",
2597    "checkGlobalEval");
2598
2599  checkFrameEvalFunction = CompileFunction(&env,
2600    "function checkFrameEval(exec_state) {\n"
2601    "  return exec_state.frame(0).evaluate('local').value() === 'Local';\n"
2602    "}",
2603    "checkFrameEval");
2604  debugEventCount = 0;
2605  env->AllowCodeGenerationFromStrings(false);
2606  foo->Call(env->Global(), 0, NULL);
2607  CHECK_EQ(1, debugEventCount);
2608
2609  checkGlobalEvalFunction.Clear();
2610  checkFrameEvalFunction.Clear();
2611  v8::Debug::SetDebugEventListener(NULL);
2612  CheckDebuggerUnloaded();
2613}
2614
2615
2616// Copies a C string to a 16-bit string.  Does not check for buffer overflow.
2617// Does not use the V8 engine to convert strings, so it can be used
2618// in any thread.  Returns the length of the string.
2619int AsciiToUtf16(const char* input_buffer, uint16_t* output_buffer) {
2620  int i;
2621  for (i = 0; input_buffer[i] != '\0'; ++i) {
2622    // ASCII does not use chars > 127, but be careful anyway.
2623    output_buffer[i] = static_cast<unsigned char>(input_buffer[i]);
2624  }
2625  output_buffer[i] = 0;
2626  return i;
2627}
2628
2629
2630// Copies a 16-bit string to a C string by dropping the high byte of
2631// each character.  Does not check for buffer overflow.
2632// Can be used in any thread.  Requires string length as an input.
2633int Utf16ToAscii(const uint16_t* input_buffer, int length,
2634                 char* output_buffer, int output_len = -1) {
2635  if (output_len >= 0) {
2636    if (length > output_len - 1) {
2637      length = output_len - 1;
2638    }
2639  }
2640
2641  for (int i = 0; i < length; ++i) {
2642    output_buffer[i] = static_cast<char>(input_buffer[i]);
2643  }
2644  output_buffer[length] = '\0';
2645  return length;
2646}
2647
2648
2649// We match parts of the message to get evaluate result int value.
2650bool GetEvaluateStringResult(char *message, char* buffer, int buffer_size) {
2651  if (strstr(message, "\"command\":\"evaluate\"") == NULL) {
2652    return false;
2653  }
2654  const char* prefix = "\"text\":\"";
2655  char* pos1 = strstr(message, prefix);
2656  if (pos1 == NULL) {
2657    return false;
2658  }
2659  pos1 += strlen(prefix);
2660  char* pos2 = strchr(pos1, '"');
2661  if (pos2 == NULL) {
2662    return false;
2663  }
2664  Vector<char> buf(buffer, buffer_size);
2665  int len = static_cast<int>(pos2 - pos1);
2666  if (len > buffer_size - 1) {
2667    len = buffer_size - 1;
2668  }
2669  StrNCpy(buf, pos1, len);
2670  buffer[buffer_size - 1] = '\0';
2671  return true;
2672}
2673
2674
2675struct EvaluateResult {
2676  static const int kBufferSize = 20;
2677  char buffer[kBufferSize];
2678};
2679
2680struct DebugProcessDebugMessagesData {
2681  static const int kArraySize = 5;
2682  int counter;
2683  EvaluateResult results[kArraySize];
2684
2685  void reset() {
2686    counter = 0;
2687  }
2688  EvaluateResult* current() {
2689    return &results[counter % kArraySize];
2690  }
2691  void next() {
2692    counter++;
2693  }
2694};
2695
2696DebugProcessDebugMessagesData process_debug_messages_data;
2697
2698static void DebugProcessDebugMessagesHandler(
2699    const v8::Debug::Message& message) {
2700  v8::Handle<v8::String> json = message.GetJSON();
2701  v8::String::Utf8Value utf8(json);
2702  EvaluateResult* array_item = process_debug_messages_data.current();
2703
2704  bool res = GetEvaluateStringResult(*utf8,
2705                                     array_item->buffer,
2706                                     EvaluateResult::kBufferSize);
2707  if (res) {
2708    process_debug_messages_data.next();
2709  }
2710}
2711
2712
2713// Test that the evaluation of expressions works even from ProcessDebugMessages
2714// i.e. with empty stack.
2715TEST(DebugEvaluateWithoutStack) {
2716  v8::Debug::SetMessageHandler(DebugProcessDebugMessagesHandler);
2717
2718  DebugLocalContext env;
2719  v8::HandleScope scope(env->GetIsolate());
2720
2721  const char* source =
2722      "var v1 = 'Pinguin';\n function getAnimal() { return 'Capy' + 'bara'; }";
2723
2724  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), source))
2725      ->Run();
2726
2727  v8::Debug::ProcessDebugMessages();
2728
2729  const int kBufferSize = 1000;
2730  uint16_t buffer[kBufferSize];
2731
2732  const char* command_111 = "{\"seq\":111,"
2733      "\"type\":\"request\","
2734      "\"command\":\"evaluate\","
2735      "\"arguments\":{"
2736      "    \"global\":true,"
2737      "    \"expression\":\"v1\",\"disable_break\":true"
2738      "}}";
2739
2740  v8::Isolate* isolate = CcTest::isolate();
2741  v8::Debug::SendCommand(isolate, buffer, AsciiToUtf16(command_111, buffer));
2742
2743  const char* command_112 = "{\"seq\":112,"
2744      "\"type\":\"request\","
2745      "\"command\":\"evaluate\","
2746      "\"arguments\":{"
2747      "    \"global\":true,"
2748      "    \"expression\":\"getAnimal()\",\"disable_break\":true"
2749      "}}";
2750
2751  v8::Debug::SendCommand(isolate, buffer, AsciiToUtf16(command_112, buffer));
2752
2753  const char* command_113 = "{\"seq\":113,"
2754     "\"type\":\"request\","
2755     "\"command\":\"evaluate\","
2756     "\"arguments\":{"
2757     "    \"global\":true,"
2758     "    \"expression\":\"239 + 566\",\"disable_break\":true"
2759     "}}";
2760
2761  v8::Debug::SendCommand(isolate, buffer, AsciiToUtf16(command_113, buffer));
2762
2763  v8::Debug::ProcessDebugMessages();
2764
2765  CHECK_EQ(3, process_debug_messages_data.counter);
2766
2767  CHECK_EQ(strcmp("Pinguin", process_debug_messages_data.results[0].buffer), 0);
2768  CHECK_EQ(strcmp("Capybara", process_debug_messages_data.results[1].buffer),
2769           0);
2770  CHECK_EQ(strcmp("805", process_debug_messages_data.results[2].buffer), 0);
2771
2772  v8::Debug::SetMessageHandler(NULL);
2773  v8::Debug::SetDebugEventListener(NULL);
2774  CheckDebuggerUnloaded();
2775}
2776
2777
2778// Simple test of the stepping mechanism using only store ICs.
2779TEST(DebugStepLinear) {
2780  DebugLocalContext env;
2781  v8::HandleScope scope(env->GetIsolate());
2782
2783  // Create a function for testing stepping.
2784  v8::Local<v8::Function> foo = CompileFunction(&env,
2785                                                "function foo(){a=1;b=1;c=1;}",
2786                                                "foo");
2787
2788  // Run foo to allow it to get optimized.
2789  CompileRun("a=0; b=0; c=0; foo();");
2790
2791  SetBreakPoint(foo, 3);
2792
2793  // Register a debug event listener which steps and counts.
2794  v8::Debug::SetDebugEventListener(DebugEventStep);
2795
2796  step_action = StepIn;
2797  break_point_hit_count = 0;
2798  foo->Call(env->Global(), 0, NULL);
2799
2800  // With stepping all break locations are hit.
2801  CHECK_EQ(4, break_point_hit_count);
2802
2803  v8::Debug::SetDebugEventListener(NULL);
2804  CheckDebuggerUnloaded();
2805
2806  // Register a debug event listener which just counts.
2807  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
2808
2809  SetBreakPoint(foo, 3);
2810  break_point_hit_count = 0;
2811  foo->Call(env->Global(), 0, NULL);
2812
2813  // Without stepping only active break points are hit.
2814  CHECK_EQ(1, break_point_hit_count);
2815
2816  v8::Debug::SetDebugEventListener(NULL);
2817  CheckDebuggerUnloaded();
2818}
2819
2820
2821// Test of the stepping mechanism for keyed load in a loop.
2822TEST(DebugStepKeyedLoadLoop) {
2823  DebugLocalContext env;
2824  v8::HandleScope scope(env->GetIsolate());
2825
2826  // Register a debug event listener which steps and counts.
2827  v8::Debug::SetDebugEventListener(DebugEventStep);
2828
2829  // Create a function for testing stepping of keyed load. The statement 'y=1'
2830  // is there to have more than one breakable statement in the loop, TODO(315).
2831  v8::Local<v8::Function> foo = CompileFunction(
2832      &env,
2833      "function foo(a) {\n"
2834      "  var x;\n"
2835      "  var len = a.length;\n"
2836      "  for (var i = 0; i < len; i++) {\n"
2837      "    y = 1;\n"
2838      "    x = a[i];\n"
2839      "  }\n"
2840      "}\n"
2841      "y=0\n",
2842      "foo");
2843
2844  // Create array [0,1,2,3,4,5,6,7,8,9]
2845  v8::Local<v8::Array> a = v8::Array::New(env->GetIsolate(), 10);
2846  for (int i = 0; i < 10; i++) {
2847    a->Set(v8::Number::New(env->GetIsolate(), i),
2848           v8::Number::New(env->GetIsolate(), i));
2849  }
2850
2851  // Call function without any break points to ensure inlining is in place.
2852  const int kArgc = 1;
2853  v8::Handle<v8::Value> args[kArgc] = { a };
2854  foo->Call(env->Global(), kArgc, args);
2855
2856  // Set up break point and step through the function.
2857  SetBreakPoint(foo, 3);
2858  step_action = StepNext;
2859  break_point_hit_count = 0;
2860  foo->Call(env->Global(), kArgc, args);
2861
2862  // With stepping all break locations are hit.
2863  CHECK_EQ(35, break_point_hit_count);
2864
2865  v8::Debug::SetDebugEventListener(NULL);
2866  CheckDebuggerUnloaded();
2867}
2868
2869
2870// Test of the stepping mechanism for keyed store in a loop.
2871TEST(DebugStepKeyedStoreLoop) {
2872  DebugLocalContext env;
2873  v8::HandleScope scope(env->GetIsolate());
2874
2875  // Register a debug event listener which steps and counts.
2876  v8::Debug::SetDebugEventListener(DebugEventStep);
2877
2878  // Create a function for testing stepping of keyed store. The statement 'y=1'
2879  // is there to have more than one breakable statement in the loop, TODO(315).
2880  v8::Local<v8::Function> foo = CompileFunction(
2881      &env,
2882      "function foo(a) {\n"
2883      "  var len = a.length;\n"
2884      "  for (var i = 0; i < len; i++) {\n"
2885      "    y = 1;\n"
2886      "    a[i] = 42;\n"
2887      "  }\n"
2888      "}\n"
2889      "y=0\n",
2890      "foo");
2891
2892  // Create array [0,1,2,3,4,5,6,7,8,9]
2893  v8::Local<v8::Array> a = v8::Array::New(env->GetIsolate(), 10);
2894  for (int i = 0; i < 10; i++) {
2895    a->Set(v8::Number::New(env->GetIsolate(), i),
2896           v8::Number::New(env->GetIsolate(), i));
2897  }
2898
2899  // Call function without any break points to ensure inlining is in place.
2900  const int kArgc = 1;
2901  v8::Handle<v8::Value> args[kArgc] = { a };
2902  foo->Call(env->Global(), kArgc, args);
2903
2904  // Set up break point and step through the function.
2905  SetBreakPoint(foo, 3);
2906  step_action = StepNext;
2907  break_point_hit_count = 0;
2908  foo->Call(env->Global(), kArgc, args);
2909
2910  // With stepping all break locations are hit.
2911  CHECK_EQ(34, break_point_hit_count);
2912
2913  v8::Debug::SetDebugEventListener(NULL);
2914  CheckDebuggerUnloaded();
2915}
2916
2917
2918// Test of the stepping mechanism for named load in a loop.
2919TEST(DebugStepNamedLoadLoop) {
2920  DebugLocalContext env;
2921  v8::HandleScope scope(env->GetIsolate());
2922
2923  // Register a debug event listener which steps and counts.
2924  v8::Debug::SetDebugEventListener(DebugEventStep);
2925
2926  // Create a function for testing stepping of named load.
2927  v8::Local<v8::Function> foo = CompileFunction(
2928      &env,
2929      "function foo() {\n"
2930          "  var a = [];\n"
2931          "  var s = \"\";\n"
2932          "  for (var i = 0; i < 10; i++) {\n"
2933          "    var v = new V(i, i + 1);\n"
2934          "    v.y;\n"
2935          "    a.length;\n"  // Special case: array length.
2936          "    s.length;\n"  // Special case: string length.
2937          "  }\n"
2938          "}\n"
2939          "function V(x, y) {\n"
2940          "  this.x = x;\n"
2941          "  this.y = y;\n"
2942          "}\n",
2943          "foo");
2944
2945  // Call function without any break points to ensure inlining is in place.
2946  foo->Call(env->Global(), 0, NULL);
2947
2948  // Set up break point and step through the function.
2949  SetBreakPoint(foo, 4);
2950  step_action = StepNext;
2951  break_point_hit_count = 0;
2952  foo->Call(env->Global(), 0, NULL);
2953
2954  // With stepping all break locations are hit.
2955  CHECK_EQ(55, break_point_hit_count);
2956
2957  v8::Debug::SetDebugEventListener(NULL);
2958  CheckDebuggerUnloaded();
2959}
2960
2961
2962static void DoDebugStepNamedStoreLoop(int expected) {
2963  DebugLocalContext env;
2964  v8::HandleScope scope(env->GetIsolate());
2965
2966  // Register a debug event listener which steps and counts.
2967  v8::Debug::SetDebugEventListener(DebugEventStep);
2968
2969  // Create a function for testing stepping of named store.
2970  v8::Local<v8::Function> foo = CompileFunction(
2971      &env,
2972      "function foo() {\n"
2973          "  var a = {a:1};\n"
2974          "  for (var i = 0; i < 10; i++) {\n"
2975          "    a.a = 2\n"
2976          "  }\n"
2977          "}\n",
2978          "foo");
2979
2980  // Call function without any break points to ensure inlining is in place.
2981  foo->Call(env->Global(), 0, NULL);
2982
2983  // Set up break point and step through the function.
2984  SetBreakPoint(foo, 3);
2985  step_action = StepNext;
2986  break_point_hit_count = 0;
2987  foo->Call(env->Global(), 0, NULL);
2988
2989  // With stepping all expected break locations are hit.
2990  CHECK_EQ(expected, break_point_hit_count);
2991
2992  v8::Debug::SetDebugEventListener(NULL);
2993  CheckDebuggerUnloaded();
2994}
2995
2996
2997// Test of the stepping mechanism for named load in a loop.
2998TEST(DebugStepNamedStoreLoop) {
2999  DoDebugStepNamedStoreLoop(24);
3000}
3001
3002
3003// Test the stepping mechanism with different ICs.
3004TEST(DebugStepLinearMixedICs) {
3005  DebugLocalContext env;
3006  v8::HandleScope scope(env->GetIsolate());
3007
3008  // Register a debug event listener which steps and counts.
3009  v8::Debug::SetDebugEventListener(DebugEventStep);
3010
3011  // Create a function for testing stepping.
3012  v8::Local<v8::Function> foo = CompileFunction(&env,
3013      "function bar() {};"
3014      "function foo() {"
3015      "  var x;"
3016      "  var index='name';"
3017      "  var y = {};"
3018      "  a=1;b=2;x=a;y[index]=3;x=y[index];bar();}", "foo");
3019
3020  // Run functions to allow them to get optimized.
3021  CompileRun("a=0; b=0; bar(); foo();");
3022
3023  SetBreakPoint(foo, 0);
3024
3025  step_action = StepIn;
3026  break_point_hit_count = 0;
3027  foo->Call(env->Global(), 0, NULL);
3028
3029  // With stepping all break locations are hit.
3030  CHECK_EQ(11, break_point_hit_count);
3031
3032  v8::Debug::SetDebugEventListener(NULL);
3033  CheckDebuggerUnloaded();
3034
3035  // Register a debug event listener which just counts.
3036  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
3037
3038  SetBreakPoint(foo, 0);
3039  break_point_hit_count = 0;
3040  foo->Call(env->Global(), 0, NULL);
3041
3042  // Without stepping only active break points are hit.
3043  CHECK_EQ(1, break_point_hit_count);
3044
3045  v8::Debug::SetDebugEventListener(NULL);
3046  CheckDebuggerUnloaded();
3047}
3048
3049
3050TEST(DebugStepDeclarations) {
3051  DebugLocalContext env;
3052  v8::HandleScope scope(env->GetIsolate());
3053
3054  // Register a debug event listener which steps and counts.
3055  v8::Debug::SetDebugEventListener(DebugEventStep);
3056
3057  // Create a function for testing stepping. Run it to allow it to get
3058  // optimized.
3059  const char* src = "function foo() { "
3060                    "  var a;"
3061                    "  var b = 1;"
3062                    "  var c = foo;"
3063                    "  var d = Math.floor;"
3064                    "  var e = b + d(1.2);"
3065                    "}"
3066                    "foo()";
3067  v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3068
3069  SetBreakPoint(foo, 0);
3070
3071  // Stepping through the declarations.
3072  step_action = StepIn;
3073  break_point_hit_count = 0;
3074  foo->Call(env->Global(), 0, NULL);
3075  CHECK_EQ(6, break_point_hit_count);
3076
3077  // Get rid of the debug event listener.
3078  v8::Debug::SetDebugEventListener(NULL);
3079  CheckDebuggerUnloaded();
3080}
3081
3082
3083TEST(DebugStepLocals) {
3084  DebugLocalContext env;
3085  v8::HandleScope scope(env->GetIsolate());
3086
3087  // Register a debug event listener which steps and counts.
3088  v8::Debug::SetDebugEventListener(DebugEventStep);
3089
3090  // Create a function for testing stepping. Run it to allow it to get
3091  // optimized.
3092  const char* src = "function foo() { "
3093                    "  var a,b;"
3094                    "  a = 1;"
3095                    "  b = a + 2;"
3096                    "  b = 1 + 2 + 3;"
3097                    "  a = Math.floor(b);"
3098                    "}"
3099                    "foo()";
3100  v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3101
3102  SetBreakPoint(foo, 0);
3103
3104  // Stepping through the declarations.
3105  step_action = StepIn;
3106  break_point_hit_count = 0;
3107  foo->Call(env->Global(), 0, NULL);
3108  CHECK_EQ(6, break_point_hit_count);
3109
3110  // Get rid of the debug event listener.
3111  v8::Debug::SetDebugEventListener(NULL);
3112  CheckDebuggerUnloaded();
3113}
3114
3115
3116TEST(DebugStepIf) {
3117  DebugLocalContext env;
3118  v8::Isolate* isolate = env->GetIsolate();
3119  v8::HandleScope scope(isolate);
3120
3121  // Register a debug event listener which steps and counts.
3122  v8::Debug::SetDebugEventListener(DebugEventStep);
3123
3124  // Create a function for testing stepping. Run it to allow it to get
3125  // optimized.
3126  const int argc = 1;
3127  const char* src = "function foo(x) { "
3128                    "  a = 1;"
3129                    "  if (x) {"
3130                    "    b = 1;"
3131                    "  } else {"
3132                    "    c = 1;"
3133                    "    d = 1;"
3134                    "  }"
3135                    "}"
3136                    "a=0; b=0; c=0; d=0; foo()";
3137  v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3138  SetBreakPoint(foo, 0);
3139
3140  // Stepping through the true part.
3141  step_action = StepIn;
3142  break_point_hit_count = 0;
3143  v8::Handle<v8::Value> argv_true[argc] = { v8::True(isolate) };
3144  foo->Call(env->Global(), argc, argv_true);
3145  CHECK_EQ(4, break_point_hit_count);
3146
3147  // Stepping through the false part.
3148  step_action = StepIn;
3149  break_point_hit_count = 0;
3150  v8::Handle<v8::Value> argv_false[argc] = { v8::False(isolate) };
3151  foo->Call(env->Global(), argc, argv_false);
3152  CHECK_EQ(5, break_point_hit_count);
3153
3154  // Get rid of the debug event listener.
3155  v8::Debug::SetDebugEventListener(NULL);
3156  CheckDebuggerUnloaded();
3157}
3158
3159
3160TEST(DebugStepSwitch) {
3161  DebugLocalContext env;
3162  v8::Isolate* isolate = env->GetIsolate();
3163  v8::HandleScope scope(isolate);
3164
3165  // Register a debug event listener which steps and counts.
3166  v8::Debug::SetDebugEventListener(DebugEventStep);
3167
3168  // Create a function for testing stepping. Run it to allow it to get
3169  // optimized.
3170  const int argc = 1;
3171  const char* src = "function foo(x) { "
3172                    "  a = 1;"
3173                    "  switch (x) {"
3174                    "    case 1:"
3175                    "      b = 1;"
3176                    "    case 2:"
3177                    "      c = 1;"
3178                    "      break;"
3179                    "    case 3:"
3180                    "      d = 1;"
3181                    "      e = 1;"
3182                    "      f = 1;"
3183                    "      break;"
3184                    "  }"
3185                    "}"
3186                    "a=0; b=0; c=0; d=0; e=0; f=0; foo()";
3187  v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3188  SetBreakPoint(foo, 0);
3189
3190  // One case with fall-through.
3191  step_action = StepIn;
3192  break_point_hit_count = 0;
3193  v8::Handle<v8::Value> argv_1[argc] = { v8::Number::New(isolate, 1) };
3194  foo->Call(env->Global(), argc, argv_1);
3195  CHECK_EQ(6, break_point_hit_count);
3196
3197  // Another case.
3198  step_action = StepIn;
3199  break_point_hit_count = 0;
3200  v8::Handle<v8::Value> argv_2[argc] = { v8::Number::New(isolate, 2) };
3201  foo->Call(env->Global(), argc, argv_2);
3202  CHECK_EQ(5, break_point_hit_count);
3203
3204  // Last case.
3205  step_action = StepIn;
3206  break_point_hit_count = 0;
3207  v8::Handle<v8::Value> argv_3[argc] = { v8::Number::New(isolate, 3) };
3208  foo->Call(env->Global(), argc, argv_3);
3209  CHECK_EQ(7, break_point_hit_count);
3210
3211  // Get rid of the debug event listener.
3212  v8::Debug::SetDebugEventListener(NULL);
3213  CheckDebuggerUnloaded();
3214}
3215
3216
3217TEST(DebugStepWhile) {
3218  DebugLocalContext env;
3219  v8::Isolate* isolate = env->GetIsolate();
3220  v8::HandleScope scope(isolate);
3221
3222  // Register a debug event listener which steps and counts.
3223  v8::Debug::SetDebugEventListener(DebugEventStep);
3224
3225  // Create a function for testing stepping. Run it to allow it to get
3226  // optimized.
3227  const int argc = 1;
3228  const char* src = "function foo(x) { "
3229                    "  var a = 0;"
3230                    "  while (a < x) {"
3231                    "    a++;"
3232                    "  }"
3233                    "}"
3234                    "foo()";
3235  v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3236  SetBreakPoint(foo, 8);  // "var a = 0;"
3237
3238  // Looping 0 times.  We still should break at the while-condition once.
3239  step_action = StepIn;
3240  break_point_hit_count = 0;
3241  v8::Handle<v8::Value> argv_0[argc] = { v8::Number::New(isolate, 0) };
3242  foo->Call(env->Global(), argc, argv_0);
3243  CHECK_EQ(3, break_point_hit_count);
3244
3245  // Looping 10 times.
3246  step_action = StepIn;
3247  break_point_hit_count = 0;
3248  v8::Handle<v8::Value> argv_10[argc] = { v8::Number::New(isolate, 10) };
3249  foo->Call(env->Global(), argc, argv_10);
3250  CHECK_EQ(23, break_point_hit_count);
3251
3252  // Looping 100 times.
3253  step_action = StepIn;
3254  break_point_hit_count = 0;
3255  v8::Handle<v8::Value> argv_100[argc] = { v8::Number::New(isolate, 100) };
3256  foo->Call(env->Global(), argc, argv_100);
3257  CHECK_EQ(203, break_point_hit_count);
3258
3259  // Get rid of the debug event listener.
3260  v8::Debug::SetDebugEventListener(NULL);
3261  CheckDebuggerUnloaded();
3262}
3263
3264
3265TEST(DebugStepDoWhile) {
3266  DebugLocalContext env;
3267  v8::Isolate* isolate = env->GetIsolate();
3268  v8::HandleScope scope(isolate);
3269
3270  // Register a debug event listener which steps and counts.
3271  v8::Debug::SetDebugEventListener(DebugEventStep);
3272
3273  // Create a function for testing stepping. Run it to allow it to get
3274  // optimized.
3275  const int argc = 1;
3276  const char* src = "function foo(x) { "
3277                    "  var a = 0;"
3278                    "  do {"
3279                    "    a++;"
3280                    "  } while (a < x)"
3281                    "}"
3282                    "foo()";
3283  v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3284  SetBreakPoint(foo, 8);  // "var a = 0;"
3285
3286  // Looping 10 times.
3287  step_action = StepIn;
3288  break_point_hit_count = 0;
3289  v8::Handle<v8::Value> argv_10[argc] = { v8::Number::New(isolate, 10) };
3290  foo->Call(env->Global(), argc, argv_10);
3291  CHECK_EQ(22, break_point_hit_count);
3292
3293  // Looping 100 times.
3294  step_action = StepIn;
3295  break_point_hit_count = 0;
3296  v8::Handle<v8::Value> argv_100[argc] = { v8::Number::New(isolate, 100) };
3297  foo->Call(env->Global(), argc, argv_100);
3298  CHECK_EQ(202, break_point_hit_count);
3299
3300  // Get rid of the debug event listener.
3301  v8::Debug::SetDebugEventListener(NULL);
3302  CheckDebuggerUnloaded();
3303}
3304
3305
3306TEST(DebugStepFor) {
3307  DebugLocalContext env;
3308  v8::Isolate* isolate = env->GetIsolate();
3309  v8::HandleScope scope(isolate);
3310
3311  // Register a debug event listener which steps and counts.
3312  v8::Debug::SetDebugEventListener(DebugEventStep);
3313
3314  // Create a function for testing stepping. Run it to allow it to get
3315  // optimized.
3316  const int argc = 1;
3317  const char* src = "function foo(x) { "
3318                    "  a = 1;"
3319                    "  for (i = 0; i < x; i++) {"
3320                    "    b = 1;"
3321                    "  }"
3322                    "}"
3323                    "a=0; b=0; i=0; foo()";
3324  v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3325
3326  SetBreakPoint(foo, 8);  // "a = 1;"
3327
3328  // Looping 10 times.
3329  step_action = StepIn;
3330  break_point_hit_count = 0;
3331  v8::Handle<v8::Value> argv_10[argc] = { v8::Number::New(isolate, 10) };
3332  foo->Call(env->Global(), argc, argv_10);
3333  CHECK_EQ(23, break_point_hit_count);
3334
3335  // Looping 100 times.
3336  step_action = StepIn;
3337  break_point_hit_count = 0;
3338  v8::Handle<v8::Value> argv_100[argc] = { v8::Number::New(isolate, 100) };
3339  foo->Call(env->Global(), argc, argv_100);
3340  CHECK_EQ(203, break_point_hit_count);
3341
3342  // Get rid of the debug event listener.
3343  v8::Debug::SetDebugEventListener(NULL);
3344  CheckDebuggerUnloaded();
3345}
3346
3347
3348TEST(DebugStepForContinue) {
3349  DebugLocalContext env;
3350  v8::Isolate* isolate = env->GetIsolate();
3351  v8::HandleScope scope(isolate);
3352
3353  // Register a debug event listener which steps and counts.
3354  v8::Debug::SetDebugEventListener(DebugEventStep);
3355
3356  // Create a function for testing stepping. Run it to allow it to get
3357  // optimized.
3358  const int argc = 1;
3359  const char* src = "function foo(x) { "
3360                    "  var a = 0;"
3361                    "  var b = 0;"
3362                    "  var c = 0;"
3363                    "  for (var i = 0; i < x; i++) {"
3364                    "    a++;"
3365                    "    if (a % 2 == 0) continue;"
3366                    "    b++;"
3367                    "    c++;"
3368                    "  }"
3369                    "  return b;"
3370                    "}"
3371                    "foo()";
3372  v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3373  v8::Handle<v8::Value> result;
3374  SetBreakPoint(foo, 8);  // "var a = 0;"
3375
3376  // Each loop generates 4 or 5 steps depending on whether a is equal.
3377
3378  // Looping 10 times.
3379  step_action = StepIn;
3380  break_point_hit_count = 0;
3381  v8::Handle<v8::Value> argv_10[argc] = { v8::Number::New(isolate, 10) };
3382  result = foo->Call(env->Global(), argc, argv_10);
3383  CHECK_EQ(5, result->Int32Value());
3384  CHECK_EQ(52, break_point_hit_count);
3385
3386  // Looping 100 times.
3387  step_action = StepIn;
3388  break_point_hit_count = 0;
3389  v8::Handle<v8::Value> argv_100[argc] = { v8::Number::New(isolate, 100) };
3390  result = foo->Call(env->Global(), argc, argv_100);
3391  CHECK_EQ(50, result->Int32Value());
3392  CHECK_EQ(457, break_point_hit_count);
3393
3394  // Get rid of the debug event listener.
3395  v8::Debug::SetDebugEventListener(NULL);
3396  CheckDebuggerUnloaded();
3397}
3398
3399
3400TEST(DebugStepForBreak) {
3401  DebugLocalContext env;
3402  v8::Isolate* isolate = env->GetIsolate();
3403  v8::HandleScope scope(isolate);
3404
3405  // Register a debug event listener which steps and counts.
3406  v8::Debug::SetDebugEventListener(DebugEventStep);
3407
3408  // Create a function for testing stepping. Run it to allow it to get
3409  // optimized.
3410  const int argc = 1;
3411  const char* src = "function foo(x) { "
3412                    "  var a = 0;"
3413                    "  var b = 0;"
3414                    "  var c = 0;"
3415                    "  for (var i = 0; i < 1000; i++) {"
3416                    "    a++;"
3417                    "    if (a == x) break;"
3418                    "    b++;"
3419                    "    c++;"
3420                    "  }"
3421                    "  return b;"
3422                    "}"
3423                    "foo()";
3424  v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3425  v8::Handle<v8::Value> result;
3426  SetBreakPoint(foo, 8);  // "var a = 0;"
3427
3428  // Each loop generates 5 steps except for the last (when break is executed)
3429  // which only generates 4.
3430
3431  // Looping 10 times.
3432  step_action = StepIn;
3433  break_point_hit_count = 0;
3434  v8::Handle<v8::Value> argv_10[argc] = { v8::Number::New(isolate, 10) };
3435  result = foo->Call(env->Global(), argc, argv_10);
3436  CHECK_EQ(9, result->Int32Value());
3437  CHECK_EQ(55, break_point_hit_count);
3438
3439  // Looping 100 times.
3440  step_action = StepIn;
3441  break_point_hit_count = 0;
3442  v8::Handle<v8::Value> argv_100[argc] = { v8::Number::New(isolate, 100) };
3443  result = foo->Call(env->Global(), argc, argv_100);
3444  CHECK_EQ(99, result->Int32Value());
3445  CHECK_EQ(505, break_point_hit_count);
3446
3447  // Get rid of the debug event listener.
3448  v8::Debug::SetDebugEventListener(NULL);
3449  CheckDebuggerUnloaded();
3450}
3451
3452
3453TEST(DebugStepForIn) {
3454  DebugLocalContext env;
3455  v8::HandleScope scope(env->GetIsolate());
3456
3457  // Register a debug event listener which steps and counts.
3458  v8::Debug::SetDebugEventListener(DebugEventStep);
3459
3460  // Create a function for testing stepping. Run it to allow it to get
3461  // optimized.
3462  v8::Local<v8::Function> foo;
3463  const char* src_1 = "function foo() { "
3464                      "  var a = [1, 2];"
3465                      "  for (x in a) {"
3466                      "    b = 0;"
3467                      "  }"
3468                      "}"
3469                      "foo()";
3470  foo = CompileFunction(&env, src_1, "foo");
3471  SetBreakPoint(foo, 0);  // "var a = ..."
3472
3473  step_action = StepIn;
3474  break_point_hit_count = 0;
3475  foo->Call(env->Global(), 0, NULL);
3476  CHECK_EQ(6, break_point_hit_count);
3477
3478  // Create a function for testing stepping. Run it to allow it to get
3479  // optimized.
3480  const char* src_2 = "function foo() { "
3481                      "  var a = {a:[1, 2, 3]};"
3482                      "  for (x in a.a) {"
3483                      "    b = 0;"
3484                      "  }"
3485                      "}"
3486                      "foo()";
3487  foo = CompileFunction(&env, src_2, "foo");
3488  SetBreakPoint(foo, 0);  // "var a = ..."
3489
3490  step_action = StepIn;
3491  break_point_hit_count = 0;
3492  foo->Call(env->Global(), 0, NULL);
3493  CHECK_EQ(8, break_point_hit_count);
3494
3495  // Get rid of the debug event listener.
3496  v8::Debug::SetDebugEventListener(NULL);
3497  CheckDebuggerUnloaded();
3498}
3499
3500
3501TEST(DebugStepWith) {
3502  DebugLocalContext env;
3503  v8::HandleScope scope(env->GetIsolate());
3504
3505  // Register a debug event listener which steps and counts.
3506  v8::Debug::SetDebugEventListener(DebugEventStep);
3507
3508  // Create a function for testing stepping. Run it to allow it to get
3509  // optimized.
3510  const char* src = "function foo(x) { "
3511                    "  var a = {};"
3512                    "  with (a) {}"
3513                    "  with (b) {}"
3514                    "}"
3515                    "foo()";
3516  env->Global()->Set(v8::String::NewFromUtf8(env->GetIsolate(), "b"),
3517                     v8::Object::New(env->GetIsolate()));
3518  v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3519  v8::Handle<v8::Value> result;
3520  SetBreakPoint(foo, 8);  // "var a = {};"
3521
3522  step_action = StepIn;
3523  break_point_hit_count = 0;
3524  foo->Call(env->Global(), 0, NULL);
3525  CHECK_EQ(4, break_point_hit_count);
3526
3527  // Get rid of the debug event listener.
3528  v8::Debug::SetDebugEventListener(NULL);
3529  CheckDebuggerUnloaded();
3530}
3531
3532
3533TEST(DebugConditional) {
3534  DebugLocalContext env;
3535  v8::Isolate* isolate = env->GetIsolate();
3536  v8::HandleScope scope(isolate);
3537
3538  // Register a debug event listener which steps and counts.
3539  v8::Debug::SetDebugEventListener(DebugEventStep);
3540
3541  // Create a function for testing stepping. Run it to allow it to get
3542  // optimized.
3543  const char* src = "function foo(x) { "
3544                    "  var a;"
3545                    "  a = x ? 1 : 2;"
3546                    "  return a;"
3547                    "}"
3548                    "foo()";
3549  v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
3550  SetBreakPoint(foo, 0);  // "var a;"
3551
3552  step_action = StepIn;
3553  break_point_hit_count = 0;
3554  foo->Call(env->Global(), 0, NULL);
3555  CHECK_EQ(5, break_point_hit_count);
3556
3557  step_action = StepIn;
3558  break_point_hit_count = 0;
3559  const int argc = 1;
3560  v8::Handle<v8::Value> argv_true[argc] = { v8::True(isolate) };
3561  foo->Call(env->Global(), argc, argv_true);
3562  CHECK_EQ(5, break_point_hit_count);
3563
3564  // Get rid of the debug event listener.
3565  v8::Debug::SetDebugEventListener(NULL);
3566  CheckDebuggerUnloaded();
3567}
3568
3569
3570TEST(StepInOutSimple) {
3571  DebugLocalContext env;
3572  v8::HandleScope scope(env->GetIsolate());
3573
3574  // Create a function for checking the function when hitting a break point.
3575  frame_function_name = CompileFunction(&env,
3576                                        frame_function_name_source,
3577                                        "frame_function_name");
3578
3579  // Register a debug event listener which steps and counts.
3580  v8::Debug::SetDebugEventListener(DebugEventStepSequence);
3581
3582  // Create a function for testing stepping. Run it to allow it to get
3583  // optimized.
3584  const char* src = "function a() {b();c();}; "
3585                    "function b() {c();}; "
3586                    "function c() {}; "
3587                    "a(); b(); c()";
3588  v8::Local<v8::Function> a = CompileFunction(&env, src, "a");
3589  SetBreakPoint(a, 0);
3590
3591  // Step through invocation of a with step in.
3592  step_action = StepIn;
3593  break_point_hit_count = 0;
3594  expected_step_sequence = "abcbaca";
3595  a->Call(env->Global(), 0, NULL);
3596  CHECK_EQ(StrLength(expected_step_sequence),
3597           break_point_hit_count);
3598
3599  // Step through invocation of a with step next.
3600  step_action = StepNext;
3601  break_point_hit_count = 0;
3602  expected_step_sequence = "aaa";
3603  a->Call(env->Global(), 0, NULL);
3604  CHECK_EQ(StrLength(expected_step_sequence),
3605           break_point_hit_count);
3606
3607  // Step through invocation of a with step out.
3608  step_action = StepOut;
3609  break_point_hit_count = 0;
3610  expected_step_sequence = "a";
3611  a->Call(env->Global(), 0, NULL);
3612  CHECK_EQ(StrLength(expected_step_sequence),
3613           break_point_hit_count);
3614
3615  // Get rid of the debug event listener.
3616  v8::Debug::SetDebugEventListener(NULL);
3617  CheckDebuggerUnloaded();
3618}
3619
3620
3621TEST(StepInOutTree) {
3622  DebugLocalContext env;
3623  v8::HandleScope scope(env->GetIsolate());
3624
3625  // Create a function for checking the function when hitting a break point.
3626  frame_function_name = CompileFunction(&env,
3627                                        frame_function_name_source,
3628                                        "frame_function_name");
3629
3630  // Register a debug event listener which steps and counts.
3631  v8::Debug::SetDebugEventListener(DebugEventStepSequence);
3632
3633  // Create a function for testing stepping. Run it to allow it to get
3634  // optimized.
3635  const char* src = "function a() {b(c(d()),d());c(d());d()}; "
3636                    "function b(x,y) {c();}; "
3637                    "function c(x) {}; "
3638                    "function d() {}; "
3639                    "a(); b(); c(); d()";
3640  v8::Local<v8::Function> a = CompileFunction(&env, src, "a");
3641  SetBreakPoint(a, 0);
3642
3643  // Step through invocation of a with step in.
3644  step_action = StepIn;
3645  break_point_hit_count = 0;
3646  expected_step_sequence = "adacadabcbadacada";
3647  a->Call(env->Global(), 0, NULL);
3648  CHECK_EQ(StrLength(expected_step_sequence),
3649           break_point_hit_count);
3650
3651  // Step through invocation of a with step next.
3652  step_action = StepNext;
3653  break_point_hit_count = 0;
3654  expected_step_sequence = "aaaa";
3655  a->Call(env->Global(), 0, NULL);
3656  CHECK_EQ(StrLength(expected_step_sequence),
3657           break_point_hit_count);
3658
3659  // Step through invocation of a with step out.
3660  step_action = StepOut;
3661  break_point_hit_count = 0;
3662  expected_step_sequence = "a";
3663  a->Call(env->Global(), 0, NULL);
3664  CHECK_EQ(StrLength(expected_step_sequence),
3665           break_point_hit_count);
3666
3667  // Get rid of the debug event listener.
3668  v8::Debug::SetDebugEventListener(NULL);
3669  CheckDebuggerUnloaded(true);
3670}
3671
3672
3673TEST(StepInOutBranch) {
3674  DebugLocalContext env;
3675  v8::HandleScope scope(env->GetIsolate());
3676
3677  // Create a function for checking the function when hitting a break point.
3678  frame_function_name = CompileFunction(&env,
3679                                        frame_function_name_source,
3680                                        "frame_function_name");
3681
3682  // Register a debug event listener which steps and counts.
3683  v8::Debug::SetDebugEventListener(DebugEventStepSequence);
3684
3685  // Create a function for testing stepping. Run it to allow it to get
3686  // optimized.
3687  const char* src = "function a() {b(false);c();}; "
3688                    "function b(x) {if(x){c();};}; "
3689                    "function c() {}; "
3690                    "a(); b(); c()";
3691  v8::Local<v8::Function> a = CompileFunction(&env, src, "a");
3692  SetBreakPoint(a, 0);
3693
3694  // Step through invocation of a.
3695  step_action = StepIn;
3696  break_point_hit_count = 0;
3697  expected_step_sequence = "abbaca";
3698  a->Call(env->Global(), 0, NULL);
3699  CHECK_EQ(StrLength(expected_step_sequence),
3700           break_point_hit_count);
3701
3702  // Get rid of the debug event listener.
3703  v8::Debug::SetDebugEventListener(NULL);
3704  CheckDebuggerUnloaded();
3705}
3706
3707
3708// Test that step in does not step into native functions.
3709TEST(DebugStepNatives) {
3710  DebugLocalContext env;
3711  v8::HandleScope scope(env->GetIsolate());
3712
3713  // Create a function for testing stepping.
3714  v8::Local<v8::Function> foo = CompileFunction(
3715      &env,
3716      "function foo(){debugger;Math.sin(1);}",
3717      "foo");
3718
3719  // Register a debug event listener which steps and counts.
3720  v8::Debug::SetDebugEventListener(DebugEventStep);
3721
3722  step_action = StepIn;
3723  break_point_hit_count = 0;
3724  foo->Call(env->Global(), 0, NULL);
3725
3726  // With stepping all break locations are hit.
3727  CHECK_EQ(3, break_point_hit_count);
3728
3729  v8::Debug::SetDebugEventListener(NULL);
3730  CheckDebuggerUnloaded();
3731
3732  // Register a debug event listener which just counts.
3733  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
3734
3735  break_point_hit_count = 0;
3736  foo->Call(env->Global(), 0, NULL);
3737
3738  // Without stepping only active break points are hit.
3739  CHECK_EQ(1, break_point_hit_count);
3740
3741  v8::Debug::SetDebugEventListener(NULL);
3742  CheckDebuggerUnloaded();
3743}
3744
3745
3746// Test that step in works with function.apply.
3747TEST(DebugStepFunctionApply) {
3748  DebugLocalContext env;
3749  v8::HandleScope scope(env->GetIsolate());
3750
3751  // Create a function for testing stepping.
3752  v8::Local<v8::Function> foo = CompileFunction(
3753      &env,
3754      "function bar(x, y, z) { if (x == 1) { a = y; b = z; } }"
3755      "function foo(){ debugger; bar.apply(this, [1,2,3]); }",
3756      "foo");
3757
3758  // Register a debug event listener which steps and counts.
3759  v8::Debug::SetDebugEventListener(DebugEventStep);
3760
3761  step_action = StepIn;
3762  break_point_hit_count = 0;
3763  foo->Call(env->Global(), 0, NULL);
3764
3765  // With stepping all break locations are hit.
3766  CHECK_EQ(7, break_point_hit_count);
3767
3768  v8::Debug::SetDebugEventListener(NULL);
3769  CheckDebuggerUnloaded();
3770
3771  // Register a debug event listener which just counts.
3772  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
3773
3774  break_point_hit_count = 0;
3775  foo->Call(env->Global(), 0, NULL);
3776
3777  // Without stepping only the debugger statement is hit.
3778  CHECK_EQ(1, break_point_hit_count);
3779
3780  v8::Debug::SetDebugEventListener(NULL);
3781  CheckDebuggerUnloaded();
3782}
3783
3784
3785// Test that step in works with function.call.
3786TEST(DebugStepFunctionCall) {
3787  DebugLocalContext env;
3788  v8::Isolate* isolate = env->GetIsolate();
3789  v8::HandleScope scope(isolate);
3790
3791  // Create a function for testing stepping.
3792  v8::Local<v8::Function> foo = CompileFunction(
3793      &env,
3794      "function bar(x, y, z) { if (x == 1) { a = y; b = z; } }"
3795      "function foo(a){ debugger;"
3796      "                 if (a) {"
3797      "                   bar.call(this, 1, 2, 3);"
3798      "                 } else {"
3799      "                   bar.call(this, 0);"
3800      "                 }"
3801      "}",
3802      "foo");
3803
3804  // Register a debug event listener which steps and counts.
3805  v8::Debug::SetDebugEventListener(DebugEventStep);
3806  step_action = StepIn;
3807
3808  // Check stepping where the if condition in bar is false.
3809  break_point_hit_count = 0;
3810  foo->Call(env->Global(), 0, NULL);
3811  CHECK_EQ(6, break_point_hit_count);
3812
3813  // Check stepping where the if condition in bar is true.
3814  break_point_hit_count = 0;
3815  const int argc = 1;
3816  v8::Handle<v8::Value> argv[argc] = { v8::True(isolate) };
3817  foo->Call(env->Global(), argc, argv);
3818  CHECK_EQ(8, break_point_hit_count);
3819
3820  v8::Debug::SetDebugEventListener(NULL);
3821  CheckDebuggerUnloaded();
3822
3823  // Register a debug event listener which just counts.
3824  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
3825
3826  break_point_hit_count = 0;
3827  foo->Call(env->Global(), 0, NULL);
3828
3829  // Without stepping only the debugger statement is hit.
3830  CHECK_EQ(1, break_point_hit_count);
3831
3832  v8::Debug::SetDebugEventListener(NULL);
3833  CheckDebuggerUnloaded();
3834}
3835
3836
3837// Tests that breakpoint will be hit if it's set in script.
3838TEST(PauseInScript) {
3839  DebugLocalContext env;
3840  v8::HandleScope scope(env->GetIsolate());
3841  env.ExposeDebug();
3842
3843  // Register a debug event listener which counts.
3844  v8::Debug::SetDebugEventListener(DebugEventCounter);
3845
3846  // Create a script that returns a function.
3847  const char* src = "(function (evt) {})";
3848  const char* script_name = "StepInHandlerTest";
3849
3850  // Set breakpoint in the script.
3851  SetScriptBreakPointByNameFromJS(env->GetIsolate(), script_name, 0, -1);
3852  break_point_hit_count = 0;
3853
3854  v8::ScriptOrigin origin(
3855      v8::String::NewFromUtf8(env->GetIsolate(), script_name),
3856      v8::Integer::New(env->GetIsolate(), 0));
3857  v8::Handle<v8::Script> script = v8::Script::Compile(
3858      v8::String::NewFromUtf8(env->GetIsolate(), src), &origin);
3859  v8::Local<v8::Value> r = script->Run();
3860
3861  CHECK(r->IsFunction());
3862  CHECK_EQ(1, break_point_hit_count);
3863
3864  // Get rid of the debug event listener.
3865  v8::Debug::SetDebugEventListener(NULL);
3866  CheckDebuggerUnloaded();
3867}
3868
3869
3870// Test break on exceptions. For each exception break combination the number
3871// of debug event exception callbacks and message callbacks are collected. The
3872// number of debug event exception callbacks are used to check that the
3873// debugger is called correctly and the number of message callbacks is used to
3874// check that uncaught exceptions are still returned even if there is a break
3875// for them.
3876TEST(BreakOnException) {
3877  DebugLocalContext env;
3878  v8::HandleScope scope(env->GetIsolate());
3879  env.ExposeDebug();
3880
3881  // Create functions for testing break on exception.
3882  CompileFunction(&env, "function throws(){throw 1;}", "throws");
3883  v8::Local<v8::Function> caught =
3884      CompileFunction(&env,
3885                      "function caught(){try {throws();} catch(e) {};}",
3886                      "caught");
3887  v8::Local<v8::Function> notCaught =
3888      CompileFunction(&env, "function notCaught(){throws();}", "notCaught");
3889
3890  v8::V8::AddMessageListener(MessageCallbackCount);
3891  v8::Debug::SetDebugEventListener(DebugEventCounter);
3892
3893  // Initial state should be no break on exceptions.
3894  DebugEventCounterClear();
3895  MessageCallbackCountClear();
3896  caught->Call(env->Global(), 0, NULL);
3897  CHECK_EQ(0, exception_hit_count);
3898  CHECK_EQ(0, uncaught_exception_hit_count);
3899  CHECK_EQ(0, message_callback_count);
3900  notCaught->Call(env->Global(), 0, NULL);
3901  CHECK_EQ(0, exception_hit_count);
3902  CHECK_EQ(0, uncaught_exception_hit_count);
3903  CHECK_EQ(1, message_callback_count);
3904
3905  // No break on exception
3906  DebugEventCounterClear();
3907  MessageCallbackCountClear();
3908  ChangeBreakOnException(false, false);
3909  caught->Call(env->Global(), 0, NULL);
3910  CHECK_EQ(0, exception_hit_count);
3911  CHECK_EQ(0, uncaught_exception_hit_count);
3912  CHECK_EQ(0, message_callback_count);
3913  notCaught->Call(env->Global(), 0, NULL);
3914  CHECK_EQ(0, exception_hit_count);
3915  CHECK_EQ(0, uncaught_exception_hit_count);
3916  CHECK_EQ(1, message_callback_count);
3917
3918  // Break on uncaught exception
3919  DebugEventCounterClear();
3920  MessageCallbackCountClear();
3921  ChangeBreakOnException(false, true);
3922  caught->Call(env->Global(), 0, NULL);
3923  CHECK_EQ(0, exception_hit_count);
3924  CHECK_EQ(0, uncaught_exception_hit_count);
3925  CHECK_EQ(0, message_callback_count);
3926  notCaught->Call(env->Global(), 0, NULL);
3927  CHECK_EQ(1, exception_hit_count);
3928  CHECK_EQ(1, uncaught_exception_hit_count);
3929  CHECK_EQ(1, message_callback_count);
3930
3931  // Break on exception and uncaught exception
3932  DebugEventCounterClear();
3933  MessageCallbackCountClear();
3934  ChangeBreakOnException(true, true);
3935  caught->Call(env->Global(), 0, NULL);
3936  CHECK_EQ(1, exception_hit_count);
3937  CHECK_EQ(0, uncaught_exception_hit_count);
3938  CHECK_EQ(0, message_callback_count);
3939  notCaught->Call(env->Global(), 0, NULL);
3940  CHECK_EQ(2, exception_hit_count);
3941  CHECK_EQ(1, uncaught_exception_hit_count);
3942  CHECK_EQ(1, message_callback_count);
3943
3944  // Break on exception
3945  DebugEventCounterClear();
3946  MessageCallbackCountClear();
3947  ChangeBreakOnException(true, false);
3948  caught->Call(env->Global(), 0, NULL);
3949  CHECK_EQ(1, exception_hit_count);
3950  CHECK_EQ(0, uncaught_exception_hit_count);
3951  CHECK_EQ(0, message_callback_count);
3952  notCaught->Call(env->Global(), 0, NULL);
3953  CHECK_EQ(2, exception_hit_count);
3954  CHECK_EQ(1, uncaught_exception_hit_count);
3955  CHECK_EQ(1, message_callback_count);
3956
3957  // No break on exception using JavaScript
3958  DebugEventCounterClear();
3959  MessageCallbackCountClear();
3960  ChangeBreakOnExceptionFromJS(env->GetIsolate(), false, false);
3961  caught->Call(env->Global(), 0, NULL);
3962  CHECK_EQ(0, exception_hit_count);
3963  CHECK_EQ(0, uncaught_exception_hit_count);
3964  CHECK_EQ(0, message_callback_count);
3965  notCaught->Call(env->Global(), 0, NULL);
3966  CHECK_EQ(0, exception_hit_count);
3967  CHECK_EQ(0, uncaught_exception_hit_count);
3968  CHECK_EQ(1, message_callback_count);
3969
3970  // Break on uncaught exception using JavaScript
3971  DebugEventCounterClear();
3972  MessageCallbackCountClear();
3973  ChangeBreakOnExceptionFromJS(env->GetIsolate(), false, true);
3974  caught->Call(env->Global(), 0, NULL);
3975  CHECK_EQ(0, exception_hit_count);
3976  CHECK_EQ(0, uncaught_exception_hit_count);
3977  CHECK_EQ(0, message_callback_count);
3978  notCaught->Call(env->Global(), 0, NULL);
3979  CHECK_EQ(1, exception_hit_count);
3980  CHECK_EQ(1, uncaught_exception_hit_count);
3981  CHECK_EQ(1, message_callback_count);
3982
3983  // Break on exception and uncaught exception using JavaScript
3984  DebugEventCounterClear();
3985  MessageCallbackCountClear();
3986  ChangeBreakOnExceptionFromJS(env->GetIsolate(), true, true);
3987  caught->Call(env->Global(), 0, NULL);
3988  CHECK_EQ(1, exception_hit_count);
3989  CHECK_EQ(0, message_callback_count);
3990  CHECK_EQ(0, uncaught_exception_hit_count);
3991  notCaught->Call(env->Global(), 0, NULL);
3992  CHECK_EQ(2, exception_hit_count);
3993  CHECK_EQ(1, uncaught_exception_hit_count);
3994  CHECK_EQ(1, message_callback_count);
3995
3996  // Break on exception using JavaScript
3997  DebugEventCounterClear();
3998  MessageCallbackCountClear();
3999  ChangeBreakOnExceptionFromJS(env->GetIsolate(), true, false);
4000  caught->Call(env->Global(), 0, NULL);
4001  CHECK_EQ(1, exception_hit_count);
4002  CHECK_EQ(0, uncaught_exception_hit_count);
4003  CHECK_EQ(0, message_callback_count);
4004  notCaught->Call(env->Global(), 0, NULL);
4005  CHECK_EQ(2, exception_hit_count);
4006  CHECK_EQ(1, uncaught_exception_hit_count);
4007  CHECK_EQ(1, message_callback_count);
4008
4009  v8::Debug::SetDebugEventListener(NULL);
4010  CheckDebuggerUnloaded();
4011  v8::V8::RemoveMessageListeners(MessageCallbackCount);
4012}
4013
4014
4015TEST(EvalJSInDebugEventListenerOnNativeReThrownException) {
4016  DebugLocalContext env;
4017  v8::HandleScope scope(env->GetIsolate());
4018  env.ExposeDebug();
4019
4020  // Create functions for testing break on exception.
4021  v8::Local<v8::Function> noThrowJS = CompileFunction(
4022      &env, "function noThrowJS(){var a=[1]; a.push(2); return a.length;}",
4023      "noThrowJS");
4024
4025  debug_event_listener_callback = noThrowJS;
4026  debug_event_listener_callback_result = 2;
4027
4028  v8::V8::AddMessageListener(MessageCallbackCount);
4029  v8::Debug::SetDebugEventListener(DebugEventCounter);
4030  // Break on uncaught exception
4031  ChangeBreakOnException(false, true);
4032  DebugEventCounterClear();
4033  MessageCallbackCountClear();
4034
4035  // ReThrow native error
4036  {
4037    v8::TryCatch tryCatch;
4038    env->GetIsolate()->ThrowException(v8::Exception::TypeError(
4039        v8::String::NewFromUtf8(env->GetIsolate(), "Type error")));
4040    CHECK(tryCatch.HasCaught());
4041    tryCatch.ReThrow();
4042  }
4043  CHECK_EQ(1, exception_hit_count);
4044  CHECK_EQ(1, uncaught_exception_hit_count);
4045  CHECK_EQ(0, message_callback_count);  // FIXME: Should it be 1 ?
4046  CHECK(!debug_event_listener_callback.IsEmpty());
4047
4048  debug_event_listener_callback.Clear();
4049}
4050
4051
4052// Test break on exception from compiler errors. When compiling using
4053// v8::Script::Compile there is no JavaScript stack whereas when compiling using
4054// eval there are JavaScript frames.
4055TEST(BreakOnCompileException) {
4056  DebugLocalContext env;
4057  v8::HandleScope scope(env->GetIsolate());
4058
4059  // For this test, we want to break on uncaught exceptions:
4060  ChangeBreakOnException(false, true);
4061
4062  // Create a function for checking the function when hitting a break point.
4063  frame_count = CompileFunction(&env, frame_count_source, "frame_count");
4064
4065  v8::V8::AddMessageListener(MessageCallbackCount);
4066  v8::Debug::SetDebugEventListener(DebugEventCounter);
4067
4068  DebugEventCounterClear();
4069  MessageCallbackCountClear();
4070
4071  // Check initial state.
4072  CHECK_EQ(0, exception_hit_count);
4073  CHECK_EQ(0, uncaught_exception_hit_count);
4074  CHECK_EQ(0, message_callback_count);
4075  CHECK_EQ(-1, last_js_stack_height);
4076
4077  // Throws SyntaxError: Unexpected end of input
4078  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), "+++"));
4079  CHECK_EQ(1, exception_hit_count);
4080  CHECK_EQ(1, uncaught_exception_hit_count);
4081  CHECK_EQ(1, message_callback_count);
4082  CHECK_EQ(0, last_js_stack_height);  // No JavaScript stack.
4083
4084  // Throws SyntaxError: Unexpected identifier
4085  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), "x x"));
4086  CHECK_EQ(2, exception_hit_count);
4087  CHECK_EQ(2, uncaught_exception_hit_count);
4088  CHECK_EQ(2, message_callback_count);
4089  CHECK_EQ(0, last_js_stack_height);  // No JavaScript stack.
4090
4091  // Throws SyntaxError: Unexpected end of input
4092  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), "eval('+++')"))
4093      ->Run();
4094  CHECK_EQ(3, exception_hit_count);
4095  CHECK_EQ(3, uncaught_exception_hit_count);
4096  CHECK_EQ(3, message_callback_count);
4097  CHECK_EQ(1, last_js_stack_height);
4098
4099  // Throws SyntaxError: Unexpected identifier
4100  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), "eval('x x')"))
4101      ->Run();
4102  CHECK_EQ(4, exception_hit_count);
4103  CHECK_EQ(4, uncaught_exception_hit_count);
4104  CHECK_EQ(4, message_callback_count);
4105  CHECK_EQ(1, last_js_stack_height);
4106}
4107
4108
4109TEST(StepWithException) {
4110  DebugLocalContext env;
4111  v8::HandleScope scope(env->GetIsolate());
4112
4113  // For this test, we want to break on uncaught exceptions:
4114  ChangeBreakOnException(false, true);
4115
4116  // Create a function for checking the function when hitting a break point.
4117  frame_function_name = CompileFunction(&env,
4118                                        frame_function_name_source,
4119                                        "frame_function_name");
4120
4121  // Register a debug event listener which steps and counts.
4122  v8::Debug::SetDebugEventListener(DebugEventStepSequence);
4123
4124  // Create functions for testing stepping.
4125  const char* src = "function a() { n(); }; "
4126                    "function b() { c(); }; "
4127                    "function c() { n(); }; "
4128                    "function d() { x = 1; try { e(); } catch(x) { x = 2; } }; "
4129                    "function e() { n(); }; "
4130                    "function f() { x = 1; try { g(); } catch(x) { x = 2; } }; "
4131                    "function g() { h(); }; "
4132                    "function h() { x = 1; throw 1; }; ";
4133
4134  // Step through invocation of a.
4135  v8::Local<v8::Function> a = CompileFunction(&env, src, "a");
4136  SetBreakPoint(a, 0);
4137  step_action = StepIn;
4138  break_point_hit_count = 0;
4139  expected_step_sequence = "aa";
4140  a->Call(env->Global(), 0, NULL);
4141  CHECK_EQ(StrLength(expected_step_sequence),
4142           break_point_hit_count);
4143
4144  // Step through invocation of b + c.
4145  v8::Local<v8::Function> b = CompileFunction(&env, src, "b");
4146  SetBreakPoint(b, 0);
4147  step_action = StepIn;
4148  break_point_hit_count = 0;
4149  expected_step_sequence = "bcc";
4150  b->Call(env->Global(), 0, NULL);
4151  CHECK_EQ(StrLength(expected_step_sequence),
4152           break_point_hit_count);
4153  // Step through invocation of d + e.
4154  v8::Local<v8::Function> d = CompileFunction(&env, src, "d");
4155  SetBreakPoint(d, 0);
4156  ChangeBreakOnException(false, true);
4157  step_action = StepIn;
4158  break_point_hit_count = 0;
4159  expected_step_sequence = "ddedd";
4160  d->Call(env->Global(), 0, NULL);
4161  CHECK_EQ(StrLength(expected_step_sequence),
4162           break_point_hit_count);
4163
4164  // Step through invocation of d + e now with break on caught exceptions.
4165  ChangeBreakOnException(true, true);
4166  step_action = StepIn;
4167  break_point_hit_count = 0;
4168  expected_step_sequence = "ddeedd";
4169  d->Call(env->Global(), 0, NULL);
4170  CHECK_EQ(StrLength(expected_step_sequence),
4171           break_point_hit_count);
4172
4173  // Step through invocation of f + g + h.
4174  v8::Local<v8::Function> f = CompileFunction(&env, src, "f");
4175  SetBreakPoint(f, 0);
4176  ChangeBreakOnException(false, true);
4177  step_action = StepIn;
4178  break_point_hit_count = 0;
4179  expected_step_sequence = "ffghhff";
4180  f->Call(env->Global(), 0, NULL);
4181  CHECK_EQ(StrLength(expected_step_sequence),
4182           break_point_hit_count);
4183
4184  // Step through invocation of f + g + h now with break on caught exceptions.
4185  ChangeBreakOnException(true, true);
4186  step_action = StepIn;
4187  break_point_hit_count = 0;
4188  expected_step_sequence = "ffghhhff";
4189  f->Call(env->Global(), 0, NULL);
4190  CHECK_EQ(StrLength(expected_step_sequence),
4191           break_point_hit_count);
4192
4193  // Get rid of the debug event listener.
4194  v8::Debug::SetDebugEventListener(NULL);
4195  CheckDebuggerUnloaded();
4196}
4197
4198
4199TEST(DebugBreak) {
4200  i::FLAG_stress_compaction = false;
4201#ifdef VERIFY_HEAP
4202  i::FLAG_verify_heap = true;
4203#endif
4204  DebugLocalContext env;
4205  v8::Isolate* isolate = env->GetIsolate();
4206  v8::HandleScope scope(isolate);
4207
4208  // Register a debug event listener which sets the break flag and counts.
4209  v8::Debug::SetDebugEventListener(DebugEventBreak);
4210
4211  // Create a function for testing stepping.
4212  const char* src = "function f0() {}"
4213                    "function f1(x1) {}"
4214                    "function f2(x1,x2) {}"
4215                    "function f3(x1,x2,x3) {}";
4216  v8::Local<v8::Function> f0 = CompileFunction(&env, src, "f0");
4217  v8::Local<v8::Function> f1 = CompileFunction(&env, src, "f1");
4218  v8::Local<v8::Function> f2 = CompileFunction(&env, src, "f2");
4219  v8::Local<v8::Function> f3 = CompileFunction(&env, src, "f3");
4220
4221  // Call the function to make sure it is compiled.
4222  v8::Handle<v8::Value> argv[] = { v8::Number::New(isolate, 1),
4223                                   v8::Number::New(isolate, 1),
4224                                   v8::Number::New(isolate, 1),
4225                                   v8::Number::New(isolate, 1) };
4226
4227  // Call all functions to make sure that they are compiled.
4228  f0->Call(env->Global(), 0, NULL);
4229  f1->Call(env->Global(), 0, NULL);
4230  f2->Call(env->Global(), 0, NULL);
4231  f3->Call(env->Global(), 0, NULL);
4232
4233  // Set the debug break flag.
4234  v8::Debug::DebugBreak(env->GetIsolate());
4235  CHECK(v8::Debug::CheckDebugBreak(env->GetIsolate()));
4236
4237  // Call all functions with different argument count.
4238  break_point_hit_count = 0;
4239  for (unsigned int i = 0; i < arraysize(argv); i++) {
4240    f0->Call(env->Global(), i, argv);
4241    f1->Call(env->Global(), i, argv);
4242    f2->Call(env->Global(), i, argv);
4243    f3->Call(env->Global(), i, argv);
4244  }
4245
4246  // One break for each function called.
4247  CHECK_EQ(4 * arraysize(argv), break_point_hit_count);
4248
4249  // Get rid of the debug event listener.
4250  v8::Debug::SetDebugEventListener(NULL);
4251  CheckDebuggerUnloaded();
4252}
4253
4254
4255// Test to ensure that JavaScript code keeps running while the debug break
4256// through the stack limit flag is set but breaks are disabled.
4257TEST(DisableBreak) {
4258  DebugLocalContext env;
4259  v8::HandleScope scope(env->GetIsolate());
4260
4261  // Register a debug event listener which sets the break flag and counts.
4262  v8::Debug::SetDebugEventListener(DebugEventCounter);
4263
4264  // Create a function for testing stepping.
4265  const char* src = "function f() {g()};function g(){i=0; while(i<10){i++}}";
4266  v8::Local<v8::Function> f = CompileFunction(&env, src, "f");
4267
4268  // Set, test and cancel debug break.
4269  v8::Debug::DebugBreak(env->GetIsolate());
4270  CHECK(v8::Debug::CheckDebugBreak(env->GetIsolate()));
4271  v8::Debug::CancelDebugBreak(env->GetIsolate());
4272  CHECK(!v8::Debug::CheckDebugBreak(env->GetIsolate()));
4273
4274  // Set the debug break flag.
4275  v8::Debug::DebugBreak(env->GetIsolate());
4276
4277  // Call all functions with different argument count.
4278  break_point_hit_count = 0;
4279  f->Call(env->Global(), 0, NULL);
4280  CHECK_EQ(1, break_point_hit_count);
4281
4282  {
4283    v8::Debug::DebugBreak(env->GetIsolate());
4284    i::Isolate* isolate = reinterpret_cast<i::Isolate*>(env->GetIsolate());
4285    v8::internal::DisableBreak disable_break(isolate->debug(), true);
4286    f->Call(env->Global(), 0, NULL);
4287    CHECK_EQ(1, break_point_hit_count);
4288  }
4289
4290  f->Call(env->Global(), 0, NULL);
4291  CHECK_EQ(2, break_point_hit_count);
4292
4293  // Get rid of the debug event listener.
4294  v8::Debug::SetDebugEventListener(NULL);
4295  CheckDebuggerUnloaded();
4296}
4297
4298static const char* kSimpleExtensionSource =
4299  "(function Foo() {"
4300  "  return 4;"
4301  "})() ";
4302
4303// http://crbug.com/28933
4304// Test that debug break is disabled when bootstrapper is active.
4305TEST(NoBreakWhenBootstrapping) {
4306  v8::Isolate* isolate = CcTest::isolate();
4307  v8::HandleScope scope(isolate);
4308
4309  // Register a debug event listener which sets the break flag and counts.
4310  v8::Debug::SetDebugEventListener(DebugEventCounter);
4311
4312  // Set the debug break flag.
4313  v8::Debug::DebugBreak(isolate);
4314  break_point_hit_count = 0;
4315  {
4316    // Create a context with an extension to make sure that some JavaScript
4317    // code is executed during bootstrapping.
4318    v8::RegisterExtension(new v8::Extension("simpletest",
4319                                            kSimpleExtensionSource));
4320    const char* extension_names[] = { "simpletest" };
4321    v8::ExtensionConfiguration extensions(1, extension_names);
4322    v8::HandleScope handle_scope(isolate);
4323    v8::Context::New(isolate, &extensions);
4324  }
4325  // Check that no DebugBreak events occured during the context creation.
4326  CHECK_EQ(0, break_point_hit_count);
4327
4328  // Get rid of the debug event listener.
4329  v8::Debug::SetDebugEventListener(NULL);
4330  CheckDebuggerUnloaded();
4331}
4332
4333
4334static void NamedEnum(const v8::PropertyCallbackInfo<v8::Array>& info) {
4335  v8::Handle<v8::Array> result = v8::Array::New(info.GetIsolate(), 3);
4336  result->Set(v8::Integer::New(info.GetIsolate(), 0),
4337              v8::String::NewFromUtf8(info.GetIsolate(), "a"));
4338  result->Set(v8::Integer::New(info.GetIsolate(), 1),
4339              v8::String::NewFromUtf8(info.GetIsolate(), "b"));
4340  result->Set(v8::Integer::New(info.GetIsolate(), 2),
4341              v8::String::NewFromUtf8(info.GetIsolate(), "c"));
4342  info.GetReturnValue().Set(result);
4343}
4344
4345
4346static void IndexedEnum(const v8::PropertyCallbackInfo<v8::Array>& info) {
4347  v8::Isolate* isolate = info.GetIsolate();
4348  v8::Handle<v8::Array> result = v8::Array::New(isolate, 2);
4349  result->Set(v8::Integer::New(isolate, 0), v8::Number::New(isolate, 1));
4350  result->Set(v8::Integer::New(isolate, 1), v8::Number::New(isolate, 10));
4351  info.GetReturnValue().Set(result);
4352}
4353
4354
4355static void NamedGetter(v8::Local<v8::String> name,
4356                        const v8::PropertyCallbackInfo<v8::Value>& info) {
4357  v8::String::Utf8Value n(name);
4358  if (strcmp(*n, "a") == 0) {
4359    info.GetReturnValue().Set(v8::String::NewFromUtf8(info.GetIsolate(), "AA"));
4360    return;
4361  } else if (strcmp(*n, "b") == 0) {
4362    info.GetReturnValue().Set(v8::String::NewFromUtf8(info.GetIsolate(), "BB"));
4363    return;
4364  } else if (strcmp(*n, "c") == 0) {
4365    info.GetReturnValue().Set(v8::String::NewFromUtf8(info.GetIsolate(), "CC"));
4366    return;
4367  } else {
4368    info.GetReturnValue().SetUndefined();
4369    return;
4370  }
4371  info.GetReturnValue().Set(name);
4372}
4373
4374
4375static void IndexedGetter(uint32_t index,
4376                          const v8::PropertyCallbackInfo<v8::Value>& info) {
4377  info.GetReturnValue().Set(static_cast<double>(index + 1));
4378}
4379
4380
4381TEST(InterceptorPropertyMirror) {
4382  // Create a V8 environment with debug access.
4383  DebugLocalContext env;
4384  v8::Isolate* isolate = env->GetIsolate();
4385  v8::HandleScope scope(isolate);
4386  env.ExposeDebug();
4387
4388  // Create object with named interceptor.
4389  v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New(isolate);
4390  named->SetNamedPropertyHandler(NamedGetter, NULL, NULL, NULL, NamedEnum);
4391  env->Global()->Set(
4392      v8::String::NewFromUtf8(isolate, "intercepted_named"),
4393      named->NewInstance());
4394
4395  // Create object with indexed interceptor.
4396  v8::Handle<v8::ObjectTemplate> indexed = v8::ObjectTemplate::New(isolate);
4397  indexed->SetIndexedPropertyHandler(IndexedGetter,
4398                                     NULL,
4399                                     NULL,
4400                                     NULL,
4401                                     IndexedEnum);
4402  env->Global()->Set(
4403      v8::String::NewFromUtf8(isolate, "intercepted_indexed"),
4404      indexed->NewInstance());
4405
4406  // Create object with both named and indexed interceptor.
4407  v8::Handle<v8::ObjectTemplate> both = v8::ObjectTemplate::New(isolate);
4408  both->SetNamedPropertyHandler(NamedGetter, NULL, NULL, NULL, NamedEnum);
4409  both->SetIndexedPropertyHandler(IndexedGetter, NULL, NULL, NULL, IndexedEnum);
4410  env->Global()->Set(
4411      v8::String::NewFromUtf8(isolate, "intercepted_both"),
4412      both->NewInstance());
4413
4414  // Get mirrors for the three objects with interceptor.
4415  CompileRun(
4416      "var named_mirror = debug.MakeMirror(intercepted_named);"
4417      "var indexed_mirror = debug.MakeMirror(intercepted_indexed);"
4418      "var both_mirror = debug.MakeMirror(intercepted_both)");
4419  CHECK(CompileRun(
4420       "named_mirror instanceof debug.ObjectMirror")->BooleanValue());
4421  CHECK(CompileRun(
4422        "indexed_mirror instanceof debug.ObjectMirror")->BooleanValue());
4423  CHECK(CompileRun(
4424        "both_mirror instanceof debug.ObjectMirror")->BooleanValue());
4425
4426  // Get the property names from the interceptors
4427  CompileRun(
4428      "named_names = named_mirror.propertyNames();"
4429      "indexed_names = indexed_mirror.propertyNames();"
4430      "both_names = both_mirror.propertyNames()");
4431  CHECK_EQ(3, CompileRun("named_names.length")->Int32Value());
4432  CHECK_EQ(2, CompileRun("indexed_names.length")->Int32Value());
4433  CHECK_EQ(5, CompileRun("both_names.length")->Int32Value());
4434
4435  // Check the expected number of properties.
4436  const char* source;
4437  source = "named_mirror.properties().length";
4438  CHECK_EQ(3, CompileRun(source)->Int32Value());
4439
4440  source = "indexed_mirror.properties().length";
4441  CHECK_EQ(2, CompileRun(source)->Int32Value());
4442
4443  source = "both_mirror.properties().length";
4444  CHECK_EQ(5, CompileRun(source)->Int32Value());
4445
4446  // 1 is PropertyKind.Named;
4447  source = "both_mirror.properties(1).length";
4448  CHECK_EQ(3, CompileRun(source)->Int32Value());
4449
4450  // 2 is PropertyKind.Indexed;
4451  source = "both_mirror.properties(2).length";
4452  CHECK_EQ(2, CompileRun(source)->Int32Value());
4453
4454  // 3 is PropertyKind.Named  | PropertyKind.Indexed;
4455  source = "both_mirror.properties(3).length";
4456  CHECK_EQ(5, CompileRun(source)->Int32Value());
4457
4458  // Get the interceptor properties for the object with only named interceptor.
4459  CompileRun("var named_values = named_mirror.properties()");
4460
4461  // Check that the properties are interceptor properties.
4462  for (int i = 0; i < 3; i++) {
4463    EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
4464    SNPrintF(buffer,
4465             "named_values[%d] instanceof debug.PropertyMirror", i);
4466    CHECK(CompileRun(buffer.start())->BooleanValue());
4467
4468    SNPrintF(buffer, "named_values[%d].isNative()", i);
4469    CHECK(CompileRun(buffer.start())->BooleanValue());
4470  }
4471
4472  // Get the interceptor properties for the object with only indexed
4473  // interceptor.
4474  CompileRun("var indexed_values = indexed_mirror.properties()");
4475
4476  // Check that the properties are interceptor properties.
4477  for (int i = 0; i < 2; i++) {
4478    EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
4479    SNPrintF(buffer,
4480             "indexed_values[%d] instanceof debug.PropertyMirror", i);
4481    CHECK(CompileRun(buffer.start())->BooleanValue());
4482  }
4483
4484  // Get the interceptor properties for the object with both types of
4485  // interceptors.
4486  CompileRun("var both_values = both_mirror.properties()");
4487
4488  // Check that the properties are interceptor properties.
4489  for (int i = 0; i < 5; i++) {
4490    EmbeddedVector<char, SMALL_STRING_BUFFER_SIZE> buffer;
4491    SNPrintF(buffer, "both_values[%d] instanceof debug.PropertyMirror", i);
4492    CHECK(CompileRun(buffer.start())->BooleanValue());
4493  }
4494
4495  // Check the property names.
4496  source = "both_values[0].name() == 'a'";
4497  CHECK(CompileRun(source)->BooleanValue());
4498
4499  source = "both_values[1].name() == 'b'";
4500  CHECK(CompileRun(source)->BooleanValue());
4501
4502  source = "both_values[2].name() == 'c'";
4503  CHECK(CompileRun(source)->BooleanValue());
4504
4505  source = "both_values[3].name() == 1";
4506  CHECK(CompileRun(source)->BooleanValue());
4507
4508  source = "both_values[4].name() == 10";
4509  CHECK(CompileRun(source)->BooleanValue());
4510}
4511
4512
4513TEST(HiddenPrototypePropertyMirror) {
4514  // Create a V8 environment with debug access.
4515  DebugLocalContext env;
4516  v8::Isolate* isolate = env->GetIsolate();
4517  v8::HandleScope scope(isolate);
4518  env.ExposeDebug();
4519
4520  v8::Handle<v8::FunctionTemplate> t0 = v8::FunctionTemplate::New(isolate);
4521  t0->InstanceTemplate()->Set(v8::String::NewFromUtf8(isolate, "x"),
4522                              v8::Number::New(isolate, 0));
4523  v8::Handle<v8::FunctionTemplate> t1 = v8::FunctionTemplate::New(isolate);
4524  t1->SetHiddenPrototype(true);
4525  t1->InstanceTemplate()->Set(v8::String::NewFromUtf8(isolate, "y"),
4526                              v8::Number::New(isolate, 1));
4527  v8::Handle<v8::FunctionTemplate> t2 = v8::FunctionTemplate::New(isolate);
4528  t2->SetHiddenPrototype(true);
4529  t2->InstanceTemplate()->Set(v8::String::NewFromUtf8(isolate, "z"),
4530                              v8::Number::New(isolate, 2));
4531  v8::Handle<v8::FunctionTemplate> t3 = v8::FunctionTemplate::New(isolate);
4532  t3->InstanceTemplate()->Set(v8::String::NewFromUtf8(isolate, "u"),
4533                              v8::Number::New(isolate, 3));
4534
4535  // Create object and set them on the global object.
4536  v8::Handle<v8::Object> o0 = t0->GetFunction()->NewInstance();
4537  env->Global()->Set(v8::String::NewFromUtf8(isolate, "o0"), o0);
4538  v8::Handle<v8::Object> o1 = t1->GetFunction()->NewInstance();
4539  env->Global()->Set(v8::String::NewFromUtf8(isolate, "o1"), o1);
4540  v8::Handle<v8::Object> o2 = t2->GetFunction()->NewInstance();
4541  env->Global()->Set(v8::String::NewFromUtf8(isolate, "o2"), o2);
4542  v8::Handle<v8::Object> o3 = t3->GetFunction()->NewInstance();
4543  env->Global()->Set(v8::String::NewFromUtf8(isolate, "o3"), o3);
4544
4545  // Get mirrors for the four objects.
4546  CompileRun(
4547      "var o0_mirror = debug.MakeMirror(o0);"
4548      "var o1_mirror = debug.MakeMirror(o1);"
4549      "var o2_mirror = debug.MakeMirror(o2);"
4550      "var o3_mirror = debug.MakeMirror(o3)");
4551  CHECK(CompileRun("o0_mirror instanceof debug.ObjectMirror")->BooleanValue());
4552  CHECK(CompileRun("o1_mirror instanceof debug.ObjectMirror")->BooleanValue());
4553  CHECK(CompileRun("o2_mirror instanceof debug.ObjectMirror")->BooleanValue());
4554  CHECK(CompileRun("o3_mirror instanceof debug.ObjectMirror")->BooleanValue());
4555
4556  // Check that each object has one property.
4557  CHECK_EQ(1, CompileRun(
4558              "o0_mirror.propertyNames().length")->Int32Value());
4559  CHECK_EQ(1, CompileRun(
4560              "o1_mirror.propertyNames().length")->Int32Value());
4561  CHECK_EQ(1, CompileRun(
4562              "o2_mirror.propertyNames().length")->Int32Value());
4563  CHECK_EQ(1, CompileRun(
4564              "o3_mirror.propertyNames().length")->Int32Value());
4565
4566  // Set o1 as prototype for o0. o1 has the hidden prototype flag so all
4567  // properties on o1 should be seen on o0.
4568  o0->Set(v8::String::NewFromUtf8(isolate, "__proto__"), o1);
4569  CHECK_EQ(2, CompileRun(
4570              "o0_mirror.propertyNames().length")->Int32Value());
4571  CHECK_EQ(0, CompileRun(
4572              "o0_mirror.property('x').value().value()")->Int32Value());
4573  CHECK_EQ(1, CompileRun(
4574              "o0_mirror.property('y').value().value()")->Int32Value());
4575
4576  // Set o2 as prototype for o0 (it will end up after o1 as o1 has the hidden
4577  // prototype flag. o2 also has the hidden prototype flag so all properties
4578  // on o2 should be seen on o0 as well as properties on o1.
4579  o0->Set(v8::String::NewFromUtf8(isolate, "__proto__"), o2);
4580  CHECK_EQ(3, CompileRun(
4581              "o0_mirror.propertyNames().length")->Int32Value());
4582  CHECK_EQ(0, CompileRun(
4583              "o0_mirror.property('x').value().value()")->Int32Value());
4584  CHECK_EQ(1, CompileRun(
4585              "o0_mirror.property('y').value().value()")->Int32Value());
4586  CHECK_EQ(2, CompileRun(
4587              "o0_mirror.property('z').value().value()")->Int32Value());
4588
4589  // Set o3 as prototype for o0 (it will end up after o1 and o2 as both o1 and
4590  // o2 has the hidden prototype flag. o3 does not have the hidden prototype
4591  // flag so properties on o3 should not be seen on o0 whereas the properties
4592  // from o1 and o2 should still be seen on o0.
4593  // Final prototype chain: o0 -> o1 -> o2 -> o3
4594  // Hidden prototypes:           ^^    ^^
4595  o0->Set(v8::String::NewFromUtf8(isolate, "__proto__"), o3);
4596  CHECK_EQ(3, CompileRun(
4597              "o0_mirror.propertyNames().length")->Int32Value());
4598  CHECK_EQ(1, CompileRun(
4599              "o3_mirror.propertyNames().length")->Int32Value());
4600  CHECK_EQ(0, CompileRun(
4601              "o0_mirror.property('x').value().value()")->Int32Value());
4602  CHECK_EQ(1, CompileRun(
4603              "o0_mirror.property('y').value().value()")->Int32Value());
4604  CHECK_EQ(2, CompileRun(
4605              "o0_mirror.property('z').value().value()")->Int32Value());
4606  CHECK(CompileRun("o0_mirror.property('u').isUndefined()")->BooleanValue());
4607
4608  // The prototype (__proto__) for o0 should be o3 as o1 and o2 are hidden.
4609  CHECK(CompileRun("o0_mirror.protoObject() == o3_mirror")->BooleanValue());
4610}
4611
4612
4613static void ProtperyXNativeGetter(
4614    v8::Local<v8::String> property,
4615    const v8::PropertyCallbackInfo<v8::Value>& info) {
4616  info.GetReturnValue().Set(10);
4617}
4618
4619
4620TEST(NativeGetterPropertyMirror) {
4621  // Create a V8 environment with debug access.
4622  DebugLocalContext env;
4623  v8::Isolate* isolate = env->GetIsolate();
4624  v8::HandleScope scope(isolate);
4625  env.ExposeDebug();
4626
4627  v8::Handle<v8::String> name = v8::String::NewFromUtf8(isolate, "x");
4628  // Create object with named accessor.
4629  v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New(isolate);
4630  named->SetAccessor(name, &ProtperyXNativeGetter, NULL,
4631      v8::Handle<v8::Value>(), v8::DEFAULT, v8::None);
4632
4633  // Create object with named property getter.
4634  env->Global()->Set(v8::String::NewFromUtf8(isolate, "instance"),
4635                     named->NewInstance());
4636  CHECK_EQ(10, CompileRun("instance.x")->Int32Value());
4637
4638  // Get mirror for the object with property getter.
4639  CompileRun("var instance_mirror = debug.MakeMirror(instance);");
4640  CHECK(CompileRun(
4641      "instance_mirror instanceof debug.ObjectMirror")->BooleanValue());
4642
4643  CompileRun("var named_names = instance_mirror.propertyNames();");
4644  CHECK_EQ(1, CompileRun("named_names.length")->Int32Value());
4645  CHECK(CompileRun("named_names[0] == 'x'")->BooleanValue());
4646  CHECK(CompileRun(
4647      "instance_mirror.property('x').value().isNumber()")->BooleanValue());
4648  CHECK(CompileRun(
4649      "instance_mirror.property('x').value().value() == 10")->BooleanValue());
4650}
4651
4652
4653static void ProtperyXNativeGetterThrowingError(
4654    v8::Local<v8::String> property,
4655    const v8::PropertyCallbackInfo<v8::Value>& info) {
4656  CompileRun("throw new Error('Error message');");
4657}
4658
4659
4660TEST(NativeGetterThrowingErrorPropertyMirror) {
4661  // Create a V8 environment with debug access.
4662  DebugLocalContext env;
4663  v8::Isolate* isolate = env->GetIsolate();
4664  v8::HandleScope scope(isolate);
4665  env.ExposeDebug();
4666
4667  v8::Handle<v8::String> name = v8::String::NewFromUtf8(isolate, "x");
4668  // Create object with named accessor.
4669  v8::Handle<v8::ObjectTemplate> named = v8::ObjectTemplate::New(isolate);
4670  named->SetAccessor(name, &ProtperyXNativeGetterThrowingError, NULL,
4671      v8::Handle<v8::Value>(), v8::DEFAULT, v8::None);
4672
4673  // Create object with named property getter.
4674  env->Global()->Set(v8::String::NewFromUtf8(isolate, "instance"),
4675                     named->NewInstance());
4676
4677  // Get mirror for the object with property getter.
4678  CompileRun("var instance_mirror = debug.MakeMirror(instance);");
4679  CHECK(CompileRun(
4680      "instance_mirror instanceof debug.ObjectMirror")->BooleanValue());
4681  CompileRun("named_names = instance_mirror.propertyNames();");
4682  CHECK_EQ(1, CompileRun("named_names.length")->Int32Value());
4683  CHECK(CompileRun("named_names[0] == 'x'")->BooleanValue());
4684  CHECK(CompileRun(
4685      "instance_mirror.property('x').value().isError()")->BooleanValue());
4686
4687  // Check that the message is that passed to the Error constructor.
4688  CHECK(CompileRun(
4689      "instance_mirror.property('x').value().message() == 'Error message'")->
4690          BooleanValue());
4691}
4692
4693
4694// Test that hidden properties object is not returned as an unnamed property
4695// among regular properties.
4696// See http://crbug.com/26491
4697TEST(NoHiddenProperties) {
4698  // Create a V8 environment with debug access.
4699  DebugLocalContext env;
4700  v8::Isolate* isolate = env->GetIsolate();
4701  v8::HandleScope scope(isolate);
4702  env.ExposeDebug();
4703
4704  // Create an object in the global scope.
4705  const char* source = "var obj = {a: 1};";
4706  v8::Script::Compile(v8::String::NewFromUtf8(isolate, source))
4707      ->Run();
4708  v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(
4709      env->Global()->Get(v8::String::NewFromUtf8(isolate, "obj")));
4710  // Set a hidden property on the object.
4711  obj->SetHiddenValue(
4712      v8::String::NewFromUtf8(isolate, "v8::test-debug::a"),
4713      v8::Int32::New(isolate, 11));
4714
4715  // Get mirror for the object with property getter.
4716  CompileRun("var obj_mirror = debug.MakeMirror(obj);");
4717  CHECK(CompileRun(
4718      "obj_mirror instanceof debug.ObjectMirror")->BooleanValue());
4719  CompileRun("var named_names = obj_mirror.propertyNames();");
4720  // There should be exactly one property. But there is also an unnamed
4721  // property whose value is hidden properties dictionary. The latter
4722  // property should not be in the list of reguar properties.
4723  CHECK_EQ(1, CompileRun("named_names.length")->Int32Value());
4724  CHECK(CompileRun("named_names[0] == 'a'")->BooleanValue());
4725  CHECK(CompileRun(
4726      "obj_mirror.property('a').value().value() == 1")->BooleanValue());
4727
4728  // Object created by t0 will become hidden prototype of object 'obj'.
4729  v8::Handle<v8::FunctionTemplate> t0 = v8::FunctionTemplate::New(isolate);
4730  t0->InstanceTemplate()->Set(v8::String::NewFromUtf8(isolate, "b"),
4731                              v8::Number::New(isolate, 2));
4732  t0->SetHiddenPrototype(true);
4733  v8::Handle<v8::FunctionTemplate> t1 = v8::FunctionTemplate::New(isolate);
4734  t1->InstanceTemplate()->Set(v8::String::NewFromUtf8(isolate, "c"),
4735                              v8::Number::New(isolate, 3));
4736
4737  // Create proto objects, add hidden properties to them and set them on
4738  // the global object.
4739  v8::Handle<v8::Object> protoObj = t0->GetFunction()->NewInstance();
4740  protoObj->SetHiddenValue(
4741      v8::String::NewFromUtf8(isolate, "v8::test-debug::b"),
4742      v8::Int32::New(isolate, 12));
4743  env->Global()->Set(v8::String::NewFromUtf8(isolate, "protoObj"),
4744                     protoObj);
4745  v8::Handle<v8::Object> grandProtoObj = t1->GetFunction()->NewInstance();
4746  grandProtoObj->SetHiddenValue(
4747      v8::String::NewFromUtf8(isolate, "v8::test-debug::c"),
4748      v8::Int32::New(isolate, 13));
4749  env->Global()->Set(
4750      v8::String::NewFromUtf8(isolate, "grandProtoObj"),
4751      grandProtoObj);
4752
4753  // Setting prototypes: obj->protoObj->grandProtoObj
4754  protoObj->Set(v8::String::NewFromUtf8(isolate, "__proto__"),
4755                grandProtoObj);
4756  obj->Set(v8::String::NewFromUtf8(isolate, "__proto__"), protoObj);
4757
4758  // Get mirror for the object with property getter.
4759  CompileRun("var obj_mirror = debug.MakeMirror(obj);");
4760  CHECK(CompileRun(
4761      "obj_mirror instanceof debug.ObjectMirror")->BooleanValue());
4762  CompileRun("var named_names = obj_mirror.propertyNames();");
4763  // There should be exactly two properties - one from the object itself and
4764  // another from its hidden prototype.
4765  CHECK_EQ(2, CompileRun("named_names.length")->Int32Value());
4766  CHECK(CompileRun("named_names.sort(); named_names[0] == 'a' &&"
4767                   "named_names[1] == 'b'")->BooleanValue());
4768  CHECK(CompileRun(
4769      "obj_mirror.property('a').value().value() == 1")->BooleanValue());
4770  CHECK(CompileRun(
4771      "obj_mirror.property('b').value().value() == 2")->BooleanValue());
4772}
4773
4774
4775// Multithreaded tests of JSON debugger protocol
4776
4777// Support classes
4778
4779// Provides synchronization between N threads, where N is a template parameter.
4780// The Wait() call blocks a thread until it is called for the Nth time, then all
4781// calls return.  Each ThreadBarrier object can only be used once.
4782template <int N>
4783class ThreadBarrier FINAL {
4784 public:
4785  ThreadBarrier() : num_blocked_(0) {}
4786
4787  ~ThreadBarrier() {
4788    LockGuard<Mutex> lock_guard(&mutex_);
4789    if (num_blocked_ != 0) {
4790      CHECK_EQ(N, num_blocked_);
4791    }
4792  }
4793
4794  void Wait() {
4795    LockGuard<Mutex> lock_guard(&mutex_);
4796    CHECK_LT(num_blocked_, N);
4797    num_blocked_++;
4798    if (N == num_blocked_) {
4799      // Signal and unblock all waiting threads.
4800      cv_.NotifyAll();
4801      printf("BARRIER\n\n");
4802      fflush(stdout);
4803    } else {  // Wait for the semaphore.
4804      while (num_blocked_ < N) {
4805        cv_.Wait(&mutex_);
4806      }
4807    }
4808    CHECK_EQ(N, num_blocked_);
4809  }
4810
4811 private:
4812  ConditionVariable cv_;
4813  Mutex mutex_;
4814  int num_blocked_;
4815
4816  STATIC_ASSERT(N > 0);
4817
4818  DISALLOW_COPY_AND_ASSIGN(ThreadBarrier);
4819};
4820
4821
4822// A set containing enough barriers and semaphores for any of the tests.
4823class Barriers {
4824 public:
4825  Barriers() : semaphore_1(0), semaphore_2(0) {}
4826  ThreadBarrier<2> barrier_1;
4827  ThreadBarrier<2> barrier_2;
4828  ThreadBarrier<2> barrier_3;
4829  ThreadBarrier<2> barrier_4;
4830  ThreadBarrier<2> barrier_5;
4831  v8::base::Semaphore semaphore_1;
4832  v8::base::Semaphore semaphore_2;
4833};
4834
4835
4836// We match parts of the message to decide if it is a break message.
4837bool IsBreakEventMessage(char *message) {
4838  const char* type_event = "\"type\":\"event\"";
4839  const char* event_break = "\"event\":\"break\"";
4840  // Does the message contain both type:event and event:break?
4841  return strstr(message, type_event) != NULL &&
4842         strstr(message, event_break) != NULL;
4843}
4844
4845
4846// We match parts of the message to decide if it is a exception message.
4847bool IsExceptionEventMessage(char *message) {
4848  const char* type_event = "\"type\":\"event\"";
4849  const char* event_exception = "\"event\":\"exception\"";
4850  // Does the message contain both type:event and event:exception?
4851  return strstr(message, type_event) != NULL &&
4852      strstr(message, event_exception) != NULL;
4853}
4854
4855
4856// We match the message wether it is an evaluate response message.
4857bool IsEvaluateResponseMessage(char* message) {
4858  const char* type_response = "\"type\":\"response\"";
4859  const char* command_evaluate = "\"command\":\"evaluate\"";
4860  // Does the message contain both type:response and command:evaluate?
4861  return strstr(message, type_response) != NULL &&
4862         strstr(message, command_evaluate) != NULL;
4863}
4864
4865
4866static int StringToInt(const char* s) {
4867  return atoi(s);  // NOLINT
4868}
4869
4870
4871// We match parts of the message to get evaluate result int value.
4872int GetEvaluateIntResult(char *message) {
4873  const char* value = "\"value\":";
4874  char* pos = strstr(message, value);
4875  if (pos == NULL) {
4876    return -1;
4877  }
4878  int res = -1;
4879  res = StringToInt(pos + strlen(value));
4880  return res;
4881}
4882
4883
4884// We match parts of the message to get hit breakpoint id.
4885int GetBreakpointIdFromBreakEventMessage(char *message) {
4886  const char* breakpoints = "\"breakpoints\":[";
4887  char* pos = strstr(message, breakpoints);
4888  if (pos == NULL) {
4889    return -1;
4890  }
4891  int res = -1;
4892  res = StringToInt(pos + strlen(breakpoints));
4893  return res;
4894}
4895
4896
4897// We match parts of the message to get total frames number.
4898int GetTotalFramesInt(char *message) {
4899  const char* prefix = "\"totalFrames\":";
4900  char* pos = strstr(message, prefix);
4901  if (pos == NULL) {
4902    return -1;
4903  }
4904  pos += strlen(prefix);
4905  int res = StringToInt(pos);
4906  return res;
4907}
4908
4909
4910// We match parts of the message to get source line.
4911int GetSourceLineFromBreakEventMessage(char *message) {
4912  const char* source_line = "\"sourceLine\":";
4913  char* pos = strstr(message, source_line);
4914  if (pos == NULL) {
4915    return -1;
4916  }
4917  int res = -1;
4918  res = StringToInt(pos + strlen(source_line));
4919  return res;
4920}
4921
4922
4923/* Test MessageQueues */
4924/* Tests the message queues that hold debugger commands and
4925 * response messages to the debugger.  Fills queues and makes
4926 * them grow.
4927 */
4928Barriers message_queue_barriers;
4929
4930// This is the debugger thread, that executes no v8 calls except
4931// placing JSON debugger commands in the queue.
4932class MessageQueueDebuggerThread : public v8::base::Thread {
4933 public:
4934  MessageQueueDebuggerThread()
4935      : Thread(Options("MessageQueueDebuggerThread")) {}
4936  void Run();
4937};
4938
4939
4940static void MessageHandler(const v8::Debug::Message& message) {
4941  v8::Handle<v8::String> json = message.GetJSON();
4942  v8::String::Utf8Value utf8(json);
4943  if (IsBreakEventMessage(*utf8)) {
4944    // Lets test script wait until break occurs to send commands.
4945    // Signals when a break is reported.
4946    message_queue_barriers.semaphore_2.Signal();
4947  }
4948
4949  // Allow message handler to block on a semaphore, to test queueing of
4950  // messages while blocked.
4951  message_queue_barriers.semaphore_1.Wait();
4952}
4953
4954
4955void MessageQueueDebuggerThread::Run() {
4956  const int kBufferSize = 1000;
4957  uint16_t buffer_1[kBufferSize];
4958  uint16_t buffer_2[kBufferSize];
4959  const char* command_1 =
4960      "{\"seq\":117,"
4961       "\"type\":\"request\","
4962       "\"command\":\"evaluate\","
4963       "\"arguments\":{\"expression\":\"1+2\"}}";
4964  const char* command_2 =
4965    "{\"seq\":118,"
4966     "\"type\":\"request\","
4967     "\"command\":\"evaluate\","
4968     "\"arguments\":{\"expression\":\"1+a\"}}";
4969  const char* command_3 =
4970    "{\"seq\":119,"
4971     "\"type\":\"request\","
4972     "\"command\":\"evaluate\","
4973     "\"arguments\":{\"expression\":\"c.d * b\"}}";
4974  const char* command_continue =
4975    "{\"seq\":106,"
4976     "\"type\":\"request\","
4977     "\"command\":\"continue\"}";
4978  const char* command_single_step =
4979    "{\"seq\":107,"
4980     "\"type\":\"request\","
4981     "\"command\":\"continue\","
4982     "\"arguments\":{\"stepaction\":\"next\"}}";
4983
4984  /* Interleaved sequence of actions by the two threads:*/
4985  // Main thread compiles and runs source_1
4986  message_queue_barriers.semaphore_1.Signal();
4987  message_queue_barriers.barrier_1.Wait();
4988  // Post 6 commands, filling the command queue and making it expand.
4989  // These calls return immediately, but the commands stay on the queue
4990  // until the execution of source_2.
4991  // Note: AsciiToUtf16 executes before SendCommand, so command is copied
4992  // to buffer before buffer is sent to SendCommand.
4993  v8::Isolate* isolate = CcTest::isolate();
4994  v8::Debug::SendCommand(isolate, buffer_1, AsciiToUtf16(command_1, buffer_1));
4995  v8::Debug::SendCommand(isolate, buffer_2, AsciiToUtf16(command_2, buffer_2));
4996  v8::Debug::SendCommand(isolate, buffer_2, AsciiToUtf16(command_3, buffer_2));
4997  v8::Debug::SendCommand(isolate, buffer_2, AsciiToUtf16(command_3, buffer_2));
4998  v8::Debug::SendCommand(isolate, buffer_2, AsciiToUtf16(command_3, buffer_2));
4999  message_queue_barriers.barrier_2.Wait();
5000  // Main thread compiles and runs source_2.
5001  // Queued commands are executed at the start of compilation of source_2(
5002  // beforeCompile event).
5003  // Free the message handler to process all the messages from the queue. 7
5004  // messages are expected: 2 afterCompile events and 5 responses.
5005  // All the commands added so far will fail to execute as long as call stack
5006  // is empty on beforeCompile event.
5007  for (int i = 0; i < 6 ; ++i) {
5008    message_queue_barriers.semaphore_1.Signal();
5009  }
5010  message_queue_barriers.barrier_3.Wait();
5011  // Main thread compiles and runs source_3.
5012  // Don't stop in the afterCompile handler.
5013  message_queue_barriers.semaphore_1.Signal();
5014  // source_3 includes a debugger statement, which causes a break event.
5015  // Wait on break event from hitting "debugger" statement
5016  message_queue_barriers.semaphore_2.Wait();
5017  // These should execute after the "debugger" statement in source_2
5018  v8::Debug::SendCommand(isolate, buffer_1, AsciiToUtf16(command_1, buffer_1));
5019  v8::Debug::SendCommand(isolate, buffer_2, AsciiToUtf16(command_2, buffer_2));
5020  v8::Debug::SendCommand(isolate, buffer_2, AsciiToUtf16(command_3, buffer_2));
5021  v8::Debug::SendCommand(
5022      isolate, buffer_2, AsciiToUtf16(command_single_step, buffer_2));
5023  // Run after 2 break events, 4 responses.
5024  for (int i = 0; i < 6 ; ++i) {
5025    message_queue_barriers.semaphore_1.Signal();
5026  }
5027  // Wait on break event after a single step executes.
5028  message_queue_barriers.semaphore_2.Wait();
5029  v8::Debug::SendCommand(isolate, buffer_1, AsciiToUtf16(command_2, buffer_1));
5030  v8::Debug::SendCommand(
5031      isolate, buffer_2, AsciiToUtf16(command_continue, buffer_2));
5032  // Run after 2 responses.
5033  for (int i = 0; i < 2 ; ++i) {
5034    message_queue_barriers.semaphore_1.Signal();
5035  }
5036  // Main thread continues running source_3 to end, waits for this thread.
5037}
5038
5039
5040// This thread runs the v8 engine.
5041TEST(MessageQueues) {
5042  MessageQueueDebuggerThread message_queue_debugger_thread;
5043
5044  // Create a V8 environment
5045  DebugLocalContext env;
5046  v8::HandleScope scope(env->GetIsolate());
5047  v8::Debug::SetMessageHandler(MessageHandler);
5048  message_queue_debugger_thread.Start();
5049
5050  const char* source_1 = "a = 3; b = 4; c = new Object(); c.d = 5;";
5051  const char* source_2 = "e = 17;";
5052  const char* source_3 = "a = 4; debugger; a = 5; a = 6; a = 7;";
5053
5054  // See MessageQueueDebuggerThread::Run for interleaved sequence of
5055  // API calls and events in the two threads.
5056  CompileRun(source_1);
5057  message_queue_barriers.barrier_1.Wait();
5058  message_queue_barriers.barrier_2.Wait();
5059  CompileRun(source_2);
5060  message_queue_barriers.barrier_3.Wait();
5061  CompileRun(source_3);
5062  message_queue_debugger_thread.Join();
5063  fflush(stdout);
5064}
5065
5066
5067class TestClientData : public v8::Debug::ClientData {
5068 public:
5069  TestClientData() {
5070    constructor_call_counter++;
5071  }
5072  virtual ~TestClientData() {
5073    destructor_call_counter++;
5074  }
5075
5076  static void ResetCounters() {
5077    constructor_call_counter = 0;
5078    destructor_call_counter = 0;
5079  }
5080
5081  static int constructor_call_counter;
5082  static int destructor_call_counter;
5083};
5084
5085int TestClientData::constructor_call_counter = 0;
5086int TestClientData::destructor_call_counter = 0;
5087
5088
5089// Tests that MessageQueue doesn't destroy client data when expands and
5090// does destroy when it dies.
5091TEST(MessageQueueExpandAndDestroy) {
5092  TestClientData::ResetCounters();
5093  { // Create a scope for the queue.
5094    CommandMessageQueue queue(1);
5095    queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
5096                                  new TestClientData()));
5097    queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
5098                                  new TestClientData()));
5099    queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
5100                                  new TestClientData()));
5101    CHECK_EQ(0, TestClientData::destructor_call_counter);
5102    queue.Get().Dispose();
5103    CHECK_EQ(1, TestClientData::destructor_call_counter);
5104    queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
5105                                  new TestClientData()));
5106    queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
5107                                  new TestClientData()));
5108    queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
5109                                  new TestClientData()));
5110    queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
5111                                  new TestClientData()));
5112    queue.Put(CommandMessage::New(Vector<uint16_t>::empty(),
5113                                  new TestClientData()));
5114    CHECK_EQ(1, TestClientData::destructor_call_counter);
5115    queue.Get().Dispose();
5116    CHECK_EQ(2, TestClientData::destructor_call_counter);
5117  }
5118  // All the client data should be destroyed when the queue is destroyed.
5119  CHECK_EQ(TestClientData::destructor_call_counter,
5120           TestClientData::destructor_call_counter);
5121}
5122
5123
5124static int handled_client_data_instances_count = 0;
5125static void MessageHandlerCountingClientData(
5126    const v8::Debug::Message& message) {
5127  if (message.GetClientData() != NULL) {
5128    handled_client_data_instances_count++;
5129  }
5130}
5131
5132
5133// Tests that all client data passed to the debugger are sent to the handler.
5134TEST(SendClientDataToHandler) {
5135  // Create a V8 environment
5136  DebugLocalContext env;
5137  v8::Isolate* isolate = env->GetIsolate();
5138  v8::HandleScope scope(isolate);
5139  TestClientData::ResetCounters();
5140  handled_client_data_instances_count = 0;
5141  v8::Debug::SetMessageHandler(MessageHandlerCountingClientData);
5142  const char* source_1 = "a = 3; b = 4; c = new Object(); c.d = 5;";
5143  const int kBufferSize = 1000;
5144  uint16_t buffer[kBufferSize];
5145  const char* command_1 =
5146      "{\"seq\":117,"
5147       "\"type\":\"request\","
5148       "\"command\":\"evaluate\","
5149       "\"arguments\":{\"expression\":\"1+2\"}}";
5150  const char* command_2 =
5151    "{\"seq\":118,"
5152     "\"type\":\"request\","
5153     "\"command\":\"evaluate\","
5154     "\"arguments\":{\"expression\":\"1+a\"}}";
5155  const char* command_continue =
5156    "{\"seq\":106,"
5157     "\"type\":\"request\","
5158     "\"command\":\"continue\"}";
5159
5160  v8::Debug::SendCommand(isolate, buffer, AsciiToUtf16(command_1, buffer),
5161                         new TestClientData());
5162  v8::Debug::