[mcs] Inflate referenced current types for imported type definitions. Fixes #56462

[mono.git] / mcs / tests / test-7.cs

diff --git a/mcs/tests/test-7.cs b/mcs/tests/test-7.cs
index 4587dc1ad960f4ae322b023151e87623d14375ed..8d27a6dec75a797514cddef3046d6492ac945db6 100644 (file)
--- a/mcs/tests/test-7.cs
+++ b/mcs/tests/test-7.cs
@@ -2,113 +2,205 @@ using System;
 
 namespace Mine {
 
-       public class Blah {
-
-               public int i;
+       public class MyBoolean {
+               public static implicit operator bool (MyBoolean x)
+               {
+                       return true;
+               }
+       }
 
-               public Blah ()
+       public class MyTrueFalse {
+               public static bool operator true (MyTrueFalse i)
+               {
+                       return true;
+               }
+               
+               public static bool operator false (MyTrueFalse i)
                {
-                       Console.WriteLine ("Inside the constructor now");
+                       return false;
                }
+       }
        
+       public class Blah {
+
+               public int i;
+
                public static int Main ()
                {
-                       Blah k;
+                       Blah k, l;
+
+                       k = new Blah (2) + new Blah (3);
+                       if (k.i != 5)
+                               return 1;
+                       
+                       k = ~ new Blah (5);
+                       if (k.i != -6)
+                               return 1;
+                       
+                       
+                       k = + new Blah (4);
+                       if (k.i != 4)
+                               return 1;
+                       
+                       k = - new Blah (21);
+                       if (k.i != -21)
+                               return 1;
 
-                       k = new Blah () + new Blah (); 
-                       k = ~ new Blah ();
-                       k = + new Blah ();
+                       k = new Blah (22) - new Blah (21);
+                       if (k.i != 1)
+                               return 1;
 
                        if (!k)
-                               Console.WriteLine ("Overloaded ! operator returned true");
+                               Console.WriteLine ("! returned true");
 
                        int number = k;
-                       Console.WriteLine (number);
+                       if (number != 1)
+                               return 1;
                        
-                       k = 5;          
-
                        k++;    
                        ++k;
 
                        if (k)
                                Console.WriteLine ("k is definitely true");
 
-                       k = new Blah ();
+                       k = new Blah (30);
 
-                       float f = (float) k;
+                       double f = (double) k;
 
-                       if (f == 2.0)
-                               Console.WriteLine ("Explicit conversion correct.");
+                       if (f != 30.0)
+                               return 1;
 
-                       return 0;
+                       int i = new Blah (5) * new Blah (10);
+
+                       if (i != 50)
+                               return 1;
+
+                       k = new Blah (50);
+                       l = new Blah (10);
                        
+                       i = k / l;
+
+                       if (i != 5)
+                               return 1;
+
+                       i = k % l;
+
+                       if (i != 0)
+                               return 1;
+
+                       MyBoolean myb = new MyBoolean ();
+
+                       if (!myb)
+                               return 10;
+
+                       //
+                       // Tests the conditional operator invoking operator true
+                       MyTrueFalse mf = new MyTrueFalse ();
+                       int x = mf ? 1 : 2;
+                       if (x != 1)
+                               return 11;
+                       
+                       Console.WriteLine ("Test passed");
+                       return 0;
                }
-               
+       
+               public Blah (int v)
+               {
+                       i = v;
+               }
+       
                public static Blah operator + (Blah i, Blah j)
                {
-                       Console.WriteLine ("Overloaded binary + operator");
-                       return null; 
+                       Blah b = new Blah (i.i + j.i);
+                       Console.WriteLine ("Overload binary + operator");
+                       return b;
                }
 
                public static Blah operator + (Blah i)
                {
-                       Console.WriteLine ("Overloaded unary + operator");
-                       return null;
+                       Console.WriteLine ("Overload unary + operator");
+                       return new Blah (i.i);
+               }
+
+               public static Blah operator - (Blah i)
+               {
+                       Console.WriteLine ("Overloaded unary - operator");
+                       return new Blah (- i.i);
+               }
+
+               public static Blah operator - (Blah i, Blah j)
+               {
+                       Blah b = new Blah (i.i - j.i);
+                       Console.WriteLine ("Overloaded binary - operator");
+                       return b;
+               }
+
+               public static int operator * (Blah i, Blah j)
+               {
+                       Console.WriteLine ("Overloaded binary * operator");
+                       return i.i * j.i;
+               }
+
+               public static int operator / (Blah i, Blah j)
+               {
+                       Console.WriteLine ("Overloaded binary / operator");
+                       return i.i / j.i;
+               }
+
+               public static int operator % (Blah i, Blah j)
+               {
+                       Console.WriteLine ("Overloaded binary % operator");
+                       return i.i % j.i;
                }
                
-       
                public static Blah operator ~ (Blah i)
                {
                        Console.WriteLine ("Overloaded ~ operator");
-                       return null;
+                       return new Blah (~i.i);
                }
        
                public static bool operator ! (Blah i)
                {
                        Console.WriteLine ("Overloaded ! operator");
-                       return true;
+                       return (i.i == 1);
                }
 
                public static Blah operator ++ (Blah i)
                {
+                       Blah b = new Blah (i.i + 1);
                        Console.WriteLine ("Incrementing i");
-                       return null;
+                       return b;
                }
 
                public static Blah operator -- (Blah i)
                {
+                       Blah b = new Blah (i.i - 1);
                        Console.WriteLine ("Decrementing i");
-                       return null;
+                       return b;
                }       
        
                public static bool operator true (Blah i)
                {
                        Console.WriteLine ("Overloaded true operator");
-                       return true;
+                       return (i.i == 3);
                }
 
                public static bool operator false (Blah i)
                {
                        Console.WriteLine ("Overloaded false operator");
-                       return false;
+                       return (i.i != 1);
                }       
        
                public static implicit operator int (Blah i) 
                {       
                        Console.WriteLine ("Converting implicitly from Blah->int");
-                       return 3;
-               }
-
-               public static implicit operator Blah (int i)
-               {
-                       Console.WriteLine ("Converting implicitly from int->Blah");
-                       return null;
+                       return i.i;
                }
 
-               public static explicit operator float (Blah i)
+               public static explicit operator double (Blah i)
                {
-                       Console.WriteLine ("Converting explicitly from Blah->float");
-                       return 2.0;
+                       Console.WriteLine ("Converting explicitly from Blah->double");
+                       return (double) i.i;
                }
 
        }