OLD | NEW |
| (Empty) |
1 // Copyright 2008 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 // Flags: --expose-debug-as debug | |
29 // Get the Debug object exposed from the debug context global object. | |
30 Debug = debug.Debug | |
31 | |
32 var exception = null; | |
33 var state = 0; | |
34 | |
35 // Simple debug event handler which first time will cause 'step in' action | |
36 // to get into g.call and than check that execution is pauesed inside | |
37 // function 'g'. | |
38 function listener(event, exec_state, event_data, data) { | |
39 try { | |
40 if (event == Debug.DebugEvent.Break) { | |
41 if (state < 2) { | |
42 // Step into f2.call: | |
43 exec_state.prepareStep(Debug.StepAction.StepIn); | |
44 state++; | |
45 } else { | |
46 assertEquals('g', event_data.func().name()); | |
47 assertEquals(' return t + 1; // expected line', | |
48 event_data.sourceLineText()); | |
49 state = 3; | |
50 } | |
51 } | |
52 } catch(e) { | |
53 exception = e; | |
54 } | |
55 }; | |
56 | |
57 // Add the debug event listener. | |
58 Debug.setListener(listener); | |
59 | |
60 | |
61 // Sample functions. | |
62 function g(t) { | |
63 return t + 1; // expected line | |
64 } | |
65 | |
66 // Test step into function call from a function without local variables. | |
67 function call1() { | |
68 debugger; | |
69 g.call(null, 3); | |
70 } | |
71 | |
72 | |
73 // Test step into function call from a function with some local variables. | |
74 function call2() { | |
75 var aLocalVar = 'test'; | |
76 var anotherLocalVar = g(aLocalVar) + 's'; | |
77 var yetAnotherLocal = 10; | |
78 debugger; | |
79 g.call(null, 3); | |
80 } | |
81 | |
82 // Test step into function call which is a part of an expression. | |
83 function call3() { | |
84 var alias = g; | |
85 debugger; | |
86 var r = 10 + alias.call(null, 3); | |
87 var aLocalVar = 'test'; | |
88 var anotherLocalVar = g(aLocalVar) + 's'; | |
89 var yetAnotherLocal = 10; | |
90 } | |
91 | |
92 // Test step into function call from a function with some local variables. | |
93 function call4() { | |
94 var alias = g; | |
95 debugger; | |
96 alias.call(null, 3); | |
97 var aLocalVar = 'test'; | |
98 var anotherLocalVar = g(aLocalVar) + 's'; | |
99 var yetAnotherLocal = 10; | |
100 } | |
101 | |
102 // Test step into function apply from a function without local variables. | |
103 function apply1() { | |
104 debugger; | |
105 g.apply(null, [3]); | |
106 } | |
107 | |
108 | |
109 // Test step into function apply from a function with some local variables. | |
110 function apply2() { | |
111 var aLocalVar = 'test'; | |
112 var anotherLocalVar = g(aLocalVar) + 's'; | |
113 var yetAnotherLocal = 10; | |
114 debugger; | |
115 g.apply(null, [3, 4]); | |
116 } | |
117 | |
118 // Test step into function apply which is a part of an expression. | |
119 function apply3() { | |
120 var alias = g; | |
121 debugger; | |
122 var r = 10 + alias.apply(null, [3, 'unused arg']); | |
123 var aLocalVar = 'test'; | |
124 var anotherLocalVar = g(aLocalVar) + 's'; | |
125 var yetAnotherLocal = 10; | |
126 } | |
127 | |
128 // Test step into function apply from a function with some local variables. | |
129 function apply4() { | |
130 var alias = g; | |
131 debugger; | |
132 alias.apply(null, [3]); | |
133 var aLocalVar = 'test'; | |
134 var anotherLocalVar = g(aLocalVar) + 's'; | |
135 var yetAnotherLocal = 10; | |
136 } | |
137 | |
138 // Test step into bound function. | |
139 function bind1() { | |
140 var bound = g.bind(null, 3); | |
141 debugger; | |
142 bound(); | |
143 } | |
144 | |
145 // Test step into apply of bound function. | |
146 function applyAndBind1() { | |
147 var bound = g.bind(null, 3); | |
148 debugger; | |
149 bound.apply(null, [3]); | |
150 var aLocalVar = 'test'; | |
151 var anotherLocalVar = g(aLocalVar) + 's'; | |
152 var yetAnotherLocal = 10; | |
153 } | |
154 | |
155 var testFunctions = | |
156 [call1, call2, call3, call4, apply1, apply2, apply3, apply4, bind1, | |
157 applyAndBind1]; | |
158 | |
159 for (var i = 0; i < testFunctions.length; i++) { | |
160 state = 0; | |
161 testFunctions[i](); | |
162 assertNull(exception); | |
163 assertEquals(3, state); | |
164 } | |
165 | |
166 // Test global bound function. | |
167 state = 0; | |
168 var globalBound = g.bind(null, 3); | |
169 debugger; | |
170 globalBound(); | |
171 assertNull(exception); | |
172 assertEquals(3, state); | |
173 | |
174 // Get rid of the debug event listener. | |
175 Debug.setListener(null); | |
OLD | NEW |