public void TestBaseTypeDynamicTransforms()
{
CommonTestInitialization();
// public class Base0 { }
Assert.Equal(_objectType, _base0Class.BaseType());
Assert.False(_base0Class.ContainsDynamic());
// public class Base1<T> { }
Assert.Equal(_objectType, _base1Class.BaseType());
Assert.False(_base1Class.ContainsDynamic());
// public class Base2<T, U> { }
Assert.Equal(_objectType, _base2Class.BaseType());
Assert.False(_base2Class.ContainsDynamic());
// public class Derived<T> : Outer<dynamic>.Inner<Outer<dynamic>.Inner<T[], dynamic>.InnerInner<int>[], dynamic>.InnerInner<dynamic> where T : Derived<T> { ... }
Assert.False(_derivedClass.ContainsDynamic());
Assert.True(_derivedClass.BaseType().ContainsDynamic());
// Outer<dynamic>
var outerClassOfDynamic = _outerClass.Construct(s_dynamicType);
// Outer<dynamic>.Inner<T[], dynamic>
var t = _derivedClass.TypeParameters[0];
var arrayOfT = ArrayTypeSymbol.CreateCSharpArray(_assembly, TypeWithAnnotations.Create(t));
var innerClassOfTArrDynamic = outerClassOfDynamic.GetTypeMember("Inner").Construct(arrayOfT, s_dynamicType);
// Outer<dynamic>.Inner<T[], dynamic>.InnerInner<int>[]
var memberInnerInnerOfInt = innerClassOfTArrDynamic.GetTypeMember("InnerInner").Construct(_intType);
var arrayOfInnerInnerOfInt = ArrayTypeSymbol.CreateCSharpArray(_assembly, TypeWithAnnotations.Create(memberInnerInnerOfInt));
// Outer<dynamic>.Inner<Outer<dynamic>.Inner<T[], dynamic>.InnerInner<int>[], dynamic>
var memberComplicatedInner = outerClassOfDynamic.GetTypeMember("Inner").Construct(arrayOfInnerInnerOfInt, s_dynamicType);
// Outer<dynamic>.Inner<Outer<dynamic>.Inner<T[], dynamic>.InnerInner<int>[], dynamic>.InnerInner<dynamic>
var memberInnerInnerOfDynamic = memberComplicatedInner.GetTypeMember("InnerInner").Construct(s_dynamicType);
Assert.Equal(memberInnerInnerOfDynamic, _derivedClass.BaseType());
// public class Outer<T> : Base1<dynamic>
Assert.False(_outerClass.ContainsDynamic());
Assert.True(_outerClass.BaseType().ContainsDynamic());
var base1OfDynamic = _base1Class.Construct(s_dynamicType);
Assert.Equal(base1OfDynamic, _outerClass.BaseType());
// public class Inner<U, V> : Base2<dynamic, V>
Assert.False(_innerClass.ContainsDynamic());
Assert.True(_innerClass.BaseType().ContainsDynamic());
var base2OfDynamicV = _base2Class.Construct(s_dynamicType, _innerClass.TypeParameters[1]);
Assert.Equal(base2OfDynamicV, _innerClass.BaseType());
// public class InnerInner<W> : Base1<dynamic> { }
Assert.False(_innerInnerClass.ContainsDynamic());
Assert.True(_innerInnerClass.BaseType().ContainsDynamic());
Assert.Equal(base1OfDynamic, _innerInnerClass.BaseType());
// public class Outer2<T> : Base1<dynamic>
Assert.False(_outer2Class.ContainsDynamic());
Assert.True(_outer2Class.BaseType().ContainsDynamic());
Assert.Equal(base1OfDynamic, _outer2Class.BaseType());
// public class Inner2<U, V> : Base0
Assert.False(_inner2Class.ContainsDynamic());
Assert.False(_inner2Class.BaseType().ContainsDynamic());
Assert.Equal(_base0Class, _inner2Class.BaseType());
// public class InnerInner2<W> : Base0 { }
Assert.False(_innerInner2Class.ContainsDynamic());
Assert.False(_innerInner2Class.BaseType().ContainsDynamic());
Assert.Equal(_base0Class, _innerInner2Class.BaseType());
// public class Inner3<U>
Assert.False(_inner3Class.ContainsDynamic());
}
public void TestBaseTypeDynamicTransforms()
{
CommonTestInitialization();
// public class Base0 { }
Assert.Equal(objectType, base0Class.BaseType);
Assert.False(base0Class.ContainsDynamic());
// public class Base1<T> { }
Assert.Equal(objectType, base1Class.BaseType);
Assert.False(base1Class.ContainsDynamic());
// public class Base2<T, U> { }
Assert.Equal(objectType, base2Class.BaseType);
Assert.False(base2Class.ContainsDynamic());
// public class Derived<T> : Outer<dynamic>.Inner<Outer<dynamic>.Inner<T[], dynamic>.InnerInner<int>[], dynamic>.InnerInner<dynamic> where T : Derived<T> { ... }
Assert.False(derivedClass.ContainsDynamic());
Assert.True(derivedClass.BaseType.ContainsDynamic());
// Outer<dynamic>
var outerClassOfDynamic = outerClass.Construct(dynamicType);
// Outer<dynamic>.Inner<T[], dynamic>
var t = derivedClass.TypeParameters[0];
var arrayOfT = new ArrayTypeSymbol(assembly, t);
var innerClassOfTArrDynamic = outerClassOfDynamic.GetTypeMember("Inner").Construct(arrayOfT, dynamicType);
// Outer<dynamic>.Inner<T[], dynamic>.InnerInner<int>[]
var memberInnerInnerOfInt = innerClassOfTArrDynamic.GetTypeMember("InnerInner").Construct(intType);
var arrayOfInnerInnerOfInt = new ArrayTypeSymbol(assembly, memberInnerInnerOfInt);
// Outer<dynamic>.Inner<Outer<dynamic>.Inner<T[], dynamic>.InnerInner<int>[], dynamic>
var memberComplicatedInner = outerClassOfDynamic.GetTypeMember("Inner").Construct(arrayOfInnerInnerOfInt, dynamicType);
// Outer<dynamic>.Inner<Outer<dynamic>.Inner<T[], dynamic>.InnerInner<int>[], dynamic>.InnerInner<dynamic>
var memberInnerInnerOfDynamic = memberComplicatedInner.GetTypeMember("InnerInner").Construct(dynamicType);
Assert.Equal(memberInnerInnerOfDynamic, derivedClass.BaseType);
// public class Outer<T> : Base1<dynamic>
Assert.False(outerClass.ContainsDynamic());
Assert.True(outerClass.BaseType.ContainsDynamic());
var base1OfDynamic = base1Class.Construct(dynamicType);
Assert.Equal(base1OfDynamic, outerClass.BaseType);
// public class Inner<U, V> : Base2<dynamic, V>
Assert.False(innerClass.ContainsDynamic());
Assert.True(innerClass.BaseType.ContainsDynamic());
var base2OfDynamicV = base2Class.Construct(dynamicType, innerClass.TypeParameters[1]);
Assert.Equal(base2OfDynamicV, innerClass.BaseType);
// public class InnerInner<W> : Base1<dynamic> { }
Assert.False(innerInnerClass.ContainsDynamic());
Assert.True(innerInnerClass.BaseType.ContainsDynamic());
Assert.Equal(base1OfDynamic, innerInnerClass.BaseType);
// public class Outer2<T> : Base1<dynamic>
Assert.False(outer2Class.ContainsDynamic());
Assert.True(outer2Class.BaseType.ContainsDynamic());
Assert.Equal(base1OfDynamic, outer2Class.BaseType);
// public class Inner2<U, V> : Base0
Assert.False(inner2Class.ContainsDynamic());
Assert.False(inner2Class.BaseType.ContainsDynamic());
Assert.Equal(base0Class, inner2Class.BaseType);
// public class InnerInner2<W> : Base0 { }
Assert.False(innerInner2Class.ContainsDynamic());
Assert.False(innerInner2Class.BaseType.ContainsDynamic());
Assert.Equal(base0Class, innerInner2Class.BaseType);
// public class Inner3<U>
Assert.False(inner3Class.ContainsDynamic());
}