OLD | NEW |
| (Empty) |
1 // Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file | |
2 // for details. All rights reserved. Use of this source code is governed by a | |
3 // BSD-style license that can be found in the LICENSE file. | |
4 // VMOptions=--compile-all --error_on_bad_type --error_on_bad_override --checked | |
5 | |
6 import 'package:observatory/service_io.dart'; | |
7 import 'package:unittest/unittest.dart'; | |
8 import 'test_helper.dart'; | |
9 import 'dart:async'; | |
10 | |
11 void helper(i) { | |
12 print(i); | |
13 } | |
14 | |
15 void testFunction() { | |
16 int i = 0; | |
17 while (true) { | |
18 if (++i % 100000000 == 0) { | |
19 helper(i); // line 18 | |
20 } | |
21 } | |
22 } | |
23 | |
24 var tests = [ | |
25 | |
26 // Pause | |
27 (Isolate isolate) { | |
28 Completer completer = new Completer(); | |
29 var subscription; | |
30 subscription = isolate.vm.events.stream.listen((ServiceEvent event) { | |
31 if (event.eventType == ServiceEvent.kPauseInterrupted) { | |
32 subscription.cancel(); | |
33 completer.complete(); | |
34 } | |
35 }); | |
36 isolate.pause(); | |
37 return completer.future; | |
38 }, | |
39 | |
40 // Resume | |
41 (Isolate isolate) { | |
42 Completer completer = new Completer(); | |
43 var subscription; | |
44 subscription = isolate.vm.events.stream.listen((ServiceEvent event) { | |
45 if (event.eventType == ServiceEvent.kResume) { | |
46 subscription.cancel(); | |
47 completer.complete(); | |
48 } | |
49 }); | |
50 isolate.resume(); | |
51 return completer.future; | |
52 }, | |
53 | |
54 // Add breakpoint | |
55 (Isolate isolate) { | |
56 return isolate.rootLib.load().then((_) { | |
57 // Set up a listener to wait for breakpoint events. | |
58 Completer completer = new Completer(); | |
59 var subscription; | |
60 subscription = isolate.vm.events.stream.listen((ServiceEvent event) { | |
61 if (event.eventType == ServiceEvent.kPauseBreakpoint) { | |
62 print('Breakpoint reached'); | |
63 subscription.cancel(); | |
64 completer.complete(); | |
65 } | |
66 }); | |
67 | |
68 // Add the breakpoint. | |
69 var script = isolate.rootLib.scripts[0]; | |
70 return isolate.addBreakpoint(script, 18).then((result) { | |
71 expect(result is Breakpoint, isTrue); | |
72 Breakpoint bpt = result; | |
73 expect(bpt.type, equals('Breakpoint')); | |
74 expect(bpt.script.id, equals(script.id)); | |
75 expect(bpt.tokenPos, equals(58)); | |
76 expect(isolate.breakpoints.length, equals(1)); | |
77 return completer.future; // Wait for breakpoint events. | |
78 }); | |
79 }); | |
80 }, | |
81 | |
82 // Get the stack trace | |
83 (Isolate isolate) { | |
84 return isolate.getStack().then((ServiceMap stack) { | |
85 expect(stack.type, equals('Stack')); | |
86 expect(stack['frames'].length, greaterThanOrEqualTo(1)); | |
87 expect(stack['frames'][0]['function'].name, equals('testFunction')); | |
88 expect(stack['frames'][0]['tokenPos'], equals(58)); | |
89 }); | |
90 }, | |
91 | |
92 // Stepping | |
93 (Isolate isolate) { | |
94 // Set up a listener to wait for breakpoint events. | |
95 Completer completer = new Completer(); | |
96 var subscription; | |
97 subscription = isolate.vm.events.stream.listen((ServiceEvent event) { | |
98 if (event.eventType == ServiceEvent.kPauseBreakpoint) { | |
99 print('Breakpoint reached'); | |
100 subscription.cancel(); | |
101 completer.complete(); | |
102 } | |
103 }); | |
104 | |
105 return isolate.stepInto().then((isolate) { | |
106 return completer.future; // Wait for breakpoint events. | |
107 }); | |
108 }, | |
109 | |
110 // Get the stack trace again. Our position has updated. | |
111 (Isolate isolate) { | |
112 return isolate.getStack().then((ServiceMap stack) { | |
113 expect(stack.type, equals('Stack')); | |
114 expect(stack['frames'].length, greaterThanOrEqualTo(2)); | |
115 expect(stack['frames'][0]['function'].name, equals('testFunction')); | |
116 expect(stack['frames'][0]['tokenPos'], equals(60)); | |
117 }); | |
118 }, | |
119 | |
120 // Remove breakpoint | |
121 (Isolate isolate) { | |
122 // Set up a listener to wait for breakpoint events. | |
123 Completer completer = new Completer(); | |
124 var subscription; | |
125 subscription = isolate.vm.events.stream.listen((ServiceEvent event) { | |
126 if (event.eventType == ServiceEvent.kBreakpointRemoved) { | |
127 print('Breakpoint removed'); | |
128 expect(isolate.breakpoints.length, equals(0)); | |
129 subscription.cancel(); | |
130 completer.complete(); | |
131 } | |
132 }); | |
133 | |
134 expect(isolate.breakpoints.length, equals(1)); | |
135 var bpt = isolate.breakpoints.values.first; | |
136 return isolate.removeBreakpoint(bpt).then((_) { | |
137 return completer.future; | |
138 }); | |
139 }, | |
140 | |
141 // Resume | |
142 (Isolate isolate) { | |
143 Completer completer = new Completer(); | |
144 var subscription; | |
145 subscription = isolate.vm.events.stream.listen((ServiceEvent event) { | |
146 if (event.eventType == ServiceEvent.kResume) { | |
147 subscription.cancel(); | |
148 completer.complete(); | |
149 } | |
150 }); | |
151 isolate.resume(); | |
152 return completer.future; | |
153 }, | |
154 | |
155 // Add breakpoint at function entry | |
156 (Isolate isolate) { | |
157 // Set up a listener to wait for breakpoint events. | |
158 Completer completer = new Completer(); | |
159 var subscription; | |
160 subscription = isolate.vm.events.stream.listen((ServiceEvent event) { | |
161 if (event.eventType == ServiceEvent.kPauseBreakpoint) { | |
162 print('Breakpoint reached'); | |
163 subscription.cancel(); | |
164 completer.complete(); | |
165 } | |
166 }); | |
167 | |
168 // Find a specific function. | |
169 ServiceFunction function = isolate.rootLib.functions.firstWhere( | |
170 (f) => f.name == 'helper'); | |
171 expect(function, isNotNull); | |
172 | |
173 // Add the breakpoint at function entry | |
174 return isolate.addBreakpointAtEntry(function).then((result) { | |
175 expect(result is Breakpoint, isTrue); | |
176 Breakpoint bpt = result; | |
177 expect(bpt.type, equals('Breakpoint')); | |
178 expect(bpt.script.name, equals('debugging_test.dart')); | |
179 expect(bpt.tokenPos, equals(29)); | |
180 expect(isolate.breakpoints.length, equals(1)); | |
181 return completer.future; // Wait for breakpoint events. | |
182 }); | |
183 }, | |
184 | |
185 ]; | |
186 | |
187 main(args) => runIsolateTests(args, tests, testeeConcurrent: testFunction); | |
OLD | NEW |