← Back to branch summary

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

« back to all changes in this revision

Viewing changes to tests/UnitTests/MonoDevelop.Projects/DomPersistenceTests.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:
tests/UnitTests/MonoDevelop.Projects/DomPersistenceTests.cs
 
1
//
 
2
// DomPersistenceTests.cs
 
3
//
 
4
// Author:
 
5
//   Mike Krüger <mkrueger@novell.com>
 
6
//
 
7
// Copyright (C) 2008 Novell, Inc (http://www.novell.com)
 
8
//
 
9
// Permission is hereby granted, free of charge, to any person obtaining
 
10
// a copy of this software and associated documentation files (the
 
11
// "Software"), to deal in the Software without restriction, including
 
12
// without limitation the rights to use, copy, modify, merge, publish,
 
13
// distribute, sublicense, and/or sell copies of the Software, and to
 
14
// permit persons to whom the Software is furnished to do so, subject to
 
15
// the following conditions:
 
16
// 
 
17
// The above copyright notice and this permission notice shall be
 
18
// included in all copies or substantial portions of the Software.
 
19
// 
 
20
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
21
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
22
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 
23
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 
24
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 
25
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 
26
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
27
//
 
28
 
 
29
using System;
 
30
using System.CodeDom;
 
31
using System.Collections.Generic;
 
32
using System.IO;
 
33
using NUnit.Framework;
 
34
using MonoDevelop.Projects.Dom;
 
35
using MonoDevelop.Projects.Dom.Serialization;
 
36
 
 
37
namespace MonoDevelop.Projects.DomTests
 
