← Back to branch summary

~ubuntu-branches/ubuntu/saucy/monodevelop/saucy-proposed

« back to all changes in this revision

Viewing changes to tests/UnitTests/MonoDevelop.Projects/DomPersistenceTests.cs

  • Committer: Bazaar Package Importer
  • Author(s): Jo Shields
  • Date: 2010-09-10 16:54:48 UTC
  • mfrom: (19.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20100910165448-0rybfk25zd4o9431
Tags: 2.4+dfsg-2
* debian/patches/inject_Mono.Debugger.Soft_source.patch,
  debian/patches/use_system_Mono.Debugger.Soft.patch,
  debian/control:
  + Build against system Soft Debugger, since we now have a new
    enough Mono to match MonoDevelop's required API

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/UnitTests/MonoDevelop.Projects/DomPersistenceTests.cs
27
27
//
28
28
 
29
29
using System;
 
30
using System.CodeDom;
30
31
using System.Collections.Generic;
31
32
using System.IO;
32
33
using NUnit.Framework;
134
135
                        DomPersistence.Write (writer, DefaultNameEncoder, input);
135
136
                        byte[] bytes = ms.ToArray ();
136
137
                        
137
 
                        DomReturnType result = DomPersistence.ReadReturnType (CreateReader (bytes), DefaultNameDecoder);
 
138
                        IReturnType result = DomPersistence.ReadReturnType (CreateReader (bytes), DefaultNameDecoder);
138
139
                        Assert.AreEqual ("Test", result.Name);
139
140
                        Assert.AreEqual ("Namespace", result.Namespace);
140
141
                        Assert.AreEqual ("Namespace.Test", result.FullName);
275
276
                        
276
277
                }
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);
 
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
                
278
330
                static BinaryReader CreateReader (byte[] bytes)
279
331
                {
280
332
                        return new BinaryReader (new MemoryStream (bytes));