← Back to branch summary

~ubuntu-branches/ubuntu/utopic/monodevelop/utopic

« back to all changes in this revision

Viewing changes to external/nrefactory/ICSharpCode.NRefactory.Tests/CSharp/Resolver/ConversionsTest.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-10-10 14:50:04 UTC
  • mfrom: (10.3.4)
  • Revision ID: package-import@ubuntu.com-20131010145004-80l130sny21b17sb
Tags: 4.0.12+dfsg-1
http://bugs.debian.org/714246
* [5dcb6e1] Fix debian/watch for new source tarball name format
* [5c68cb5] Refresh list of files removed by get-orig-source to 
  reflect 4.0.12
* [96d60a0] Imported Upstream version 4.0.12+dfsg
* [b989752] Refresh debian/patches/no_appmenu to ensure it applies
* [2a4c351] Ensure every assembly in external/ is cleaned properly
* [92762f7] Add more excluded Mac-specific modulerefs
* [bc698ba] Add symlinks to NUnit assemblies (Closes: #714246)

Show diffs side-by-side

added added

removed removed

Lines of Context:
external/nrefactory/ICSharpCode.NRefactory.Tests/CSharp/Resolver/ConversionsTest.cs
257
257
                [Test]
258
258
                public void UnconstrainedTypeParameter()
259
259
                {
260
 
                        ITypeParameter t = new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 0, "T");
261
 
                        ITypeParameter t2 = new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 1, "T2");
262
 
                        ITypeParameter tm = new DefaultTypeParameter(compilation, EntityType.Method, 0, "TM");
 
260
                        ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T");
 
261
                        ITypeParameter t2 = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 1, "T2");
 
262
                        ITypeParameter tm = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "TM");
263
263
                        
264
264
                        Assert.AreEqual(C.None, conversions.ImplicitConversion(SpecialType.NullType, t));
265
265
                        Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, compilation.FindType(KnownTypeCode.Object)));
276
276
                [Test]
277
277
                public void TypeParameterWithReferenceTypeConstraint()
278
278
                {
279
 
                        ITypeParameter t = new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 0, "T", hasReferenceTypeConstraint: true);
 
279
                        ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T", hasReferenceTypeConstraint: true);
280
280
                        
281
281
                        Assert.AreEqual(C.NullLiteralConversion, conversions.ImplicitConversion(SpecialType.NullType, t));
282
282
                        Assert.AreEqual(C.ImplicitReferenceConversion, conversions.ImplicitConversion(t, compilation.FindType(KnownTypeCode.Object)));
287
287
                [Test]
288
288
                public void TypeParameterWithValueTypeConstraint()
289
289
                {
290
 
                        ITypeParameter t = new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 0, "T", hasValueTypeConstraint: true);
 
290
                        ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T", hasValueTypeConstraint: true);
291
291
                        
292
292
                        Assert.AreEqual(C.None, conversions.ImplicitConversion(SpecialType.NullType, t));
293
293
                        Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, compilation.FindType(KnownTypeCode.Object)));
298
298
                [Test]
299
299
                public void TypeParameterWithClassConstraint()
300
300
                {
301
 
                        ITypeParameter t = new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 0, "T",
 
301
                        ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T",
302
302
                                                                    constraints: new[] { compilation.FindType(typeof(StringComparer)) });
303
303
                        
304
304
                        Assert.AreEqual(C.NullLiteralConversion,
320
320
                [Test]
321
321
                public void TypeParameterWithInterfaceConstraint()
322
322
                {
323
 
                        ITypeParameter t = new DefaultTypeParameter(compilation, EntityType.TypeDefinition, 0, "T",
 
323
                        ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T",
324
324
                                                                    constraints: new [] { compilation.FindType(typeof(IList)) });
325
325
                        
326
326
                        Assert.AreEqual(C.None, conversions.ImplicitConversion(SpecialType.NullType, t));
500
500
                        var b = new DefaultUnresolvedTypeDefinition(string.Empty, "B");
501
501
                        // interface A<in U>
502
502
                        a.Kind = TypeKind.Interface;
503
 
                        a.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "U") { Variance = VarianceModifier.Contravariant });
 
