Imported Upstream version 5.2.0.175

Former-commit-id: bb0468d0f257ff100aa895eb5fe583fb5dfbf900

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

@@ -118,11 +118,13 @@ 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
 		}
 	}
 
@@ -237,12 +239,14 @@ 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;
 			}
@@ -256,6 +260,7 @@ namespace Mono.Cecil.Tests {
 			return (ISymbolReaderProvider) Activator.CreateInstance (test_case.SymbolReaderProvider);
 		}
 
+#if !READ_ONLY
 		ISymbolWriterProvider GetSymbolWriterProvider ()
 		{
 			if (test_case.SymbolReaderProvider == null)
@@ -263,6 +268,7 @@ namespace Mono.Cecil.Tests {
 
 			return (ISymbolWriterProvider) Activator.CreateInstance (test_case.SymbolWriterProvider);
 		}
+#endif
 
 		IAssemblyResolver GetAssemblyResolver ()
 		{
@@ -275,6 +281,7 @@ 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);
@@ -297,7 +304,7 @@ namespace Mono.Cecil.Tests {
 
 			return ModuleDefinition.ReadModule (rt_module, reader_parameters);
 		}
-
+#endif
 		public void RunTest ()
 		{
 			var module = GetModule ();
@@ -321,7 +328,9 @@ namespace Mono.Cecil.Tests {
 	enum TestCaseType {
 		ReadImmediate,
 		ReadDeferred,
+#if !READ_ONLY
 		WriteFromImmediate,
 		WriteFromDeferred,
+#endif
 	}
 }

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

@@ -449,6 +449,7 @@ namespace Mono.Cecil.Tests {
 			});
 		}
 
+#if !READ_ONLY
 		[Test]
 		public void DefineCustomAttributeFromBlob ()
 		{
@@ -486,7 +487,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/Formatter.cs

@@ -83,6 +83,11 @@ namespace Mono.Cecil.Tests {
 
 		static void WriteSequencePoint (TextWriter writer, SequencePoint sequence_point)
 		{
+			if (sequence_point.IsHidden) {
+				writer.Write (".line hidden '{0}'", sequence_point.Document.Url);
+				return;
+			}
+
 			writer.Write (".line {0},{1}:{2},{3} '{4}'",
 				sequence_point.StartLine,
 				sequence_point.EndLine,

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

@@ -1,7 +1,9 @@
 using System;
 using System.IO;
+using System.Linq;
 
 using Mono.Cecil;
+using Mono.Cecil.Cil;
 using Mono.Cecil.PE;
 using Mono.Cecil.Metadata;
 
@@ -179,5 +181,49 @@ namespace Mono.Cecil.Tests {
 				Assert.IsTrue (module.Assembly.Name.IsWindowsRuntime);
 			}, verify: false, assemblyResolver: resolver);
 		}
+
+		[Test]
+		public void DeterministicAssembly ()
+		{
+			TestModule ("Deterministic.dll", module => {
+				Assert.IsTrue (module.HasDebugHeader);
+
+				var header = module.GetDebugHeader ();
+
+				Assert.AreEqual (1, header.Entries.Length);
+				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.Deterministic));
+			});
+		}
+
+#if !READ_ONLY
+		[Test]
+		public void ExternalPdbDeterministicAssembly ()
+		{
+			TestModule ("ExternalPdbDeterministic.dll", module => {
+				Assert.IsTrue (module.HasDebugHeader);
+
+				var header = module.GetDebugHeader ();
+
+				Assert.AreEqual (2, header.Entries.Length);
+				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.CodeView));
+				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.Deterministic));
+			}, symbolReaderProvider: typeof (PortablePdbReaderProvider), symbolWriterProvider: typeof (PortablePdbWriterProvider));
+		}
+
+		[Test]
+		public void EmbeddedPdbDeterministicAssembly ()
+		{
+			TestModule ("EmbeddedPdbDeterministic.dll", module => {
+				Assert.IsTrue (module.HasDebugHeader);
+
+				var header = module.GetDebugHeader ();
+
+				Assert.AreEqual (3, header.Entries.Length);
+				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.CodeView));
+				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.Deterministic));
+				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,3 +1,4 @@
+#if !READ_ONLY
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -372,3 +373,4 @@ namespace Mono.Cecil.Tests {
 		}
 	}
 }
+#endif

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

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

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

@@ -281,6 +281,25 @@ namespace Mono.Cecil.Tests {
 			});
 		}
 