38
{
 
39
        [TestFixture()]
 
40
        public class DomPersistenceTests : UnitTests.TestBase
 
41
        {
 
42
                
 
43
                [Test()]
 
44
                public void ReadWriteLocationTest ()
 
45
                {
 
46
                        DomLocation input = new DomLocation (3, 9);
 
47
                        MemoryStream ms = new MemoryStream ();
 
48
                        BinaryWriter writer = new BinaryWriter (ms);
 
49
                        DomPersistence.Write (writer, null, input);
 
50
                        byte[] bytes = ms.ToArray ();
 
51
                        
 
52
                        DomLocation result = DomPersistence.ReadLocation (CreateReader (bytes), null);
 
53
                        Assert.AreEqual (3, result.Line);
 
54
                        Assert.AreEqual (9, result.Column);
 
55
                }
 
56
                
 
57
                [Test()]
 
58
                public void ReadWriteRegionTest ()
 
59
                {
 
60
                        DomRegion input = new DomRegion (1, 2, 3, 4);
 
61
                        
 
62
                        MemoryStream ms = new MemoryStream ();
 
63
                        BinaryWriter writer = new BinaryWriter (ms);
 
64
                        DomPersistence.Write (writer, DefaultNameEncoder, input);
 
65
                        byte[] bytes = ms.ToArray ();
 
66
                        
 
67
                        DomRegion result = DomPersistence.ReadRegion (CreateReader (bytes), DefaultNameDecoder);
 
68
                        Assert.AreEqual (1, result.Start.Line);
 
69
                        Assert.AreEqual (2, result.Start.Column);
 
70
                        Assert.AreEqual (3, result.End.Line);
 
71
                        Assert.AreEqual (4, result.End.Column);
 
72
                }
 
73
                
 
74
                
 
75
                [Test()]
 
76
                public void ReadWriteFieldTest ()
 
77
                {
 
78
                        DomField input = new DomField ();
 
79
                        input.Name = "TestField";
 
80
                        input.Location = new DomLocation (5, 10);
 
81
                        input.Documentation = "testDocumentation";
 
82
                        input.Modifiers = Modifiers.Static;
 
83
                        input.ReturnType = new DomReturnType ("System.String");
 
84
                        
 
85
                        MemoryStream ms = new MemoryStream ();
 
86
                        BinaryWriter writer = new BinaryWriter (ms);
 
87
                        DomPersistence.Write (writer, DefaultNameEncoder, input);
 
88
                        byte[] bytes = ms.ToArray ();
 
89
                        
 
90
                        DomField result = DomPersistence.ReadField (CreateReader (bytes), DefaultNameDecoder, null);
 
91
                        Assert.AreEqual ("TestField", result.Name);
 
92
                        Assert.AreEqual ("testDocumentation", result.Documentation);
 
93
                        Assert.AreEqual (new DomLocation (5, 10), result.Location);
 
94
                        Assert.AreEqual (Modifiers.Static, result.Modifiers);
 
95
                        Assert.AreEqual ("System.String", result.ReturnType.FullName);
 
96
                }
 
97
                
 
98
                [Test()]
 
99
                public void ReadWriteFieldTest2 ()
 
100
                {
 
101
                        DomField input = new DomField ();
 
102
                        input.Name = null;
 
103
                        input.Location = DomLocation.Empty;
 
104
                        input.Documentation = null;
 
105
                        input.Modifiers = Modifiers.None;
 
106
                        input.ReturnType = null;
 
107
                        
 
108
                        MemoryStream ms = new MemoryStream ();
 
109
                        BinaryWriter writer = new BinaryWriter (ms);
 
110
                        DomPersistence.Write (writer, DefaultNameEncoder, input);
 
111
                        byte[] bytes = ms.ToArray ();
 
112
                        
 
113
                        DomField result = DomPersistence.ReadField (CreateReader (bytes), DefaultNameDecoder, null);
 
114
                        Assert.AreEqual (null, result.Name);
 
115
                        Assert.AreEqual (null, result.Documentation);
 
116
                        Assert.AreEqual (DomLocation.Empty, result.Location);
 
117
                        Assert.AreEqual (Modifiers.None, result.Modifiers);
 
118
                        Assert.AreEqual (null, result.ReturnType);
 
119
                }
 
120
                
 
121
                [Test()]
 
122
                public void ReadWriteReturnTypeTest ()
 
123
                {
 
124
                        DomReturnType input = new DomReturnType ();
 
125
                        input.Name      = "Test";
 
126
                        input.Namespace = "Namespace";
 
127
                        input.ArrayDimensions = 5;
 
128
                        input.IsByRef = true;
 
129
                        input.IsNullable = true;
 
130
                        input.PointerNestingLevel = 666;
 
131
                        input.AddTypeParameter (new DomReturnType ("System.String"));
 
132
                        input.AddTypeParameter (new DomReturnType ("System.Int32"));
 
133
                        MemoryStream ms = new MemoryStream ();
 
134
                        BinaryWriter writer = new BinaryWriter (ms);
 
135
                        DomPersistence.Write (writer, DefaultNameEncoder, input);
 
136
                        byte[] bytes = ms.ToArray ();
 
137
                        
 
138
                        IReturnType result = DomPersistence.ReadReturnType (CreateReader (bytes), DefaultNameDecoder, null);
 
139
                        Assert.AreEqual ("Test", result.Name);
 
140
                        Assert.AreEqual ("Namespace", result.Namespace);
 
141
                        Assert.AreEqual ("Namespace.Test", result.FullName);
 
142
                        Assert.AreEqual (5, result.ArrayDimensions);
 
143
                        Assert.AreEqual (true, result.IsByRef);
 
144
                        Assert.AreEqual (true, result.IsNullable);
 
145
                        Assert.AreEqual ("System.String", result.GenericArguments[0].FullName);
 
146
                        Assert.AreEqual ("System.Int32", result.GenericArguments[1].FullName);
 
147
                }
 
148
                
 
149
                [Test()]
 
150
                public void ReadWriteMethodTest ()
 
151
                {
 
152
                        DomMethod input = new DomMethod ();
 
153
                        input.Name      = "Test";
 
154
                        input.MethodModifier = MethodModifier.IsConstructor;
 
155
                        input.Add (new DomParameter (input, "par1", DomReturnType.Void));
 
156
                        input.AddTypeParameter (new TypeParameter ("T"));
 
157
                        MemoryStream ms = new MemoryStream ();
 
158
                        BinaryWriter writer = new BinaryWriter (ms);
 
159
                        DomPersistence.Write (writer, DefaultNameEncoder, input);
 
160
                        byte[] bytes = ms.ToArray ();
 
161
                        
 
162
                        DomMethod result = DomPersistence.ReadMethod (CreateReader (bytes), DefaultNameDecoder, null);
 
163
                        Assert.AreEqual ("Test", result.Name);
 
164
                        Assert.AreEqual (true, result.IsConstructor);
 
165
                        Assert.AreEqual ("par1", result.Parameters [0].Name);
 
166
                        Assert.AreEqual ("Void", result.Parameters [0].ReturnType.Name);
 
167
                        Assert.AreEqual (1, result.TypeParameters.Count);
 
168
                        Assert.AreEqual ("T", result.TypeParameters [0].Name);
 
169
                }
 
170
                
 
171
                [Test()]
 
172
                public void ReadWriteDelegateTest ()
 
173
                {
 
174
                        DomType input = DomType.CreateDelegate (null, "TestDelegate", new DomLocation (10, 10), DomReturnType.Void, new List<IParameter> ());
 
175
                        
 
176
                        MemoryStream ms = new MemoryStream ();
 
177
                        BinaryWriter writer = new BinaryWriter (ms);
 
178
                        DomPersistence.Write (writer, DefaultNameEncoder, input);
 
179
                        byte[] bytes = ms.ToArray ();
 
180
                        
 
181
                        DomType result = DomPersistence.ReadType (CreateReader (bytes), DefaultNameDecoder, null);
 
182
                        Assert.AreEqual ("TestDelegate", result.Name);
 
183
                        Assert.AreEqual (ClassType.Delegate, result.ClassType);
 
184
                }
 
185
                
 
186
                [Test()]
 
187
                public void ReadWritePropertyTest ()
 
188
                {
 
189
                        DomProperty input = new DomProperty ();
 
190
                        input.Name      = "Test";
 
191
                        input.PropertyModifier = PropertyModifier.IsIndexer | PropertyModifier.HasGet | PropertyModifier.HasSet;
 
192
                        
 
193
                        MemoryStream ms = new MemoryStream ();
 
194
                        BinaryWriter writer = new BinaryWriter (ms);
 
195
                        DomPersistence.Write (writer, DefaultNameEncoder, input);
 
196
                        byte[] bytes = ms.ToArray ();
 
197
                        
 
198
                        DomProperty result = DomPersistence.ReadProperty (CreateReader (bytes), DefaultNameDecoder, null);
 
199
                        Assert.AreEqual ("Test", result.Name);
 
200
                        Assert.AreEqual (true, result.IsIndexer);
 
201
                        Assert.AreEqual (true, result.HasGet);
 
202
                        Assert.AreEqual (true, result.HasSet);
 
203
                }
 
204
                
 
205
                [Test()]
 
206
                public void ReadWriteEventTest ()
 
207
                {
 
208
                        DomEvent input     = new DomEvent ();
 
209
                        input.Name         = "Test";
 
210
                        input.AddMethod    = new DomMethod ("AddMethod", Modifiers.New, MethodModifier.None, DomLocation.Empty, DomRegion.Empty);
 
211
                        input.RemoveMethod = new DomMethod ("RemoveMethod", Modifiers.New, MethodModifier.None, DomLocation.Empty, DomRegion.Empty);
 
212
                        input.RaiseMethod  = new DomMethod ("RaiseMethod", Modifiers.New, MethodModifier.None, DomLocation.Empty, DomRegion.Empty);
 
213
                        
 
214
                        MemoryStream ms = new MemoryStream ();
 
215
                        BinaryWriter writer = new BinaryWriter (ms);
 
216
                        DomPersistence.Write (writer, DefaultNameEncoder, input);
 
217
                        byte[] bytes = ms.ToArray ();
 
218
                        
 
219
                        DomEvent result = DomPersistence.ReadEvent (CreateReader (bytes), DefaultNameDecoder, null);
 
220
                        Assert.AreEqual ("Test", result.Name);
 
221
                        Assert.AreEqual ("AddMethod", result.AddMethod.Name);
 
222
                        Assert.AreEqual ("RemoveMethod", result.RemoveMethod.Name);
 
223
                        Assert.AreEqual ("RaiseMethod", result.RaiseMethod.Name);
 
224
                }
 
225
                
 
226
                [Test()]
 
227
                public void ReadWriteTypeTest ()
 
228
                {
 
229
                        DomType input     = new DomType ();
 
230
                        input.Name         = "Test";
 
231
                        input.ClassType    = ClassType.Struct;
 
232
                        input.BaseType     = new DomReturnType ("BaseClass");
 
233
                        
 
234
                        MemoryStream ms = new MemoryStream ();
 
235
                        BinaryWriter writer = new BinaryWriter (ms);
 
236
                        DomPersistence.Write (writer, DefaultNameEncoder, input);
 
237
                        byte[] bytes = ms.ToArray ();
 
238
                        
 
239
                        DomType result = DomPersistence.ReadType (CreateReader (bytes), DefaultNameDecoder, null);
 
240
                        Assert.AreEqual ("Test", result.Name);
 
241
                        Assert.AreEqual (ClassType.Struct, result.ClassType);
 
242
                        Assert.AreEqual ("BaseClass", result.BaseType.Name);
 
243
                }
 
244
                
 
245
                [Test()]
 
246
                public void ReadWriteTypeTestComplex ()
 
247
                {
 
248
                        DomType input   = new DomType ();
 
249
                        
 
250
                        input.Name      = "Test";
 
251
                        input.ClassType = ClassType.Struct;
 
252
                        input.BaseType  = new DomReturnType ("BaseClass");
 
253
                        input.AddInterfaceImplementation (new DomReturnType ("Interface1"));
 
254
                        input.AddInterfaceImplementation (new DomReturnType ("Interface2"));
 
255
                        
 
256
                        input.Add (new DomMethod ("TestMethod", Modifiers.None, MethodModifier.None, DomLocation.Empty, DomRegion.Empty));
 
257
                        input.Add (new DomMethod (".ctor", Modifiers.None, MethodModifier.IsConstructor, DomLocation.Empty, DomRegion.Empty));
 
258
                        
 
259
                        input.Add (new DomField ("TestField", Modifiers.None, DomLocation.Empty, DomReturnType.Void));
 
260
                        input.Add (new DomProperty ("TestProperty", Modifiers.None, DomLocation.Empty, DomRegion.Empty, DomReturnType.Void));
 
261
                        input.Add (new DomEvent ("TestEvent", Modifiers.None, DomLocation.Empty, DomReturnType.Void));
 
262
                        MemoryStream ms = new MemoryStream ();
 
263
                        BinaryWriter writer = new BinaryWriter (ms);
 
264
                        DomPersistence.Write (writer, DefaultNameEncoder, input);
 
265
                        byte[] bytes = ms.ToArray ();
 
266
                        
 
267
                        DomType result = DomPersistence.ReadType (CreateReader (bytes), DefaultNameDecoder, null);
 
268
                        Assert.AreEqual ("Test", result.Name);
 
269
                        Assert.AreEqual (ClassType.Struct, result.ClassType);
 
270
                        Assert.AreEqual ("BaseClass", result.BaseType.Name);
 
271
                        Assert.AreEqual (1, result.MethodCount);
 
272
                        Assert.AreEqual (1, result.ConstructorCount);
 
273
                        Assert.AreEqual (1, result.FieldCount);
 
274
                        Assert.AreEqual (1, result.PropertyCount);
 
275
                        Assert.AreEqual (1, result.EventCount);
 
276
                        
 
277
                }
 
278
                
 
279
                [Test()]
 
280
                public void ReadWriteAttributeTest ()
 
281
                {
 
282
                        DomAttribute attr = new DomAttribute ();
 
283
                        
 
284
                        CodePropertyReferenceExpression exp1 = new CodePropertyReferenceExpression ();
 
285
                        exp1.TargetObject = new CodeTypeReferenceExpression ("SomeType");
 
286
                        exp1.PropertyName = "SomeProperty";
 
287
                        
 
288
                        CodeTypeOfExpression exp2 = new CodeTypeOfExpression ("SomeTypeOf");
 
289
                        
 
290
                        CodeBinaryOperatorExpression exp3 = new CodeBinaryOperatorExpression ();
 
291
                        exp3.Left = new CodePrimitiveExpression ("one");
 
292
                        exp3.Right = new CodePrimitiveExpression ("two");
 
293
                        exp3.Operator = CodeBinaryOperatorType.Add;
 
294
                        
 
295
                        CodePrimitiveExpression exp4 = new CodePrimitiveExpression (37);
 
296
                        
 
297
                        attr.AddPositionalArgument (exp1);
 
298
                        attr.AddPositionalArgument (exp2);
 
299
                        attr.AddPositionalArgument (exp3);
 
300
                        attr.AddPositionalArgument (exp4);
 
301
                        
 
302
                        MemoryStream ms = new MemoryStream ();
 
303
                        BinaryWriter writer = new BinaryWriter (ms);
 
304
                        DomPersistence.Write (writer, DefaultNameEncoder, attr);
 
305
                        byte[] bytes = ms.ToArray ();
 
306
                        DomAttribute result = DomPersistence.ReadAttribute (CreateReader (bytes), DefaultNameDecoder, null);
 
307
                        
 
308
                        Assert.AreEqual (4, result.PositionalArguments.Count);
 
309
                        
 
310
                        Assert.AreEqual (typeof(CodePropertyReferenceExpression), result.PositionalArguments [0].GetType ());
 
311
                        CodePropertyReferenceExpression rexp1 = (CodePropertyReferenceExpression) result.PositionalArguments [0];
 
312
                        Assert.AreEqual (typeof(CodeTypeReferenceExpression), rexp1.TargetObject.GetType ());
 
313
                        Assert.AreEqual ("SomeType", ((CodeTypeReferenceExpression)rexp1.TargetObject).Type.BaseType);
 
314
                        Assert.AreEqual ("SomeProperty", rexp1.PropertyName);
 
315
                        
 
316
                        Assert.AreEqual (typeof(CodeTypeOfExpression), result.PositionalArguments [1].GetType ());
 
317
                        Assert.AreEqual ("SomeTypeOf", ((CodeTypeOfExpression)result.PositionalArguments [1]).Type.BaseType);
 
318
                        
 
319
                        Assert.AreEqual (typeof(CodeBinaryOperatorExpression), result.PositionalArguments [2].GetType ());
 
320
                        CodeBinaryOperatorExpression rexp3 = (CodeBinaryOperatorExpression) result.PositionalArguments [2];
 
321
                        Assert.AreEqual (typeof(CodePrimitiveExpression), rexp3.Left.GetType ());
 
322
                        Assert.AreEqual ("one", ((CodePrimitiveExpression)rexp3.Left).Value);
 
323
                        Assert.AreEqual (typeof(CodePrimitiveExpression), rexp3.Right.GetType ());
 
324
                        Assert.AreEqual ("two", ((CodePrimitiveExpression)rexp3.Right).Value);
 
325
                        
 
326
                        Assert.AreEqual (typeof(CodePrimitiveExpression), result.PositionalArguments [3].GetType ());
 
327
                        Assert.AreEqual (37, ((CodePrimitiveExpression)result.PositionalArguments [3]).Value);
 
328
                }
 
329
                
 
330
                static BinaryReader CreateReader (byte[] bytes)
 
331
                {
 
332
                        return new BinaryReader (new MemoryStream (bytes));
 
333
                }
 
334
 
 
335
//      Doesn't work: ?
 
336
//              byte[] Write<T> (T input)
 
337
//              {
 
338
//                      MemoryStream ms = new MemoryStream ();
 
339
//                      BinaryWriter writer = new BinaryWriter (ms);
 
340
//                      DomPersistence.Write (writer, null, input);
 
341
//                      return ms.ToArray ();
 
342
//              }
 
343
                
 
344
                
 
345
                static StringNameTable DefaultNameEncoder;
 
346
                static StringNameTable DefaultNameDecoder;
 
347
                
 
348
                static DomPersistenceTests ()
 
349
                {
 
350
                        DefaultNameEncoder = new StringNameTable (sharedNameTable);
 
351
                        DefaultNameDecoder = new StringNameTable (sharedNameTable);
 
352
                }
 
353
                
 
354
                static readonly string[] sharedNameTable = new string[] {
 
355
                        "", // 505195
 
356
                        "System.Void", // 116020
 
357
                        "To be added", // 78598
 
358
                        "System.Int32", // 72669
 
359
                        "System.String", // 72097
 
360
                        "System.Object", // 48530
 
361
                        "System.Boolean", // 46200
 
362
                        ".ctor", // 39938
 
363
                        "System.IntPtr", // 35184
 
364
                        "To be added.", // 19082
 
365
                        "value", // 11906
 
366
                        "System.Byte", // 8524
 
367
                        "To be added: an object of type 'string'", // 7928
 
368
                        "e", // 7858
 
369
                        "raw", // 7830
 
370
                        "System.IAsyncResult", // 7760
 
371
                        "System.Type", // 7518
 
372
                        "name", // 7188
 
373
                        "object", // 6982
 
374
                        "System.UInt32", // 6966
 
375
                        "index", // 6038
 
376
                        "To be added: an object of type 'int'", // 5196
 
377
                        "System.Int64", // 4166
 
378
                        "callback", // 4158
 
379
                        "System.EventArgs", // 4140
 
380
                        "method", // 4030
 
381
                        "System.Enum", // 3980
 
382
                        "value__", // 3954
 
383
                        "Invoke", // 3906
 
384
                        "result", // 3856
 
385
                        "System.AsyncCallback", // 3850
 
386
                        "System.MulticastDelegate", // 3698
 
387
                        "BeginInvoke", // 3650
 
388
                        "EndInvoke", // 3562
 
389
                        "node", // 3416
 
390
                        "sender", // 3398
 
391
                        "context", // 3310
 
392
                        "System.EventHandler", // 3218
 
393
                        "System.Double", // 3206
 
394
                        "type", // 3094
 
395
                        "x", // 3056
 
396
                        "System.Single", // 2940
 
397
                        "data", // 2930
 
398
                        "args", // 2926
 
399
                        "System.Char", // 2813
 
400
                        "Gdk.Key", // 2684
 
401
                        "ToString", // 2634
 
402
                        "'a", // 2594
 
403
                        "System.Drawing.Color", // 2550
 
404
                        "y", // 2458
 
405
                        "To be added: an object of type 'object'", // 2430
 
406
                        "System.DateTime", // 2420
 
407
                        "message", // 2352
 
408
                        "GLib.GType", // 2292
 
409
                        "o", // 2280
 
410
                        "a <see cref=\"T:System.Int32\" />", // 2176
 
411
                        "path", // 2062
 
412
                        "obj", // 2018
 
413
                        "Nemerle.Core.list`1", // 1950
 
414
                        "System.Windows.Forms", // 1942
 
415
                        "System.Collections.ArrayList", // 1918
 
416
                        "a <see cref=\"T:System.String\" />", // 1894
 
417
                        "key", // 1868
 
418
                        "Add", // 1864
 
419
                        "arg0", // 1796
 
420
                        "System.IO.Stream", // 1794
 
421
                        "s", // 1784
 
422
                        "arg1", // 1742
 
423
                        "provider", // 1704
 
424
                        "System.UInt64", // 1700
 
425
                        "System.Drawing.Rectangle", // 1684
 
426
                        "System.IFormatProvider", // 1684
 
427
                        "gch", // 1680
 
428
                        "System.Exception", // 1652
 
429
                        "Equals", // 1590
 
430
                        "System.Drawing.Pen", // 1584
 
431
                        "count", // 1548
 
432
                        "System.Collections.IEnumerator", // 1546
 
433
                        "info", // 1526
 
434
                        "Name", // 1512
 
435
                        "System.Attribute", // 1494
 
436
                        "gtype", // 1470
 
437
                        "To be added: an object of type 'Type'", // 1444
 
438
                        "System.Collections.Hashtable", // 1416
 
439
                        "array", // 1380
 
440
                        "System.Int16", // 1374
 
441
                        "Gtk", // 1350
 
442
                        "System.ComponentModel.ITypeDescriptorContext", // 1344
 
443
                        "System.Collections.ICollection", // 1330
 
444
                        "Dispose", // 1330
 
445
                        "Gtk.Widget", // 1326
 
446
                        "System.Runtime.Serialization.StreamingContext", // 1318
 
447
                        "Nemerle.Compiler.Parsetree.PExpr", // 1312
 
448
                        "System.Guid", // 1310
 
449
                        "i", // 1302
 
450
                        "Gtk.TreeIter", // 1300
 
451
                        "text", // 1290
 
452
                        "System.Runtime.Serialization.SerializationInfo", // 1272
 
453
                        "state", // 1264
 
454
                        "Remove" // 1256
 
455
                };              
 
456
        }
 
457
}