503
                        a.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "U") { Variance = VarianceModifier.Contravariant });
504
504
                        // interface B<X> : A<A<B<X>>> { }
505
 
                        b.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "X"));
 
505
                        b.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "X"));
506
506
                        b.BaseTypes.Add(new ParameterizedTypeReference(
507
507
                                a, new[] { new ParameterizedTypeReference(
508
508
                                        a, new [] { new ParameterizedTypeReference(
509
 
                                                b, new [] { new TypeParameterReference(EntityType.TypeDefinition, 0) }
 
509
                                                b, new [] { new TypeParameterReference(SymbolKind.TypeDefinition, 0) }
510
510
                                        ) } ) }));
511
511
                        
512
512
                        ICompilation compilation = TypeSystemHelper.CreateCompilation(a, b);
615
615
                        var c = GetConversion(program);
616
616
                        Assert.IsTrue(c.IsValid);
617
617
                        Assert.IsTrue(c.IsMethodGroupConversion);
 
618
                        Assert.IsFalse(c.DelegateCapturesFirstArgument);
 
619
                        Assert.IsNotNull(c.Method);
 
620
                }
 
621
                
 
622
                [Test]
 
623
                public void MethodGroupConversion_Void_InstanceMethod()
 
624
                {
 
625
                        string program = @"using System;
 
626
delegate void D();
 
627
class Test {
 
628
        D d;
 
629
        public void M() {
 
630
                d = $M$;
 
631
        }
 
632
}";
 
633
                        var c = GetConversion(program);
 
634
                        Assert.IsTrue(c.IsValid);
 
635
                        Assert.IsTrue(c.IsMethodGroupConversion);
 
636
                        Assert.IsTrue(c.DelegateCapturesFirstArgument);
618
637
                        Assert.IsNotNull(c.Method);
619
638
                }
620
639
                
833
852
                }
834
853
 
835
854
                [Test]
 
855
                public void MethodGroupConversion_ExtensionMethod()
 
