Debian Codegraph @

external/cecil/symbols/pdb/Test/Mono.Cecil.Tests/PdbTests.cs

raw
1 using System.IO;
2 using System.Linq;
3
4 using Mono.Cecil.Cil;
5 using Mono.Cecil.Pdb;
6
7 using NUnit.Framework;
8
9 namespace Mono.Cecil.Tests {
10
11 [TestFixture]
12 public class PdbTests : BaseTestFixture {
13
14 [Test]
15 public void Main ()
16 {
17 TestModule ("test.exe", module => {
18 var type = module.GetType ("Program");
19 var main = type.GetMethod ("Main");
20
21 AssertCode (@"
22 .locals init (System.Int32 i, System.Int32 CS$1$0000, System.Boolean CS$4$0001)
23 .line 6,6:2,3 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs'
24 IL_0000: nop
25 .line 7,7:8,18 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs'
26 IL_0001: ldc.i4.0
27 IL_0002: stloc.0
28 .line hidden 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs'
29 IL_0003: br.s IL_0012
30 .line 8,8:4,21 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs'
31 IL_0005: ldarg.0
32 IL_0006: ldloc.0
33 IL_0007: ldelem.ref
34 IL_0008: call System.Void Program::Print(System.String)
35 IL_000d: nop
36 .line 7,7:36,39 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs'
37 IL_000e: ldloc.0
38 IL_000f: ldc.i4.1
39 IL_0010: add
40 IL_0011: stloc.0
41 .line 7,7:19,34 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs'
42 IL_0012: ldloc.0
43 IL_0013: ldarg.0
44 IL_0014: ldlen
45 IL_0015: conv.i4
46 IL_0016: clt
47 IL_0018: stloc.2
48 .line hidden 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs'
49 IL_0019: ldloc.2
50 IL_001a: brtrue.s IL_0005
51 .line 10,10:3,12 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs'
52 IL_001c: ldc.i4.0
53 IL_001d: stloc.1
54 IL_001e: br.s IL_0020
55 .line 11,11:2,3 'c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs'
56 IL_0020: ldloc.1
57 IL_0021: ret
58 ", main);
59 }, readOnly: !Platform.HasNativePdbSupport, symbolReaderProvider: typeof(PdbReaderProvider), symbolWriterProvider: typeof(PdbWriterProvider));
60 }
61
62 [Test]
63 public void DebuggerHiddenVariable ()
64 {
65 TestModule ("test.exe", module => {
66 var type = module.GetType ("Program");
67 var method = type.GetMethod ("Main");
68
69 var scope = method.DebugInformation.Scope;
70
71 Assert.IsTrue (scope.HasVariables);
72 var variables = scope.Variables;
73
74 Assert.AreEqual ("CS$1$0000", variables [0].Name);
75 Assert.IsTrue (variables [0].IsDebuggerHidden);
76 Assert.AreEqual ("CS$4$0001", variables [1].Name);
77 Assert.IsTrue (variables [1].IsDebuggerHidden);
78
79 Assert.AreEqual (1, scope.Scopes.Count);
80 scope = scope.Scopes [0];
81 variables = scope.Variables;
82
83 Assert.AreEqual ("i", variables [0].Name);
84 Assert.IsFalse (variables [0].IsDebuggerHidden);
85 }, readOnly: !Platform.HasNativePdbSupport, symbolReaderProvider: typeof(PdbReaderProvider), symbolWriterProvider: typeof(PdbWriterProvider));
86 }
87
88 [Test]
89 public void Document ()
90 {
91 TestModule ("test.exe", module => {
92 var type = module.GetType ("Program");
93 var method = type.GetMethod ("Main");
94
95 var sequence_point = method.DebugInformation.SequencePoints.First (sp => sp != null);
96 var document = sequence_point.Document;
97
98 Assert.IsNotNull (document);
99
100 Assert.AreEqual (@"c:\sources\cecil\symbols\Mono.Cecil.Pdb\Test\Resources\assemblies\test.cs", document.Url);
101 Assert.AreEqual (DocumentType.Text, document.Type);
102 Assert.AreEqual (DocumentHashAlgorithm.MD5, document.HashAlgorithm);
103 Assert.AreEqual (new byte [] { 228, 176, 152, 54, 82, 238, 238, 68, 237, 156, 5, 142, 118, 160, 118, 245 }, document.Hash);
104 Assert.AreEqual (DocumentLanguage.CSharp, document.Language);
105 Assert.AreEqual (DocumentLanguageVendor.Microsoft, document.LanguageVendor);
106 }, readOnly: !Platform.HasNativePdbSupport, symbolReaderProvider: typeof(PdbReaderProvider), symbolWriterProvider: typeof(PdbWriterProvider));
107 }
108
109 [Test]
110 public void BasicDocument ()
111 {
112 TestModule ("VBConsApp.exe", module => {
113 var type = module.GetType ("VBConsApp.Program");
114 var method = type.GetMethod ("Main");
115
116 var sequence_point = method.DebugInformation.SequencePoints.First (sp => sp != null);
117 var document = sequence_point.Document;
118
119 Assert.IsNotNull (document);
120
121 Assert.AreEqual (@"c:\tmp\VBConsApp\Program.vb", document.Url);
122 Assert.AreEqual (DocumentType.Text, document.Type);
123 Assert.AreEqual (DocumentHashAlgorithm.MD5, document.HashAlgorithm);
124 Assert.AreEqual (new byte [] { 184, 188, 100, 23, 27, 123, 187, 201, 175, 206, 110, 198, 242, 139, 154, 119 }, document.Hash);
125 Assert.AreEqual (DocumentLanguage.Basic, document.Language);
126 Assert.AreEqual (DocumentLanguageVendor.Microsoft, document.LanguageVendor);
127 }, readOnly: !Platform.HasNativePdbSupport, symbolReaderProvider: typeof(PdbReaderProvider), symbolWriterProvider: typeof(PdbWriterProvider));
128 }
129
130 [Test]
131 public void FSharpDocument ()
132 {
133 TestModule ("fsapp.exe", module => {
134 var type = module.GetType ("Program");
135 var method = type.GetMethod ("fact");
136
137 var sequence_point = method.DebugInformation.SequencePoints.First (sp => sp != null);
138 var document = sequence_point.Document;
139
140 Assert.IsNotNull (document);
141
142 Assert.AreEqual (@"c:\tmp\fsapp\Program.fs", document.Url);
143 Assert.AreEqual (DocumentType.Text, document.Type);
144 Assert.AreEqual (DocumentHashAlgorithm.None, document.HashAlgorithm);
145 Assert.AreEqual (DocumentLanguage.FSharp, document.Language);
146 Assert.AreEqual (DocumentLanguageVendor.Microsoft, document.LanguageVendor);
147 }, readOnly: !Platform.HasNativePdbSupport, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
148 }
149
150 [Test]
151 public void EmptyEnumerable ()
152 {
153 TestModule ("empty-iterator.dll", module => {
154 }, readOnly: !Platform.HasNativePdbSupport, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
155 }
156
157 [Test]
158 public void EmptyRootNamespace ()
159 {
160 TestModule ("EmptyRootNamespace.dll", module => {
161 }, readOnly: !Platform.HasNativePdbSupport, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
162 }
163
164 [Test]
165 public void VisualBasicNamespace ()
166 {
167 TestModule ("AVbTest.exe", module => {
168 }, readOnly: !Platform.HasNativePdbSupport, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
169
170 }
171
172 [Test]
173 public void LocalVariables ()
174 {
175 TestModule ("ComplexPdb.dll", module => {
176 var type = module.GetType ("ComplexPdb.Program");
177 var method = type.GetMethod ("Bar");
178 var debug_info = method.DebugInformation;
179
180 Assert.IsNotNull (debug_info.Scope);
181 Assert.IsTrue (debug_info.Scope.HasScopes);
182 Assert.AreEqual (2, debug_info.Scope.Scopes.Count);
183
184 var scope = debug_info.Scope.Scopes [0];
185
186 Assert.IsNotNull (scope);
187 Assert.IsTrue (scope.HasVariables);
188 Assert.AreEqual (1, scope.Variables.Count);
189
190 var variable = scope.Variables [0];
191
192 Assert.AreEqual ("s", variable.Name);
193 Assert.IsFalse (variable.IsDebuggerHidden);
194 Assert.AreEqual (2, variable.Index);
195
196 scope = debug_info.Scope.Scopes [1];
197
198 Assert.IsNotNull (scope);
199 Assert.IsTrue (scope.HasVariables);
200 Assert.AreEqual (1, scope.Variables.Count);
201
202 variable = scope.Variables [0];
203
204 Assert.AreEqual ("s", variable.Name);
205 Assert.IsFalse (variable.IsDebuggerHidden);
206 Assert.AreEqual (3, variable.Index);
207
208 Assert.IsTrue (scope.HasScopes);
209 Assert.AreEqual (1, scope.Scopes.Count);
210
211 scope = scope.Scopes [0];
212
213 Assert.IsNotNull (scope);
214 Assert.IsTrue (scope.HasVariables);
215 Assert.AreEqual (1, scope.Variables.Count);
216
217 variable = scope.Variables [0];
218
219 Assert.AreEqual ("u", variable.Name);
220 Assert.IsFalse (variable.IsDebuggerHidden);
221 Assert.AreEqual (5, variable.Index);
222 }, readOnly: !Platform.HasNativePdbSupport, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
223 }
224
225 [Test]
226 public void LocalConstants ()
227 {
228 TestModule ("ComplexPdb.dll", module => {
229 var type = module.GetType ("ComplexPdb.Program");
230 var method = type.GetMethod ("Bar");
231 var debug_info = method.DebugInformation;
232
233 Assert.IsNotNull (debug_info.Scope);
234 Assert.IsTrue (debug_info.Scope.HasScopes);
235 Assert.AreEqual (2, debug_info.Scope.Scopes.Count);
236
237 var scope = debug_info.Scope.Scopes [1];
238
239 Assert.IsNotNull (scope);
240 Assert.IsTrue (scope.HasConstants);
241 Assert.AreEqual (2, scope.Constants.Count);
242
243 var constant = scope.Constants [0];
244
245 Assert.AreEqual ("b", constant.Name);
246 Assert.AreEqual (12, constant.Value);
247 Assert.AreEqual (MetadataType.Int32, constant.ConstantType.MetadataType);
248
249 constant = scope.Constants [1];
250 Assert.AreEqual ("c", constant.Name);
251 Assert.AreEqual ((decimal) 74, constant.Value);
252 Assert.AreEqual (MetadataType.ValueType, constant.ConstantType.MetadataType);
253
254 method = type.GetMethod ("Foo");
255 debug_info = method.DebugInformation;
256
257 Assert.IsNotNull (debug_info.Scope);
258 Assert.IsTrue (debug_info.Scope.HasConstants);
259 Assert.AreEqual (4, debug_info.Scope.Constants.Count);
260
261 constant = debug_info.Scope.Constants [0];
262 Assert.AreEqual ("s", constant.Name);
263 Assert.AreEqual ("const string", constant.Value);
264 Assert.AreEqual (MetadataType.String, constant.ConstantType.MetadataType);
265
266 constant = debug_info.Scope.Constants [1];
267 Assert.AreEqual ("f", constant.Name);
268 Assert.AreEqual (1, constant.Value);
269 Assert.AreEqual (MetadataType.Int32, constant.ConstantType.MetadataType);
270
271 constant = debug_info.Scope.Constants [2];
272 Assert.AreEqual ("o", constant.Name);
273 Assert.AreEqual (null, constant.Value);
274 Assert.AreEqual (MetadataType.Object, constant.ConstantType.MetadataType);
275
276 constant = debug_info.Scope.Constants [3];
277 Assert.AreEqual ("u", constant.Name);
278 Assert.AreEqual (null, constant.Value);
279 Assert.AreEqual (MetadataType.String, constant.ConstantType.MetadataType);
280 }, readOnly: !Platform.HasNativePdbSupport, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
281 }
282
283 [Test]
284 public void ImportScope ()
285 {
286 TestModule ("ComplexPdb.dll", module => {
287 var type = module.GetType ("ComplexPdb.Program");
288 var method = type.GetMethod ("Bar");
289 var debug_info = method.DebugInformation;
290
291 Assert.IsNotNull (debug_info.Scope);
292
293 var import = debug_info.Scope.Import;
294 Assert.IsNotNull (import);
295
296 Assert.IsTrue (import.HasTargets);
297 Assert.AreEqual (6, import.Targets.Count);
298 var target = import.Targets [0];
299
300 Assert.AreEqual (ImportTargetKind.ImportNamespace, target.Kind);
301 Assert.AreEqual ("System", target.Namespace);
302
303 target = import.Targets [1];
304
305 Assert.AreEqual (ImportTargetKind.ImportNamespace, target.Kind);
306 Assert.AreEqual ("System.Collections.Generic", target.Namespace);
307
308 target = import.Targets [2];
309
310 Assert.AreEqual (ImportTargetKind.ImportNamespace, target.Kind);
311 Assert.AreEqual ("System.Threading.Tasks", target.Namespace);
312
313 target = import.Targets [3];
314
315 Assert.AreEqual (ImportTargetKind.ImportType, target.Kind);
316 Assert.AreEqual ("System.Console", target.Type.FullName);
317
318 target = import.Targets [4];
319
320 Assert.AreEqual (ImportTargetKind.DefineTypeAlias, target.Kind);
321 Assert.AreEqual ("Foo1", target.Alias);
322 Assert.AreEqual ("System.Console", target.Type.FullName);
323
324 target = import.Targets [5];
325
326 Assert.AreEqual (ImportTargetKind.DefineNamespaceAlias, target.Kind);
327 Assert.AreEqual ("Foo2", target.Alias);
328 Assert.AreEqual ("System.Reflection", target.Namespace);
329 }, readOnly: !Platform.HasNativePdbSupport, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
330 }
331
332 [Test]
333 public void StateMachineKickOff ()
334 {
335 TestModule ("ComplexPdb.dll", module => {
336 var state_machine = module.GetType ("ComplexPdb.Program/<TestAsync>d__2");
337 var move_next = state_machine.GetMethod ("MoveNext");
338 var symbol = move_next.DebugInformation;
339
340 Assert.IsNotNull (symbol);
341 Assert.IsNotNull (symbol.StateMachineKickOffMethod);
342 Assert.AreEqual ("System.Threading.Tasks.Task ComplexPdb.Program::TestAsync()", symbol.StateMachineKickOffMethod.FullName);
343 }, readOnly: !Platform.HasNativePdbSupport, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
344 }
345
346 [Test]
347 public void Iterators ()
348 {
349 TestModule ("ComplexPdb.dll", module => {
350 var state_machine = module.GetType ("ComplexPdb.Program/<TestAsync>d__2");
351 var move_next = state_machine.GetMethod ("MoveNext");
352
353 Assert.IsTrue (move_next.DebugInformation.HasCustomDebugInformations);
354 Assert.AreEqual (2, move_next.DebugInformation.CustomDebugInformations.Count);
355
356 var state_machine_scope = move_next.DebugInformation.CustomDebugInformations [0] as StateMachineScopeDebugInformation;
357 Assert.IsNotNull (state_machine_scope);
358 Assert.AreEqual (1, state_machine_scope.Scopes.Count);
359 Assert.AreEqual (142, state_machine_scope.Scopes [0].Start.Offset);
360 Assert.AreEqual (319, state_machine_scope.Scopes [0].End.Offset);
361
362 var async_body = move_next.DebugInformation.CustomDebugInformations [1] as AsyncMethodBodyDebugInformation;
363 Assert.IsNotNull (async_body);
364 Assert.AreEqual (-1, async_body.CatchHandler.Offset);
365
366 Assert.AreEqual (2, async_body.Yields.Count);
367 Assert.AreEqual (68, async_body.Yields [0].Offset);
368 Assert.AreEqual (197, async_body.Yields [1].Offset);
369
370 Assert.AreEqual (2, async_body.Resumes.Count);
371 Assert.AreEqual (98, async_body.Resumes [0].Offset);
372 Assert.AreEqual (227, async_body.Resumes [1].Offset);
373
374 Assert.AreEqual (move_next, async_body.ResumeMethods [0]);
375 Assert.AreEqual (move_next, async_body.ResumeMethods [1]);
376 }, readOnly: !Platform.HasNativePdbSupport, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
377 }
378
379 [Test]
380 public void ImportsForFirstMethod ()
381 {
382 TestModule ("CecilTest.exe", module => {
383 var type = module.GetType ("CecilTest.Program");
384 var method = type.GetMethod ("Main");
385
386 var debug = method.DebugInformation;
387 var scope = debug.Scope;
388
389 Assert.IsTrue (scope.End.IsEndOfMethod);
390
391 var import = scope.Import;
392
393 Assert.IsNotNull (import);
394 Assert.AreEqual (5, import.Targets.Count);
395
396 var ns = new [] {
397 "System",
398 "System.Collections.Generic",
399 "System.Linq",
400 "System.Text",
401 "System.Threading.Tasks",
402 };
403
404 for (int i = 0; i < import.Targets.Count; i++) {
405 var target = import.Targets [i];
406
407 Assert.AreEqual (ImportTargetKind.ImportNamespace, target.Kind);
408 Assert.AreEqual (ns [i], target.Namespace);
409 }
410
411 Assert.AreEqual ("System", import.Targets [0].Namespace);
412 }, readOnly: !Platform.HasNativePdbSupport, symbolReaderProvider: typeof (PdbReaderProvider), symbolWriterProvider: typeof (PdbWriterProvider));
413 }
414
415 [Test]
416 public void CreateMethodFromScratch ()
417 {
418 if (!Platform.HasNativePdbSupport)
419 Assert.Ignore ();
420
421 var module = ModuleDefinition.CreateModule ("Pan", ModuleKind.Dll);
422 var type = new TypeDefinition ("Pin", "Pon", TypeAttributes.Public | TypeAttributes.Abstract | TypeAttributes.Sealed, module.ImportReference (typeof (object)));
423 module.Types.Add (type);
424
425 var method = new MethodDefinition ("Pang", MethodAttributes.Public | MethodAttributes.Static, module.ImportReference (typeof (string)));
426 type.Methods.Add (method);
427
428 var body = method.Body;
429
430 body.InitLocals = true;
431
432 var il = body.GetILProcessor ();
433 var temp = new VariableDefinition (module.ImportReference (typeof (string)));
434 body.Variables.Add (temp);
435
436 il.Emit (OpCodes.Nop);
437 il.Emit (OpCodes.Ldstr, "hello");
438 il.Emit (OpCodes.Stloc, temp);
439 il.Emit (OpCodes.Ldloc, temp);
440 il.Emit (OpCodes.Ret);
441
442 var sequence_point = new SequencePoint (body.Instructions [0], new Document (@"C:\test.cs")) {
443 StartLine = 0,
444 StartColumn = 0,
445 EndLine = 0,
446 EndColumn = 4,
447 };
448
449 method.DebugInformation.SequencePoints.Add (sequence_point);
450
451 method.DebugInformation.Scope = new ScopeDebugInformation (body.Instructions [0], null) {
452 Variables = { new VariableDebugInformation (temp, "temp") }
453 };
454
455 var file = Path.Combine (Path.GetTempPath (), "Pan.dll");
456 module.Write (file, new WriterParameters {
457 SymbolWriterProvider = new PdbWriterProvider (),
458 });
459
460 module = ModuleDefinition.ReadModule (file, new ReaderParameters {
461 SymbolReaderProvider = new PdbReaderProvider (),
462 });
463
464 method = module.GetType ("Pin.Pon").GetMethod ("Pang");
465
466 Assert.AreEqual ("temp", method.DebugInformation.Scope.Variables [0].Name);
467 }
468 }
469 }