+		[Test]
+		public void BranchOutsideMethod ()
+		{
+			IgnoreOnMono ();
+
+			TestIL ("branch-out.il", module => {
+				var type = module.GetType ("Foo");
+				var method = type.GetMethod ("BranchOutside");
+
+				Assert.IsNotNull (method);
+				Assert.IsNotNull (method.Body);
+
+				var leave = method.Body.Instructions [0];
+				Assert.AreEqual (OpCodes.Leave, leave.OpCode);
+				Assert.IsNull (leave.Operand);
+				Assert.AreEqual ("IL_0000: leave", leave.ToString ());
+			}, verify: false);
+		}
+
 		[Test]
 		public void Iterator ()
 		{

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

@@ -12,6 +12,7 @@ namespace Mono.Cecil.Tests {
 	[TestFixture]
 	public class ModuleTests : BaseTestFixture {
 
+#if !READ_ONLY
 		[Test]
 		public void CreateModuleEscapesAssemblyName ()
 		{
@@ -21,6 +22,7 @@ namespace Mono.Cecil.Tests {
 			module = ModuleDefinition.CreateModule ("Test.exe", ModuleKind.Console);
 			Assert.AreEqual ("Test", module.Assembly.Name.Name);
 		}
+#endif
 
 		[Test]
 		public void SingleModule ()
@@ -263,6 +265,21 @@ namespace Mono.Cecil.Tests {
 			}
 		}
 
+		[Test]
+		public void OwnedStreamModuleFileName ()
+		{
+			var path = GetAssemblyResourcePath ("hello.exe", GetType ().Assembly);
+			using (var file = File.Open (path, FileMode.Open))
+			{
+				using (var module = ModuleDefinition.ReadModule (file))
+				{
+					Assert.IsNotNullOrEmpty (module.FileName);
+					Assert.AreEqual (path, module.FileName);
+				}
+			}
+		}
+
+#if !READ_ONLY
 		[Test]
 		public void ReadAndWriteFile ()
 		{
@@ -280,5 +297,21 @@ namespace Mono.Cecil.Tests {
 			using (var module = ModuleDefinition.ReadModule (path))
 				Assert.AreEqual ("Foo.Foo", module.Types [1].FullName);
 		}
+
+		[Test]
+		public void ExceptionInWriteDoesNotKeepLockOnFile ()
+		{
+			var path = Path.GetTempFileName ();
+
+			var module = ModuleDefinition.CreateModule ("FooFoo", ModuleKind.Dll);
+			// Mixed mode module that Cecil can not write
+			module.Attributes = (ModuleAttributes) 0;
+
+			Assert.Throws<NotSupportedException>(() => module.Write (path));
+
+			// Ensure you can still delete the file
+			File.Delete (path);
+		}
+#endif
 	}
 }

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

@@ -1,6 +1,7 @@
+#if !READ_ONLY
 using System;
 using System.IO;
-
+using System.Linq;
 using NUnit.Framework;
 
 using Mono.Cecil.Cil;
@@ -28,7 +29,7 @@ namespace Mono.Cecil.Tests {
 	IL_0003: stloc.1
 	IL_0004: ldc.i4.0
 	IL_0005: stloc.2
-	.line 16707566,0:16707566,0 'C:\sources\PdbTarget\Program.cs'
+	.line hidden 'C:\sources\PdbTarget\Program.cs'
 	IL_0006: br.s IL_0017
 	.line 22,22:13,20 'C:\sources\PdbTarget\Program.cs'
 	IL_0008: ldloc.1
@@ -39,7 +40,7 @@ namespace Mono.Cecil.Tests {
 	IL_000c: ldloc.3
 	IL_000d: call System.Void System.Console::WriteLine(System.String)
 	IL_0012: nop
-	.line 16707566,0:16707566,0 'C:\sources\PdbTarget\Program.cs'
+	.line hidden 'C:\sources\PdbTarget\Program.cs'
 	IL_0013: ldloc.2
 	IL_0014: ldc.i4.1
 	IL_0015: add
@@ -315,14 +316,13 @@ namespace Mono.Cecil.Tests {
 				var move_next = state_machine.GetMethod ("MoveNext");
 
 				Assert.IsTrue (move_next.HasCustomDebugInformations);
-				Assert.AreEqual (2, move_next.CustomDebugInformations.Count);
 
-				var state_machine_scope = move_next.CustomDebugInformations [0] as StateMachineScopeDebugInformation;
+				var state_machine_scope = move_next.CustomDebugInformations.OfType<StateMachineScopeDebugInformation> ().FirstOrDefault ();
 				Assert.IsNotNull (state_machine_scope);
 				Assert.AreEqual (0, state_machine_scope.Start.Offset);
 				Assert.IsTrue (state_machine_scope.End.IsEndOfMethod);
 
-				var async_body = move_next.CustomDebugInformations [1] as AsyncMethodBodyDebugInformation;
+				var async_body = move_next.CustomDebugInformations.OfType<AsyncMethodBodyDebugInformation> ().FirstOrDefault ();
 				Assert.IsNotNull (async_body);
 				Assert.AreEqual (-1, async_body.CatchHandler.Offset);
 
@@ -338,10 +338,31 @@ namespace Mono.Cecil.Tests {
 			});
 		}
 
+#if !READ_ONLY
+		[Test]
+		public void EmbeddedCompressedPortablePdb ()
+		{
+			TestModule("EmbeddedCompressedPdbTarget.exe", module => {
+				Assert.IsTrue (module.HasDebugHeader);
+
+				var header = module.GetDebugHeader ();
+
+				Assert.IsNotNull (header);
+				Assert.AreEqual (2, header.Entries.Length);
+
+				var cv = header.Entries [0];
+				Assert.AreEqual (ImageDebugType.CodeView, cv.Directory.Type);
+
+				var eppdb = header.Entries [1];
+				Assert.AreEqual (ImageDebugType.EmbeddedPortablePdb, eppdb.Directory.Type);
+			}, symbolReaderProvider: typeof (EmbeddedPortablePdbReaderProvider), symbolWriterProvider: typeof (EmbeddedPortablePdbWriterProvider));
+		}
+
 		void TestPortablePdbModule (Action<ModuleDefinition> test)
 		{
 			TestModule ("PdbTarget.exe", test, symbolReaderProvider: typeof (PortablePdbReaderProvider), symbolWriterProvider: typeof (PortablePdbWriterProvider));
 			TestModule ("EmbeddedPdbTarget.exe", test, verify: !Platform.OnMono);
+			TestModule("EmbeddedCompressedPdbTarget.exe", test, symbolReaderProvider: typeof(EmbeddedPortablePdbReaderProvider), symbolWriterProvider: typeof(EmbeddedPortablePdbWriterProvider));
 		}
 
 		[Test]
@@ -399,5 +420,7 @@ namespace Mono.Cecil.Tests {
 	IL_0001: ret", main);
 			}, symbolReaderProvider: typeof (PortablePdbReaderProvider), symbolWriterProvider: typeof (PortablePdbWriterProvider));
 		}
+#endif
 	}
 }