856
                {
 
857
                        string program = @"using System;
 
858
static class Ext {
 
859
        public static void M(this string s, int x) {}
 
860
}
 
861
class Test {
 
862
        delegate void D(int a);
 
863
        void F() {
 
864
                string s = """";
 
865
                D d = $s.M$;
 
866
        }
 
867
}";
 
868
                        var c = GetConversion(program);
 
869
                        Assert.IsTrue(c.IsValid);
 
870
                        Assert.IsTrue(c.IsMethodGroupConversion);
 
871
                        Assert.IsTrue(c.DelegateCapturesFirstArgument);
 
872
                }
 
873
 
 
874
                [Test]
 
875
                public void MethodGroupConversion_ExtensionMethodUsedAsStaticMethod()
 
876
                {
 
877
                        string program = @"using System;
 
878
static class Ext {
 
879
        public static void M(this string s, int x) {}
 
880
}
 
881
class Test {
 
882
        delegate void D(string s, int a);
 
883
        void F() {
 
884
                D d = $Ext.M$;
 
885
        }
 
886
}";
 
887
                        var c = GetConversion(program);
 
888
                        Assert.IsTrue(c.IsValid);
 
889
                        Assert.IsTrue(c.IsMethodGroupConversion);
 
890
                        Assert.IsFalse(c.DelegateCapturesFirstArgument);
 
891
                }
 
892
 
 
893
                [Test]
 
894
                public void MethodGroupConversion_ObjectToDynamic() {
 
895
                        string program = @"using System;
 
896
class Test {
 
897
        public void F(object o) {}
 
898
        public void M() {
 
899
                Action<dynamic> x = $F$;
 
900
        }
 
901
}";
 
902
                        var c = GetConversion(program);
 
903
                        Assert.IsTrue(c.IsValid);
 
904
                }
 
905
 
 
906
                [Test]
 
907
                public void MethodGroupConversion_ObjectToDynamicGenericArgument() {
 
908
                        string program = @"using System;
 
909
using System.Collections.Generic;
 
910
class Test {
 
911
        public void F(List<object> l) {}
 
912
        public void M() {
 
913
                Action<List<dynamic>> x = $F$;
 
914
        }
 
915
}";
 
916
                        var c = GetConversion(program);
 
917
                        Assert.IsTrue(c.IsValid);
 
918
                }
 
919
 
 
920
                [Test]
 
921
                public void MethodGroupConversion_ObjectToDynamicReturnValue() {
 
922
                        string program = @"using System;
 
923
class Test {
 
924
        public object F() {}
 
925
        public void M() {
 
926
                Func<dynamic> x = $F$;
 
927
        }
 
928
}";
 
929
                        var c = GetConversion(program);
 
930
                        Assert.IsTrue(c.IsValid);
 
931
                }
 
932
 
 
933
                [Test]
 
934
                public void MethodGroupConversion_DynamicToObject() {
 
935
                        string program = @"using System;
 
936
class Test {
 
937
        public void F(dynamic o) {}
 
938
        public void M() {
 
939
                Action<object> x = $F$;
 
940
        }
 
941
}";
 
942
                        var c = GetConversion(program);
 
943
                        Assert.IsTrue(c.IsValid);
 
944
                }
 
945
 
 
946
                [Test]
 
947
                public void MethodGroupConversion_DynamicToObjectGenericArgument() {
 
948
                        string program = @"using System;
 
949
using System.Collections.Generic;
 
950
class Test {
 
951
        public void F(List<dynamic> l) {}
 
952
        public void M() {
 
953
                Action<List<object>> x = $F$;
 
954
        }
 
955
}";
 
956
                        var c = GetConversion(program);
 
957
                        Assert.IsTrue(c.IsValid);
 
958
                }
 
959
 
 
960
                [Test]
 
961
                public void MethodGroupConversion_DynamicToObjectReturnValue() {
 
962
                        string program = @"using System;
 
963
class Test {
 
964
        public dynamic F() {}
 
965
        public void M() {
 
966
                Func<object> x = $F$;
 
967
        }
 
968
}";
 
969
                        var c = GetConversion(program);
 
970
                        Assert.IsTrue(c.IsValid);
 
971
                }
 
972
 
 
973
                [Test]
836
974
                public void UserDefined_IntLiteral_ViaUInt_ToCustomStruct()
837
975
                {
838
976
                        string program = @"using System;
1290
1428
                        Assert.IsTrue(c.ConversionAfterUserDefinedOperator.IsNumericConversion);
1291
1429
                        Assert.IsTrue(c.ConversionAfterUserDefinedOperator.IsValid);
1292
1430
                }
 
1431
                
 
1432
                [Test]
 
1433
                public void UserDefinedImplicitConversion_IsImplicit()
 
1434
                {
 
1435
                        // Bug icsharpcode/NRefactory#183: conversions from constant expressions were incorrectly marked as explicit
 
1436
                        string program = @"using System;
 
1437
        class Test {
 
1438
                void Hello(JsNumber3 x) {
 
1439
                        Hello($7$);
 
1440
                }
 
1441
        }
 
1442
        public class JsNumber3 {
 
1443
                public static implicit operator JsNumber3(int d) {
 
1444
                        return null;
 
1445
                }
 
1446
        }";
 
1447
                        var c = GetConversion(program);
 
1448
                        Assert.IsTrue(c.IsValid);
 
1449
                        Assert.IsTrue(c.IsImplicit);
 
1450
                        Assert.IsFalse(c.IsExplicit);
 
1451
                        Assert.AreEqual(Conversion.IdentityConversion, c.ConversionBeforeUserDefinedOperator);
 
1452
                        Assert.AreEqual(Conversion.IdentityConversion, c.ConversionAfterUserDefinedOperator);
 
1453
                }
1293
1454
        }
1294
1455
}