← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.Tests/EvaluationTests.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.Tests/EvaluationTests.cs
 
1
// 
 
2
// EvaluationTests.cs
 
3
//  
 
4
// Author:
 
5
//       Lluis Sanchez Gual <lluis@novell.com>
 
6
// 
 
7
// Copyright (c) 2009 Novell, Inc (http://www.novell.com)
 
8
// 
 
9
// Permission is hereby granted, free of charge, to any person obtaining a copy
 
10
// of this software and associated documentation files (the "Software"), to deal
 
11
// in the Software without restriction, including without limitation the rights
 
12
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
13
// copies of the Software, and to permit persons to whom the Software is
 
14
// furnished to do so, subject to the following conditions:
 
15
// 
 
16
// The above copyright notice and this permission notice shall be included in
 
17
// all copies or substantial portions of the Software.
 
18
// 
 
19
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
20
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
21
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 
22
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
23
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
24
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
25
// THE SOFTWARE.
 
26
 
 
27
using System;
 
28
using Mono.Debugging.Client;
 
29
using NUnit.Framework;
 
30
 
 
31
namespace MonoDevelop.Debugger.Tests
 
32
{
 
33
        public abstract class EvaluationTests: DebugTests
 
34
        {
 
35
                DebuggerSession ds;
 
36
                StackFrame frame;
 
37
                
 
38
                public EvaluationTests (string de): base (de)
 
39
                {
 
40
                }
 
41
                
 
42
                public override void Setup ()
 
43
                {
 
44
                        base.Setup ();
 
45
                        ds = Start ("TestEvaluation");
 
46
                        frame = ds.ActiveThread.Backtrace.GetFrame (0);
 
47
                }
 
48
                
 
49
                public override void TearDown ()
 
50
                {
 
51
                        base.TearDown ();
 
52
                        ds.Exit ();
 
53
                        ds.Dispose ();
 
54
                }
 
55
 
 
56
 
 
57
                ObjectValue Eval (string exp)
 
58
                {
 
59
                        return frame.GetExpressionValue (exp, true).Sync ();
 
60
                }
 
61
                
 
62
                [Test()]
 
63
                public void This ()
 
64
                {
 
65
                        ObjectValue val = Eval ("this");
 
66
                        Assert.AreEqual ("{MonoDevelop.Debugger.Tests.TestApp.MainClass}", val.Value);
 
67
                        Assert.AreEqual ("MonoDevelop.Debugger.Tests.TestApp.MainClass", val.TypeName);
 
68
                }
 
69
                
 
70
                [Test()]
 
71
                public void UnaryOperators ()
 
72
                {
 
73
                        ObjectValue val = Eval ("~1234");
 
74
                        Assert.AreEqual ((~1234).ToString (), val.Value);
 
75
                        Assert.AreEqual ("int", val.TypeName);
 
76
                        
 
77
                        val = Eval ("!true");
 
78
                        Assert.AreEqual ("false", val.Value);
 
79
                        Assert.AreEqual ("bool", val.TypeName);
 
80
                        
 
81
                        val = Eval ("!false");
 
82
                        Assert.AreEqual ("true", val.Value);
 
83
                        Assert.AreEqual ("bool", val.TypeName);
 
84
                        
 
85
                        val = Eval ("-1234");
 
86
                        Assert.AreEqual ("-1234", val.Value);
 
87
                        Assert.AreEqual ("int", val.TypeName);
 
88
                        
 
89
                        val = Eval ("+1234");
 
90
                        Assert.AreEqual ("1234", val.Value);
 
91
                        Assert.AreEqual ("int", val.TypeName);
 
92
                }
 
93
                
 
94
                [Test()]
 
95
                public void TypeReference ()
 
96
                {
 
97
                        ObjectValue val = Eval ("System.String");
 
98
                        Assert.AreEqual ("string", val.Value);
 
99
                        Assert.AreEqual ("<type>", val.TypeName);
 
100
                        Assert.AreEqual (ObjectValueFlags.Type, val.Flags & ObjectValueFlags.OriginMask);
 
101
                        
 
102
                        val = Eval ("MainClass");
 
103
                        Assert.AreEqual ("MonoDevelop.Debugger.Tests.TestApp.MainClass", val.Value);
 
104
                        Assert.AreEqual ("<type>", val.TypeName);
 
105
                        Assert.AreEqual (ObjectValueFlags.Type, val.Flags & ObjectValueFlags.OriginMask);
 
106
                        
 
107
                        val = Eval ("MonoDevelop.Debugger.Tests.TestApp.MainClass");
 
108
                        Assert.AreEqual ("MonoDevelop.Debugger.Tests.TestApp.MainClass", val.Value);
 
109
                        Assert.AreEqual ("<type>", val.TypeName);
 
110
                        Assert.AreEqual (ObjectValueFlags.Type, val.Flags & ObjectValueFlags.OriginMask);
 
111
                }
 
112
                
 
113
                [Test()]
 
114
                public virtual void TypeReferenceGeneric ()
 
115
                {
 
116
                        ObjectValue val = Eval ("System.Collections.Generic.Dictionary<string,int>");
 
117
                        Assert.AreEqual ("System.Collections.Generic.Dictionary<string,int>", val.Value);
 
118
                        Assert.AreEqual ("<type>", val.TypeName);
 
119
                        Assert.AreEqual (ObjectValueFlags.Type, val.Flags & ObjectValueFlags.OriginMask);
 
120
                }
 
121
                
 
122
                [Test()]
 
123
                public virtual void Typeof ()
 
124
                {
 
125
                        ObjectValue val = Eval ("typeof(System.Console)");
 
126
                        Assert.IsTrue (val.TypeName == "System.MonoType" || val.TypeName == "System.RuntimeType", "Incorrect type name: " + val.TypeName);
 
127
                        Assert.AreEqual ("{System.Console}", val.Value);
 
128
                }
 
129
                
 
130
                [Test()]
 
131
                public void MethodInvoke ()
 
132
                {
 
133
                        ObjectValue val;
 
134
                        val = Eval ("TestMethod ()");
 
135
                        Assert.AreEqual ("1", val.Value);
 
136
                        Assert.AreEqual ("int", val.TypeName);
 
137
                        
 
138
                        val = Eval ("TestMethod (\"23\")");
 
139
                        Assert.AreEqual ("24", val.Value);
 
140
                        Assert.AreEqual ("int", val.TypeName);
 
141
                        
 
142
                        val = Eval ("TestMethod (42)");
 
143
                        Assert.AreEqual ("43", val.Value);
 
144
                        Assert.AreEqual ("int", val.TypeName);
 
145
                                                 
 
146
                        val = Eval ("TestMethod (false)");
 
147
                        Assert.AreEqual ("2", val.Value);
 
148
                        Assert.AreEqual ("int", val.TypeName);
 
149
                        
 
150
                        val = Eval ("this.TestMethod ()");
 
151
                        Assert.AreEqual ("1", val.Value);
 
152
                        Assert.AreEqual ("int", val.TypeName);
 
153
                        
 
154
                        val = Eval ("this.TestMethod (\"23\")");
 
155
                        Assert.AreEqual ("24", val.Value);
 
156
                        Assert.AreEqual ("int", val.TypeName);
 
157
                        
 
158
                        val = Eval ("this.TestMethod (42)");
 
159
                        Assert.AreEqual ("43", val.Value);
 
160
                        Assert.AreEqual ("int", val.TypeName);
 
161
                        
 
162
                        val = Eval ("System.Int32.Parse (\"67\")");
 
163
                        Assert.AreEqual ("67", val.Value);
 
164
                        Assert.AreEqual ("int", val.TypeName);
 
165
                        
 
166
                        val = Eval ("this.BoxingTestMethod (43)");
 
167
                        Assert.AreEqual ("\"43\"", val.Value);
 
168
                        Assert.AreEqual ("string", val.TypeName);
 
169
                }
 
170
                
 
171
                [Test()]
 
172
                public void Indexers ()
 
173
                {
 
174
                        ObjectValue val = Eval ("numbers[0]");
 
175
                        Assert.AreEqual ("\"one\"", val.Value);
 
176
                        Assert.AreEqual ("string", val.TypeName);
 
177
                        
 
178
                        val = Eval ("numbers[1]");
 
179
                        Assert.AreEqual ("\"two\"", val.Value);
 
180
                        Assert.AreEqual ("string", val.TypeName);
 
181
                        
 
182
                        val = Eval ("numbers[2]");
 
183
                        Assert.AreEqual ("\"three\"", val.Value);
 
184
                        Assert.AreEqual ("string", val.TypeName);
 
185
                        
 
186
                        val = Eval ("staticString[2]");
 
187
                        Assert.AreEqual ("'m'", val.Value);
 
188
                        Assert.AreEqual ("char", val.TypeName);
 
189
                        
 
190
                        val = Eval ("alist[0]");
 
191
                        Assert.AreEqual ("1", val.Value);
 
192
                        Assert.AreEqual ("int", val.TypeName);
 
193
                        
 
194
                        val = Eval ("alist[1]");
 
195
                        Assert.AreEqual ("\"two\"", val.Value);
 
196
                        Assert.AreEqual ("string", val.TypeName);
 
197
                        
 
198
                        val = Eval ("alist[2]");
 
199
                        Assert.AreEqual ("3", val.Value);
 
200
                        Assert.AreEqual ("int", val.TypeName);
 
201
                }
 
202
                
 
203
                [Test()]
 
204
                public void MemberReference ()
 
205
                {
 
206
                        ObjectValue val = Eval ("alist.Count");
 
207
                        Assert.AreEqual ("3", val.Value);
 
208
                        Assert.AreEqual ("int", val.TypeName);
 
209
                        
 
210
                        Eval ("var tt = this");
 
211
                        
 
212
                        val = Eval ("tt.someString");
 
213
                        Assert.AreEqual ("\"hi\"", val.Value);
 
214
                        Assert.AreEqual ("string", val.TypeName);
 
215
                        
 
216
                        val = Eval ("MonoDevelop.Debugger.Tests");
 
217
                        Assert.AreEqual ("MonoDevelop.Debugger.Tests", val.Value);
 
218
                        Assert.AreEqual ("<namespace>", val.TypeName);
 
219
                        
 
220
                        val = Eval ("MonoDevelop.Debugger.Tests.TestApp.MainClass");
 
221
                        Assert.AreEqual ("MonoDevelop.Debugger.Tests.TestApp.MainClass", val.Value);
 
222
                        Assert.AreEqual ("<type>", val.TypeName);
 
223
                        
 
224
                        val = Eval ("MonoDevelop.Debugger.Tests.TestApp.MainClass.staticString");
 
225
                        Assert.AreEqual ("\"some static\"", val.Value);
 
226
                        Assert.AreEqual ("string", val.TypeName);
 
227
                }
 
228
                
 
229
                [Test()]
 
230
                public void ConditionalExpression ()
 
231
                {
 
232
                        ObjectValue val = Eval ("true ? \"yes\" : \"no\"");
 
233
                        Assert.AreEqual ("\"yes\"", val.Value);
 
234
                        Assert.AreEqual ("string", val.TypeName);
 
235
                        
 
236
                        val = Eval ("false ? \"yes\" : \"no\"");
 
237
                        Assert.AreEqual ("\"no\"", val.Value);
 
238
                        Assert.AreEqual ("string", val.TypeName);
 
239
                }
 
240
                
 
241
                [Test()]
 
242
                public void Cast ()
 
243
                {
 
244
                        ObjectValue val;
 
245
                        val = Eval ("(byte)n");
 
246
                        Assert.AreEqual ("32", val.Value);
 
247
                        Assert.AreEqual ("byte", val.TypeName);
 
248
                        
 
249
                        val = Eval ("(int)n");
 
250
                        Assert.AreEqual ("32", val.Value);
 
251
                        Assert.AreEqual ("int", val.TypeName);
 
252
                        
 
253
                        val = Eval ("(long)n");
 
254
                        Assert.AreEqual ("32", val.Value);
 
255
                        Assert.AreEqual ("long", val.TypeName);
 
256
                        
 
257
                        val = Eval ("(float)n");
 
258
                        Assert.AreEqual ("32", val.Value);
 
259
                        Assert.AreEqual ("float", val.TypeName);
 
260
                        
 
261
                        val = Eval ("(double)n");
 
262
                        Assert.AreEqual ("32", val.Value);
 
263
                        Assert.AreEqual ("double", val.TypeName);
 
264
                        
 
265
                        val = Eval ("(string)staticString");
 
266
                        Assert.AreEqual ("\"some static\"", val.Value);
 
267
                        Assert.AreEqual ("string", val.TypeName);
 
268
                        
 
269
                        val = Eval ("(int)numbers");
 
270
                        Assert.IsTrue (val.IsError);
 
271
                        
 
272
                        val = Eval ("(int)this");
 
273
                        Assert.IsTrue (val.IsError);
 
274
                        
 
275
                        val = Eval ("(C)a");
 
276
                        Assert.IsTrue (val.IsError);
 
277
                        
 
278
                        val = Eval ("(C)b");
 
279
                        Assert.IsTrue (val.IsError);
 
280
                        
 
281
                        val = Eval ("(C)c");
 
282
                        Assert.AreEqual ("{C}", val.Value);
 
283
                        Assert.AreEqual ("C", val.TypeName);
 
284
                        
 
285
                        val = Eval ("(B)a");
 
286
                        Assert.IsTrue (val.IsError);
 
287
                        
 
288
                        val = Eval ("(B)b");
 
289
                        Assert.AreEqual ("{B}", val.Value);
 
290
                        Assert.AreEqual ("B", val.TypeName);
 
291
                        
 
292
                        val = Eval ("(B)c");
 
293
                        Assert.AreEqual ("{C}", val.Value);
 
294
                        Assert.AreEqual ("C", val.TypeName);
 
295
                        
 
296
                        val = Eval ("(A)a");
 
297
                        Assert.AreEqual ("{A}", val.Value);
 
298
                        Assert.AreEqual ("A", val.TypeName);
 
299
                        
 
300
                        val = Eval ("(A)b");
 
301
                        Assert.AreEqual ("{B}", val.Value);
 
302
                        Assert.AreEqual ("B", val.TypeName);
 
303
                        
 
304
                        val = Eval ("(A)c");
 
305
                        Assert.AreEqual ("{C}", val.Value);
 
306
                        Assert.AreEqual ("C", val.TypeName);
 
307
                        
 
308
                        // Try cast
 
309
                        
 
310
                        val = Eval ("c as A");
 
311
                        Assert.AreEqual ("{C}", val.Value);
 
312
                        Assert.AreEqual ("C", val.TypeName);
 
313
                        
 
314
                        val = Eval ("c as B");
 
315
                        Assert.AreEqual ("{C}", val.Value);
 
316
                        Assert.AreEqual ("C", val.TypeName);
 
317
                        
 
318
                        val = Eval ("c as C");
 
319
                        Assert.AreEqual ("{C}", val.Value);
 
320
                        Assert.AreEqual ("C", val.TypeName);
 
321
                        
 
322
                        val = Eval ("b as A");
 
323
                        Assert.AreEqual ("{B}", val.Value);
 
324
                        Assert.AreEqual ("B", val.TypeName);
 
325
                        
 
326
                        val = Eval ("b as B");
 
327
                        Assert.AreEqual ("{B}", val.Value);
 
328
                        Assert.AreEqual ("B", val.TypeName);
 
329
                        
 
330
                        val = Eval ("b as C");
 
331
                        Assert.AreEqual ("null", val.Value);
 
332
                        Assert.AreEqual ("C", val.TypeName);
 
333
                        
 
334
                        val = Eval ("a as A");
 
335
                        Assert.AreEqual ("{A}", val.Value);
 
336
                        Assert.AreEqual ("A", val.TypeName);
 
337
                        
 
338
                        val = Eval ("a as B");
 
339
                        Assert.AreEqual ("null", val.Value);
 
340
                        Assert.AreEqual ("B", val.TypeName);
 
341
                        
 
342
                        val = Eval ("a as C");
 
343
                        Assert.AreEqual ("null", val.Value);
 
344
                        Assert.AreEqual ("C", val.TypeName);
 
345
                        
 
346
                        // Enum cast
 
347
                        
 
348
                        val = Eval ("(int)SomeEnum.two");
 
349
                        Assert.AreEqual ("2", val.Value);
 
350
                        Assert.AreEqual ("int", val.TypeName);
 
351
                        
 
352
                        val = Eval ("(long)SomeEnum.two");
 
353
                        Assert.AreEqual ("2", val.Value);
 
354
                        Assert.AreEqual ("long", val.TypeName);
 
355
                        
 
356
                        val = Eval ("(SomeEnum)2");
 
357
                        Assert.AreEqual ("SomeEnum.two", val.Value);
 
358
                        Assert.AreEqual ("two", val.DisplayValue);
 
359
                        Assert.AreEqual ("SomeEnum", val.TypeName);
 
360
                        
 
361
                        val = Eval ("(SomeEnum)3");
 
362
                        Assert.AreEqual ("SomeEnum.one|SomeEnum.two", val.Value);
 
363
                        Assert.AreEqual ("one|two", val.DisplayValue);
 
364
                        Assert.AreEqual ("SomeEnum", val.TypeName);
 
365
                }
 
366
                
 
367
                [Test()]
 
368
                public void BinaryOperators ()
 
369
                {
 
370
                        ObjectValue val;
 
371
                        
 
372
                        // Boolean
 
373
                        
 
374
                        val = Eval ("true && true");
 
375
                        Assert.AreEqual ("true", val.Value);
 
376
                        Assert.AreEqual ("bool", val.TypeName);
 
377
                        
 
378
                        val = Eval ("true && false");
 
379
                        Assert.AreEqual ("false", val.Value);
 
380
                        Assert.AreEqual ("bool", val.TypeName);
 
381
                        
 
382
                        val = Eval ("false && true");
 
383
                        Assert.AreEqual ("false", val.Value);
 
384
                        Assert.AreEqual ("bool", val.TypeName);
 
385
                        
 
386
                        val = Eval ("false && false");
 
387
                        Assert.AreEqual ("false", val.Value);
 
388
                        Assert.AreEqual ("bool", val.TypeName);
 
389
                        
 
390
                        val = Eval ("false || false");
 
391
                        Assert.AreEqual ("false", val.Value);
 
392
                        Assert.AreEqual ("bool", val.TypeName);
 
393
                        
 
394
                        val = Eval ("false || true");
 
395
                        Assert.AreEqual ("true", val.Value);
 
396
                        Assert.AreEqual ("bool", val.TypeName);
 
397
                        
 
398
                        val = Eval ("true || false");
 
399
                        Assert.AreEqual ("true", val.Value);
 
400
                        Assert.AreEqual ("bool", val.TypeName);
 
401
                        
 
402
                        val = Eval ("true || true");
 
403
                        Assert.AreEqual ("true", val.Value);
 
404
                        Assert.AreEqual ("bool", val.TypeName);
 
405
                        
 
406
                        val = Eval ("false || 1");
 
407
                        Assert.IsTrue (val.IsError);
 
408
                        
 
409
                        val = Eval ("1 || true");
 
410
                        Assert.IsTrue (val.IsError);
 
411
                        
 
412
                        val = Eval ("true && 1");
 
413
                        Assert.IsTrue (val.IsError);
 
414
                        
 
415
                        val = Eval ("1 && true");
 
416
                        Assert.IsTrue (val.IsError);
 
417
                        
 
418
                        // Concat string
 
419
                        
 
420
                        val = Eval ("\"a\" + \"b\"");
 
421
                        Assert.AreEqual ("\"ab\"", val.Value);
 
422
                        Assert.AreEqual ("string", val.TypeName);
 
423
                        
 
424
                        val = Eval ("\"a\" + 2");
 
425
                        Assert.AreEqual ("\"a2\"", val.Value);
 
426
                        Assert.AreEqual ("string", val.TypeName);
 
427
                        
 
428
                        val = Eval ("2 + \"a\"");
 
429
                        Assert.AreEqual ("\"2a\"", val.Value);
 
430
                        Assert.AreEqual ("string", val.TypeName);
 
431
                        
 
432
                        val = Eval ("this + \"a\"");
 
433
                        Assert.AreEqual ("\"MonoDevelop.Debugger.Tests.TestApp.MainClassa\"", val.Value);
 
434
                        Assert.AreEqual ("string", val.TypeName);
 
435
                        
 
436
                        // Equality
 
437
                        
 
438
                        val = Eval ("2 == 2");
 
439
                        Assert.AreEqual ("true", val.Value);
 
440
                        Assert.AreEqual ("bool", val.TypeName);
 
441
                        
 
442
                        val = Eval ("2 == 3");
 
443
                        Assert.AreEqual ("false", val.Value);
 
444
                        Assert.AreEqual ("bool", val.TypeName);
 
445
                        
 
446
                        val = Eval ("(long)2 == (int)2");
 
447
                        Assert.AreEqual ("true", val.Value);
 
448
                        Assert.AreEqual ("bool", val.TypeName);
 
449
                        
 
450
                        // Arithmetic
 
451
                        
 
452
                        val = Eval ("2 + 3");
 
453
                        Assert.AreEqual ("5", val.Value);
 
454
                        
 
455
                        val = Eval ("2 + 2 == 4");
 
456
                        Assert.AreEqual ("true", val.Value);
 
457
                        Assert.AreEqual ("bool", val.TypeName);
 
458
                }
 
459
                
 
460
                [Test()]
 
461
                public virtual void Assignment ()
 
462
                {
 
463
                        ObjectValue val;
 
464
                        Eval ("n = 6");
 
465
                        val = Eval ("n");
 
466
                        Assert.AreEqual ("6", val.Value);
 
467
                        Assert.AreEqual ("int", val.TypeName);
 
468
                        Eval ("n = 32");
 
469
                        val = Eval ("n");
 
470
                        Assert.AreEqual ("32", val.Value);
 
471
                        
 
472
                        Eval ("someString = \"test\"");
 
473
                        val = Eval ("someString");
 
474
                        Assert.AreEqual ("\"test\"", val.Value);
 
475
                        Assert.AreEqual ("string", val.TypeName);
 
476
                        Eval ("someString = \"hi\"");
 
477
                        val = Eval ("someString");
 
478
                        Assert.AreEqual ("\"hi\"", val.Value);
 
479
                        
 
480
                        Eval ("numbers[0] = \"test\"");
 
481
                        val = Eval ("numbers[0]");
 
482
                        Assert.AreEqual ("\"test\"", val.Value);
 
483
                        Assert.AreEqual ("string", val.TypeName);
 
484
                        Eval ("numbers[0] = \"one\"");
 
485
                        val = Eval ("numbers[0]");
 
486
                        Assert.AreEqual ("\"one\"", val.Value);
 
487
 
 
488
                        Eval ("alist[0] = 6");
 
489
                        val = Eval ("alist[0]");
 
490
                        Assert.AreEqual ("6", val.Value);
 
491
                        Assert.AreEqual ("int", val.TypeName);
 
492
                        Eval ("alist[0] = 1");
 
493
                        val = Eval ("alist[0]");
 
494
                        Assert.AreEqual ("1", val.Value);
 
495
                }
 
496
                
 
497
                [Test()]
 
498
                public virtual void AssignmentStatic ()
 
499
                {
 
500
                        ObjectValue val;
 
501
                        
 
502
                        Eval ("staticString = \"test\"");
 
503
                        val = Eval ("staticString");
 
504
                        Assert.AreEqual ("\"test\"", val.Value);
 
505
                        Assert.AreEqual ("string", val.TypeName);
 
506
                        Eval ("staticString = \"some static\"");
 
507
                        val = Eval ("staticString");
 
508
                        Assert.AreEqual ("\"some static\"", val.Value);
 
509
                }
 
510
                
 
511
                [Test()]
 
512
                public void FormatBool ()
 
513
                {
 
514
                        ObjectValue val;
 
515
                        val = Eval ("true");
 
516
                        Assert.AreEqual ("true", val.Value);
 
517
                        val = Eval ("false");
 
518
                        Assert.AreEqual ("false", val.Value);
 
519
                }
 
520
                
 
521
                [Test()]
 
522
                public void FormatNumber ()
 
523
                {
 
524
                        ObjectValue val;
 
525
                        val = Eval ("(int)123");
 
526
                        Assert.AreEqual ("123", val.Value);
 
527
                        val = Eval ("(int)-123");
 
528
                        Assert.AreEqual ("-123", val.Value);
 
529
                        
 
530
                        val = Eval ("(long)123");
 
531
                        Assert.AreEqual ("123", val.Value);
 
532
                        val = Eval ("(long)-123");
 
533
                        Assert.AreEqual ("-123", val.Value);
 
534
                        
 
535
                        val = Eval ("(byte)123");
 
536
                        Assert.AreEqual ("123", val.Value);
 
537
                        
 
538
                        val = Eval ("(uint)123");
 
539
                        Assert.AreEqual ("123", val.Value);
 
540
                        
 
541
                        val = Eval ("(ulong)123");
 
542
                        Assert.AreEqual ("123", val.Value);
 
543
                        
 
544
                        val = Eval ("dec");
 
545
                        Assert.AreEqual ("123.456", val.Value);
 
546
                }
 
547
                
 
548
                [Test()]
 
549
                public void FormatString ()
 
550
                {
 
551
                        ObjectValue val;
 
552
                        val = Eval ("\"hi\"");
 
553
                        Assert.AreEqual ("\"hi\"", val.Value);
 
554
                        
 
555
                        val = Eval ("EscapedStrings");
 
556
                        Assert.AreEqual ("\" \\\" \\\\ \\a \\b \\f \\v \\n \\r \\t\"", val.Value);
 
557
                        
 
558
                        val = Eval ("\" \\\" \\\\ \\a \\b \\f \\v \\n \\r \\t\"");
 
559
                        Assert.AreEqual ("\" \\\" \\\\ \\a \\b \\f \\v \\n \\r \\t\"", val.Value);
 
560
                }
 
561
                
 
562
                [Test()]
 
563
                public void FormatChar ()
 
564
                {
 
565
                        ObjectValue val;
 
566
                        val = Eval ("'A'");
 
567
                        Assert.AreEqual ("'A'", val.Value);
 
568
                        Assert.AreEqual ("65 'A'", val.DisplayValue);
 
569
                        
 
570
                        val = Eval ("'\\0'");
 
571
                        Assert.AreEqual ("'\\0'", val.Value);
 
572
                        Assert.AreEqual ("0 '\\0'", val.DisplayValue);
 
573
                        
 
574
                        val = Eval ("'\"'");
 
575
                        Assert.AreEqual ("'\"'", val.Value);
 
576
                        Assert.AreEqual ("34 '\"'", val.DisplayValue);
 
577
                        
 
578
                        val = Eval ("'\\''");
 
579
                        Assert.AreEqual ("'\\''", val.Value);
 
580
                        Assert.AreEqual ("39 '\\''", val.DisplayValue);
 
581
                        
 
582
                        val = Eval ("'\\\\'");
 
583
                        Assert.AreEqual ("'\\\\'", val.Value);
 
584
                        Assert.AreEqual ("92 '\\\\'", val.DisplayValue);
 
585
                        
 
586
                        val = Eval ("'\\a'");
 
587
                        Assert.AreEqual ("'\\a'", val.Value);
 
588
                        Assert.AreEqual ("7 '\\a'", val.DisplayValue);
 
589
                        
 
590
                        val = Eval ("'\\b'");
 
591
                        Assert.AreEqual ("'\\b'", val.Value);
 
592
                        Assert.AreEqual ("8 '\\b'", val.DisplayValue);
 
593
                        
 
594
                        val = Eval ("'\\f'");
 
595
                        Assert.AreEqual ("'\\f'", val.Value);
 
596
                        Assert.AreEqual ("12 '\\f'", val.DisplayValue);
 
597
                        
 
598
                        val = Eval ("'\\v'");
 
599
                        Assert.AreEqual ("'\\v'", val.Value);
 
600
                        Assert.AreEqual ("11 '\\v'", val.DisplayValue);
 
601
                        
 
602
                        val = Eval ("'\\n'");
 
603
                        Assert.AreEqual ("'\\n'", val.Value);
 
604
                        Assert.AreEqual ("10 '\\n'", val.DisplayValue);
 
605
                        
 
606
                        val = Eval ("'\\r'");
 
607
                        Assert.AreEqual ("'\\r'", val.Value);
 
608
                        Assert.AreEqual ("13 '\\r'", val.DisplayValue);
 
609
                        
 
610
                        val = Eval ("'\\t'");
 
611
                        Assert.AreEqual ("'\\t'", val.Value);
 
612
                        Assert.AreEqual ("9 '\\t'", val.DisplayValue);
 
613
                }
 
614
                
 
615
                [Test()]
 
616
                public void FormatObject ()
 
617
                {
 
618
                        ObjectValue val;
 
619
                        
 
620
                        val = Eval ("c");
 
621
                        Assert.AreEqual ("{C}", val.Value);
 
622
                        Assert.AreEqual ("C", val.TypeName);
 
623
                        
 
624
                        val = Eval ("withDisplayString");
 
625
                        Assert.AreEqual ("Some one Value 2 End", val.Value);
 
626
                        Assert.AreEqual ("WithDisplayString", val.TypeName);
 
627
                        
 
628
                        val = Eval ("withProxy");
 
629
                        Assert.AreEqual ("{WithProxy}", val.Value);
 
630
                        Assert.AreEqual ("WithProxy", val.TypeName);
 
631
                        
 
632
/*                      val = Eval ("withToString");
 
633
                        Assert.AreEqual ("{SomeString}", val.Value);
 
634
                        Assert.AreEqual ("WithToString", val.TypeName);*/
 
635
                }
 
636
                
 
637
                [Test()]
 
638
                public void FormatArray ()
 
639
                {
 
640
                        ObjectValue val;
 
641
                        
 
642
                        val = Eval ("numbers");
 
643
                        Assert.AreEqual ("{string[3]}", val.Value);
 
644
                        Assert.AreEqual ("string[]", val.TypeName);
 
645
                        
 
646
                        val = Eval ("numbersArrays");
 
647
                        Assert.AreEqual ("{int[2][]}", val.Value);
 
648
                        Assert.AreEqual ("int[][]", val.TypeName);
 
649
                        
 
650
                        val = Eval ("numbersMulti");
 
651
                        Assert.AreEqual ("{int[3,4,5]}", val.Value);
 
652
                        Assert.AreEqual ("int[,,]", val.TypeName);
 
653
                }
 
654
                
 
655
                [Test()]
 
656
                public void FormatGeneric ()
 
657
                {
 
658
                        ObjectValue val;
 
659
                
 
660
                        ds.Options.EvaluationOptions.AllowTargetInvoke = false;
 
661
                        val = Eval ("dict");
 
662
                        ds.Options.EvaluationOptions.AllowTargetInvoke = true;
 
663
                        Assert.AreEqual ("{System.Collections.Generic.Dictionary<int,string[]>}", val.Value);
 
664
                        Assert.AreEqual ("System.Collections.Generic.Dictionary<int,string[]>", val.TypeName);
 
665
                        
 
666
                        ds.Options.EvaluationOptions.AllowTargetInvoke = false;
 
667
                        val = Eval ("dictArray");
 
668
                        ds.Options.EvaluationOptions.AllowTargetInvoke = true;
 
669
                        Assert.AreEqual ("{System.Collections.Generic.Dictionary<int,string[]>[2,3]}", val.Value);
 
670
                        Assert.AreEqual ("System.Collections.Generic.Dictionary<int,string[]>[,]", val.TypeName);
 
671
                        
 
672
                        val = Eval ("thing.done");
 
673
                        Assert.AreEqual ("{Thing<string>.Done<int>[1]}", val.Value);
 
674
                        Assert.AreEqual ("Thing<string>.Done<int>[]", val.TypeName);
 
675
                        
 
676
                        val = Eval ("done");
 
677
                        Assert.AreEqual ("{Thing<string>.Done<int>}", val.Value);
 
678
                        Assert.AreEqual ("Thing<string>.Done<int>", val.TypeName);
 
679
                }
 
680
                
 
681
                [Test()]
 
682
                public void FormatEnum ()
 
683
                {
 
684
                        ObjectValue val;
 
685
                        
 
686
                        val = Eval ("SomeEnum.one");
 
687
                        Assert.AreEqual ("SomeEnum.one", val.Value);
 
688
                        Assert.AreEqual ("one", val.DisplayValue);
 
689
                        
 
690
                        val = Eval ("SomeEnum.two");
 
691
                        Assert.AreEqual ("SomeEnum.two", val.Value);
 
692
                        Assert.AreEqual ("two", val.DisplayValue);
 
693
                        
 
694
                        val = Eval ("SomeEnum.one | SomeEnum.two");
 
695
                        Assert.AreEqual ("SomeEnum.one|SomeEnum.two", val.Value);
 
696
                        Assert.AreEqual ("one|two", val.DisplayValue);
 
697
                }
 
698
        }
 
699
}