Lines Matching refs:TEST
931 // Test that the debug break function is the expected one for different kinds
933 TEST(DebugStub) {
954 // TODO(1240753): Make the test architecture independent or split
1001 // Test that the debug info in the VM is in sync with the functions being
1003 TEST(DebugInfo) {
1006 // Create a couple of functions for the test.
1038 // Test that a break point can be set at an IC store location.
1039 TEST(BreakPointICStore) {
1071 // Test that a break point can be set at an IC load location.
1072 TEST(BreakPointICLoad) {
1104 // Test that a break point can be set at an IC call location.
1105 TEST(BreakPointICCall) {
1137 // Test that a break point can be set at a return store location.
1138 TEST(BreakPointReturn) {
1195 // Test GC during break point processing.
1196 TEST(GCDuringBreakPointProcessing) {
1205 // Test IC store break point with garbage collection.
1210 // Test IC load break point with garbage collection.
1215 // Test IC call break point with garbage collection.
1220 // Test return break point with garbage collection.
1253 // Test that a break point can be set at a return store location.
1254 TEST(BreakPointSurviveGC) {
1263 // Test IC store break point with garbage collection.
1268 // Test IC load break point with garbage collection.
1273 // Test IC call break point with garbage collection.
1278 // Test return break point with garbage collection.
1288 // Test that break points can be set using the global Debug object.
1289 TEST(BreakPointThroughJavaScript) {
1343 // Test that break points on scripts identified by name can be set using the
1345 TEST(ScriptBreakPointByNameThroughJavaScript) {
1375 v8::ScriptOrigin(v8::String::New("test"));
1390 int sbp1 = SetScriptBreakPointByNameFromJS("test", 12, 0);
1406 int sbp2 = SetScriptBreakPointByNameFromJS("test", 2, 0);
1414 int sbp3 = SetScriptBreakPointByNameFromJS("test", 4, 0);
1415 int sbp4 = SetScriptBreakPointByNameFromJS("test", 12, 0);
1416 int sbp5 = SetScriptBreakPointByNameFromJS("test", 14, 0);
1417 int sbp6 = SetScriptBreakPointByNameFromJS("test", 15, 0);
1449 TEST(ScriptBreakPointByIdThroughJavaScript) {
1479 v8::ScriptOrigin(v8::String::New("test"));
1557 // Test conditional script break points.
1558 TEST(EnableDisableScriptBreakPoint) {
1574 v8::ScriptOrigin(v8::String::New("test"));
1580 int sbp = SetScriptBreakPointByNameFromJS("test", 1, 0);
1614 // Test conditional script break points.
1615 TEST(ConditionalScriptBreakPoint) {
1635 v8::ScriptOrigin(v8::String::New("test"));
1641 int sbp1 = SetScriptBreakPointByNameFromJS("test", 5, 0);
1676 // Test ignore count on script break points.
1677 TEST(ScriptBreakPointIgnoreCount) {
1693 v8::ScriptOrigin(v8::String::New("test"));
1699 int sbp = SetScriptBreakPointByNameFromJS("test", 1, 0);
1731 // Test that script break points survive when a script is reloaded.
1732 TEST(ScriptBreakPointReload) {
1790 // Test when several scripts has the same script data
1791 TEST(ScriptBreakPointMultiple) {
1813 v8::ScriptOrigin(v8::String::New("test"));
1816 int sbp = SetScriptBreakPointByNameFromJS("test", 1, 0);
1842 sbp = SetScriptBreakPointByNameFromJS("test", 1, 0);
1856 // Test the script origin which has both name and line offset.
1857 TEST(ScriptBreakPointLineOffset) {
1874 v8::ScriptOrigin origin(v8::String::New("test.html"),
1878 int sbp1 = SetScriptBreakPointByNameFromJS("test.html", 8, 0);
1879 int sbp2 = SetScriptBreakPointByNameFromJS("test.html", 9, 0);
1900 sbp1 = SetScriptBreakPointByNameFromJS("test
1912 // Test script break points set on lines.
1913 TEST(ScriptBreakPointLine) {
1944 int sbp1 = SetScriptBreakPointByNameFromJS("test.html", 0, -1);
1945 int sbp2 = SetScriptBreakPointByNameFromJS("test.html", 1, -1);
1946 int sbp3 = SetScriptBreakPointByNameFromJS("test.html", 5, -1);
1950 v8::ScriptOrigin origin(v8::String::New("test.html"), v8::Integer::New(0));
1971 int sbp4 = SetScriptBreakPointByNameFromJS("test.html", 6, -1);
1979 // functions f and g and test that there is no break points in f and g any
1983 int sbp5 = SetScriptBreakPointByNameFromJS("test.html", 4, -1);
1996 int sbp6 = SetScriptBreakPointByNameFromJS("test.html", 12, -1);
2018 // Test that it is possible to remove the last break point for a function
2020 TEST(RemoveBreakPointInBreak) {
2044 // Test that the debugger statement causes a break.
2045 TEST(DebuggerStatement) {
2072 // Test setting a breakpoint on the debugger statement.
2073 TEST(DebuggerStatementBreakpoint) {
2101 TEST(DebugEvaluate) {
2131 // Simple test function. The "y=0" is in the function foo to provide a break
2162 // Test function with an inner function. The "y=0" is in function barbar
2313 // Test that the evaluation of expressions works even from ProcessDebugMessages
2315 TEST(DebugEvaluateWithoutStack) {
2376 // Simple test of the stepping mechanism using only store ICs.
2377 TEST(DebugStepLinear) {
2415 Test of the stepping mechanism for keyed load in a loop.
2416 TEST(DebugStepKeyedLoadLoop) {
2462 // Test of the stepping mechanism for keyed store in a loop.
2463 TEST(DebugStepKeyedStoreLoop) {
2508 // Test the stepping mechanism with different ICs.
2509 TEST(DebugStepLinearMixedICs) {
2551 TEST(DebugStepIf) {
2592 TEST(DebugStepSwitch) {
2645 TEST(DebugStepFor) {
2683 TEST(StepInOutSimple) {
2732 TEST(StepInOutTree) {
2782 TEST(StepInOutBranch) {
2815 // Test that step in does not step into native functions.
2816 TEST(DebugStepNatives) {
2853 // Test that step in works with function.apply.
2854 TEST(DebugStepFunctionApply) {
2892 // Test that step in works with function.call.
2893 TEST(DebugStepFunctionCall) {
2944 TEST(PauseInScript) {
2974 // Test break on exceptions. For each exception break combination the number
2980 TEST(BreakOnException) {
3122 // Test break on exception from compiler errors. When compiling using
3125 TEST(BreakOnCompileException) {
3176 TEST(StepWithException) {
3264 TEST(DebugBreak) {
3268 // This test should be run with option --verify-heap. As --verify-heap is
3320 // Test to ensure that JavaScript code keeps running while the debug break
3322 TEST(DisableBreak) {
3362 // Test that debug break is disabled when bootstrapper is active.
3363 TEST(NoBreakWhenBootstrapping) {
3430 TEST(InterceptorPropertyMirror) {
3561 TEST(HiddenPrototypePropertyMirror) {
3662 TEST(NativeGetterPropertyMirror) {
3699 TEST(NativeGetterThrowingErrorPropertyMirror) {
3731 // Test that hidden properties object is not returned as an unnamed property
3734 TEST(NoHiddenProperties) {
3746 obj->SetHiddenValue(v8::String::New("v8::test-debug::a"),
3772 protoObj->SetHiddenValue(v8::String::New("v8::test-debug::b"),
3776 grandProtoObj->SetHiddenValue(v8::String::New("v8::test-debug::c"),
3953 /* Test MessageQueues */
3972 // Lets test script wait until break occurs to send commands.
3977 // Allow message handler to block on a semaphore, to test queueing of
4066 TEST(MessageQueues) {
4115 TEST(MessageQueueExpandAndDestroy) {
4158 TEST(SendClientDataToHandler) {
4201 /* Test ThreadedDebugging */
4202 /* This test interrupts a running infinite loop that is
4291 TEST(ThreadedDebugging) {
4302 /* Test RecursiveBreakpoints */
4303 /* In this test, the debugger evaluates a function with a breakpoint, after
4508 TEST(RecursiveBreakpoints) {
4512 TEST(RecursiveBreakpointsGlobal) {
4524 TEST(SetDebugEventListenerOnUninitializedVM) {
4533 TEST(SetMessageHandlerOnUninitializedVM) {
4538 TEST(DebugBreakOnUninitializedVM) {
4543 TEST(SendCommandToUninitializedVM) {
4594 // Function to test passing an additional parameter to a JavaScript function
4598 v8::Handle<v8::String> data = v8::String::New("Test");
4613 // Function to test using a JavaScript with closure in the debugger.
4621 // Test functions called through the debugger.
4622 TEST(CallFunctionInDebugger) {
4664 // Test that the number of frames can be retrieved.
4670 // Test that the source line can be retrieved.
4678 // Test that a parameter can be passed to a function called in the debugger.
4681 // Test that a function with closure can be run in the debugger.
4685 // Test that the source line is correct when there is a line offset.
4686 v8::ScriptOrigin origin(v8::String::New("test"),
4710 // Test that clearing the debug event listener actually clears all break points
4712 TEST(DebuggerUnload) {
4724 // Create a couple of functions for the test.
4755 // Get the test functions again.
4806 // Test clearing the debug message handler.
4807 TEST(DebuggerClearMessageHandler) {
4849 // Test clearing the debug message handler while processing a debug event.
4850 TEST(DebuggerClearMessageHandlerWhileActive) {
4871 /* Test DebuggerHostDispatch */
4872 /* In this test, the debugger waits for a command on a breakpoint
4956 TEST(DebuggerHostDispatch) {
4972 /* Test DebugMessageDispatch */
4973 /* In this test, the V8 thread waits for a message from the debug thread.
5020 TEST(DebuggerDebugMessageDispatch) {
5037 TEST(DebuggerAgent) {
5054 // Test starting and stopping the agent without any client connection.
5055 i::Debugger::StartAgent("test", kPort1);
5058 // Test starting the agent, connecting a client and shutting down the agent
5060 ok = i::Debugger::StartAgent("test", kPort2);
5069 // Test starting and stopping the agent with the required port already
5074 i::Debugger::StartAgent("test", kPort3);
5102 i::Socket* client_; // Single client connection used by the test.
5130 TEST(DebuggerAgentProtocolOverflowHeader) {
5199 // Test for issue http://code.google.com/p/v8/issues/detail?id=289.
5213 TEST(DebugGetLoadedScripts) {
5243 // Test script break points set on lines.
5244 TEST(ScriptNameAndData) {
5264 // Test function source.
5341 // Test which creates two contexts and sets different embedder data on each.
5344 TEST(ContextData) {
5370 // Simple test function which causes a break.
5419 // Test that a debug break can be scheduled while in a message handler.
5420 TEST(DebugBreakInMessageHandler) {
5426 // Test functions.
5480 TEST(RegExpDebugBreak) {
5481 // This test only applies to native regexps.
5490 // Test RegExp which matches white spaces and comments at the begining of a
5531 // Simple test function with eval that causes a break.
5545 // Test which creates a context and sets embedder data on it. Checks that this
5549 TEST(EvalContextData) {
5612 TEST(NestedBreakEventContextData) {
5643 // Test that scripts collected are reported through the debug event listener.
5644 TEST(ScriptCollectedEvent) {
5653 // Do garbage collection to ensure that only the script in this test will be
5688 // Test that GetEventContext doesn't fail and return empty handle for
5690 TEST(ScriptCollectedEventContext) {
5700 // Do garbage collection to ensure that only the script in this test will be
5737 TEST(AfterCompileMessageWhenMessageHandlerIsReset) {
5761 TEST(BreakMessageWhenMessageHandlerIsReset) {
5796 TEST(ExceptionMessageWhenMessageHandlerIsReset) {
5821 TEST(ProvisionalBreakpointOnLineOutOfRange) {
5885 // Test that if DebugBreak is forced it is ignored when code from
5887 TEST(NoDebugBreakInAfterCompileMessageHandler) {
5922 // Test that debug messages get processed when ProcessDebugMessages is called.
5923 TEST(ProcessDebugMessages) {
5978 // Test that debug messages get processed when ProcessDebugMessages is called.
5979 TEST(Backtrace) {
6013 TEST(GetMirror) {
6030 // Test that the debug break flag works with function.apply.
6031 TEST(DebugBreakFunctionApply) {
6049 // Limit the number of debug breaks. This is a regression test for issue 493
6050 // where this test would enter an infinite loop.
6107 TEST(CallingContextIsNotDebugContext) {
