using System.Globalization;
using System.IO;
using System.Reflection;
-#if !MONOTOUCH
+#if !MONOTOUCH && !MOBILE_STATIC
using System.Reflection.Emit;
#endif
using System.Threading;
using System.Runtime.Serialization;
+using System.Runtime.CompilerServices;
using System.Security;
using System.Linq;
using System.Resources;
+// Used by GetType_TypeForwarder_Nested ()
+[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Globalization.CultureInfo))]
+
namespace MonoTests.System.Reflection
{
[TestFixture]
Assert.IsNull (type, "#B2");
}
+ [Test]
+ public void GetType_TypeForwarder_Nested () {
+ // System.Globalization is a PCL assembly
+ Type t = typeof (AssemblyTest).Assembly.GetType ("System.Globalization.CultureInfo/Data");
+ Assert.IsNotNull (t);
+ Assert.AreEqual ("System.Globalization.CultureInfo+Data", t.FullName);
+ }
+
[Test]
public void GetEntryAssembly ()
{
// note: only available in default appdomain
// http://weblogs.asp.net/asanto/archive/2003/09/08/26710.aspx
// Not sure we should emulate this behavior.
-#if !MONODROID
+#if __WATCHOS__
+ Assert.IsNull (Assembly.GetEntryAssembly (), "GetEntryAssembly");
+ Assert.IsTrue (AppDomain.CurrentDomain.IsDefaultAppDomain (), "!default appdomain");
+#elif !MONODROID
string fname = AppDomain.CurrentDomain.FriendlyName;
if (fname.EndsWith (".dll")) { // nunit-console
Assert.IsNull (Assembly.GetEntryAssembly (), "GetEntryAssembly");
#endif
}
-#if !MONOTOUCH // Reflection.Emit is not supported.
+#if !MONOTOUCH && !MOBILE_STATIC // Reflection.Emit is not supported.
[Test]
[Category("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter
public void GetModules_MissingFile ()
public void Corlib_test ()
{
Assembly corlib_test = Assembly.GetExecutingAssembly ();
-#if MONODROID
+#if MONODROID || MOBILE_STATIC || __WATCHOS__
Assert.IsNull (corlib_test.EntryPoint, "EntryPoint");
Assert.IsNull (corlib_test.Evidence, "Evidence");
#elif MOBILE
[Test]
public void LoadWithPartialName ()
{
- string [] names = { "corlib_test_net_1_1", "corlib_test_net_2_0", "corlib_test_net_4_0", "corlib_test_net_4_5", "corlib_test_net_4_x", "corlib_plattest", "mscorlibtests", "BclTests" };
+// FIXME?
+// So the problem here is that if we load an assembly
+// in a fully aot mode and then cannot load the
+// dylib, we will assert. This test is incompatible
+// with the semantics of aot'ed assembly loading, as
+// aot may assert when loading. This assumes that it's
+// safe to greedly load everything.
+#if MOBILE_STATIC
+ string [] names = { "mobile_static_corlib_test" };
+#else
+ string [] names = { "corlib_test_net_1_1", "corlib_test_net_2_0", "corlib_test_net_4_0", "corlib_test_net_4_5", "net_4_x_corlib_test", "corlib_plattest", "mscorlibtests", "BclTests" };
+#endif
foreach (string s in names)
if (Assembly.LoadWithPartialName (s) != null)
}
}
-#if !MONOTOUCH // Reflection.Emit is not supported.
+#if !MONOTOUCH && !MOBILE_STATIC // Reflection.Emit is not supported.
[Test]
public void Location_Empty() {
string assemblyFileName = Path.Combine (
Assert.AreEqual ("MonoModule", module.GetType ().Name, "#2");
-#if !MONOTOUCH
+#if !MONOTOUCH && !MOBILE_STATIC
Assert.AreEqual ("mscorlib.dll", module.Name, "#3");
#endif
Assert.IsFalse (module.IsResource (), "#4");
} catch (ArgumentException) {}
}
+ class GetCallingAssemblyCallee {
+ static int _dummy;
+
+ static void sideEffect () {
+ _dummy++;
+ }
+
+ // GetCallingAssembly may see an unpredictable
+ // view of the stack if it's called in tail
+ // position, or if its caller or the caller's
+ // caller is inlined. So we put in a side
+ // effect to get out of tail position, and we
+ // tag the methods NoInlining to discourage
+ // the inliner.
+ [MethodImplAttribute (MethodImplOptions.NoInlining)]
+ public static Assembly Leaf () {
+ var a = Assembly.GetCallingAssembly ();
+ sideEffect();
+ return a;
+ }
+
+ [MethodImplAttribute (MethodImplOptions.NoInlining)]
+ public static Assembly DirectCall () {
+ var a = Leaf();
+ sideEffect();
+ return a;
+ }
+
+ [MethodImplAttribute (MethodImplOptions.NoInlining)]
+ public static Assembly InvokeCall () {
+ var ty = typeof (GetCallingAssemblyCallee);
+ var mi = ty.GetMethod("Leaf");
+ var o = mi.Invoke(null, null);
+ sideEffect();
+ return (Assembly)o;
+ }
+ }
+
+ [Test]
+ public void GetCallingAssembly_Direct() {
+ var a = GetCallingAssemblyCallee.DirectCall ();
+ Assert.IsNotNull (a);
+
+ Assert.AreEqual (GetType().Assembly, a);
+ }
+
+ [Test]
+ public void GetCallingAssembly_SkipsReflection () {
+ // check that the calling assembly is this
+ // one, not mscorlib (aka, the reflection
+ // API).
+ var a = GetCallingAssemblyCallee.InvokeCall ();
+ Assert.IsNotNull (a);
+
+ var invokeAssembly =
+ typeof (MethodInfo).Assembly;
+ Assert.AreNotEqual (invokeAssembly, a);
+
+ Assert.AreEqual (GetType().Assembly, a);
+ }
+
#if NET_4_5
[Test]
public void DefinedTypes_Equality ()
Assert.AreSame (x1, x2, "#1");
}
#endif
+
+ class MyAssembly : Assembly { }
+
+ [Test]
+ public void CustomAssemblyImplThrows ()
+ {
+ var ma = new MyAssembly();
+ try {
+ ma.GetName ();
+ Assert.Fail ("must throw");
+ } catch (NotImplementedException){
+ }
+ }
}
public class TestDefinedTypes
projects / mono.git / blobdiff