diff options
Diffstat (limited to 'ICSharpCode.Decompiler/Tests/Generics.cs')
-rw-r--r-- | ICSharpCode.Decompiler/Tests/Generics.cs | 165 |
1 files changed, 165 insertions, 0 deletions
diff --git a/ICSharpCode.Decompiler/Tests/Generics.cs b/ICSharpCode.Decompiler/Tests/Generics.cs new file mode 100644 index 00000000..9776d42f --- /dev/null +++ b/ICSharpCode.Decompiler/Tests/Generics.cs @@ -0,0 +1,165 @@ +// Copyright (c) AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +public static class Generics +{ + public class MyArray<T> + { + public class NestedClass<Y> + { + public T Item1; + public Y Item2; + } + + public enum NestedEnum + { + A, + B + } + + private T[] arr; + + public MyArray(int capacity) + { + this.arr = new T[capacity]; + } + + public void Size(int capacity) + { + Array.Resize<T>(ref this.arr, capacity); + } + + public void Grow(int capacity) + { + if (capacity >= this.arr.Length) + { + this.Size(capacity); + } + } + } + + public interface IInterface + { + void Method1<T>() where T : class; + void Method2<T>() where T : class; + } + + public abstract class Base : Generics.IInterface + { + // constraints must be repeated on implicit interface implementation + public abstract void Method1<T>() where T : class; + + // constraints must not be specified on explicit interface implementation + void Generics.IInterface.Method2<T>() + { + } + } + + public class Derived : Generics.Base + { + // constraints are inherited automatically and must not be specified + public override void Method1<T>() + { + } + } + + private const Generics.MyArray<string>.NestedEnum enumVal = Generics.MyArray<string>.NestedEnum.A; + private static Type type1 = typeof(List<>); + private static Type type2 = typeof(Generics.MyArray<>); + private static Type type3 = typeof(List<>.Enumerator); + private static Type type4 = typeof(Generics.MyArray<>.NestedClass<>); + private static Type type5 = typeof(List<int>[]); + private static Type type6 = typeof(Generics.MyArray<>.NestedEnum); + + public static void MethodWithConstraint<T, S>() where T : class, S where S : ICloneable, new() + { + } + + public static void MethodWithStructConstraint<T>() where T : struct + { + } + + private static void MultidimensionalArray<T>(T[,] array) + { + array[0, 0] = array[0, 1]; + } + + public static Dictionary<string, string>.KeyCollection.Enumerator GetEnumerator(Dictionary<string, string> d, Generics.MyArray<string>.NestedClass<int> nc) + { + // Tests references to inner classes in generic classes + return d.Keys.GetEnumerator(); + } + + public static bool IsString<T>(T input) + { + return input is string; + } + + public static string AsString<T>(T input) + { + return input as string; + } + + public static string CastToString<T>(T input) + { + return (string)((object)input); + } + + public static T CastFromString<T>(string input) + { + return (T)((object)input); + } + + public static bool IsInt<T>(T input) + { + return input is int; + } + + public static int CastToInt<T>(T input) + { + return (int)((object)input); + } + + public static T CastFromInt<T>(int input) + { + return (T)((object)input); + } + + public static bool IsNullableInt<T>(T input) + { + return input is int?; + } + + public static int? AsNullableInt<T>(T input) + { + return input as int?; + } + + public static int? CastToNullableInt<T>(T input) + { + return (int?)((object)input); + } + + public static T CastFromNullableInt<T>(int? input) + { + return (T)((object)input); + } +} |