+#endif

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

@@ -93,6 +93,7 @@ namespace Mono.Cecil.Tests {
 			});
 		}
 
+#if !READ_ONLY
 		[Test]
 		public void DefineSecurityDeclarationByBlob ()
 		{
@@ -125,6 +126,7 @@ 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,3 +1,4 @@
+#if !READ_ONLY
 using System;
 using System.IO;
 
@@ -51,3 +52,4 @@ namespace Mono.Cecil.Tests {
 		}
 	}
 }
+#endif

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

@@ -255,10 +255,24 @@ namespace Mono.Cecil.Tests {
 		[Test]
 		public void DeferredCorlibTypeDef ()
 		{
-			var module = ModuleDefinition.ReadModule (typeof (object).Assembly.Location, new ReaderParameters (ReadingMode.Deferred));
-			var object_type = module.TypeSystem.Object;
+			using (var module = ModuleDefinition.ReadModule (typeof (object).Assembly.Location, new ReaderParameters (ReadingMode.Deferred))) {
+				var object_type = module.TypeSystem.Object;
+				Assert.IsInstanceOf<TypeDefinition> (object_type);
+			}
+		}
 
-			Assert.IsInstanceOf<TypeDefinition> (object_type);
+		[Test]
+		public void CorlibTypesMetadataType ()
+		{
+			using (var module = ModuleDefinition.ReadModule (typeof (object).Assembly.Location)) {
+				var type = module.GetType ("System.String");
+				Assert.IsNotNull (type);
+				Assert.IsNotNull (type.BaseType);
+				Assert.AreEqual ("System.Object", type.BaseType.FullName);
+				Assert.IsInstanceOf<TypeDefinition> (type.BaseType);
+				Assert.AreEqual (MetadataType.String, type.MetadataType);
+				Assert.AreEqual (MetadataType.Object, type.BaseType.MetadataType);
+			}
 		}
 	}
 }

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

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