mono/tests/generics-sharing.2.cs

   1 using System;
   2 using System.Collections.Generic;
   3
   4 public class ClassA {}
   5 public class ClassB {}
   6 public class ClassC {}
   7
   8 public class NonGen {
   9         public static int field = 123;
  10 }
  11
  12 public class GenA<T> {
  13         static T[] arr;
  14
  15         public static GenA () {
  16                 arr = new T [3];
  17         }
  18
  19         public GenA () {}
  20
  21         public GenA<T> newGen () {
  22                 return new GenA<T> ();
  23         }
  24
  25         public GenA<int> newGenInt () {
  26                 return new GenA<int> ();
  27         }
  28
  29         public int getGenField () {
  30                 return GenB<ClassA>.field;
  31         }
  32
  33         public int getNonGenField () {
  34                 return NonGen.field;
  35         }
  36
  37         public T[] getArr () {
  38                 return arr;
  39         }
  40
  41         public T[] newArr () {
  42                 return new T [3];
  43         }
  44
  45         public GenB<GenB<T>>[] newArrNested () {
  46                 /*
  47                 GenB<GenB<T>>[] arr = null;
  48                 for (int i = 0; i < 10000000; ++i)
  49                         arr = new GenB<GenB<T>> [3];
  50                 */
  51                 return new GenB<GenB<T>> [3];
  52         }
  53
  54         public int hash (T obj) {
  55                 return obj.GetHashCode ();
  56         }
  57
  58         public T ident (T obj) {
  59                 return obj;
  60         }
  61
  62         public T cast (Object obj) {
  63                 return (T)obj;
  64         }
  65 }
  66
  67 public class GenB<T> {
  68         public static int field = 345;
  69 }
  70
  71 public class main {
  72         static bool haveError = false;
  73
  74         public static void error (string message) {
  75                 haveError = true;
  76                 Console.WriteLine (message);
  77         }
  78
  79         public static void typeCheck (String method, Object obj, Type t) {
  80                 if (obj.GetType () != t)
  81                         error ("object from " + method + " should have type " + t.ToString () + " but has type " + obj.GetType ().ToString ());
  82         }
  83
  84         public static void work<T> (T obj) {
  85                 EqualityComparer<T> comp = EqualityComparer<T>.Default;
  86
  87                 GenA<T> ga = new GenA<T> ();
  88
  89                 typeCheck ("newGen", ga.newGen (), typeof (GenA<T>));
  90                 typeCheck ("newGenInt", ga.newGenInt (), typeof (GenA<int>));
  91                 typeCheck ("getArr", ga.getArr (), typeof (T[]));
  92                 typeCheck ("newArr", ga.newArr (), typeof (T[]));
  93                 //ga.newArrNested ();
  94                 typeCheck ("newArrNested", ga.newArrNested (), typeof (GenB<GenB<T>>[]));
  95
  96                 if (ga.getGenField () != 345)
  97                         error ("getGenField");
  98
  99                 if (ga.getNonGenField () != 123)
 100                         error ("getNonGenField");
 101
 102                 ga.hash (obj);
 103
 104                 if (!comp.Equals (ga.ident (obj), obj))
 105                         error ("ident");
 106
 107                 if (!comp.Equals (ga.cast (obj), obj))
 108                         error ("cast");
 109         }
 110
 111         public static int Main ()
 112         {
 113                 work<ClassA> (new ClassA ());
 114                 work<ClassB> (new ClassB ());
 115                 work<ClassC> (new ClassC ());
 116                 work<GenA<ClassA>> (new GenA<ClassA> ());
 117                 work<int[]> (new int[3]);
 118                 work<int> (123);
 119
 120                 if (haveError)
 121                         return 1;
 122                 return 0;
 123         }
 124 }