1 //
2 // Copyright (c) 2010-2018 Antmicro
3 // Copyright (c) 2011-2015 Realtime Embedded
4 //
5 // This file is licensed under the MIT License.
6 // Full license text is available in 'licenses/MIT.txt'.
7 //
8 using System.Linq;
9 using Antmicro.Renode.Core;
10 using NUnit.Framework;
11 using System.Collections.Generic;
12 using ELFSharp.ELF.Sections;
13 
14 
15 namespace Antmicro.Renode.UnitTests.SymbolLookupTests
16 {
17     [TestFixture]
18     public class SymbolLookupTests
19     {
20         [Test]
ShouldHaveMoreAndLessImportantViaName()21         public void ShouldHaveMoreAndLessImportantViaName()
22         {
23             var lookup = new SymbolLookup();
24             var symbols = new List<Symbol>
25             {
26                 new Symbol(0, 10, "LessImportant"),
27                 new Symbol(0, 10, "MoreImportant", SymbolType.Function)
28             };
29             IReadOnlyCollection<Symbol> dummy;
30             lookup.InsertSymbols(symbols);
31             Assert.IsTrue(lookup.TryGetSymbolsByName("MoreImportant", out dummy));
32             Assert.IsTrue(lookup.TryGetSymbolsByName("LessImportant", out dummy));
33         }
34 
35         [Test]
ShouldHaveImportantViaAddress()36         public void ShouldHaveImportantViaAddress()
37         {
38             int symbolNumber = 0;
39 
40             var symbols = new List<Symbol>();
41             //reverse order according to type importance. This is not optimal, but the actual
42             //importance is private to Symbol type.
43             foreach(var type in new []{ SymbolType.Function,
44                 SymbolType.NotSpecified,
45                 SymbolType.ProcessorSpecific,
46                 SymbolType.Section,
47                 SymbolType.Object,
48                 SymbolType.File })
49             {
50                 foreach(var binding in new []{ SymbolBinding.Global,
51                     SymbolBinding.Local,
52                     SymbolBinding.ProcessorSpecific,
53                     SymbolBinding.Weak })
54                 {
55                     symbols.Add(new Symbol(0, 10, symbolNumber.ToString(), type, binding));
56                     symbolNumber++;
57                 }
58             }
59             //check every symbol. The symbol in question and all LESS important are added, both in order and in reverse order.
60             for(var i = 0; i < symbols.Count; ++i)
61             {
62                 var lookup = new SymbolLookup();
63                 lookup.InsertSymbols(symbols.Skip(i));
64                 Assert.AreEqual(symbols[i], lookup.GetSymbolByAddress(5));
65                 lookup = new SymbolLookup();
66                 lookup.InsertSymbols(symbols.Skip(i).Reverse());
67                 Assert.AreEqual(symbols[i], lookup.GetSymbolByAddress(5));
68             }
69         }
70 
71         [Test]
ShouldFindOneSymbol()72         public void ShouldFindOneSymbol()
73         {
74             var lookup = new SymbolLookup();
75             lookup.InsertSymbol("Test", 0x100, 0x10);
76             Assert.AreEqual("Test", lookup.GetSymbolByAddress(0x105).Name);
77         }
78 
79         [Test]
ShouldFindOneSymbolBoundary()80         public void ShouldFindOneSymbolBoundary()
81         {
82             var lookup = new SymbolLookup();
83             lookup.InsertSymbol("Test", 0x100, 0x10);
84             Assert.AreEqual("Test", lookup.GetSymbolByAddress(0x100).Name);
85         }
86 
87         [Test]
ShouldNotFindOneSymbolBoundary()88         public void ShouldNotFindOneSymbolBoundary()
89         {
90             var lookup = new SymbolLookup();
91             lookup.InsertSymbol("Test", 0x100, 0x10);
92             Symbol dummy;
93             Assert.IsFalse(lookup.TryGetSymbolByAddress(0x110, out dummy));
94         }
95 
96         [Test]
ShouldNotFindOneSymbolMiss()97         public void ShouldNotFindOneSymbolMiss()
98         {
99             var lookup = new SymbolLookup();
100             lookup.InsertSymbol("Test", 0x100, 0x10);
101             Symbol dummy;
102             Assert.IsFalse(lookup.TryGetSymbolByAddress(0x120, out dummy));
103         }
104 
105         [Test]
ShouldTrimBigSymbol()106         public void ShouldTrimBigSymbol()
107         {
108             Symbol dummy;
109             var lookup = new SymbolLookup();
110             var symbols = new List<Symbol>
111             {
112                 MakeSymbolEntry("Large", 0, 10),
113                 MakeSymbolEntry("Small", 9, 1)
114             };
115             lookup.InsertSymbols(symbols);
116 
117             Assert.IsFalse(lookup.TryGetSymbolByAddress(10, out dummy));
118             Assert.AreEqual("Small", lookup.GetSymbolByAddress(9).Name);
119             Assert.AreEqual("Large", lookup.GetSymbolByAddress(8).Name);
120             Assert.AreEqual("Large", lookup.GetSymbolByAddress(0).Name);
121         }
122 
123         [Test]
ShouldFindTenSymbols()124         public void ShouldFindTenSymbols()
125         {
126             var symbols = Enumerable.Range(1, 10).Select(x => MakeSymbolEntry(x.ToString(), (uint)(x * 10), 5)).ToList();
127             var lookup = new SymbolLookup();
128             lookup.InsertSymbols(symbols);
129             foreach (var symbol in symbols)
130             {
131                 Assert.AreEqual(symbol.Name, lookup.GetSymbolByAddress(symbol.Start + 2).Name);
132             }
133         }
134 
135         [Test]
ShouldFindSimplyNestedSymbol()136         public void ShouldFindSimplyNestedSymbol()
137         {
138             var symbols = new List<Symbol>
139             {
140                 MakeSymbolEntry("Big", 0, 100),
141                 MakeSymbolEntry("Small", 50, 10)
142             };
143             var lookup = new SymbolLookup();
144             lookup.InsertSymbols(symbols);
145             Assert.AreEqual("Big", lookup.GetSymbolByAddress(10).Name);
146             Assert.AreEqual("Small", lookup.GetSymbolByAddress(51).Name);
147             Assert.AreEqual("Big", lookup.GetSymbolByAddress(60).Name);
148             Assert.AreEqual("Big", lookup.GetSymbolByAddress(61).Name);
149         }
150 
151         [Test]
ShouldFindRecursivelyNestedSymbol()152         public void ShouldFindRecursivelyNestedSymbol()
153         {
154             var symbols = new List<Symbol>
155             {
156                 MakeSymbolEntry("Big", 0, 100),
157                 MakeSymbolEntry("Average", 40, 20),
158                 MakeSymbolEntry("Small", 50, 5)
159             };
160             var lookup = new SymbolLookup();
161             lookup.InsertSymbols(symbols);
162 
163             Assert.AreEqual("Big", lookup.GetSymbolByAddress(10).Name);
164             Assert.AreEqual("Average", lookup.GetSymbolByAddress(41).Name);
165             Assert.AreEqual("Small", lookup.GetSymbolByAddress(51).Name);
166             Assert.AreEqual("Average", lookup.GetSymbolByAddress(55).Name);
167             Assert.AreEqual("Big", lookup.GetSymbolByAddress(60).Name);
168         }
169 
170         [Test]
ShouldNotFindHole()171         public void ShouldNotFindHole()
172         {
173             var symbols = new List<Symbol>
174             {
175                 MakeSymbolEntry("Alice", 0, 50),
176                 MakeSymbolEntry("Bob", 51, 50)
177             };
178             var lookup = new SymbolLookup();
179 
180             lookup.InsertSymbols(symbols);
181 
182             Symbol dummy;
183             Assert.IsFalse(lookup.TryGetSymbolByAddress(50, out dummy));
184         }
185 
186         [Test]
ShouldFindDoubleCut()187         public void ShouldFindDoubleCut()
188         {
189             var symbols = new List<Symbol>
190             {
191                 MakeSymbolEntry("Big", 0, 100),
192                 MakeSymbolEntry("Alice", 10, 20),
193                 MakeSymbolEntry("Bob", 70, 20)
194             };
195             var lookup = new SymbolLookup();
196             lookup.InsertSymbols(symbols);
197             Assert.AreEqual("Big", lookup.GetSymbolByAddress(5).Name);
198             Assert.AreEqual("Alice", lookup.GetSymbolByAddress(15).Name);
199             Assert.AreEqual("Big", lookup.GetSymbolByAddress(35).Name);
200             Assert.AreEqual("Bob", lookup.GetSymbolByAddress(75).Name);
201             Assert.AreEqual("Big", lookup.GetSymbolByAddress(95).Name);
202         }
203 
204         [Test]
ShouldFindNestedAndDoubleCut()205         public void ShouldFindNestedAndDoubleCut()
206         {
207             var symbols = new List<Symbol>
208             {
209                 MakeSymbolEntry("Big", 0, 100),
210                 MakeSymbolEntry("Alice", 10, 30),
211                 MakeSymbolEntry("Small1", 20, 5),
212                 MakeSymbolEntry("Small2", 30, 5),
213                 MakeSymbolEntry("Bob", 60, 30),
214                 MakeSymbolEntry("Small3", 70, 5)
215             };
216             var lookup = new SymbolLookup();
217             lookup.InsertSymbols(symbols);
218 
219             Assert.AreEqual("Big", lookup.GetSymbolByAddress(5).Name);
220             Assert.AreEqual("Alice", lookup.GetSymbolByAddress(15).Name);
221             Assert.AreEqual("Small1", lookup.GetSymbolByAddress(22).Name);
222             Assert.AreEqual("Alice", lookup.GetSymbolByAddress(26).Name);
223             Assert.AreEqual("Small2", lookup.GetSymbolByAddress(31).Name);
224             Assert.AreEqual("Alice", lookup.GetSymbolByAddress(36).Name);
225             Assert.AreEqual("Big", lookup.GetSymbolByAddress(41).Name);
226             Assert.AreEqual("Bob", lookup.GetSymbolByAddress(61).Name);
227             Assert.AreEqual("Small3", lookup.GetSymbolByAddress(71).Name);
228             Assert.AreEqual("Bob", lookup.GetSymbolByAddress(76).Name);
229             Assert.AreEqual("Big", lookup.GetSymbolByAddress(91).Name);
230         }
231 
232         [Test]
ShouldWorkWithLongSeriesAndNesting()233         public void ShouldWorkWithLongSeriesAndNesting()
234         {
235             var symbols = new List<Symbol>
236             {
237                 MakeSymbolEntry("Large", 0, 10),
238                 MakeSymbolEntry("First", 3, 3),
239                 MakeSymbolEntry("Small", 4, 1),
240                 MakeSymbolEntry("Last", 6, 1)
241             };
242 
243             var lookup = new SymbolLookup();
244             lookup.InsertSymbols(symbols);
245 
246             Symbol dummy;
247             Assert.IsFalse(lookup.TryGetSymbolByAddress(10, out dummy));
248             Assert.AreEqual("Large", lookup.GetSymbolByAddress(9).Name);
249             Assert.AreEqual("Last", lookup.GetSymbolByAddress(6).Name);
250             Assert.AreEqual("First", lookup.GetSymbolByAddress(5).Name);
251             Assert.AreEqual("Small", lookup.GetSymbolByAddress(4).Name);
252             Assert.AreEqual("First", lookup.GetSymbolByAddress(3).Name);
253             Assert.AreEqual("Large", lookup.GetSymbolByAddress(2).Name);
254         }
255 
256         [Test]
ShouldFindNestedDeeper()257         public void ShouldFindNestedDeeper()
258         {
259             var symbols = new List<Symbol>
260             {
261                 MakeSymbolEntry("First", 0, 100),
262                 MakeSymbolEntry("Second", 10, 80),
263                 MakeSymbolEntry("Third", 20, 60),
264                 MakeSymbolEntry("Fourth", 30, 40)
265             };
266             var lookup = new SymbolLookup();
267             lookup.InsertSymbols(symbols);
268 
269             Assert.AreEqual("First", lookup.GetSymbolByAddress(5).Name);
270             Assert.AreEqual("Second", lookup.GetSymbolByAddress(15).Name);
271             Assert.AreEqual("Third", lookup.GetSymbolByAddress(25).Name);
272             Assert.AreEqual("Fourth", lookup.GetSymbolByAddress(35).Name);
273             Assert.AreEqual("Third", lookup.GetSymbolByAddress(75).Name);
274             Assert.AreEqual("Second", lookup.GetSymbolByAddress(85).Name);
275             Assert.AreEqual("First", lookup.GetSymbolByAddress(95).Name);
276         }
277 
278         [Test]
ShouldFindMatroska()279         public void ShouldFindMatroska()
280         {
281             var symbols = new List<Symbol>
282             {
283                 MakeSymbolEntry("First", 90, 10),
284                 MakeSymbolEntry("Second", 80, 20),
285                 MakeSymbolEntry("Third", 70, 30),
286                 MakeSymbolEntry("Fourth", 60, 40),
287                 MakeSymbolEntry("Fifth", 85, 5),
288                 MakeSymbolEntry("Sixth", 40, 20),
289                 MakeSymbolEntry("Seventh", 0, 100)
290             };
291             var lookup = new SymbolLookup();
292             lookup.InsertSymbols(symbols);
293 
294             Assert.AreEqual("Seventh", lookup.GetSymbolByAddress(0).Name);
295             Assert.AreEqual("Sixth", lookup.GetSymbolByAddress(45).Name);
296             Assert.AreEqual("Fifth", lookup.GetSymbolByAddress(85).Name);
297             Assert.AreEqual("Fourth", lookup.GetSymbolByAddress(65).Name);
298             Assert.AreEqual("Third", lookup.GetSymbolByAddress(75).Name);
299             Assert.AreEqual("Second", lookup.GetSymbolByAddress(80).Name);
300             Assert.AreEqual("First", lookup.GetSymbolByAddress(90).Name);
301         }
302 
303         [Test]
ShouldFindComplicatedTest()304         public void ShouldFindComplicatedTest()
305         {
306             var symbols = new List<Symbol>
307             {
308                 MakeSymbolEntry("一", 0, 100),
309                 MakeSymbolEntry("二", 10, 40),
310                 MakeSymbolEntry("三", 15, 15),
311                 MakeSymbolEntry("四", 30, 15),
312                 MakeSymbolEntry("五", 55, 5),
313                 MakeSymbolEntry("中", 60, 10),
314                 MakeSymbolEntry("国", 50, 20),
315                 MakeSymbolEntry("猫", 80, 15),
316                 MakeSymbolEntry("私", 85, 5),
317                 MakeSymbolEntry("糞", 100, 20),
318                 MakeSymbolEntry("ICantSpeekJapaneese", 56, 2),
319                 MakeSymbolEntry("KoreanNeither", 58, 2)
320             };
321             var lookup = new SymbolLookup();
322             lookup.InsertSymbols(symbols);
323 
324 
325             Assert.AreEqual("一", lookup.GetSymbolByAddress(1).Name);
326             Assert.AreEqual("二", lookup.GetSymbolByAddress(11).Name);
327             Assert.AreEqual("三", lookup.GetSymbolByAddress(16).Name);
328             Assert.AreEqual("四", lookup.GetSymbolByAddress(31).Name);
329             Assert.AreEqual("二", lookup.GetSymbolByAddress(46).Name);
330             Assert.AreEqual("国", lookup.GetSymbolByAddress(52).Name);
331             Assert.AreEqual("五", lookup.GetSymbolByAddress(55).Name);
332             Assert.AreEqual("中", lookup.GetSymbolByAddress(64).Name);
333             Assert.AreEqual("一", lookup.GetSymbolByAddress(72).Name);
334             Assert.AreEqual("猫", lookup.GetSymbolByAddress(84).Name);
335             Assert.AreEqual("私", lookup.GetSymbolByAddress(86).Name);
336             Assert.AreEqual("猫", lookup.GetSymbolByAddress(94).Name);
337             Assert.AreEqual("一", lookup.GetSymbolByAddress(95).Name);
338             Assert.AreEqual("糞", lookup.GetSymbolByAddress(100).Name);
339 
340             Assert.AreEqual("ICantSpeekJapaneese", lookup.GetSymbolByAddress(57).Name);
341             Assert.AreEqual("KoreanNeither", lookup.GetSymbolByAddress(59).Name);
342         }
343 
344         [Test]
ShouldFindComplicatedFromSingleInsertsTest()345         public void ShouldFindComplicatedFromSingleInsertsTest()
346         {
347             var symbols = new List<Symbol>
348             {
349                 MakeSymbolEntry("一", 0, 100),
350                 MakeSymbolEntry("二", 10, 40),
351                 MakeSymbolEntry("三", 15, 15),
352                 MakeSymbolEntry("四", 30, 15),
353                 MakeSymbolEntry("五", 55, 5),
354                 MakeSymbolEntry("中", 60, 10),
355                 MakeSymbolEntry("国", 50, 20),
356                 MakeSymbolEntry("猫", 80, 15),
357                 MakeSymbolEntry("私", 85, 5),
358                 MakeSymbolEntry("糞", 100, 20),
359                 MakeSymbolEntry("ICantSpeekJapaneese", 56, 2),
360                 MakeSymbolEntry("KoreanNeither", 58, 2)
361             };
362             var lookup = new SymbolLookup();
363             foreach(var symbol in symbols)
364             {
365                 lookup.InsertSymbol(symbol);
366             }
367 
368             Assert.AreEqual("一", lookup.GetSymbolByAddress(1).Name);
369             Assert.AreEqual("二", lookup.GetSymbolByAddress(11).Name);
370             Assert.AreEqual("三", lookup.GetSymbolByAddress(16).Name);
371             Assert.AreEqual("四", lookup.GetSymbolByAddress(31).Name);
372             Assert.AreEqual("二", lookup.GetSymbolByAddress(46).Name);
373             Assert.AreEqual("国", lookup.GetSymbolByAddress(52).Name);
374             Assert.AreEqual("国", lookup.GetSymbolByAddress(55).Name);
375             Assert.AreEqual("国", lookup.GetSymbolByAddress(64).Name);
376             Assert.AreEqual("一", lookup.GetSymbolByAddress(72).Name);
377             Assert.AreEqual("猫", lookup.GetSymbolByAddress(84).Name);
378             Assert.AreEqual("私", lookup.GetSymbolByAddress(86).Name);
379             Assert.AreEqual("猫", lookup.GetSymbolByAddress(94).Name);
380             Assert.AreEqual("一", lookup.GetSymbolByAddress(95).Name);
381             Assert.AreEqual("糞", lookup.GetSymbolByAddress(100).Name);
382 
383             Assert.AreEqual("ICantSpeekJapaneese", lookup.GetSymbolByAddress(57).Name);
384             Assert.AreEqual("KoreanNeither", lookup.GetSymbolByAddress(59).Name);
385         }
386 
387         [Test]
ShouldFindNotSoComplicatedTest()388         public void ShouldFindNotSoComplicatedTest()
389         {
390             var symbols = new List<Symbol>
391             {
392                 MakeSymbolEntry("一", 0, 100),
393                 MakeSymbolEntry("国", 50, 20),
394                 MakeSymbolEntry("五", 55, 5),
395                 MakeSymbolEntry("中", 60, 10),
396                 MakeSymbolEntry("猫", 80, 15),
397                 MakeSymbolEntry("私", 85, 5),
398                 MakeSymbolEntry("ICantSpeekJapaneese", 56, 2),
399                 MakeSymbolEntry("KoreanNeither", 58, 2)
400             };
401             var lookup = new SymbolLookup();
402             lookup.InsertSymbols(symbols);
403 
404             Assert.AreEqual("一", lookup.GetSymbolByAddress(1).Name);
405             Assert.AreEqual("国", lookup.GetSymbolByAddress(52).Name);
406             Assert.AreEqual("五", lookup.GetSymbolByAddress(55).Name);
407             Assert.AreEqual("中", lookup.GetSymbolByAddress(64).Name);
408             Assert.AreEqual("一", lookup.GetSymbolByAddress(72).Name);
409             Assert.AreEqual("猫", lookup.GetSymbolByAddress(84).Name);
410             Assert.AreEqual("猫", lookup.GetSymbolByAddress(94).Name);
411             Assert.AreEqual("一", lookup.GetSymbolByAddress(95).Name);
412             Assert.AreEqual("ICantSpeekJapaneese", lookup.GetSymbolByAddress(57).Name);
413             Assert.AreEqual("KoreanNeither", lookup.GetSymbolByAddress(59).Name);
414         }
415 
416         [Test]
ShouldWorkWithStackedTest()417         public void ShouldWorkWithStackedTest()
418         {
419             var symbols = new List<Symbol>
420             {
421                 MakeSymbolEntry("一", 0, 50),
422                 MakeSymbolEntry("国", 50, 50),
423                 MakeSymbolEntry("五", 65, 35),
424                 MakeSymbolEntry("中", 70, 30),
425                 MakeSymbolEntry("猫", 80, 20),
426                 MakeSymbolEntry("私", 81, 9),
427                 MakeSymbolEntry("糞", 90, 10)
428             };
429             var lookup = new SymbolLookup();
430             lookup.InsertSymbols(symbols);
431 
432             Assert.AreEqual("一", lookup.GetSymbolByAddress(1).Name);
433             Assert.AreEqual("国", lookup.GetSymbolByAddress(52).Name);
434             Assert.AreEqual("五", lookup.GetSymbolByAddress(66).Name);
435             Assert.AreEqual("中", lookup.GetSymbolByAddress(71).Name);
436             Assert.AreEqual("猫", lookup.GetSymbolByAddress(80).Name);
437             Assert.AreEqual("私", lookup.GetSymbolByAddress(82).Name);
438             Assert.AreEqual("糞", lookup.GetSymbolByAddress(94).Name);
439             Assert.AreEqual("糞", lookup.GetSymbolByAddress(99).Name);
440             Symbol dummy;
441             Assert.IsFalse(lookup.TryGetSymbolByAddress(100, out dummy));
442         }
443 
444         /// <summary>
445         /// This is a regression test. It should simply not crash nor throw anything.
446         /// </summary>
447         [Test]
ShouldNotCrashOnInsertDoubledSymbol()448         public void ShouldNotCrashOnInsertDoubledSymbol()
449         {
450             var symbols = new List<Symbol>
451             {
452                 MakeSymbolEntry("一", 0, 100),
453                 MakeSymbolEntry("二", 0, 100),
454                 MakeSymbolEntry("三", 100, 15),
455                 MakeSymbolEntry("四", 100, 15),
456                 MakeSymbolEntry("国", 10, 15),
457                 MakeSymbolEntry("五", 10, 15),
458             };
459             var lookup = new SymbolLookup();
460             lookup.InsertSymbols(symbols);
461             Symbol dummySymbol;
462             foreach(var symbol in symbols)
463             {
464                 lookup.GetSymbolsByName(symbol.Name);
465                 lookup.GetSymbolByAddress(symbol.Start);
466                 lookup.TryGetSymbolByAddress(symbol.End, out dummySymbol);
467             }
468         }
469 
470         [Test]
ShouldFindZeroLenghtSymbol()471         public void ShouldFindZeroLenghtSymbol()
472         {
473             var symbols = new List<Symbol>
474             {
475                 new Symbol(0, 75, "一"),
476                 new Symbol(50, 75, "三"),
477                 new Symbol(75, 75, "二"),
478                 new Symbol(75, 100, "一"),
479                 new Symbol(75, 99, "三"),
480             };
481             var addressesToQuery = new List<uint>{5, 60, 75, 99, 76};
482             var lookup = new SymbolLookup();
483             lookup.InsertSymbols(symbols);
484             CollectionAssert.AreEqual(symbols, addressesToQuery.Select(address => lookup.GetSymbolByAddress(address)));
485         }
486 
487         [Test]
ShouldCorrectlyGuessZeroLengthSymbol()488         public void ShouldCorrectlyGuessZeroLengthSymbol()
489         {
490             var symbols = new List<Symbol>
491             {
492                 MakeSymbolEntry("一", 20, 0),
493                 MakeSymbolEntry("三", 30, 10),
494                 MakeSymbolEntry("国", 40, 0),
495                 MakeSymbolEntry("五", 50, 50),
496                 MakeSymbolEntry("中", 60, 10),
497                 MakeSymbolEntry("猫", 65, 0),
498                 MakeSymbolEntry("私", 80, 0),
499                 MakeSymbolEntry("糞", 100, 0),
500                 MakeSymbolEntry("二", 110, 0)
501             };
502             var lookup = new SymbolLookup();
503             lookup.InsertSymbols(symbols);
504             Symbol dummySymbol;
505             Assert.IsFalse(lookup.TryGetSymbolByAddress(19, out dummySymbol));
506             Assert.AreEqual("一", lookup.GetSymbolByAddress(20).Name);
507             Assert.AreEqual("一", lookup.GetSymbolByAddress(21).Name);
508             Assert.AreEqual("国", lookup.GetSymbolByAddress(40).Name);
509             Assert.AreEqual("国", lookup.GetSymbolByAddress(41).Name);
510 
511             Assert.AreEqual("猫", lookup.GetSymbolByAddress(65).Name);
512             Assert.AreEqual("中", lookup.GetSymbolByAddress(66).Name);
513             Assert.AreEqual("五", lookup.GetSymbolByAddress(70).Name);
514 
515             Assert.AreEqual("私", lookup.GetSymbolByAddress(80).Name);
516             Assert.AreEqual("五", lookup.GetSymbolByAddress(81).Name);
517 
518             Assert.AreEqual("糞", lookup.GetSymbolByAddress(100).Name);
519             Assert.AreEqual("糞", lookup.GetSymbolByAddress(101).Name);
520             Assert.AreEqual("二", lookup.GetSymbolByAddress(110).Name);
521             Assert.IsFalse(lookup.TryGetSymbolByAddress(111, out dummySymbol));
522         }
523 
MakeSymbolEntry(string name, uint start, uint length)524         private Symbol MakeSymbolEntry(string name, uint start, uint length)
525         {
526             var symbol = new Symbol(start, start + length, name);
527             return symbol;
528         }
529     }
530 }
531