Imported Upstream version 6.4.0.137

Former-commit-id: 943baa9f16a098c33e129777827f3a9d20da00d6

external/cecil/Test/Mono.Cecil.Tests/BaseTestFixture.cs

@@ -1,11 +1,24 @@
 using System;
 using System.IO;
-using System.Reflection;
+using System.Runtime.CompilerServices;
 using Mono.Cecil.Cil;
 using NUnit.Framework;
 
 using Mono.Cecil.PE;
 
+#if !NET_CORE
+namespace System.Runtime.CompilerServices {
+
+	[AttributeUsage (AttributeTargets.Parameter, Inherited = false)]
+	public sealed class CallerFilePathAttribute : Attribute {
+	}
+
+	[AttributeUsage (AttributeTargets.Parameter, Inherited = false)]
+	public sealed class CallerMemberNameAttribute : Attribute {
+	}
+}
+#endif
+
 namespace Mono.Cecil.Tests {
 
 	public abstract class BaseTestFixture {
@@ -16,49 +29,61 @@ namespace Mono.Cecil.Tests {
 				Assert.Ignore ();
 		}
 
-		public static string GetResourcePath (string name, Assembly assembly)
+		protected static void IgnoreOnCoreClr ()
 		{
-			return Path.Combine (FindResourcesDirectory (assembly), name);
+			if (Platform.OnCoreClr)
+				Assert.Ignore ();
 		}
 
-		public static string GetAssemblyResourcePath (string name, Assembly assembly)
+		protected static void OnlyOnWindows ()
 		{
-			return GetResourcePath (Path.Combine ("assemblies", name), assembly);
+			if (!Platform.OnWindows)
+				Assert.Ignore ();
 		}
 
-		public static string GetCSharpResourcePath (string name, Assembly assembly)
+		public static string GetResourcePath (string name, string sourceFilePath)
 		{
-			return GetResourcePath (Path.Combine ("cs", name), assembly);
+			return Path.Combine (FindResourcesDirectory (sourceFilePath), name);
 		}
 
-		public static string GetILResourcePath (string name, Assembly assembly)
+		public static string GetAssemblyResourcePath (string name, [CallerFilePath] string sourceFilePath = "")
 		{
-			return GetResourcePath (Path.Combine ("il", name), assembly);
+			return GetResourcePath (Path.Combine ("assemblies", name), sourceFilePath);
 		}
 
-		public ModuleDefinition GetResourceModule (string name)
+		public static string GetCSharpResourcePath (string name, [CallerFilePath] string sourceFilePath = "")
 		{
-			return ModuleDefinition.ReadModule (GetAssemblyResourcePath (name, GetType ().Assembly));
+			return GetResourcePath (Path.Combine ("cs", name), sourceFilePath);
 		}
 
-		public ModuleDefinition GetResourceModule (string name, ReaderParameters parameters)
+		public static string GetILResourcePath (string name, [CallerFilePath] string sourceFilePath = "")
 		{
-			return ModuleDefinition.ReadModule (GetAssemblyResourcePath (name, GetType ().Assembly), parameters);
+			return GetResourcePath (Path.Combine ("il", name), sourceFilePath);
 		}
 
-		public ModuleDefinition GetResourceModule (string name, ReadingMode mode)
+		public ModuleDefinition GetResourceModule (string name, [CallerFilePath] string sourceFilePath = "")
 		{
-			return ModuleDefinition.ReadModule (GetAssemblyResourcePath (name, GetType ().Assembly), new ReaderParameters (mode));
+			return ModuleDefinition.ReadModule (GetAssemblyResourcePath (name, sourceFilePath));
 		}
 
-		public Stream GetResourceStream (string name)
+		public ModuleDefinition GetResourceModule (string name, ReaderParameters parameters, [CallerFilePath] string sourceFilePath = "")
 		{
-			return new FileStream (GetAssemblyResourcePath (name, GetType ().Assembly), FileMode.Open, FileAccess.Read);
+			return ModuleDefinition.ReadModule (GetAssemblyResourcePath (name, sourceFilePath), parameters);
 		}
 
-		internal Image GetResourceImage (string name)
+		public ModuleDefinition GetResourceModule (string name, ReadingMode mode, [CallerFilePath] string sourceFilePath = "")
 		{
-			var file = new FileStream (GetAssemblyResourcePath (name, GetType ().Assembly), FileMode.Open, FileAccess.Read);
+			return ModuleDefinition.ReadModule (GetAssemblyResourcePath (name, sourceFilePath), new ReaderParameters (mode));
+		}
+
+		public Stream GetResourceStream (string name, [CallerFilePath] string sourceFilePath = "")
+		{
+			return new FileStream (GetAssemblyResourcePath (name, sourceFilePath), FileMode.Open, FileAccess.Read);
+		}
+
+		internal Image GetResourceImage (string name, [CallerFilePath] string sourceFilePath = "")
+		{
+			var file = new FileStream (GetAssemblyResourcePath (name, sourceFilePath), FileMode.Open, FileAccess.Read);
 			return ImageReader.ReadImage (Disposable.Owned (file as Stream), file.Name);
 		}
 
@@ -72,9 +97,9 @@ namespace Mono.Cecil.Tests {
 			return ModuleDefinition.ReadModule (GetType ().Module.FullyQualifiedName, parameters);
 		}
 
-		public static string FindResourcesDirectory (Assembly assembly)
+		public static string FindResourcesDirectory (string sourceFilePath)
 		{
-			var path = Path.GetDirectoryName (new Uri (assembly.CodeBase).LocalPath);
+			var path = Path.GetDirectoryName (sourceFilePath);
 			while (!Directory.Exists (Path.Combine (path, "Resources"))) {
 				var old = path;
 				path = Path.GetDirectoryName (path);
@@ -97,19 +122,19 @@ namespace Mono.Cecil.Tests {
 			return str.Trim ().Replace ("\r\n", "\n");
 		}
 
-		public static void TestModule (string file, Action<ModuleDefinition> test, bool verify = true, bool readOnly = false, Type symbolReaderProvider = null, Type symbolWriterProvider = null, IAssemblyResolver assemblyResolver = null, bool applyWindowsRuntimeProjections = false)
+		public static void TestModule (string file, Action<ModuleDefinition> test, bool verify = true, bool readOnly = false, Type symbolReaderProvider = null, Type symbolWriterProvider = null, IAssemblyResolver assemblyResolver = null, bool applyWindowsRuntimeProjections = false, [CallerFilePath] string sourceFilePath = "")
 		{
-			Run (new ModuleTestCase (file, test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections));
+			Run (new ModuleTestCase (file, test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections, sourceFilePath));
 		}
 
-		public static void TestCSharp (string file, Action<ModuleDefinition> test, bool verify = true, bool readOnly = false, Type symbolReaderProvider = null, Type symbolWriterProvider = null, IAssemblyResolver assemblyResolver = null, bool applyWindowsRuntimeProjections = false)
+		public static void TestCSharp (string file, Action<ModuleDefinition> test, bool verify = true, bool readOnly = false, Type symbolReaderProvider = null, Type symbolWriterProvider = null, IAssemblyResolver assemblyResolver = null, bool applyWindowsRuntimeProjections = false, [CallerFilePath] string sourceFilePath = "")
 		{
-			Run (new CSharpTestCase (file, test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections));
+			Run (new CSharpTestCase (file, test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections, sourceFilePath));
 		}
 
-		public static void TestIL (string file, Action<ModuleDefinition> test, bool verify = true, bool readOnly = false, Type symbolReaderProvider = null, Type symbolWriterProvider = null, IAssemblyResolver assemblyResolver = null, bool applyWindowsRuntimeProjections = false)
+		public static void TestIL (string file, Action<ModuleDefinition> test, bool verify = true, bool readOnly = false, Type symbolReaderProvider = null, Type symbolWriterProvider = null, IAssemblyResolver assemblyResolver = null, bool applyWindowsRuntimeProjections = false, [CallerFilePath] string sourceFilePath = "")
 		{
-			Run (new ILTestCase (file, test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections));
+			Run (new ILTestCase (file, test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections, sourceFilePath));
 		}
 
 		static void Run (TestCase testCase)
@@ -123,13 +148,11 @@ namespace Mono.Cecil.Tests {
 			if (testCase.ReadOnly)
 				return;
 
-#if !READ_ONLY
 			using (var runner = new TestRunner (testCase, TestCaseType.WriteFromDeferred))
 				runner.RunTest ();
 
 			using (var runner = new TestRunner (testCase, TestCaseType.WriteFromImmediate))
 				runner.RunTest ();
-#endif
 		}
 	}
 
@@ -142,12 +165,11 @@ namespace Mono.Cecil.Tests {
 		public readonly IAssemblyResolver AssemblyResolver;
 		public readonly Action<ModuleDefinition> Test;
 		public readonly bool ApplyWindowsRuntimeProjections;
+		public readonly string SourceFilePath;
 
 		public abstract string ModuleLocation { get; }
 
-		protected Assembly Assembly { get { return Test.Method.Module.Assembly; } }
-
-		protected TestCase (Action<ModuleDefinition> test, bool verify, bool readOnly, Type symbolReaderProvider, Type symbolWriterProvider, IAssemblyResolver assemblyResolver, bool applyWindowsRuntimeProjections)
+		protected TestCase (Action<ModuleDefinition> test, bool verify, bool readOnly, Type symbolReaderProvider, Type symbolWriterProvider, IAssemblyResolver assemblyResolver, bool applyWindowsRuntimeProjections, string sourceFilePath = "")
 		{
 			Test = test;
 			Verify = verify;
@@ -156,6 +178,7 @@ namespace Mono.Cecil.Tests {
 			SymbolWriterProvider = symbolWriterProvider;
 			AssemblyResolver = assemblyResolver;
 			ApplyWindowsRuntimeProjections = applyWindowsRuntimeProjections;
+			SourceFilePath = sourceFilePath;
 		}
 	}
 
@@ -163,15 +186,15 @@ namespace Mono.Cecil.Tests {
 
 		public readonly string Module;
 
-		public ModuleTestCase (string module, Action<ModuleDefinition> test, bool verify, bool readOnly, Type symbolReaderProvider, Type symbolWriterProvider, IAssemblyResolver assemblyResolver, bool applyWindowsRuntimeProjections)
-			: base (test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections)
+		public ModuleTestCase (string module, Action<ModuleDefinition> test, bool verify, bool readOnly, Type symbolReaderProvider, Type symbolWriterProvider, IAssemblyResolver assemblyResolver, bool applyWindowsRuntimeProjections, string sourceFilePath = "")
+			: base (test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections, sourceFilePath)
 		{
 			Module = module;
 		}
 
 		public override string ModuleLocation
 		{
-			get { return BaseTestFixture.GetAssemblyResourcePath (Module, Assembly); }
+			get { return BaseTestFixture.GetAssemblyResourcePath (Module, SourceFilePath); }
 		}
 	}
 
@@ -179,8 +202,8 @@ namespace Mono.Cecil.Tests {
 
 		public readonly string File;
 
-		public CSharpTestCase (string file, Action<ModuleDefinition> test, bool verify, bool readOnly, Type symbolReaderProvider, Type symbolWriterProvider, IAssemblyResolver assemblyResolver, bool applyWindowsRuntimeProjections)
-			: base (test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections)
+		public CSharpTestCase (string file, Action<ModuleDefinition> test, bool verify, bool readOnly, Type symbolReaderProvider, Type symbolWriterProvider, IAssemblyResolver assemblyResolver, bool applyWindowsRuntimeProjections, string sourceFilePath = "")
+			: base (test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections, sourceFilePath)
 		{
 			File = file;
 		}
@@ -189,7 +212,7 @@ namespace Mono.Cecil.Tests {
 		{
 			get
 			{
-				return CompilationService.CompileResource (BaseTestFixture.GetCSharpResourcePath (File, Assembly));
+				return CompilationService.CompileResource (BaseTestFixture.GetCSharpResourcePath (File, SourceFilePath));
 			}
 		}
 	}
@@ -198,8 +221,8 @@ namespace Mono.Cecil.Tests {
 
 		public readonly string File;
 
-		public ILTestCase (string file, Action<ModuleDefinition> test, bool verify, bool readOnly, Type symbolReaderProvider, Type symbolWriterProvider, IAssemblyResolver assemblyResolver, bool applyWindowsRuntimeProjections)
-			: base (test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections)
+		public ILTestCase (string file, Action<ModuleDefinition> test, bool verify, bool readOnly, Type symbolReaderProvider, Type symbolWriterProvider, IAssemblyResolver assemblyResolver, bool applyWindowsRuntimeProjections, string sourceFilePath = "")
+			: base (test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections, sourceFilePath)
 		{
 			File = file;
 		}
@@ -208,7 +231,7 @@ namespace Mono.Cecil.Tests {
 		{
 			get
 			{
-				return CompilationService.CompileResource (BaseTestFixture.GetILResourcePath (File, Assembly)); ;
+				return CompilationService.CompileResource (BaseTestFixture.GetILResourcePath (File, SourceFilePath)); ;
 			}
 		}
 	}
@@ -244,14 +267,12 @@ namespace Mono.Cecil.Tests {
 			case TestCaseType.ReadDeferred:
 				parameters.ReadingMode = ReadingMode.Deferred;
 				return ModuleDefinition.ReadModule (location, parameters);
-#if !READ_ONLY
 			case TestCaseType.WriteFromImmediate:
 				parameters.ReadingMode = ReadingMode.Immediate;
 				return RoundTrip (location, parameters, "cecil-irt");
 			case TestCaseType.WriteFromDeferred:
 				parameters.ReadingMode = ReadingMode.Deferred;
 				return RoundTrip (location, parameters, "cecil-drt");
-#endif
 			default:
 				return null;
 			}
@@ -265,7 +286,6 @@ namespace Mono.Cecil.Tests {
 			return (ISymbolReaderProvider) Activator.CreateInstance (test_case.SymbolReaderProvider);
 		}
 
-#if !READ_ONLY
 		ISymbolWriterProvider GetSymbolWriterProvider ()
 		{
 			if (test_case.SymbolReaderProvider == null)
@@ -273,7 +293,6 @@ namespace Mono.Cecil.Tests {
 
 			return (ISymbolWriterProvider) Activator.CreateInstance (test_case.SymbolWriterProvider);
 		}
-#endif
 
 		IAssemblyResolver GetAssemblyResolver ()
 		{
@@ -286,7 +305,6 @@ namespace Mono.Cecil.Tests {
 			return test_resolver;
 		}
 
-#if !READ_ONLY
 		ModuleDefinition RoundTrip (string location, ReaderParameters reader_parameters, string folder)
 		{
 			var rt_folder = Path.Combine (Path.GetTempPath (), folder);
@@ -309,7 +327,7 @@ namespace Mono.Cecil.Tests {
 
 			return ModuleDefinition.ReadModule (rt_module, reader_parameters);
 		}
-#endif
+
 		public void RunTest ()
 		{
 			var module = GetModule ();
@@ -333,9 +351,7 @@ namespace Mono.Cecil.Tests {
 	enum TestCaseType {
 		ReadImmediate,
 		ReadDeferred,
-#if !READ_ONLY
 		WriteFromImmediate,
 		WriteFromDeferred,
-#endif
 	}
 }

external/cecil/Test/Mono.Cecil.Tests/CallerMemberNameAttribute.cs

@@ -1,10 +0,0 @@
-#if NET_3_5 || NET_4_0
-namespace System.Runtime.CompilerServices {
-	[AttributeUsage (AttributeTargets.Parameter, Inherited = false)]
-	public sealed class CallerMemberNameAttribute : Attribute {
-		public CallerMemberNameAttribute ()
-		{
-		}
-	}
-}
-#endif

external/cecil/Test/Mono.Cecil.Tests/CompilationService.cs

@@ -11,7 +11,6 @@ using NUnit.Framework;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Emit;
 using CS = Microsoft.CodeAnalysis.CSharp;
-using VB = Microsoft.CodeAnalysis.VisualBasic;
 #endif
 
 namespace Mono.Cecil.Tests {
@@ -37,6 +36,14 @@ namespace Mono.Cecil.Tests {
 			get { return TryGetType ("System.Runtime.Loader.AssemblyLoadContext, System.Runtime.Loader, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a") != null; }
 		}
 
+		public static bool OnWindows {
+			get { return Environment.OSVersion.Platform == PlatformID.Win32NT; }
+		}
+
+		public static bool HasNativePdbSupport {
+			get { return OnWindows && !OnMono; }
+		}
+
 		static Type TryGetType (string assemblyQualifiedName)
 		{
 			try {
@@ -90,7 +97,7 @@ namespace Mono.Cecil.Tests {
 			if (extension == ".il")
 				return IlasmCompilationService.Instance.Compile (name);
 
-			if (extension == ".cs" || extension == ".vb")
+			if (extension == ".cs")
 #if NET_CORE
 				return RoslynCompilationService.Instance.Compile (name);
 #else
@@ -182,14 +189,6 @@ namespace Mono.Cecil.Tests {
 					new [] { CS.SyntaxFactory.ParseSyntaxTree (source) },
 					references, 
 					new CS.CSharpCompilationOptions (OutputKind.DynamicallyLinkedLibrary, optimizationLevel: OptimizationLevel.Release));
-
-			case ".vb":
-				return VB.VisualBasicCompilation.Create (
-					assemblyName,
-					new [] { VB.SyntaxFactory.ParseSyntaxTree (source) },
-					references,
-					new VB.VisualBasicCompilationOptions (OutputKind.DynamicallyLinkedLibrary, optimizationLevel: OptimizationLevel.Release));
-
 			default:
 				throw new NotSupportedException ();
 			}
@@ -320,7 +319,7 @@ namespace Mono.Cecil.Tests {
 		public static ProcessOutput ILAsm (string source, string output)
 		{
 			var ilasm = "ilasm";
-			if (!Platform.OnMono)
+			if (Platform.OnWindows)
 				ilasm = NetFrameworkTool ("ilasm");
 
 			return RunProcess (ilasm, "/nologo", "/dll", "/out:" + Quote (output), Quote (source));

external/cecil/Test/Mono.Cecil.Tests/CustomAttributesTests.cs

@@ -437,7 +437,7 @@ namespace Mono.Cecil.Tests {
 		[Test]
 		public void InterfaceImplementation ()
 		{
-			IgnoreOnMono();
+			OnlyOnWindows (); // Mono's ilasm doesn't support .interfaceimpl
 
 			TestIL ("ca-iface-impl.il", module => {
 				var type = module.GetType ("FooType");
@@ -493,7 +493,6 @@ namespace Mono.Cecil.Tests {
 			});
 		}
 
-#if !READ_ONLY
 		[Test]
 		public void DefineCustomAttributeFromBlob ()
 		{
@@ -531,7 +530,7 @@ namespace Mono.Cecil.Tests {
 
 			module.Dispose ();
 		}
-#endif
+
 		static void AssertCustomAttribute (string expected, CustomAttribute attribute)
 		{
 			Assert.AreEqual (expected, PrettyPrint (attribute));

external/cecil/Test/Mono.Cecil.Tests/ImageReadTests.cs

@@ -207,7 +207,6 @@ namespace Mono.Cecil.Tests {
 			});
 		}
 
-#if !READ_ONLY
 		[Test]
 		public void ExternalPdbDeterministicAssembly ()
 		{
@@ -236,6 +235,5 @@ namespace Mono.Cecil.Tests {
 				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.EmbeddedPortablePdb));
 			}, symbolReaderProvider: typeof (EmbeddedPortablePdbReaderProvider), symbolWriterProvider: typeof (EmbeddedPortablePdbWriterProvider));
 		}
-#endif
 	}
 }

external/cecil/Test/Mono.Cecil.Tests/ImportCecilTests.cs

@@ -1,4 +1,3 @@
-#if !READ_ONLY
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -361,8 +360,9 @@ namespace Mono.Cecil.Tests {
 
 		static ModuleDefinition CreateModule (string name)
 		{
-			return ModuleDefinition.CreateModule (name, ModuleKind.Dll);
+			var resolver = new DefaultAssemblyResolver ();
+			resolver.AddSearchDirectory (Path.GetDirectoryName (typeof (ImportCecilTests).Assembly.Location));
+			return ModuleDefinition.CreateModule (name, new ModuleParameters { Kind = ModuleKind.Dll, AssemblyResolver = resolver });
 		}
 	}
 }
-#endif

external/cecil/Test/Mono.Cecil.Tests/ImportReflectionTests.cs

@@ -1,4 +1,3 @@
-#if !READ_ONLY
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -427,4 +426,3 @@ namespace Mono.Cecil.Tests {
 		}
 	}
 }
-#endif

external/cecil/Test/Mono.Cecil.Tests/MethodBodyTests.cs

@@ -284,7 +284,7 @@ namespace Mono.Cecil.Tests {
 		[Test]
 		public void BranchOutsideMethod ()
 		{
-			IgnoreOnMono ();
+			OnlyOnWindows (); // Mono's ilasm doesn't support branching outside of method
 
 			TestIL ("branch-out.il", module => {
 				var type = module.GetType ("Foo");

external/cecil/Test/Mono.Cecil.Tests/ModuleTests.cs

@@ -12,7 +12,6 @@ namespace Mono.Cecil.Tests {
 	[TestFixture]
 	public class ModuleTests : BaseTestFixture {
 
-#if !READ_ONLY
 		[Test]
 		public void CreateModuleEscapesAssemblyName ()
 		{
@@ -22,7 +21,6 @@ namespace Mono.Cecil.Tests {
 			module = ModuleDefinition.CreateModule ("Test.exe", ModuleKind.Console);
 			Assert.AreEqual ("Test", module.Assembly.Name.Name);
 		}
-#endif
 
 		[Test]
 		public void SingleModule ()
@@ -49,8 +47,7 @@ namespace Mono.Cecil.Tests {
 		[Test]
 		public void MultiModules ()
 		{
-			if (Platform.OnCoreClr)
-				return;
+			IgnoreOnCoreClr ();
 
 			TestModule("mma.exe", module => {
 				var assembly = module.Assembly;
@@ -160,8 +157,7 @@ namespace Mono.Cecil.Tests {
 		[Test]
 		public void ExportedTypeFromNetModule ()
 		{
-			if (Platform.OnCoreClr)
-				return;
+			IgnoreOnCoreClr ();
 
 			TestModule ("mma.exe", module => {
 				Assert.IsTrue (module.HasExportedTypes);
@@ -215,6 +211,8 @@ namespace Mono.Cecil.Tests {
 		[Test]
 		public void Win32FileVersion ()
 		{
+			IgnoreOnCoreClr ();
+
 			TestModule ("libhello.dll", module => {
 				var version = FileVersionInfo.GetVersionInfo (module.FileName);
 
@@ -282,7 +280,7 @@ namespace Mono.Cecil.Tests {
 		[Test]
 		public void OwnedStreamModuleFileName ()
 		{
-			var path = GetAssemblyResourcePath ("hello.exe", GetType ().Assembly);
+			var path = GetAssemblyResourcePath ("hello.exe");
 			using (var file = File.Open (path, FileMode.Open))
 			{
 				using (var module = ModuleDefinition.ReadModule (file))
@@ -294,7 +292,6 @@ namespace Mono.Cecil.Tests {
 			}
 		}
 
-#if !READ_ONLY
 		[Test]
 		public void ReadAndWriteFile ()
 		{
@@ -327,6 +324,5 @@ namespace Mono.Cecil.Tests {
 			// Ensure you can still delete the file
 			File.Delete (path);
 		}
-#endif
 	}
 }

external/cecil/Test/Mono.Cecil.Tests/PortablePdbTests.cs

@@ -1,4 +1,3 @@
-#if !READ_ONLY
 using System;
 using System.IO;
 using System.Linq;
@@ -672,4 +671,3 @@ class Program
 		}
 	}
 }
-#endif

external/cecil/Test/Mono.Cecil.Tests/ResolveTests.cs

@@ -134,7 +134,7 @@ namespace Mono.Cecil.Tests {
 			var parameters = new ReaderParameters { AssemblyResolver = resolver };
 
 			var types = ModuleDefinition.ReadModule (
-				CompilationService.CompileResource (GetCSharpResourcePath ("CustomAttributes.cs", typeof (ResolveTests).Assembly)),
+				CompilationService.CompileResource (GetCSharpResourcePath ("CustomAttributes.cs")),
 				parameters);
 
 			resolver.Register (types.Assembly);
@@ -155,7 +155,7 @@ namespace Mono.Cecil.Tests {
 			var parameters = new ReaderParameters { AssemblyResolver = resolver };
 
 			var types = ModuleDefinition.ReadModule (
-				CompilationService.CompileResource (GetCSharpResourcePath ("CustomAttributes.cs", typeof (ResolveTests).Assembly)),
+				CompilationService.CompileResource (GetCSharpResourcePath ("CustomAttributes.cs")),
 				parameters);
 
 			resolver.Register (types.Assembly);

external/cecil/Test/Mono.Cecil.Tests/SecurityDeclarationTests.cs

@@ -93,7 +93,6 @@ namespace Mono.Cecil.Tests {
 			});
 		}
 
-#if !READ_ONLY
 		[Test]
 		public void DefineSecurityDeclarationByBlob ()
 		{
@@ -126,7 +125,6 @@ namespace Mono.Cecil.Tests {
 			Assert.AreEqual ("System.String", argument.Type.FullName);
 			Assert.AreEqual (permission_set, argument.Value);
 		}
-#endif
 
 		[Test]
 		public void SecurityDeclarationWithoutAttributes ()

external/cecil/Test/Mono.Cecil.Tests/SymbolTests.cs

@@ -1,4 +1,3 @@
-#if !READ_ONLY
 using System;
 using System.IO;
 
@@ -16,12 +15,10 @@ namespace Mono.Cecil.Tests {
 		[Test]
 		public void DefaultPdb ()
 		{
-			IgnoreOnMono ();
-
 			TestModule ("libpdb.dll", module => {
 				Assert.IsTrue (module.HasSymbols);
 				Assert.AreEqual (typeof (NativePdbReader), module.SymbolReader.GetType ());
-			}, symbolReaderProvider: typeof (DefaultSymbolReaderProvider), symbolWriterProvider: typeof (DefaultSymbolWriterProvider));
+			}, readOnly: !Platform.HasNativePdbSupport, symbolReaderProvider: typeof (DefaultSymbolReaderProvider), symbolWriterProvider: typeof (DefaultSymbolWriterProvider));
 		}
 
 		[Test]
@@ -133,5 +130,3 @@ namespace Mono.Cecil.Tests {
 		}
 	}
 }
-
-#endif

external/cecil/Test/Mono.Cecil.Tests/TypeTests.cs

@@ -30,8 +30,6 @@ namespace Mono.Cecil.Tests {
 			});
 		}
 
-#if !READ_ONLY
-
 		[Test]
 		public void EmptyStructLayout ()
 		{
@@ -45,8 +43,6 @@ namespace Mono.Cecil.Tests {
 			}) ;
 		}
 
-#endif
-
 		[Test]
 		public void SimpleInterfaces ()
 		{

external/cecil/Test/Mono.Cecil.Tests/WindowsRuntimeAssemblyResolver.cs

@@ -68,23 +68,13 @@ namespace Mono.Cecil.Tests {
 
 		void LoadWindowsSdk (string registryVersion, string windowsKitsVersion, Action<string> registerAssembliesCallback)
 		{
-#if NET_4_0
 			using (var localMachine32Key = RegistryKey.OpenBaseKey (RegistryHive.LocalMachine, RegistryView.Registry32)) {
 				using (var sdkKey = localMachine32Key.OpenSubKey (@"SOFTWARE\Microsoft\Microsoft SDKs\Windows\v" + registryVersion)) {
-#else
-			{
-				// this will fail on 64-bit process as there's no way (other than pinoke) to read from 32-bit registry view
-				using (var sdkKey = Registry.LocalMachine.OpenSubKey (@"SOFTWARE\Microsoft\Microsoft SDKs\Windows\" + registryVersion)) {
-#endif
 					string installationFolder = null;
 					if (sdkKey != null)
 						installationFolder = (string)sdkKey.GetValue ("InstallationFolder");
 					if (string.IsNullOrEmpty (installationFolder)) {
-#if NET_4_0
 						var programFilesX86 = Environment.GetFolderPath (Environment.SpecialFolder.ProgramFilesX86);
-#else
-						var programFilesX86 = Environment.GetEnvironmentVariable ("ProgramFiles(x86)");
-#endif
 						installationFolder = Path.Combine (programFilesX86, @"Windows Kits\" + windowsKitsVersion);
 					}
 					registerAssembliesCallback (installationFolder);

external/cecil/Test/Mono.Cecil.Tests/WindowsRuntimeProjectionsTests.cs

@@ -65,7 +65,6 @@ namespace Mono.Cecil.Tests {
 			}, verify: false, assemblyResolver: WindowsRuntimeAssemblyResolver.CreateInstance (), applyWindowsRuntimeProjections: true);
 		}
 
-#if !READ_ONLY
 		[Test]
 		public void CanStripType ()
 		{
@@ -93,7 +92,6 @@ namespace Mono.Cecil.Tests {
 				}
 			}, readOnly: true, verify: false, assemblyResolver: assemblyResolver, applyWindowsRuntimeProjections: true);
 		}
-#endif
 	}
 
 	[TestFixture]