[xBuild] Support use of properties defined in Choose elements in project references

[mono.git] / mono / tests / coreclr-security.cs

diff --git a/mono/tests/coreclr-security.cs b/mono/tests/coreclr-security.cs
index 2479dc2e1f742afe0d91dc5f01888b8937014715..89ad2c1a3f8ad2904821fc848c0dd10ecfe8773f 100644 (file)
--- a/mono/tests/coreclr-security.cs
+++ b/mono/tests/coreclr-security.cs
@@ -106,10 +106,73 @@ public class CriticalClass {
         }
 }
 
+public class TransparentBaseClass {
+       public virtual void TransparentMethod ()
+       {
+       }
+
+       [SecuritySafeCritical]
+       public virtual void SafeCriticalMethod ()
+       {
+       }
+
+       [SecurityCritical]
+       public virtual void CriticalMethod ()
+       {
+       }
+}
+
+public class BadTransparentOverrideClass : TransparentBaseClass {
+       [SecurityCritical]
+       public override void TransparentMethod ()
+       {
+               Test.error ("this method is critical and cannot override its base (transparent)");
+       }
+}
+
+public class BadSafeCriticalOverrideClass : TransparentBaseClass {
+       [SecurityCritical]
+       public override void SafeCriticalMethod ()
+       {
+               Test.error ("this method is critical and cannot override its base (safe critical)");
+       }
+}
+
+public class BadCriticalOverrideClass : TransparentBaseClass {
+       public override void CriticalMethod ()
+       {
+               Test.error ("this method is NOT critical and cannot override its base (critical)");
+       }
+}
+
 public delegate void MethodDelegate ();
 
 public delegate Object InvokeDelegate (Object obj, Object[] parms);
 
+// the 0.1% case from http://blogs.msdn.com/shawnfa/archive/2007/05/11/silverlight-security-iii-inheritance.aspx
+public class TransparentClassWithSafeCriticalDefaultConstructor {
+
+       [SecuritySafeCritical]
+       public TransparentClassWithSafeCriticalDefaultConstructor ()
+       {
+       }
+}
+
+public class TransparentInheritFromSafeCriticalDefaultConstructor : TransparentClassWithSafeCriticalDefaultConstructor {
+
+       public TransparentInheritFromSafeCriticalDefaultConstructor ()
+       {
+       }
+}
+
+public class SafeInheritFromSafeCriticalDefaultConstructor : TransparentClassWithSafeCriticalDefaultConstructor {
+
+       [SecuritySafeCritical]
+       public SafeInheritFromSafeCriticalDefaultConstructor ()
+       {
+       }
+}
+
 public class Test
 {
        static bool haveError = false;
@@ -163,6 +226,21 @@ public class Test
        }
        */
 
+       static void doBadTransparentOverrideClass ()
+       {
+               new BadTransparentOverrideClass ();
+       }
+
+       static void doBadSafeCriticalOverrideClass ()
+       {
+               new BadSafeCriticalOverrideClass ();
+       }
+
+       static void doBadCriticalOverrideClass ()
+       {
+               new BadCriticalOverrideClass ();
+       }
+
        public static void TransparentReflectionCMethod ()
        {
        }
@@ -195,6 +273,68 @@ public class Test
        [DllImport ("/lib64/libc.so.6")]
        static extern int getpid ();
 
+
+       static void ArraysCreatedByTransparentCaller ()
+       {
+               // Transparent creating an array of a Critical type
+               // using Class[] (rank == 1) throws a TypeLoadException on SL2 - but that looks like a bug
+               // reported as https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=490406
+               CClass[] c_array = new CClass [0];
+               // Transparent creating an array of a SafeCritical type
+               SCClass[] sc_array = new SCClass [0];
+
+               // Transparent creating a multidimentional array of a Critical type
+               CClass[,] c_multi = new CClass [0,0];
+               // Transparent creating a multidimentional array of a SafeCritical type
+               SCClass[,] sc_multi = new SCClass [0,0];
+
+               // Transparent creating a jagged array of a Critical type
+               CClass[][] c_jagged = new CClass [0][];
+               // Transparent creating a jagged array of a Critical type
+               SCClass[][] sc_jagged = new SCClass [0][];
+       }
+
+       [SecuritySafeCritical]
+       static void ArraysCreatedBySafeCriticalCaller ()
+       {
+               // SafeCritical creating an array of a Critical type
+               CClass[] c_array = new CClass [0];
+               // SafeCritical creating an array of a SafeCritical type
+               SCClass[] sc_array = new SCClass [0];
+
+               // SafeCritical creating a multidimentional array of a Critical type
+               CClass[,] c_multi = new CClass [0,0];
+               // SafeCritical creating a multidimentional array of a SafeCritical type
+               SCClass[,] sc_multi = new SCClass [0,0];
+
+               // SafeCritical creating a jagged array of a Critical type
+               CClass[][] c_jagged = new CClass [0][];
+               // SafeCritical creating a jagged array of a Critical type
+               SCClass[][] sc_jagged = new SCClass [0][];
+
+               // Transparent Main could not call a critical method by itself
+               ArraysCreatedByCriticalCaller ();
+       }
+
+       [SecurityCritical]
+       static void ArraysCreatedByCriticalCaller ()
+       {
+               // Critical creating an array of a Critical type
+               CClass[] c_array = new CClass [0];
+               // Critical creating an array of a SafeCritical type
+               SCClass[] sc_array = new SCClass [0];
+
+               // Critical creating a multidimentional array of a Critical type
+               CClass[,] c_multi = new CClass [0,0];
+               // Critical creating a multidimentional array of a SafeCritical type
+               SCClass[,] sc_multi = new SCClass [0,0];
+
+               // Critical creating a jagged array of a Critical type
+               CClass[][] c_jagged = new CClass [0][];
+               // Critical creating a jagged array of a Critical type
+               SCClass[][] sc_jagged = new SCClass [0][];
+       }
+
        public static int Main ()
        {
                SCMethod ();
@@ -301,11 +441,40 @@ public class Test
                        error ("string test failed");
                }
 
-               //Console.WriteLine ("ok");
+               try {
+                       doBadTransparentOverrideClass ();
+                       error ("BadTransparentOverrideClass error");
+               } catch (TypeLoadException) {
+               }
+
+               try {
+                       doBadSafeCriticalOverrideClass ();
+                       error ("BadSafeCriticalOverrideClass error");
+               } catch (TypeLoadException) {
+               }
+
+               try {
+                       doBadCriticalOverrideClass ();
+                       error ("BadCriticalOverrideClass error");
+               } catch (TypeLoadException) {
+               }
+
+               new TransparentClassWithSafeCriticalDefaultConstructor ();
+               try {
+                       new TransparentInheritFromSafeCriticalDefaultConstructor ();
+               } catch (TypeLoadException) {
+               }
+               new SafeInheritFromSafeCriticalDefaultConstructor ();
+
+               // arrays creation tests
+               ArraysCreatedByTransparentCaller ();
+               ArraysCreatedBySafeCriticalCaller ();
+               // the above also calls ArraysCreatedBySafeCriticalCaller since (Transparent) Main cannot call it directly
 
                if (haveError)
                        return 1;
 
+//             Console.WriteLine ("ok");
                return 0;
        }
 }