Ensure consistent sources formatting (#1138)

* Apply consistent formatting based on .editorconfig

```
dotnet format -f <path>
```

* Add lint step to the CI

* Use local tool

* Suppress publish logs warning

* Fix more style errors

* Fixes bad merge

* Write something to log dir

* Move lint job to global scope

So it doesn't get the arcade publish logs/test steps injected.

* Split sources and tests reporting

* Include also src folder in the run

* Exclude cecil sources

* Remove duplicate line

* Trigger notification

* Format more code

Co-authored-by: Alexander Köplinger <alex.koeplinger@outlook.com>

667 files changed, 5201 insertions, 3231 deletions

diff --git a/test/Mono.Linker.Tests.Cases/Advanced/DeadCodeElimination1.cs b/test/Mono.Linker.Tests.Cases/Advanced/DeadCodeElimination1.cs
index 339d223b6..78d127633 100644
--- a/test/Mono.Linker.Tests.Cases/Advanced/DeadCodeElimination1.cs
+++ b/test/Mono.Linker.Tests.Cases/Advanced/DeadCodeElimination1.cs
@@ -1,8 +1,10 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Advanced {
+namespace Mono.Linker.Tests.Cases.Advanced
+{
 	[IgnoreTestCase ("We cannot do this yet")]
-	class DeadCodeElimination1 {
+	class DeadCodeElimination1
+	{
 		public static void Main ()
 		{
 			object o = null;
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Advanced {
 				((B) o).Method ();
 		}
 
-		class B {
+		class B
+		{
 			public void Method ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Advanced/FieldThatOnlyGetsSetIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Advanced/FieldThatOnlyGetsSetIsRemoved.cs
index 8c4933ad2..8aaaf6f73 100644
--- a/test/Mono.Linker.Tests.Cases/Advanced/FieldThatOnlyGetsSetIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Advanced/FieldThatOnlyGetsSetIsRemoved.cs
@@ -1,15 +1,18 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Advanced {
+namespace Mono.Linker.Tests.Cases.Advanced
+{
 	[IgnoreTestCase ("We cannot do this yet")]
-	class FieldThatOnlyGetsSetIsRemoved {
+	class FieldThatOnlyGetsSetIsRemoved
+	{
 		public static void Main ()
 		{
 			new B ().Method ();
 		}
 
 		[KeptMember (".ctor()")]
-		class B {
+		class B
+		{
 			public int _unused = 3;
 
 			[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnAssemblyUsingTarget.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnAssemblyUsingTarget.cs
index d7d74833d..ebef31c6f 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnAssemblyUsingTarget.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnAssemblyUsingTarget.cs
@@ -6,16 +6,18 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 [assembly: KeptAttributeAttribute (typeof (DebuggerDisplayAttribute))]
 [assembly: DebuggerDisplay ("{Property}", Target = typeof (DebuggerDisplayAttributeOnAssemblyUsingTarget.Foo))]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("false")]
-	
+
 	// Can be removed once this bug is fixed https://bugzilla.xamarin.com/show_bug.cgi?id=58168
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
 
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), ".ctor(System.String)")]
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), "set_Target(System.Type)")]
-	public class DebuggerDisplayAttributeOnAssemblyUsingTarget {
+	public class DebuggerDisplayAttributeOnAssemblyUsingTarget
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -24,7 +26,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Debugger {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		public class Foo {
+		public class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			public int Property { get; [Kept] set; }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnAssemblyUsingTargetOnUnusedType.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnAssemblyUsingTargetOnUnusedType.cs
index a0661ed62..0d49ae6b7 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnAssemblyUsingTargetOnUnusedType.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnAssemblyUsingTargetOnUnusedType.cs
@@ -5,7 +5,8 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
 [assembly: DebuggerDisplay ("{Property}", Target = typeof (DebuggerDisplayAttributeOnAssemblyUsingTargetOnUnusedType.Foo))]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("false")]
 
@@ -13,12 +14,14 @@ namespace Mono.Linker.Tests.Cases.Attributes.Debugger {
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
 
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), ".ctor(System.String)")]
-	public class DebuggerDisplayAttributeOnAssemblyUsingTargetOnUnusedType {
+	public class DebuggerDisplayAttributeOnAssemblyUsingTargetOnUnusedType
+	{
 		public static void Main ()
 		{
 		}
 
-		public class Foo {
+		public class Foo
+		{
 			public int Property { get; set; }
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly.cs
index 40819bd10..cd7ee8a5c 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly.cs
@@ -6,20 +6,22 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 [assembly: KeptAttributeAttribute (typeof (DebuggerDisplayAttribute))]
 [assembly: DebuggerDisplay ("{Property}", TargetTypeName = "Mono.Linker.Tests.Cases.Attributes.Debugger.Dependencies.DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib, library")]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("false")]
-	[SetupCompileBefore ("library.dll", new [] { typeof (DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib) })]
-	
+	[SetupCompileBefore ("library.dll", new[] { typeof (DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib) })]
+
 	// Can be removed once this bug is fixed https://bugzilla.xamarin.com/show_bug.cgi?id=58168
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
 
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), ".ctor(System.String)")]
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), "set_TargetTypeName(System.String)")]
-	
+
 	[RemovedMemberInAssembly ("library.dll", typeof (DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib), "get_Property()")]
 	[KeptMemberInAssembly ("library.dll", typeof (DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib), "set_Property(System.Int32)")]
-	public class DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly {
+	public class DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly
+	{
 		public static void Main ()
 		{
 			var foo = new DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib ();
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnType.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnType.cs
index 513b1fb1a..a0827114d 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnType.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnType.cs
@@ -2,7 +2,8 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("false")]
 
@@ -10,18 +11,20 @@ namespace Mono.Linker.Tests.Cases.Attributes.Debugger {
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
 
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), ".ctor(System.String)")]
-	public class DebuggerDisplayAttributeOnType {
+	public class DebuggerDisplayAttributeOnType
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
-			var bar = new Bar();
+			var bar = new Bar ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (DebuggerDisplayAttribute))]
 		[DebuggerDisplay ("{Property}")]
-		class Foo {
+		class Foo
+		{
 			public int Property { get; set; }
 		}
 
@@ -29,7 +32,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Debugger {
 		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (DebuggerDisplayAttribute))]
 		[DebuggerDisplay ("{Method()}")]
-		class Bar {
+		class Bar
+		{
 			public int Method ()
 			{
 				return 1;
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnTypeThatIsNotUsed.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnTypeThatIsNotUsed.cs
index 894d5adbb..3db471578 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnTypeThatIsNotUsed.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerDisplayAttributeOnTypeThatIsNotUsed.cs
@@ -2,19 +2,22 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("false")]
 
 	// Can be removed once this bug is fixed https://bugzilla.xamarin.com/show_bug.cgi?id=58168
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	public class DebuggerDisplayAttributeOnTypeThatIsNotUsed {
+	public class DebuggerDisplayAttributeOnTypeThatIsNotUsed
+	{
 		public static void Main ()
 		{
 		}
 
 		[DebuggerDisplay ("{Property}")]
-		class Foo {
+		class Foo
+		{
 			public int Property { get; set; }
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerTypeProxyAttributeOnAssemblyUsingTarget.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerTypeProxyAttributeOnAssemblyUsingTarget.cs
index 947919e3d..eff843ca2 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerTypeProxyAttributeOnAssemblyUsingTarget.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerTypeProxyAttributeOnAssemblyUsingTarget.cs
@@ -3,18 +3,20 @@ using Mono.Linker.Tests.Cases.Attributes.Debugger;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-[assembly: KeptAttributeAttribute(typeof(DebuggerTypeProxyAttribute))]
-[assembly: DebuggerTypeProxy (typeof(DebuggerTypeProxyAttributeOnAssemblyUsingTarget.Foo.FooDebugView), Target = typeof (DebuggerTypeProxyAttributeOnAssemblyUsingTarget.Foo))]
+[assembly: KeptAttributeAttribute (typeof (DebuggerTypeProxyAttribute))]
+[assembly: DebuggerTypeProxy (typeof (DebuggerTypeProxyAttributeOnAssemblyUsingTarget.Foo.FooDebugView), Target = typeof (DebuggerTypeProxyAttributeOnAssemblyUsingTarget.Foo))]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("false")]
-	
+
 	// Can be removed once this bug is fixed https://bugzilla.xamarin.com/show_bug.cgi?id=58168
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	
+
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerTypeProxyAttribute), ".ctor(System.Type)")]
-	public class DebuggerTypeProxyAttributeOnAssemblyUsingTarget {
+	public class DebuggerTypeProxyAttributeOnAssemblyUsingTarget
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -23,7 +25,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Debugger {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		public class Foo {
+		public class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			public int Property { get; [Kept] set; }
@@ -33,7 +36,7 @@ namespace Mono.Linker.Tests.Cases.Attributes.Debugger {
 			{
 				private Foo _foo;
 
-				public FooDebugView(Foo foo)
+				public FooDebugView (Foo foo)
 				{
 					_foo = foo;
 				}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerTypeProxyAttributeOnType.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerTypeProxyAttributeOnType.cs
index e10cce1a1..857d6dfc6 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerTypeProxyAttributeOnType.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/DebuggerTypeProxyAttributeOnType.cs
@@ -2,15 +2,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("false")]
-	
+
 	// Can be removed once this bug is fixed https://bugzilla.xamarin.com/show_bug.cgi?id=58168
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	
+
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerTypeProxyAttribute), ".ctor(System.Type)")]
-	public class DebuggerTypeProxyAttributeOnType {
+	public class DebuggerTypeProxyAttributeOnType
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -20,11 +22,13 @@ namespace Mono.Linker.Tests.Cases.Attributes.Debugger {
 		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (DebuggerTypeProxyAttribute))]
 		[DebuggerTypeProxy (typeof (FooDebugView))]
-		class Foo {
+		class Foo
+		{
 		}
-		
+
 		[Kept]
-		class FooDebugView {
+		class FooDebugView
+		{
 			public FooDebugView (Foo foo)
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/Dependencies/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/Dependencies/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib.cs
index 4af869817..1a20cc03d 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/Dependencies/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/Dependencies/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib.cs
@@ -1,12 +1,16 @@
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger.Dependencies {
-	public class DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger.Dependencies
+{
+	public class DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib
+	{
 		public int Property { get; set; }
 
-		public class NestedType {
+		public class NestedType
+		{
 			public int NestedProperty { get; set; }
 		}
 
-		public class GenericType<T> {
+		public class GenericType<T>
+		{
 			public T PropertyOnGenericType { get; set; }
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTarget.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTarget.cs
index 740070469..ba4de5a86 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTarget.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTarget.cs
@@ -6,16 +6,18 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 [assembly: KeptAttributeAttribute (typeof (DebuggerDisplayAttribute))]
 [assembly: DebuggerDisplay ("{Property}", Target = typeof (DebuggerDisplayAttributeOnAssemblyUsingTarget.Foo))]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("true")]
-	
+
 	// Can be removed once this bug is fixed https://bugzilla.xamarin.com/show_bug.cgi?id=58168
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	
+
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), ".ctor(System.String)")]
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), "set_Target(System.Type)")]
-	public class DebuggerDisplayAttributeOnAssemblyUsingTarget {
+	public class DebuggerDisplayAttributeOnAssemblyUsingTarget
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -24,7 +26,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		public class Foo {
+		public class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			public int Property { [Kept] get; [Kept] set; }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetOnUnusedType.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetOnUnusedType.cs
index a45e53363..3187911b0 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetOnUnusedType.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetOnUnusedType.cs
@@ -5,7 +5,8 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
 [assembly: DebuggerDisplay ("{Property}", Target = typeof (DebuggerDisplayAttributeOnAssemblyUsingTargetOnUnusedType.Foo))]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("true")]
 
@@ -13,12 +14,14 @@ namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers {
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
 
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), ".ctor(System.String)")]
-	public class DebuggerDisplayAttributeOnAssemblyUsingTargetOnUnusedType {
+	public class DebuggerDisplayAttributeOnAssemblyUsingTargetOnUnusedType
+	{
 		public static void Main ()
 		{
 		}
 
-		public class Foo {
+		public class Foo
+		{
 			public int Property { get; set; }
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly.cs
index 86fcab15b..7def48ff7 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly.cs
@@ -7,20 +7,22 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 [assembly: KeptAttributeAttribute (typeof (DebuggerDisplayAttribute))]
 [assembly: DebuggerDisplay ("{Property}", TargetTypeName = "Mono.Linker.Tests.Cases.Attributes.Debugger.Dependencies.DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib, library")]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("true")]
-	[SetupCompileBefore ("library.dll", new [] { "../Dependencies/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib.cs" })]
-	
+	[SetupCompileBefore ("library.dll", new[] { "../Dependencies/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib.cs" })]
+
 	// Can be removed once this bug is fixed https://bugzilla.xamarin.com/show_bug.cgi?id=58168
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	
+
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), ".ctor(System.String)")]
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), "set_TargetTypeName(System.String)")]
-	
+
 	[KeptMemberInAssembly ("library.dll", typeof (DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib), "get_Property()")]
 	[KeptMemberInAssembly ("library.dll", typeof (DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib), "set_Property(System.Int32)")]
-	public class DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly {
+	public class DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly
+	{
 		public static void Main ()
 		{
 			var foo = new DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib ();
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInSameAssembly.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInSameAssembly.cs
index 9365cf31c..7385c8396 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInSameAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInSameAssembly.cs
@@ -5,16 +5,18 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 [assembly: KeptAttributeAttribute (typeof (DebuggerDisplayAttribute))]
 [assembly: DebuggerDisplay ("{Property}", TargetTypeName = "Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers.DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInSameAssembly+Foo")]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("true")]
-	
+
 	// Can be removed once this bug is fixed https://bugzilla.xamarin.com/show_bug.cgi?id=58168
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	
+
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), ".ctor(System.String)")]
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), "set_TargetTypeName(System.String)")]
-	public class DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInSameAssembly {
+	public class DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInSameAssembly
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -23,7 +25,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		public class Foo {
+		public class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			public int Property { [Kept] get; [Kept] set; }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameOfGenericTypeInOtherAssembly.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameOfGenericTypeInOtherAssembly.cs
index e2db26428..e1f6466b1 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameOfGenericTypeInOtherAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameOfGenericTypeInOtherAssembly.cs
@@ -6,20 +6,22 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 [assembly: KeptAttributeAttribute (typeof (DebuggerDisplayAttribute))]
 [assembly: DebuggerDisplay ("{Property}", TargetTypeName = "Mono.Linker.Tests.Cases.Attributes.Debugger.Dependencies.DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib+GenericType`1, library")]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("true")]
-	[SetupCompileBefore ("library.dll", new [] { "../Dependencies/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib.cs" })]
+	[SetupCompileBefore ("library.dll", new[] { "../Dependencies/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib.cs" })]
 
 	// Can be removed once this bug is fixed https://bugzilla.xamarin.com/show_bug.cgi?id=58168
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	
+
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), ".ctor(System.String)")]
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), "set_TargetTypeName(System.String)")]
-	
+
 	[KeptMemberInAssembly ("library.dll", typeof (DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib.GenericType<>), "get_PropertyOnGenericType()")]
 	[KeptMemberInAssembly ("library.dll", typeof (DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib.GenericType<>), "set_PropertyOnGenericType(T)")]
-	public class DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameOfGenericTypeInOtherAssembly {
+	public class DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameOfGenericTypeInOtherAssembly
+	{
 		public static void Main ()
 		{
 			var foo = new DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib.GenericType<int> ();
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameOfNestedTypeInOtherAssembly.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameOfNestedTypeInOtherAssembly.cs
index c6a3f3ca4..9ae1730d4 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameOfNestedTypeInOtherAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameOfNestedTypeInOtherAssembly.cs
@@ -6,20 +6,22 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 [assembly: KeptAttributeAttribute (typeof (DebuggerDisplayAttribute))]
 [assembly: DebuggerDisplay ("{Property}", TargetTypeName = "Mono.Linker.Tests.Cases.Attributes.Debugger.Dependencies.DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib+NestedType, library")]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("true")]
-	[SetupCompileBefore ("library.dll", new [] { "../Dependencies/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib.cs" })]
+	[SetupCompileBefore ("library.dll", new[] { "../Dependencies/DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib.cs" })]
 
 	// Can be removed once this bug is fixed https://bugzilla.xamarin.com/show_bug.cgi?id=58168
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
 
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), ".ctor(System.String)")]
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), "set_TargetTypeName(System.String)")]
-	
+
 	[KeptMemberInAssembly ("library.dll", typeof (DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib.NestedType), "get_NestedProperty()")]
 	[KeptMemberInAssembly ("library.dll", typeof (DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib.NestedType), "set_NestedProperty(System.Int32)")]
-	public class DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameOfNestedTypeInOtherAssembly {
+	public class DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameOfNestedTypeInOtherAssembly
+	{
 		public static void Main ()
 		{
 			var foo = new DebuggerDisplayAttributeOnAssemblyUsingTargetTypeNameInOtherAssembly_Lib.NestedType ();
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnType.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnType.cs
index 621789b4e..b167bdd08 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnType.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnType.cs
@@ -2,36 +2,40 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("true")]
-	
+
 	// Can be removed once this bug is fixed https://bugzilla.xamarin.com/show_bug.cgi?id=58168
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	
+
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerDisplayAttribute), ".ctor(System.String)")]
-	public class DebuggerDisplayAttributeOnType {
+	public class DebuggerDisplayAttributeOnType
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
-			var bar = new Bar();
+			var bar = new Bar ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (DebuggerDisplayAttribute))]
 		[DebuggerDisplay ("{Property}")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			public int Property { [Kept] get; [Kept] set; }
 		}
-		
+
 		[Kept]
-		[KeptMember(".ctor()")]
+		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (DebuggerDisplayAttribute))]
 		[DebuggerDisplay ("{Method()}")]
-		class Bar {
+		class Bar
+		{
 			[Kept]
 			public int Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnTypeThatIsNotUsed.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnTypeThatIsNotUsed.cs
index de51c012b..61360f4a3 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnTypeThatIsNotUsed.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerDisplayAttributeOnTypeThatIsNotUsed.cs
@@ -2,19 +2,22 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("true")]
-	
+
 	// Can be removed once this bug is fixed https://bugzilla.xamarin.com/show_bug.cgi?id=58168
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	public class DebuggerDisplayAttributeOnTypeThatIsNotUsed {
+	public class DebuggerDisplayAttributeOnTypeThatIsNotUsed
+	{
 		public static void Main ()
 		{
 		}
 
 		[DebuggerDisplay ("{Property}")]
-		class Foo {
+		class Foo
+		{
 			public int Property { get; set; }
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerTypeProxyAttributeOnAssemblyUsingTarget.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerTypeProxyAttributeOnAssemblyUsingTarget.cs
index 220e4e707..2f2738fe9 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerTypeProxyAttributeOnAssemblyUsingTarget.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerTypeProxyAttributeOnAssemblyUsingTarget.cs
@@ -4,18 +4,20 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
 [assembly: KeptAttributeAttribute (typeof (DebuggerTypeProxyAttribute))]
-[assembly: DebuggerTypeProxy (typeof(DebuggerTypeProxyAttributeOnAssemblyUsingTarget.Foo.FooDebugView), Target = typeof (DebuggerTypeProxyAttributeOnAssemblyUsingTarget.Foo))]
+[assembly: DebuggerTypeProxy (typeof (DebuggerTypeProxyAttributeOnAssemblyUsingTarget.Foo.FooDebugView), Target = typeof (DebuggerTypeProxyAttributeOnAssemblyUsingTarget.Foo))]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("true")]
-	
+
 	// Can be removed once this bug is fixed https://bugzilla.xamarin.com/show_bug.cgi?id=58168
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	
+
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerTypeProxyAttribute), ".ctor(System.Type)")]
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerTypeProxyAttribute), "set_Target(System.Type)")]
-	public class DebuggerTypeProxyAttributeOnAssemblyUsingTarget {
+	public class DebuggerTypeProxyAttributeOnAssemblyUsingTarget
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -24,7 +26,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		public class Foo {
+		public class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			public int Property { get; [Kept] set; }
@@ -36,7 +39,7 @@ namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers {
 				private Foo _foo;
 
 				[Kept]
-				public FooDebugView(Foo foo)
+				public FooDebugView (Foo foo)
 				{
 					_foo = foo;
 				}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerTypeProxyAttributeOnType.cs b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerTypeProxyAttributeOnType.cs
index fff100055..2d963d90d 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerTypeProxyAttributeOnType.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.Debugger/KeepDebugMembers/DebuggerTypeProxyAttributeOnType.cs
@@ -2,15 +2,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers {
+namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerKeepDebugMembers ("true")]
-	
+
 	// Can be removed once this bug is fixed https://bugzilla.xamarin.com/show_bug.cgi?id=58168
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	
+
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (DebuggerTypeProxyAttribute), ".ctor(System.Type)")]
-	public class DebuggerTypeProxyAttributeOnType {
+	public class DebuggerTypeProxyAttributeOnType
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -20,11 +22,13 @@ namespace Mono.Linker.Tests.Cases.Attributes.Debugger.KeepDebugMembers {
 		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (DebuggerTypeProxyAttribute))]
 		[DebuggerTypeProxy (typeof (FooDebugView))]
-		class Foo {
+		class Foo
+		{
 		}
-		
+
 		[Kept]
-		class FooDebugView {
+		class FooDebugView
+		{
 			[Kept]
 			public FooDebugView (Foo foo)
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.StructLayout/AutoClass.cs b/test/Mono.Linker.Tests.Cases/Attributes.StructLayout/AutoClass.cs
index be4085bad..0db589421 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.StructLayout/AutoClass.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.StructLayout/AutoClass.cs
@@ -6,7 +6,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.StructLayout
 {
 	[StructLayout (LayoutKind.Auto)]
 	[KeptMember (".ctor()")]
-	class AutoClassData {
+	class AutoClassData
+	{
 		public int never_used;
 		[Kept]
 		public int used;
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.StructLayout/ExplicitClass.cs b/test/Mono.Linker.Tests.Cases/Attributes.StructLayout/ExplicitClass.cs
index dc9f60013..b9d5c960f 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.StructLayout/ExplicitClass.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.StructLayout/ExplicitClass.cs
@@ -2,10 +2,12 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Attributes.StructLayout {
+namespace Mono.Linker.Tests.Cases.Attributes.StructLayout
+{
 	[StructLayout (LayoutKind.Explicit)]
 	[KeptMember (".ctor()")]
-	class ExplicitClassData {
+	class ExplicitClassData
+	{
 		[FieldOffset (0)]
 		[Kept] // the linker could remove this
 		public int never_used;
diff --git a/test/Mono.Linker.Tests.Cases/Attributes.StructLayout/UnusedTypeWithSequentialLayoutIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Attributes.StructLayout/UnusedTypeWithSequentialLayoutIsRemoved.cs
index d3cb2c30f..b0385a1ed 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes.StructLayout/UnusedTypeWithSequentialLayoutIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes.StructLayout/UnusedTypeWithSequentialLayoutIsRemoved.cs
@@ -3,13 +3,15 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
 namespace Mono.Linker.Tests.Cases.Attributes.StructLayout
 {
-	class UnusedTypeWithSequentialLayoutIsRemoved {
+	class UnusedTypeWithSequentialLayoutIsRemoved
+	{
 		static void Main ()
 		{
 		}
 
 		[StructLayout (LayoutKind.Sequential)]
-		class B {
+		class B
+		{
 			int a;
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/AssemblyAttributeIsRemovedIfOnlyTypesUsedInAssembly.cs b/test/Mono.Linker.Tests.Cases/Attributes/AssemblyAttributeIsRemovedIfOnlyTypesUsedInAssembly.cs
index 1e74f81c2..f325de503 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/AssemblyAttributeIsRemovedIfOnlyTypesUsedInAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/AssemblyAttributeIsRemovedIfOnlyTypesUsedInAssembly.cs
@@ -5,10 +5,12 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
 [assembly: AttributeInReference]
 
-namespace Mono.Linker.Tests.Cases.Attributes {
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/AssemblyAttributeIsRemovedIfOnlyTypesUsedInAssembly_Lib.cs" })]
+namespace Mono.Linker.Tests.Cases.Attributes
+{
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/AssemblyAttributeIsRemovedIfOnlyTypesUsedInAssembly_Lib.cs" })]
 	[RemovedAssembly ("library.dll")]
-	class AssemblyAttributeIsRemovedIfOnlyTypesUsedInAssembly {
+	class AssemblyAttributeIsRemovedIfOnlyTypesUsedInAssembly
+	{
 		static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/AssemblyAttributeKeptInComplexCase.cs b/test/Mono.Linker.Tests.Cases/Attributes/AssemblyAttributeKeptInComplexCase.cs
index 59dec89d4..a67b966b4 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/AssemblyAttributeKeptInComplexCase.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/AssemblyAttributeKeptInComplexCase.cs
@@ -16,19 +16,22 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 [assembly: KeptAttributeAttribute (typeof (AssemblyAttributeKeptInComplexCase.FooAttribute))]
 [assembly: KeptAttributeAttribute (typeof (AssemblyAttributeKeptInComplexCase_Lib.OtherAssemblyAttribute))]
 
-namespace Mono.Linker.Tests.Cases.Attributes {
-	[SetupCompileBefore ("library2.dll", new [] { "Dependencies/AssemblyAttributeKeptInComplexCase_Lib.cs" })]
+namespace Mono.Linker.Tests.Cases.Attributes
+{
+	[SetupCompileBefore ("library2.dll", new[] { "Dependencies/AssemblyAttributeKeptInComplexCase_Lib.cs" })]
 	[KeptAssembly ("library2.dll")]
 	[KeptMemberInAssembly ("library2.dll", typeof (AssemblyAttributeKeptInComplexCase_Lib.OtherAssemblyAttribute), ".ctor()")]
 	[KeptMemberInAssembly ("library2.dll", typeof (AssemblyAttributeKeptInComplexCase_Lib), "MethodThatWillBeUsed()")]
-	public class AssemblyAttributeKeptInComplexCase {
+	public class AssemblyAttributeKeptInComplexCase
+	{
 		static void Main ()
 		{
 		}
 
 		[Kept]
 		[KeptBaseType (typeof (Attribute))]
-		public class FooAttribute : Attribute {
+		public class FooAttribute : Attribute
+		{
 			[Kept]
 			public FooAttribute ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnAssemblyIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnAssemblyIsKept.cs
index b42d3ff2f..615955a01 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnAssemblyIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnAssemblyIsKept.cs
@@ -5,14 +5,17 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 [assembly: AttributeOnAssemblyIsKept.Foo]
 [assembly: KeptAttributeAttribute (typeof (AttributeOnAssemblyIsKept.FooAttribute))]
 
-namespace Mono.Linker.Tests.Cases.Attributes {
-	class AttributeOnAssemblyIsKept {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
+	class AttributeOnAssemblyIsKept
+	{
 		static void Main ()
 		{
 		}
 
 		[KeptBaseType (typeof (System.Attribute))]
-		public class FooAttribute : Attribute {
+		public class FooAttribute : Attribute
+		{
 			[Kept]
 			public FooAttribute ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnAssemblyIsKeptIfDeclarationIsSkipped.cs b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnAssemblyIsKeptIfDeclarationIsSkipped.cs
index ce76d097d..3f3232d26 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnAssemblyIsKeptIfDeclarationIsSkipped.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnAssemblyIsKeptIfDeclarationIsSkipped.cs
@@ -12,9 +12,10 @@ namespace Mono.Linker.Tests.Cases.Attributes
 {
 	[SkipPeVerify]
 	[Define ("REFERENCE_INCLUDED")]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/AttributeDefinedInReference.cs" })]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/AttributeDefinedInReference.cs" })]
 	[SetupLinkerAction ("skip", "library")]
-	class AttributeOnAssemblyIsKeptIfDeclarationIsSkipped {
+	class AttributeOnAssemblyIsKeptIfDeclarationIsSkipped
+	{
 		static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnParameterInUsedMethodIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnParameterInUsedMethodIsKept.cs
index 01cdad565..2874a1139 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnParameterInUsedMethodIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnParameterInUsedMethodIsKept.cs
@@ -1,8 +1,10 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Attributes {
-	class AttributeOnParameterInUsedMethodIsKept {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
+	class AttributeOnParameterInUsedMethodIsKept
+	{
 		static void Main ()
 		{
 			Method ("Bar");
@@ -15,8 +17,9 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		[KeptBaseType (typeof(Attribute))]
-		class FooAttribute : Attribute {
+		[KeptBaseType (typeof (Attribute))]
+		class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeIsKept.cs
index 1cd0cdc23..60e64b158 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeIsKept.cs
@@ -1,16 +1,19 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Attributes {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
 	[Foo]
 	[KeptAttributeAttribute (typeof (FooAttribute))]
-	class AttributeOnPreservedTypeIsKept {
+	class AttributeOnPreservedTypeIsKept
+	{
 		public static void Main ()
 		{
 		}
 
 		[KeptBaseType (typeof (System.Attribute))]
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 			[Kept]
 			public FooAttribute ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithTypeUsedInConstructorIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithTypeUsedInConstructorIsKept.cs
index aa6600837..909c5dee1 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithTypeUsedInConstructorIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithTypeUsedInConstructorIsKept.cs
@@ -1,16 +1,19 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Attributes {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
 	[Foo (typeof (A))]
 	[KeptAttributeAttribute (typeof (FooAttribute))]
-	class AttributeOnPreservedTypeWithTypeUsedInConstructorIsKept {
+	class AttributeOnPreservedTypeWithTypeUsedInConstructorIsKept
+	{
 		public static void Main ()
 		{
 		}
 
 		[KeptBaseType (typeof (System.Attribute))]
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 			[Kept]
 			public FooAttribute (Type val)
 			{
@@ -18,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 		}
 
 		[Kept]
-		class A {
+		class A
+		{
 			public A ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithTypeUsedInDifferentNamespaceIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithTypeUsedInDifferentNamespaceIsKept.cs
index 976ac6d26..b48bbfa61 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithTypeUsedInDifferentNamespaceIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithTypeUsedInDifferentNamespaceIsKept.cs
@@ -1,25 +1,30 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace NamespaceForAttributeOnPreservedTypeWithTypeUsedInDifferentNamespaceIsKept {
+namespace NamespaceForAttributeOnPreservedTypeWithTypeUsedInDifferentNamespaceIsKept
+{
 	[Kept]
-	class A {
+	class A
+	{
 		public A ()
 		{
 		}
 	}
 }
 
-namespace Mono.Linker.Tests.Cases.Attributes {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
 	[Foo (typeof (NamespaceForAttributeOnPreservedTypeWithTypeUsedInDifferentNamespaceIsKept.A))]
 	[KeptAttributeAttribute (typeof (FooAttribute))]
-	class AttributeOnPreservedTypeWithTypeUsedInDifferentNamespaceIsKept {
+	class AttributeOnPreservedTypeWithTypeUsedInDifferentNamespaceIsKept
+	{
 		public static void Main ()
 		{
 		}
 
 		[KeptBaseType (typeof (System.Attribute))]
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 			[Kept]
 			public FooAttribute (Type val)
 			{
@@ -27,7 +32,8 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 		}
 
 		// This A is not used and should be removed
-		class A {
+		class A
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithTypeUsedInFieldIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithTypeUsedInFieldIsKept.cs
index e038333e9..4985d7f38 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithTypeUsedInFieldIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithTypeUsedInFieldIsKept.cs
@@ -1,23 +1,27 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Attributes {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
 	[Foo (Val = typeof (A))]
 	[KeptAttributeAttribute (typeof (FooAttribute))]
-	class AttributeOnPreservedTypeWithTypeUsedInFieldIsKept {
+	class AttributeOnPreservedTypeWithTypeUsedInFieldIsKept
+	{
 		public static void Main ()
 		{
 		}
 
-		[KeptMember(".ctor()")]
+		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (System.Attribute))]
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 			[Kept]
 			public Type Val;
 		}
 
 		[Kept]
-		class A {
+		class A
+		{
 			public A ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithTypeUsedInPropertySetterIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithTypeUsedInPropertySetterIsKept.cs
index 8bc4dd523..eac86ab71 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithTypeUsedInPropertySetterIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithTypeUsedInPropertySetterIsKept.cs
@@ -1,24 +1,28 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Attributes {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
 	[Foo (Val = typeof (A))]
 	[KeptAttributeAttribute (typeof (FooAttribute))]
-	class AttributeOnPreservedTypeWithTypeUsedInPropertySetterIsKept {
+	class AttributeOnPreservedTypeWithTypeUsedInPropertySetterIsKept
+	{
 		public static void Main ()
 		{
 		}
 
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (System.Attribute))]
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 			[Kept]
 			[KeptBackingField]
 			public Type Val { get; [Kept] set; }
 		}
 
 		[Kept]
-		class A {
+		class A
+		{
 			public A ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithUsedSetter.cs b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithUsedSetter.cs
index 957de91e1..1da9dc3e9 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithUsedSetter.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnPreservedTypeWithUsedSetter.cs
@@ -1,17 +1,20 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Attributes {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
 	[Foo (Val = 1)]
 	[KeptAttributeAttribute (typeof (FooAttribute))]
-	class AttributeOnPreservedTypeWithUsedSetter {
+	class AttributeOnPreservedTypeWithUsedSetter
+	{
 		public static void Main ()
 		{
 		}
 
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (System.Attribute))]
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 			[Kept]
 			[KeptBackingField]
 			public int Val { get; [Kept] set; }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnUsedFieldIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnUsedFieldIsKept.cs
index 834c446ac..e1489d10c 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnUsedFieldIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnUsedFieldIsKept.cs
@@ -1,15 +1,18 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Attributes {
-	class AttributeOnUsedFieldIsKept {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
+	class AttributeOnUsedFieldIsKept
+	{
 		public static void Main ()
 		{
 			var val = new A ().field;
 		}
 
 		[KeptMember (".ctor()")]
-		class A {
+		class A
+		{
 			[Kept]
 			[KeptAttributeAttribute (typeof (FooAttribute))]
 			[Foo]
@@ -17,9 +20,10 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 		}
 
 		[Kept]
-		[KeptMember(".ctor()")]
+		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (System.Attribute))]
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnUsedMethodIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnUsedMethodIsKept.cs
index 0f99a1ca9..05a448f33 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnUsedMethodIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnUsedMethodIsKept.cs
@@ -1,15 +1,18 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Attributes {
-	class AttributeOnUsedMethodIsKept {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
+	class AttributeOnUsedMethodIsKept
+	{
 		public static void Main ()
 		{
 			new A ().Method ();
 		}
 
 		[KeptMember (".ctor()")]
-		class A {
+		class A
+		{
 			[Foo]
 			[Kept]
 			[KeptAttributeAttribute (typeof (FooAttribute))]
@@ -21,7 +24,8 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (System.Attribute))]
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnUsedPropertyIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnUsedPropertyIsKept.cs
index 8e61c12c1..9d32b382f 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnUsedPropertyIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/AttributeOnUsedPropertyIsKept.cs
@@ -1,8 +1,10 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Attributes {
-	class AttributeOnUsedPropertyIsKept {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
+	class AttributeOnUsedPropertyIsKept
+	{
 		public static void Main ()
 		{
 			var val = new A ().Field;
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 
 		[KeptMember (".ctor()")]
 		[KeptMember ("get_Field()")]
-		class A {
+		class A
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptAttributeAttribute (typeof (FooAttribute))]
@@ -21,7 +24,8 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (System.Attribute))]
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/BoxedValues.cs b/test/Mono.Linker.Tests.Cases/Attributes/BoxedValues.cs
index 0d4448ccb..184224dd6 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/BoxedValues.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/BoxedValues.cs
@@ -1,8 +1,10 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Attributes {
-	public class BoxedValues {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
+	public class BoxedValues
+	{
 		// mcs bug
 		//        [TestAttribute ((object)typeof (Enum_2))]
 		//		[Kept]
@@ -25,7 +27,7 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 		{
 		}
 
-		[TestAttribute (TestProperty = new object [] { Enum_4.B, null, typeof (Enum_5) })]
+		[TestAttribute (TestProperty = new object[] { Enum_4.B, null, typeof (Enum_5) })]
 		[Kept]
 		[KeptAttributeAttribute (typeof (TestAttribute))]
 		public void Test_4 ()
@@ -42,7 +44,8 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 	}
 
 	[KeptBaseType (typeof (System.Attribute))]
-	public class TestAttribute : Attribute {
+	public class TestAttribute : Attribute
+	{
 		[Kept]
 		public TestAttribute ()
 		{
@@ -61,7 +64,8 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 		public object TestField;
 	}
 
-	public enum Enum_1 {
+	public enum Enum_1
+	{
 		A = 1,
 		B,
 		C
@@ -70,7 +74,8 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 	[Kept]
 	[KeptMember ("value__")]
 	[KeptBaseType (typeof (Enum))]
-	public enum Enum_2 {
+	public enum Enum_2
+	{
 		[Kept]
 		A = 1,
 		[Kept]
@@ -82,7 +87,8 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 	[Kept]
 	[KeptMember ("value__")]
 	[KeptBaseType (typeof (Enum))]
-	public enum Enum_3 {
+	public enum Enum_3
+	{
 		[Kept]
 		C
 	}
@@ -90,7 +96,8 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 	[Kept]
 	[KeptMember ("value__")]
 	[KeptBaseType (typeof (Enum))]
-	public enum Enum_4 {
+	public enum Enum_4
+	{
 		[Kept]
 		B
 	}
@@ -98,7 +105,8 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 	[Kept]
 	[KeptMember ("value__")]
 	[KeptBaseType (typeof (Enum))]
-	public enum Enum_5 {
+	public enum Enum_5
+	{
 		[Kept]
 		B
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/CoreLibraryAssemblyAttributesAreKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/CoreLibraryAssemblyAttributesAreKept.cs
index cff049ebb..4dc91982e 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/CoreLibraryAssemblyAttributesAreKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/CoreLibraryAssemblyAttributesAreKept.cs
@@ -3,7 +3,8 @@ using System.Timers;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
 	[Reference ("System.dll")]
 	[SetupLinkerCoreAction ("link")]
 	[KeptAttributeInAssembly (PlatformAssemblies.CoreLib, typeof (AssemblyDescriptionAttribute))]
@@ -13,7 +14,8 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 	[KeptAttributeInAssembly ("System.dll", typeof (AssemblyCompanyAttribute))]
 #endif
 	[SkipPeVerify]
-	public class CoreLibraryAssemblyAttributesAreKept {
+	public class CoreLibraryAssemblyAttributesAreKept
+	{
 		public static void Main ()
 		{
 			// Use something from System so that the entire reference isn't linked away
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeArrayOnAttributeCtorOnType.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeArrayOnAttributeCtorOnType.cs
index 66ac1deeb..8e08ad380 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeArrayOnAttributeCtorOnType.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeArrayOnAttributeCtorOnType.cs
@@ -2,19 +2,21 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// This explicit csc test exists to ensure that csc adds references in this scenario
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType1.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithType2.dll", new [] { typeof(TypeDefinedInReference2) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType1.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType2.dll", new[] { typeof (TypeDefinedInReference2) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType1.dll", typeof (TypeDefinedInReference))]
 	[KeptTypeInAssembly ("LibraryWithType2.dll", typeof (TypeDefinedInReference2))]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor(System.Type[])")]
-	public class OnlyTypeUsedInAssemblyIsTypeArrayOnAttributeCtorOnType {
-		public static void Main()
+	public class OnlyTypeUsedInAssemblyIsTypeArrayOnAttributeCtorOnType
+	{
+		public static void Main ()
 		{
 			var foo = new Foo ();
 		}
@@ -22,8 +24,9 @@ namespace Mono.Linker.Tests.Cases.Attributes.Csc {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
-		[AttributeDefinedInReference (new [] { typeof (TypeDefinedInReference), typeof (TypeDefinedInReference2) })]
-		class Foo {
+		[AttributeDefinedInReference (new[] { typeof (TypeDefinedInReference), typeof (TypeDefinedInReference2) })]
+		class Foo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssembly.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssembly.cs
index 2c4e74f7a..4ff91bb66 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssembly.cs
@@ -4,18 +4,20 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
 [assembly: AttributeDefinedInReference (typeof (TypeDefinedInReference))]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// In the case of attributes on assemblies, we expect both assemblies to be removed because we don't keep assembly level attributes
 	/// when that is the only type marked in the assembly
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[RemovedAssembly ("LibraryWithType.dll")]
 	[RemovedAssembly ("LibraryWithAttribute.dll")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssembly {
-		public static void Main()
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssembly
+	{
+		public static void Main ()
 		{
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssemblyOtherTypesInAttributeAssemblyUsed.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssemblyOtherTypesInAttributeAssemblyUsed.cs
index eac7c96d7..576c85f24 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssemblyOtherTypesInAttributeAssemblyUsed.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssemblyOtherTypesInAttributeAssemblyUsed.cs
@@ -5,23 +5,25 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 [assembly: KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
 [assembly: AttributeDefinedInReference (typeof (TypeDefinedInReference))]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// This explicit csc test exists to ensure that csc adds references in this scenario
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof (AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor(System.Type)")]
 	[KeptTypeInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference_OtherType))]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssemblyOtherTypesInAttributeAssemblyUsed {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssemblyOtherTypesInAttributeAssemblyUsed
+	{
 		public static void Main ()
 		{
 			// Use something in the attribute assembly so that the special behavior of not preserving a reference if the only thing that is marked
 			// are attributes is not trigged
-			AttributeDefinedInReference_OtherType.Method();
+			AttributeDefinedInReference_OtherType.Method ();
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnEvent.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnEvent.cs
index 5241fe700..6b9c5ff8e 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnEvent.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnEvent.cs
@@ -3,22 +3,24 @@ using Mono.Linker.Tests.Cases.Attributes.Dependencies;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// This explicit csc test exists to ensure that csc adds references in this scenario
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor(System.Type)")]
 	[KeptDelegateCacheField ("0")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnEvent {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnEvent
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
-			foo.MyEvent += FooOnMyEvent; 
+			foo.MyEvent += FooOnMyEvent;
 		}
 
 		[Kept]
@@ -34,7 +36,7 @@ namespace Mono.Linker.Tests.Cases.Attributes.Csc {
 			[KeptBackingField]
 			[KeptEventAddMethod]
 			[KeptEventRemoveMethod]
-			[KeptAttributeAttribute (typeof( AttributeDefinedInReference))]
+			[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
 			[AttributeDefinedInReference (typeof (TypeDefinedInReference))]
 			public event EventHandler MyEvent;
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnMethod.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnMethod.cs
index 18900f311..ced3f8a2c 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnMethod.cs
@@ -2,17 +2,19 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// This explicit csc test exists to ensure that csc adds references in this scenario
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof (TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof (AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor(System.Type)")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnMethod {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnMethod
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -21,7 +23,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Csc {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
 			[AttributeDefinedInReference (typeof (TypeDefinedInReference))]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnProperty.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnProperty.cs
index 3f97866a6..b09349e29 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnProperty.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnProperty.cs
@@ -2,17 +2,19 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// This explicit csc test exists to ensure that csc adds references in this scenario
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor(System.Type)")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnProperty {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnProperty
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -21,7 +23,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Csc {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnType.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnType.cs
index 0b7cfdc2b..8211c496a 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnType.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnType.cs
@@ -2,20 +2,22 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// This explicit csc test exists to ensure that csc adds references in this scenario
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof (TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof (AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor(System.Type)")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnType {
-		public static void Main()
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnType
+	{
+		public static void Main ()
 		{
-			var foo = new Foo();
+			var foo = new Foo ();
 		}
 
 		[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnAssembly.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnAssembly.cs
index afb890223..9c5f402d3 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnAssembly.cs
@@ -4,14 +4,15 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
 [assembly: AttributeDefinedInReference (FieldType = typeof (TypeDefinedInReference))]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// In the case of attributes on assemblies, we expect both assemblies to be removed because we don't keep assembly level attributes
 	/// when that is the only type marked in the assembly
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[RemovedAssembly ("LibraryWithType.dll")]
 	[RemovedAssembly ("LibraryWithAttribute.dll")]
 	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnAssembly
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnEvent.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnEvent.cs
index 939787ff8..9026e6048 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnEvent.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnEvent.cs
@@ -3,23 +3,25 @@ using Mono.Linker.Tests.Cases.Attributes.Dependencies;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// This explicit csc test exists to ensure that csc adds references in this scenario
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), "FieldType")]
 	[KeptDelegateCacheField ("0")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnEvent {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnEvent
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
-			foo.MyEvent += FooOnMyEvent; 
+			foo.MyEvent += FooOnMyEvent;
 		}
 
 		[Kept]
@@ -29,7 +31,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Csc {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptEventAddMethod]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnMethod.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnMethod.cs
index 423c2d571..8cdf7bfdb 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnMethod.cs
@@ -2,13 +2,14 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// This explicit csc test exists to ensure that csc adds references in this scenario
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor()")]
@@ -23,10 +24,11 @@ namespace Mono.Linker.Tests.Cases.Attributes.Csc {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
-			[AttributeDefinedInReference (FieldType = typeof(TypeDefinedInReference))]
+			[AttributeDefinedInReference (FieldType = typeof (TypeDefinedInReference))]
 			public void Method ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnProperty.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnProperty.cs
index cfe5869f9..6401a1bce 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnProperty.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnProperty.cs
@@ -2,18 +2,20 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// This explicit csc test exists to ensure that csc adds references in this scenario
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), "FieldType")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnProperty {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnProperty
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -22,7 +24,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Csc {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnType.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnType.cs
index 971fd317e..b048f5de8 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnType.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnType.cs
@@ -2,18 +2,20 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// This explicit csc test exists to ensure that csc adds references in this scenario
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), "FieldType")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnType {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnType
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -23,7 +25,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Csc {
 		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
 		[AttributeDefinedInReference (FieldType = typeof (TypeDefinedInReference))]
-		class Foo {
+		class Foo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnAssembly.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnAssembly.cs
index 904ccb278..24275b74d 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnAssembly.cs
@@ -4,17 +4,19 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
 [assembly: AttributeDefinedInReference (PropertyType = typeof (TypeDefinedInReference))]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// In the case of attributes on assemblies, we expect both assemblies to be removed because we don't keep assembly level attributes
 	/// when that is the only type marked in the assembly
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[RemovedAssembly ("LibraryWithType.dll")]
 	[RemovedAssembly ("LibraryWithAttribute.dll")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnAssembly {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnAssembly
+	{
 		public static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnEvent.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnEvent.cs
index b48d1e64e..5f1791948 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnEvent.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnEvent.cs
@@ -3,23 +3,25 @@ using Mono.Linker.Tests.Cases.Attributes.Dependencies;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// This explicit csc test exists to ensure that csc adds references in this scenario
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), "set_PropertyType(System.Type)")]
 	[KeptDelegateCacheField ("0")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnEvent {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnEvent
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
-			foo.MyEvent += FooOnMyEvent; 
+			foo.MyEvent += FooOnMyEvent;
 		}
 
 		[Kept]
@@ -29,7 +31,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Csc {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptEventAddMethod]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnMethod.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnMethod.cs
index cf503c561..af1c958d7 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnMethod.cs
@@ -2,18 +2,20 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// This explicit csc test exists to ensure that csc adds references in this scenario
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), "set_PropertyType(System.Type)")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnMethod {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnMethod
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -22,7 +24,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Csc {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
 			[AttributeDefinedInReference (PropertyType = typeof (TypeDefinedInReference))]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnProperty.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnProperty.cs
index b382e28f8..a615ef0c1 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnProperty.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnProperty.cs
@@ -2,18 +2,20 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// This explicit csc test exists to ensure that csc adds references in this scenario
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), "set_PropertyType(System.Type)")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnProperty {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnProperty
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -22,7 +24,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Csc {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnType.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnType.cs
index 1e1b24706..92bbcd3a4 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnType.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnType.cs
@@ -2,18 +2,20 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// This explicit csc test exists to ensure that csc adds references in this scenario
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), "set_PropertyType(System.Type)")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnType {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnType
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -23,7 +25,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Csc {
 		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
 		[AttributeDefinedInReference (PropertyType = typeof (TypeDefinedInReference))]
-		class Foo {
+		class Foo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyWithReferenceIsTypeOnAttributeCtorOnType.cs b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyWithReferenceIsTypeOnAttributeCtorOnType.cs
index 265107a78..ef7f6f10f 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyWithReferenceIsTypeOnAttributeCtorOnType.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Csc/OnlyTypeUsedInAssemblyWithReferenceIsTypeOnAttributeCtorOnType.cs
@@ -2,20 +2,22 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Csc {
+namespace Mono.Linker.Tests.Cases.Attributes.Csc
+{
 	/// <summary>
 	/// This explicit csc test exists to ensure that csc adds references in this scenario
 	/// </summary>
 	[SetupCSharpCompilerToUse ("csc")]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithTypeAndReference.dll", new [] { typeof(TypeDefinedInReferenceWithReference) }, new [] { "LibraryWithType.dll", "LibraryWithAttribute.dll" }, compilerToUse: "csc")]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithTypeAndReference.dll", new[] { typeof (TypeDefinedInReferenceWithReference) }, new[] { "LibraryWithType.dll", "LibraryWithAttribute.dll" }, compilerToUse: "csc")]
 	[KeptTypeInAssembly ("LibraryWithTypeAndReference.dll", typeof (TypeDefinedInReferenceWithReference))]
 	[RemovedMemberInAssembly ("LibraryWithTypeAndReference.dll", typeof (TypeDefinedInReferenceWithReference), "Unused()")]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor(System.Type)")]
-	public class OnlyTypeUsedInAssemblyWithReferenceIsTypeOnAttributeCtorOnType {
+	public class OnlyTypeUsedInAssemblyWithReferenceIsTypeOnAttributeCtorOnType
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -25,7 +27,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Csc {
 		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
 		[AttributeDefinedInReference (typeof (TypeDefinedInReferenceWithReference))]
-		class Foo {
+		class Foo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/AssemblyAttributeIsRemovedIfOnlyTypesUsedInAssembly_Lib.cs b/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/AssemblyAttributeIsRemovedIfOnlyTypesUsedInAssembly_Lib.cs
index b52782cd8..b0212d7fe 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/AssemblyAttributeIsRemovedIfOnlyTypesUsedInAssembly_Lib.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/AssemblyAttributeIsRemovedIfOnlyTypesUsedInAssembly_Lib.cs
@@ -1,6 +1,8 @@
 using System;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Dependencies {
-	public class AttributeInReferenceAttribute : Attribute {
+namespace Mono.Linker.Tests.Cases.Attributes.Dependencies
+{
+	public class AttributeInReferenceAttribute : Attribute
+	{
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/AssemblyAttributeKeptInComplexCase_Lib.cs b/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/AssemblyAttributeKeptInComplexCase_Lib.cs
index 914361f07..187fdd9b7 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/AssemblyAttributeKeptInComplexCase_Lib.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/AssemblyAttributeKeptInComplexCase_Lib.cs
@@ -1,8 +1,11 @@
 using System;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Dependencies {
-	public class AssemblyAttributeKeptInComplexCase_Lib {
-		public class OtherAssemblyAttribute : Attribute {
+namespace Mono.Linker.Tests.Cases.Attributes.Dependencies
+{
+	public class AssemblyAttributeKeptInComplexCase_Lib
+	{
+		public class OtherAssemblyAttribute : Attribute
+		{
 		}
 
 		public static void MethodThatWillBeUsed ()
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/AttributeDefinedInReference.cs b/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/AttributeDefinedInReference.cs
index cc6d8d928..0b9620a9d 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/AttributeDefinedInReference.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/AttributeDefinedInReference.cs
@@ -1,18 +1,20 @@
 using System;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Dependencies {
+namespace Mono.Linker.Tests.Cases.Attributes.Dependencies
+{
 	[AttributeUsage (AttributeTargets.All, AllowMultiple = true)]
-	public class AttributeDefinedInReference : Attribute {
+	public class AttributeDefinedInReference : Attribute
+	{
 		public Type FieldType;
-		
+
 		public AttributeDefinedInReference ()
 		{
 		}
-		
+
 		public AttributeDefinedInReference (Type t)
 		{
 		}
-		
+
 		public AttributeDefinedInReference (Type[] t)
 		{
 		}
@@ -20,7 +22,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Dependencies {
 		public Type PropertyType { get; set; }
 	}
 
-	public class AttributeDefinedInReference_OtherType {
+	public class AttributeDefinedInReference_OtherType
+	{
 		public static void Method ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/TypeDefinedInReference.cs b/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/TypeDefinedInReference.cs
index 76c32933b..63b0b1999 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/TypeDefinedInReference.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/TypeDefinedInReference.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.Attributes.Dependencies {
-	public class TypeDefinedInReference {
+namespace Mono.Linker.Tests.Cases.Attributes.Dependencies
+{
+	public class TypeDefinedInReference
+	{
 		public static void Unused ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/TypeDefinedInReference2.cs b/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/TypeDefinedInReference2.cs
index b306dcea5..08a0e2386 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/TypeDefinedInReference2.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/TypeDefinedInReference2.cs
@@ -1,4 +1,6 @@
-namespace Mono.Linker.Tests.Cases.Attributes.Dependencies {
-	public class TypeDefinedInReference2 {
+namespace Mono.Linker.Tests.Cases.Attributes.Dependencies
+{
+	public class TypeDefinedInReference2
+	{
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/TypeDefinedInReferenceWithReference.cs b/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/TypeDefinedInReferenceWithReference.cs
index 2f60f4763..e2cf52619 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/TypeDefinedInReferenceWithReference.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Dependencies/TypeDefinedInReferenceWithReference.cs
@@ -1,6 +1,8 @@
-namespace Mono.Linker.Tests.Cases.Attributes.Dependencies {
+namespace Mono.Linker.Tests.Cases.Attributes.Dependencies
+{
 	[AttributeDefinedInReference (typeof (TypeDefinedInReference))]
-	public class TypeDefinedInReferenceWithReference {
+	public class TypeDefinedInReferenceWithReference
+	{
 		public static void Unused ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/FixedLengthArrayAttributesArePreserved.cs b/test/Mono.Linker.Tests.Cases/Attributes/FixedLengthArrayAttributesArePreserved.cs
index 3c65d0204..4e9727304 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/FixedLengthArrayAttributesArePreserved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/FixedLengthArrayAttributesArePreserved.cs
@@ -3,14 +3,16 @@ using System.Security;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
 	/// <summary>
 	/// The purpose of this test is mainly to provide coverage on the `KeptAttributeOnFixedBufferType` attribute
 	/// </summary>
 	[SetupCompileArgument ("/unsafe")]
 	// Can't verify because the test contains unsafe code
 	[SkipPeVerify]
-	public class FixedLengthArrayAttributesArePreserved {
+	public class FixedLengthArrayAttributesArePreserved
+	{
 		public static void Main ()
 		{
 			Helper ();
@@ -28,14 +30,15 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 		static unsafe void AMethodToUseTheReturnValue (int* ptr)
 		{
 		}
-		
+
 		[Kept]
-		public unsafe struct WithFixedArrayField {
+		public unsafe struct WithFixedArrayField
+		{
 			[Kept]
 			[KeptFixedBuffer]
 			[KeptAttributeOnFixedBufferType (typeof (UnsafeValueTypeAttribute))]
 			[KeptAttributeAttribute (typeof (FixedBufferAttribute))]
-			public fixed int Values [10];
+			public fixed int Values[10];
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeArrayOnAttributeCtorOnType.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeArrayOnAttributeCtorOnType.cs
index 4f06ea861..a07cc9d5f 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeArrayOnAttributeCtorOnType.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeArrayOnAttributeCtorOnType.cs
@@ -2,20 +2,22 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// This explicit mcs test exists because mcs did not add a reference prior to https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5
 	/// </summary>
 	[IgnoreTestCase ("Can be enabled once the mcs contains https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5")]
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType1.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithType2.dll", new [] { typeof(TypeDefinedInReference2) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType1.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType2.dll", new[] { typeof (TypeDefinedInReference2) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType1.dll", typeof (TypeDefinedInReference))]
 	[KeptTypeInAssembly ("LibraryWithType2.dll", typeof (TypeDefinedInReference2))]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor(System.Type[])")]
-	public class OnlyTypeUsedInAssemblyIsTypeArrayOnAttributeCtorOnType {
-		public static void Main()
+	public class OnlyTypeUsedInAssemblyIsTypeArrayOnAttributeCtorOnType
+	{
+		public static void Main ()
 		{
 			var foo = new Foo ();
 		}
@@ -23,8 +25,9 @@ namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
-		[AttributeDefinedInReference (new [] { typeof (TypeDefinedInReference), typeof (TypeDefinedInReference2) })]
-		class Foo {
+		[AttributeDefinedInReference (new[] { typeof (TypeDefinedInReference), typeof (TypeDefinedInReference2) })]
+		class Foo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssembly.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssembly.cs
index 1d0ab35ca..681365077 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssembly.cs
@@ -4,7 +4,8 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
 [assembly: AttributeDefinedInReference (typeof (TypeDefinedInReference))]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// In the case of attributes on assemblies, we expect both assemblies to be removed because we don't keep assembly level attributes
 	/// when that is the only type marked in the assembly
@@ -13,12 +14,13 @@ namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
 	[IgnoreTestCase ("Don't try to compile with mcs on .NET Core")]
 #endif
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[RemovedAssembly ("LibraryWithType.dll")]
 	[RemovedAssembly ("LibraryWithAttribute.dll")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssembly {
-		public static void Main()
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssembly
+	{
+		public static void Main ()
 		{
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssemblyOtherTypesInAttributeAssemblyUsed.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssemblyOtherTypesInAttributeAssemblyUsed.cs
index c3a62bed0..c04373888 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssemblyOtherTypesInAttributeAssemblyUsed.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssemblyOtherTypesInAttributeAssemblyUsed.cs
@@ -5,24 +5,26 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 [assembly: KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
 [assembly: AttributeDefinedInReference (typeof (TypeDefinedInReference))]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// This explicit mcs test exists because mcs did not add a reference prior to https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5
 	/// </summary>
 	[IgnoreTestCase ("Can be enabled once the mcs contains https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5")]
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof (AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor(System.Type)")]
 	[KeptTypeInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference_OtherType))]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssemblyOtherTypesInAttributeAssemblyUsed {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnAssemblyOtherTypesInAttributeAssemblyUsed
+	{
 		public static void Main ()
 		{
 			// Use something in the attribute assembly so that the special behavior of not preserving a reference if the only thing that is marked
 			// are attributes is not trigged
-			AttributeDefinedInReference_OtherType.Method();
+			AttributeDefinedInReference_OtherType.Method ();
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnEvent.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnEvent.cs
index 0df1c12e5..cb34014ae 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnEvent.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnEvent.cs
@@ -3,23 +3,25 @@ using Mono.Linker.Tests.Cases.Attributes.Dependencies;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// This explicit mcs test exists because mcs did not add a reference prior to https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5
 	/// </summary>
 	[IgnoreTestCase ("Can be enabled once the mcs contains https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5")]
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor(System.Type)")]
 	[KeptDelegateCacheField ("0")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnEvent {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnEvent
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
-			foo.MyEvent += FooOnMyEvent; 
+			foo.MyEvent += FooOnMyEvent;
 		}
 
 		[Kept]
@@ -35,7 +37,7 @@ namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
 			[KeptBackingField]
 			[KeptEventAddMethod]
 			[KeptEventRemoveMethod]
-			[KeptAttributeAttribute (typeof( AttributeDefinedInReference))]
+			[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
 			[AttributeDefinedInReference (typeof (TypeDefinedInReference))]
 			public event EventHandler MyEvent;
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnMethod.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnMethod.cs
index 0d191d7f4..b1a4a54ef 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnMethod.cs
@@ -2,18 +2,20 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// This explicit mcs test exists because mcs did not add a reference prior to https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5
 	/// </summary>
 	[IgnoreTestCase ("Can be enabled once the mcs contains https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5")]
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof (TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof (AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor(System.Type)")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnMethod {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnMethod
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -22,7 +24,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
 			[AttributeDefinedInReference (typeof (TypeDefinedInReference))]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnProperty.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnProperty.cs
index ec52d0556..84e498cd1 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnProperty.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnProperty.cs
@@ -2,18 +2,20 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// This explicit mcs test exists because mcs did not add a reference prior to https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5
 	/// </summary>
 	[IgnoreTestCase ("Can be enabled once the mcs contains https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5")]
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor(System.Type)")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnProperty {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnProperty
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -22,7 +24,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnType.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnType.cs
index 1708be4a4..dbf006b92 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnType.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnType.cs
@@ -2,21 +2,23 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// This explicit mcs test exists because mcs did not add a reference prior to https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5
 	/// </summary>
 	[IgnoreTestCase ("Can be enabled once the mcs contains https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5")]
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof (TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof (AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor(System.Type)")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnType {
-		public static void Main()
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeCtorOnType
+	{
+		public static void Main ()
 		{
-			var foo = new Foo();
+			var foo = new Foo ();
 		}
 
 		[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnAssembly.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnAssembly.cs
index b083155e1..e79418e94 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnAssembly.cs
@@ -4,7 +4,8 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
 [assembly: AttributeDefinedInReference (FieldType = typeof (TypeDefinedInReference))]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// In the case of attributes on assemblies, we expect both assemblies to be removed because we don't keep assembly level attributes
 	/// when that is the only type marked in the assembly
@@ -13,8 +14,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
 	[IgnoreTestCase ("Don't try to compile with mcs on .NET Core")]
 #endif
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[RemovedAssembly ("LibraryWithType.dll")]
 	[RemovedAssembly ("LibraryWithAttribute.dll")]
 	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnAssembly
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnEvent.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnEvent.cs
index ad376f852..3c60ba4dc 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnEvent.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnEvent.cs
@@ -3,24 +3,26 @@ using Mono.Linker.Tests.Cases.Attributes.Dependencies;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// This explicit mcs test exists because mcs did not add a reference prior to https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5
 	/// </summary>
 	[IgnoreTestCase ("Can be enabled once the mcs contains https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5")]
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), "FieldType")]
 	[KeptDelegateCacheField ("0")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnEvent {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnEvent
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
-			foo.MyEvent += FooOnMyEvent; 
+			foo.MyEvent += FooOnMyEvent;
 		}
 
 		[Kept]
@@ -30,7 +32,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptEventAddMethod]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnMethod.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnMethod.cs
index 26574eb8a..df30b6fb8 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnMethod.cs
@@ -2,14 +2,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// This explicit mcs test exists because mcs did not add a reference prior to https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5
 	/// </summary>
 	[IgnoreTestCase ("Can be enabled once the mcs contains https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5")]
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor()")]
@@ -24,10 +25,11 @@ namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
-			[AttributeDefinedInReference (FieldType = typeof(TypeDefinedInReference))]
+			[AttributeDefinedInReference (FieldType = typeof (TypeDefinedInReference))]
 			public void Method ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnProperty.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnProperty.cs
index 87b1853eb..12b1cc59b 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnProperty.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnProperty.cs
@@ -2,19 +2,21 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// This explicit mcs test exists because mcs did not add a reference prior to https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5
 	/// </summary>
 	[IgnoreTestCase ("Can be enabled once the mcs contains https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5")]
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), "FieldType")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnProperty {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnProperty
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -23,7 +25,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnType.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnType.cs
index cd62f5b3d..253ce9027 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnType.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnType.cs
@@ -2,19 +2,21 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// This explicit mcs test exists because mcs did not add a reference prior to https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5
 	/// </summary>
 	[IgnoreTestCase ("Can be enabled once the mcs contains https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5")]
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), "FieldType")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnType {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributeFieldOnType
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -24,7 +26,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
 		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
 		[AttributeDefinedInReference (FieldType = typeof (TypeDefinedInReference))]
-		class Foo {
+		class Foo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnAssembly.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnAssembly.cs
index b33931b38..bac66108d 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnAssembly.cs
@@ -4,7 +4,8 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
 [assembly: AttributeDefinedInReference (PropertyType = typeof (TypeDefinedInReference))]
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// In the case of attributes on assemblies, we expect both assemblies to be removed because we don't keep assembly level attributes
 	/// when that is the only type marked in the assembly
@@ -13,11 +14,12 @@ namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
 	[IgnoreTestCase ("Don't try to compile with mcs on .NET Core")]
 #endif
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[RemovedAssembly ("LibraryWithType.dll")]
 	[RemovedAssembly ("LibraryWithAttribute.dll")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnAssembly {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnAssembly
+	{
 		public static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnEvent.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnEvent.cs
index 3c479943d..f54f4b0f6 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnEvent.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnEvent.cs
@@ -3,24 +3,26 @@ using Mono.Linker.Tests.Cases.Attributes.Dependencies;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// This explicit mcs test exists because mcs did not add a reference prior to https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5
 	/// </summary>
 	[IgnoreTestCase ("Can be enabled once the mcs contains https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5")]
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), "set_PropertyType(System.Type)")]
 	[KeptDelegateCacheField ("0")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnEvent {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnEvent
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
-			foo.MyEvent += FooOnMyEvent; 
+			foo.MyEvent += FooOnMyEvent;
 		}
 
 		[Kept]
@@ -30,7 +32,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptEventAddMethod]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnMethod.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnMethod.cs
index 41d1c803e..77b5fc091 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnMethod.cs
@@ -2,19 +2,21 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// This explicit mcs test exists because mcs did not add a reference prior to https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5
 	/// </summary>
 	[IgnoreTestCase ("Can be enabled once the mcs contains https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5")]
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), "set_PropertyType(System.Type)")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnMethod {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnMethod
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -23,7 +25,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
 			[AttributeDefinedInReference (PropertyType = typeof (TypeDefinedInReference))]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnProperty.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnProperty.cs
index 66d1a04af..d204ea428 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnProperty.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnProperty.cs
@@ -2,19 +2,21 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// This explicit mcs test exists because mcs did not add a reference prior to https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5
 	/// </summary>
 	[IgnoreTestCase ("Can be enabled once the mcs contains https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5")]
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), "set_PropertyType(System.Type)")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnProperty {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnProperty
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -23,7 +25,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnType.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnType.cs
index 668f8a9ab..6965171c6 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnType.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnType.cs
@@ -2,19 +2,21 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// This explicit mcs test exists because mcs did not add a reference prior to https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5
 	/// </summary>
 	[IgnoreTestCase ("Can be enabled once the mcs contains https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5")]
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), "set_PropertyType(System.Type)")]
-	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnType {
+	public class OnlyTypeUsedInAssemblyIsTypeOnAttributePropertyOnType
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -24,7 +26,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
 		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
 		[AttributeDefinedInReference (PropertyType = typeof (TypeDefinedInReference))]
-		class Foo {
+		class Foo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyWithReferenceIsTypeOnAttributeCtorOnType.cs b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyWithReferenceIsTypeOnAttributeCtorOnType.cs
index 22a34cffb..6be1ce03e 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyWithReferenceIsTypeOnAttributeCtorOnType.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/Mcs/OnlyTypeUsedInAssemblyWithReferenceIsTypeOnAttributeCtorOnType.cs
@@ -2,21 +2,23 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
+namespace Mono.Linker.Tests.Cases.Attributes.Mcs
+{
 	/// <summary>
 	/// This explicit mcs test exists because mcs did not add a reference prior to https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5
 	/// </summary>
 	[IgnoreTestCase ("Can be enabled once the mcs contains https://github.com/mono/mono/commit/f71b208ca7b41a2a97ca70b955df0c4c411ce8e5")]
 	[SetupCSharpCompilerToUse ("mcs")]
-	[SetupCompileBefore ("LibraryWithAttribute.dll", new [] { typeof(AttributeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithType.dll", new [] { typeof(TypeDefinedInReference) })]
-	[SetupCompileBefore ("LibraryWithTypeAndReference.dll", new [] { typeof(TypeDefinedInReferenceWithReference) }, new [] { "LibraryWithType.dll", "LibraryWithAttribute.dll" }, compilerToUse: "mcs")]
+	[SetupCompileBefore ("LibraryWithAttribute.dll", new[] { typeof (AttributeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithType.dll", new[] { typeof (TypeDefinedInReference) })]
+	[SetupCompileBefore ("LibraryWithTypeAndReference.dll", new[] { typeof (TypeDefinedInReferenceWithReference) }, new[] { "LibraryWithType.dll", "LibraryWithAttribute.dll" }, compilerToUse: "mcs")]
 	[KeptTypeInAssembly ("LibraryWithTypeAndReference.dll", typeof (TypeDefinedInReferenceWithReference))]
 	[RemovedMemberInAssembly ("LibraryWithTypeAndReference.dll", typeof (TypeDefinedInReferenceWithReference), "Unused()")]
 	[KeptTypeInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference))]
 	[RemovedMemberInAssembly ("LibraryWithType.dll", typeof (TypeDefinedInReference), "Unused()")]
 	[KeptMemberInAssembly ("LibraryWithAttribute.dll", typeof (AttributeDefinedInReference), ".ctor(System.Type)")]
-	public class OnlyTypeUsedInAssemblyWithReferenceIsTypeOnAttributeCtorOnType {
+	public class OnlyTypeUsedInAssemblyWithReferenceIsTypeOnAttributeCtorOnType
+	{
 		public static void Main ()
 		{
 			var foo = new Foo ();
@@ -26,7 +28,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.Mcs {
 		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (AttributeDefinedInReference))]
 		[AttributeDefinedInReference (typeof (TypeDefinedInReferenceWithReference))]
-		class Foo {
+		class Foo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/NoSecurity/CoreLibrarySecurityAttributeTypesAreRemoved.cs b/test/Mono.Linker.Tests.Cases/Attributes/NoSecurity/CoreLibrarySecurityAttributeTypesAreRemoved.cs
index 46a3f5a16..0bfc6b5d2 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/NoSecurity/CoreLibrarySecurityAttributeTypesAreRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/NoSecurity/CoreLibrarySecurityAttributeTypesAreRemoved.cs
@@ -4,7 +4,8 @@ using System.Security.Permissions;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.NoSecurity {
+namespace Mono.Linker.Tests.Cases.Attributes.NoSecurity
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerArgument ("--strip-security", "true")]
 	[Reference ("System.dll")]
@@ -33,7 +34,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.NoSecurity {
 	// detects a GetType("SHA256CryptoServiceProvider") in System.dll, which then causes a type in System.Core.dll to be marked.
 	// PeVerify fails on the original GAC copy of System.Core.dll so it's expected that it will also fail on the stripped version we output
 	[SkipPeVerify ("System.Core.dll")]
-	public class CoreLibrarySecurityAttributeTypesAreRemoved {
+	public class CoreLibrarySecurityAttributeTypesAreRemoved
+	{
 		public static void Main ()
 		{
 			// Use something that has security attributes to make this test more meaningful
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/NoSecurity/SecurityAttributesOnUsedMethodAreRemoved.cs b/test/Mono.Linker.Tests.Cases/Attributes/NoSecurity/SecurityAttributesOnUsedMethodAreRemoved.cs
index eba5ba81f..196569a2a 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/NoSecurity/SecurityAttributesOnUsedMethodAreRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/NoSecurity/SecurityAttributesOnUsedMethodAreRemoved.cs
@@ -2,9 +2,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.NoSecurity {
+namespace Mono.Linker.Tests.Cases.Attributes.NoSecurity
+{
 	[SetupLinkerArgument ("--strip-security", "true")]
-	public class SecurityAttributesOnUsedMethodAreRemoved {
+	public class SecurityAttributesOnUsedMethodAreRemoved
+	{
 		static void Main ()
 		{
 			new Foo ().Method ();
@@ -12,7 +14,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.NoSecurity {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[SecurityPermission (SecurityAction.LinkDemand)]
 			[Kept]
 			[RemovedPseudoAttribute (16384)]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/NoSecurity/SecurityAttributesOnUsedTypeAreRemoved.cs b/test/Mono.Linker.Tests.Cases/Attributes/NoSecurity/SecurityAttributesOnUsedTypeAreRemoved.cs
index a5b251400..533b3c0cc 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/NoSecurity/SecurityAttributesOnUsedTypeAreRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/NoSecurity/SecurityAttributesOnUsedTypeAreRemoved.cs
@@ -2,9 +2,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.NoSecurity {
+namespace Mono.Linker.Tests.Cases.Attributes.NoSecurity
+{
 	[SetupLinkerArgument ("--strip-security", "true")]
-	public class SecurityAttributesOnUsedTypeAreRemoved {
+	public class SecurityAttributesOnUsedTypeAreRemoved
+	{
 		static void Main ()
 		{
 			new Foo ();
@@ -14,7 +16,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.NoSecurity {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[RemovedPseudoAttribute (262144u)]
-		class Foo {
+		class Foo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/AttributeDefinedAndUsedInOtherAssemblyIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/AttributeDefinedAndUsedInOtherAssemblyIsKept.cs
index 826ad0011..f89ccb42a 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/AttributeDefinedAndUsedInOtherAssemblyIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/AttributeDefinedAndUsedInOtherAssemblyIsKept.cs
@@ -3,11 +3,13 @@ using Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed.Dependencies;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/AttributeDefinedAndUsedInOtherAssemblyIsKept_Lib.cs" })]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/AttributeDefinedAndUsedInOtherAssemblyIsKept_Lib.cs" })]
 	[KeptMemberInAssembly ("library.dll", typeof (AttributeDefinedAndUsedInOtherAssemblyIsKept_Lib.FooAttribute), ".ctor()")]
-	class AttributeDefinedAndUsedInOtherAssemblyIsKept {
+	class AttributeDefinedAndUsedInOtherAssemblyIsKept
+	{
 		static void Main ()
 		{
 			Method ();
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/AttributeUsedByAttributeIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/AttributeUsedByAttributeIsKept.cs
index 3c7c0d292..b5c8c6347 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/AttributeUsedByAttributeIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/AttributeUsedByAttributeIsKept.cs
@@ -2,9 +2,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	class AttributeUsedByAttributeIsKept {
+	class AttributeUsedByAttributeIsKept
+	{
 		static void Main ()
 		{
 			var jar = new Jar ();
@@ -17,22 +19,24 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 		[NotUsed]
 		[Kept]
 		[KeptMember (".ctor()")]
-		[KeptAttributeAttribute (typeof(FooAttribute))]
-		[KeptAttributeAttribute (typeof(BarAttribute))]
-		[KeptAttributeAttribute (typeof(KarAttribute))]
-		class Jar {
+		[KeptAttributeAttribute (typeof (FooAttribute))]
+		[KeptAttributeAttribute (typeof (BarAttribute))]
+		[KeptAttributeAttribute (typeof (KarAttribute))]
+		class Jar
+		{
 			[Kept]
 			public void SomeMethod ()
 			{
-				var attr = typeof (Jar).GetCustomAttributes (typeof (FooAttribute), false) [0];
+				var attr = typeof (Jar).GetCustomAttributes (typeof (FooAttribute), false)[0];
 				var asFooAttr = (FooAttribute) attr;
 				asFooAttr.MethodWeWillCall ();
 			}
 		}
 
 		[Kept]
-		[KeptBaseType (typeof(Attribute))]
-		class FooAttribute : Attribute {
+		[KeptBaseType (typeof (Attribute))]
+		class FooAttribute : Attribute
+		{
 			[Kept]
 			public FooAttribute ()
 			{
@@ -56,8 +60,9 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 		}
 
 		[Kept]
-		[KeptBaseType (typeof(Attribute))]
-		class BarAttribute : Attribute {
+		[KeptBaseType (typeof (Attribute))]
+		class BarAttribute : Attribute
+		{
 			[Kept]
 			public BarAttribute ()
 			{
@@ -69,7 +74,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 
 		[Kept]
 		[KeptBaseType (typeof (Attribute))]
-		class KarAttribute : Attribute {
+		class KarAttribute : Attribute
+		{
 			[Kept]
 			public KarAttribute ()
 			{
@@ -77,11 +83,13 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 			}
 		}
 
-		class NotUsedAttribute : Attribute {
+		class NotUsedAttribute : Attribute
+		{
 		}
 
 		[Kept]
-		static class MethodsUsedFromLateMarking {
+		static class MethodsUsedFromLateMarking
+		{
 			[Kept]
 			public static void Method1 ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/CanLinkCoreLibrariesWithOnlyKeepUsedAttributes.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/CanLinkCoreLibrariesWithOnlyKeepUsedAttributes.cs
index 6599677e4..36de9c1af 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/CanLinkCoreLibrariesWithOnlyKeepUsedAttributes.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/CanLinkCoreLibrariesWithOnlyKeepUsedAttributes.cs
@@ -3,7 +3,8 @@ using System.Timers;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
 	[Reference ("System.dll")]
@@ -13,7 +14,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 	[SkipPeVerify ("System.Core.dll")]
 	// Fails with `Runtime critical type System.Reflection.CustomAttributeData not found`
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	class CanLinkCoreLibrariesWithOnlyKeepUsedAttributes {
+	class CanLinkCoreLibrariesWithOnlyKeepUsedAttributes
+	{
 		static void Main ()
 		{
 			// Use something from System so that the entire reference isn't linked away
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/ComAttributesArePreserved.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/ComAttributesArePreserved.cs
index 8c34640d1..15e0b2972 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/ComAttributesArePreserved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/ComAttributesArePreserved.cs
@@ -2,12 +2,14 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	/// <summary>
 	/// COM related attributes are required at runtime
 	/// </summary>
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	public class ComAttributesArePreserved {
+	public class ComAttributesArePreserved
+	{
 		public static void Main ()
 		{
 			var tmp = ReturnValueUsedToMarkType ();
@@ -18,14 +20,15 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 		{
 			return null;
 		}
-		
+
 		[Kept]
 		[KeptAttributeAttribute (typeof (GuidAttribute))]
 		[KeptAttributeAttribute (typeof (InterfaceTypeAttribute))]
 		[ComImport]
 		[Guid ("D7BB1889-3AB7-4681-A115-60CA9158FECA")]
 		[InterfaceType (ComInterfaceType.InterfaceIsIUnknown)]
-		interface A {
+		interface A
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/ComAttributesAreRemovedWhenFeatureExcluded.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/ComAttributesAreRemovedWhenFeatureExcluded.cs
index 0fd0317f7..e33e7d27f 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/ComAttributesAreRemovedWhenFeatureExcluded.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/ComAttributesAreRemovedWhenFeatureExcluded.cs
@@ -2,30 +2,33 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("--exclude-feature is not supported on .NET Core")]
 #endif
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
 	[SetupLinkerArgument ("--exclude-feature", "com")]
-	public class ComAttributesAreRemovedWhenFeatureExcluded {
+	public class ComAttributesAreRemovedWhenFeatureExcluded
+	{
 		public static void Main ()
 		{
 			var tmp = ReturnValueUsedToMarkType ();
 		}
-		
+
 		[Kept]
 		static A ReturnValueUsedToMarkType ()
 		{
 			return null;
 		}
-		
+
 		[Kept]
 		[RemovedPseudoAttribute (0x00001000u)]
 		[ComImport]
 		[Guid ("D7BB1889-3AB7-4681-A115-60CA9158FECA")]
 		[InterfaceType (ComInterfaceType.InterfaceIsIUnknown)]
-		interface A {
+		interface A
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/ContextStaticIsPreservedOnField.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/ContextStaticIsPreservedOnField.cs
index 39fecc123..451607d69 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/ContextStaticIsPreservedOnField.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/ContextStaticIsPreservedOnField.cs
@@ -2,17 +2,19 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	/// <summary>
 	/// [ContextStatic] is required by the mono runtime
 	/// </summary>
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	public class ContextStaticIsPreservedOnField {
+	public class ContextStaticIsPreservedOnField
+	{
 		[ContextStatic]
 		[Kept]
 		[KeptAttributeAttribute (typeof (ContextStaticAttribute))]
 		public static int UsedField;
-		
+
 		public static void Main ()
 		{
 			UsedField = 0;
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/CoreLibraryUnusedAssemblyAttributesAreRemoved.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/CoreLibraryUnusedAssemblyAttributesAreRemoved.cs
index 96d11f006..cba8cdb7a 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/CoreLibraryUnusedAssemblyAttributesAreRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/CoreLibraryUnusedAssemblyAttributesAreRemoved.cs
@@ -3,7 +3,8 @@ using System.Timers;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[Reference ("System.dll")]
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
@@ -12,7 +13,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 	[RemovedAttributeInAssembly ("System.dll", typeof (AssemblyDescriptionAttribute))]
 #endif
 	[SkipPeVerify]
-	public class CoreLibraryUnusedAssemblyAttributesAreRemoved {
+	public class CoreLibraryUnusedAssemblyAttributesAreRemoved
+	{
 		public static void Main ()
 		{
 			// Use something from System so that the entire reference isn't linked away
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/CoreLibraryUsedAssemblyAttributesAreKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/CoreLibraryUsedAssemblyAttributesAreKept.cs
index 95ee305d4..496450768 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/CoreLibraryUsedAssemblyAttributesAreKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/CoreLibraryUsedAssemblyAttributesAreKept.cs
@@ -3,7 +3,8 @@ using System.Timers;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[Reference ("System.dll")]
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
@@ -12,7 +13,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 	[KeptAttributeInAssembly ("System.dll", typeof (AssemblyDescriptionAttribute))]
 #endif
 	[SkipPeVerify]
-	public class CoreLibraryUsedAssemblyAttributesAreKept {
+	public class CoreLibraryUsedAssemblyAttributesAreKept
+	{
 		public static void Main ()
 		{
 			// Use something from System so that the entire reference isn't linked away
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/Dependencies/AttributeDefinedAndUsedInOtherAssemblyIsKept_Lib.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/Dependencies/AttributeDefinedAndUsedInOtherAssemblyIsKept_Lib.cs
index c94d85ba0..43e81ac96 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/Dependencies/AttributeDefinedAndUsedInOtherAssemblyIsKept_Lib.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/Dependencies/AttributeDefinedAndUsedInOtherAssemblyIsKept_Lib.cs
@@ -1,13 +1,16 @@
 using System;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed.Dependencies {
-	public class AttributeDefinedAndUsedInOtherAssemblyIsKept_Lib {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed.Dependencies
+{
+	public class AttributeDefinedAndUsedInOtherAssemblyIsKept_Lib
+	{
 		public static void UseTheAttributeType ()
 		{
 			var str = typeof (FooAttribute).ToString ();
 		}
 
-		public class FooAttribute : Attribute {
+		public class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/Dependencies/UnusedAttributeWithTypeForwarderIsRemoved_Lib.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/Dependencies/UnusedAttributeWithTypeForwarderIsRemoved_Lib.cs
index b22c07be9..46522ba57 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/Dependencies/UnusedAttributeWithTypeForwarderIsRemoved_Lib.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/Dependencies/UnusedAttributeWithTypeForwarderIsRemoved_Lib.cs
@@ -1,13 +1,16 @@
 using System;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed.Dependencies {
-	public class UnusedAttributeWithTypeForwarderIsRemoved_LibAttribute : Attribute {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed.Dependencies
+{
+	public class UnusedAttributeWithTypeForwarderIsRemoved_LibAttribute : Attribute
+	{
 		public UnusedAttributeWithTypeForwarderIsRemoved_LibAttribute (string arg)
 		{
 		}
 	}
 
-	public class UnusedAttributeWithTypeForwarderIsRemoved_OtherUsedClass {
+	public class UnusedAttributeWithTypeForwarderIsRemoved_OtherUsedClass
+	{
 		public static void UsedMethod ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/FixedLengthArrayAttributesArePreserved.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/FixedLengthArrayAttributesArePreserved.cs
index 3e33c8584..16bfacea2 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/FixedLengthArrayAttributesArePreserved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/FixedLengthArrayAttributesArePreserved.cs
@@ -2,13 +2,15 @@ using System.Runtime.CompilerServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
 	[SetupCompileArgument ("/unsafe")]
 
 	// Can't verify because the test contains unsafe code
 	[SkipPeVerify]
-	public class FixedLengthArrayAttributesArePreserved {
+	public class FixedLengthArrayAttributesArePreserved
+	{
 		public static void Main ()
 		{
 			Helper ();
@@ -26,13 +28,14 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 		static unsafe void AMethodToUseTheReturnValue (int* ptr)
 		{
 		}
-		
+
 		[Kept]
-		public unsafe struct WithFixedArrayField {
+		public unsafe struct WithFixedArrayField
+		{
 			[Kept]
 			[KeptFixedBuffer]
 			[KeptAttributeAttribute (typeof (FixedBufferAttribute))]
-			public fixed int Values [10];
+			public fixed int Values[10];
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/MethodWithUnmanagedConstraint.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/MethodWithUnmanagedConstraint.cs
index 8d4bd199c..e2d3e86fb 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/MethodWithUnmanagedConstraint.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/MethodWithUnmanagedConstraint.cs
@@ -1,11 +1,13 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupCSharpCompilerToUse ("csc")]
 	[SetupCompileArgument ("/langversion:7.3")]
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	public class MethodWithUnmanagedConstraint {
+	public class MethodWithUnmanagedConstraint
+	{
 		public static void Main ()
 		{
 			Method<int> ();
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/NullableOnConstraints.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/NullableOnConstraints.cs
index e64a1b3f1..3e3c4c767 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/NullableOnConstraints.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/NullableOnConstraints.cs
@@ -4,7 +4,8 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupCSharpCompilerToUse ("csc")]
 	[SetupCompileArgument ("/langversion:8.0")]
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
@@ -43,6 +44,6 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 	[KeptMember (".ctor()")]
 	class C<T> where T : I?
 	{
-	}	
+	}
 }
 #endif
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/ThreadStaticIsPreservedOnField.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/ThreadStaticIsPreservedOnField.cs
index 35ed32fc1..74e32194b 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/ThreadStaticIsPreservedOnField.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/ThreadStaticIsPreservedOnField.cs
@@ -2,17 +2,19 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	/// <summary>
 	/// [ThreadStatic] is required by the mono runtime
 	/// </summary>
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	public class ThreadStaticIsPreservedOnField {
+	public class ThreadStaticIsPreservedOnField
+	{
 		[ThreadStatic]
 		[Kept]
 		[KeptAttributeAttribute (typeof (ThreadStaticAttribute))]
 		public static int UsedField;
-		
+
 		public static void Main ()
 		{
 			UsedField = 0;
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeOnGenericParameterIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeOnGenericParameterIsRemoved.cs
index 519e7e521..91bf2fc45 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeOnGenericParameterIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeOnGenericParameterIsRemoved.cs
@@ -1,12 +1,14 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
 	[Define ("IL_ASSEMBLY_AVAILABLE")]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/AssemblyWithUnusedAttributeOnGenericParameter.il" })]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/AssemblyWithUnusedAttributeOnGenericParameter.il" })]
 	[RemovedTypeInAssembly ("library.dll", "Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed.Dependencies.FooAttribute")]
-	public class UnusedAttributeOnGenericParameterIsRemoved {
+	public class UnusedAttributeOnGenericParameterIsRemoved
+	{
 		static void Main ()
 		{
 #if IL_ASSEMBLY_AVAILABLE
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeOnReturnTypeIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeOnReturnTypeIsRemoved.cs
index 1bab0b53f..42250a1b3 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeOnReturnTypeIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeOnReturnTypeIsRemoved.cs
@@ -1,13 +1,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
 	[Define ("IL_ASSEMBLY_AVAILABLE")]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/AssemblyWithUnusedAttributeOnReturnParameterDefinition.il" })]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/AssemblyWithUnusedAttributeOnReturnParameterDefinition.il" })]
 	[RemovedTypeInAssembly ("library.dll", "Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed.Dependencies.AssemblyWithUnusedAttributeOnReturnParameterDefinition/FooAttribute")]
 	[RemovedTypeInAssembly ("library.dll", "Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed.Dependencies.BarAttribute")]
-	public class UnusedAttributeOnReturnTypeIsRemoved {
+	public class UnusedAttributeOnReturnTypeIsRemoved
+	{
 		static void Main ()
 		{
 #if IL_ASSEMBLY_AVAILABLE
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributePreservedViaLinkXmlIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributePreservedViaLinkXmlIsKept.cs
index c7273e993..50dc794f1 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributePreservedViaLinkXmlIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributePreservedViaLinkXmlIsKept.cs
@@ -2,9 +2,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	class UnusedAttributePreservedViaLinkXmlIsKept {
+	class UnusedAttributePreservedViaLinkXmlIsKept
+	{
 		static void Main ()
 		{
 			var tmp = new Bar ();
@@ -15,7 +17,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (FooAttribute))]
 		[Foo]
-		class Bar {
+		class Bar
+		{
 			[Kept]
 			[KeptAttributeAttribute (typeof (FooAttribute))]
 			[Foo]
@@ -27,7 +30,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Attribute))]
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnAssemblyIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnAssemblyIsRemoved.cs
index bbe066f6f..afcee4372 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnAssemblyIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnAssemblyIsRemoved.cs
@@ -4,14 +4,17 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
 [assembly: UnusedAttributeTypeOnAssemblyIsRemoved.Foo]
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	class UnusedAttributeTypeOnAssemblyIsRemoved {
+	class UnusedAttributeTypeOnAssemblyIsRemoved
+	{
 		static void Main ()
 		{
 		}
 
-		public class FooAttribute : Attribute {
+		public class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnEventIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnEventIsRemoved.cs
index 9f0a5271c..ff8775974 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnEventIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnEventIsRemoved.cs
@@ -2,10 +2,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
 	[KeptDelegateCacheField ("0")]
-	class UnusedAttributeTypeOnEventIsRemoved {
+	class UnusedAttributeTypeOnEventIsRemoved
+	{
 		static void Main ()
 		{
 			var tmp = new Bar ();
@@ -19,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Bar {
+		class Bar
+		{
 			[Foo]
 			[Kept]
 			[KeptEventAddMethod]
@@ -27,7 +30,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 			public event EventHandler<EventArgs> Something { [Foo] add { } [Foo] remove { } }
 		}
 
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnMethodIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnMethodIsRemoved.cs
index 2804e2ff4..4e30d17f4 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnMethodIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnMethodIsRemoved.cs
@@ -2,13 +2,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
 	// System.Core.dll is referenced by System.dll in the .NET FW class libraries. Our GetType reflection marking code
 	// detects a GetType("SHA256CryptoServiceProvider") in System.dll, which then causes a type in System.Core.dll to be marked.
 	// PeVerify fails on the original GAC copy of System.Core.dll so it's expected that it will also fail on the stripped version we output
 	[SkipPeVerify ("System.Core.dll")]
-	class UnusedAttributeTypeOnMethodIsRemoved {
+	class UnusedAttributeTypeOnMethodIsRemoved
+	{
 		static void Main ()
 		{
 			new Bar ().Method ();
@@ -16,7 +18,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Bar {
+		class Bar
+		{
 			[Foo]
 			[Kept]
 			public void Method ()
@@ -24,7 +27,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 			}
 		}
 
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnModuleIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnModuleIsRemoved.cs
index 90619679c..e315e45f1 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnModuleIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnModuleIsRemoved.cs
@@ -4,14 +4,17 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
 [module: UnusedAttributeTypeOnModuleIsRemoved.Foo]
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	class UnusedAttributeTypeOnModuleIsRemoved {
+	class UnusedAttributeTypeOnModuleIsRemoved
+	{
 		static void Main ()
 		{
 		}
 
-		public class FooAttribute : Attribute {
+		public class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnParameterIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnParameterIsRemoved.cs
index c74e4f6c0..f0d315c3c 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnParameterIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnParameterIsRemoved.cs
@@ -2,9 +2,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	class UnusedAttributeTypeOnParameterIsRemoved {
+	class UnusedAttributeTypeOnParameterIsRemoved
+	{
 		static void Main ()
 		{
 			new Bar ().Method ("Hello");
@@ -12,14 +14,16 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Bar {
+		class Bar
+		{
 			[Kept]
 			public void Method ([Foo] string arg)
 			{
 			}
 		}
 
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnPropertyIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnPropertyIsRemoved.cs
index 7144700ff..359e900a8 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnPropertyIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnPropertyIsRemoved.cs
@@ -2,9 +2,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	class UnusedAttributeTypeOnPropertyIsRemoved {
+	class UnusedAttributeTypeOnPropertyIsRemoved
+	{
 		static void Main ()
 		{
 			var bar = new Bar ();
@@ -14,14 +16,16 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Bar {
+		class Bar
+		{
 			[Foo]
 			[Kept]
 			[KeptBackingField]
 			public string Value { [Foo] [Kept] get; [Foo] [Kept] set; }
 		}
 
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnTypeIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnTypeIsRemoved.cs
index 03aba0d14..45f867049 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnTypeIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeTypeOnTypeIsRemoved.cs
@@ -2,9 +2,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	class UnusedAttributeTypeOnTypeIsRemoved {
+	class UnusedAttributeTypeOnTypeIsRemoved
+	{
 		static void Main ()
 		{
 			new Bar ();
@@ -13,10 +15,12 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[Foo]
-		class Bar {
+		class Bar
+		{
 		}
 
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeWithTypeForwarderIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeWithTypeForwarderIsRemoved.cs
index 49167f6a7..52afdeaae 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeWithTypeForwarderIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UnusedAttributeWithTypeForwarderIsRemoved.cs
@@ -3,23 +3,25 @@ using Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed.Dependencies;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[KeepTypeForwarderOnlyAssemblies ("true")]
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
 	[SetupCompileBefore ("library.dll", new[] { "Dependencies/UnusedAttributeWithTypeForwarderIsRemoved_Lib.cs" })]
 	[SetupCompileAfter ("implementation.dll", new[] { "Dependencies/UnusedAttributeWithTypeForwarderIsRemoved_Lib.cs" })]
 	[SetupCompileAfter ("library.dll", new[] { "Dependencies/UnusedAttributeWithTypeForwarderIsRemoved_Forwarder.cs" }, new[] { "implementation.dll" })]
 
-	[RemovedTypeInAssembly ("library.dll", typeof(UnusedAttributeWithTypeForwarderIsRemoved_LibAttribute))]
+	[RemovedTypeInAssembly ("library.dll", typeof (UnusedAttributeWithTypeForwarderIsRemoved_LibAttribute))]
 	[RemovedTypeInAssembly ("implementation.dll", typeof (UnusedAttributeWithTypeForwarderIsRemoved_LibAttribute))]
-	class UnusedAttributeWithTypeForwarderIsRemoved {
+	class UnusedAttributeWithTypeForwarderIsRemoved
+	{
 		static void Main ()
 		{
 			Method (null);
 		}
 
 		[Kept]
-		
+
 		static void Method ([UnusedAttributeWithTypeForwarderIsRemoved_Lib ("")] string arg)
 		{
 			UnusedAttributeWithTypeForwarderIsRemoved_OtherUsedClass.UsedMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnAssemblyIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnAssemblyIsKept.cs
index 3f84fddbb..19431989c 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnAssemblyIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnAssemblyIsKept.cs
@@ -6,9 +6,11 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 [assembly: UsedAttributeTypeOnAssemblyIsKept.Foo]
 [assembly: KeptAttributeAttribute (typeof (UsedAttributeTypeOnAssemblyIsKept.FooAttribute))]
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
-	[SetupLinkerArgument("--used-attrs-only", "true")]
-	class UsedAttributeTypeOnAssemblyIsKept {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
+	[SetupLinkerArgument ("--used-attrs-only", "true")]
+	class UsedAttributeTypeOnAssemblyIsKept
+	{
 		static void Main ()
 		{
 			var str = typeof (FooAttribute).ToString ();
@@ -17,7 +19,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Attribute))]
-		public class FooAttribute : Attribute {
+		public class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnEventIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnEventIsKept.cs
index 72fb256dc..6b4437f36 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnEventIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnEventIsKept.cs
@@ -2,10 +2,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
 	[KeptDelegateCacheField ("0")]
-	class UsedAttributeTypeOnEventIsKept {
+	class UsedAttributeTypeOnEventIsKept
+	{
 		static void Main ()
 		{
 			var tmp = new Bar ();
@@ -20,7 +22,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Bar {
+		class Bar
+		{
 			[Foo]
 			[Kept]
 			[KeptAttributeAttribute (typeof (FooAttribute))]
@@ -31,8 +34,9 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		[KeptBaseType (typeof(Attribute))]
-		class FooAttribute : Attribute {
+		[KeptBaseType (typeof (Attribute))]
+		class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnMethodIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnMethodIsKept.cs
index fc8516f87..7904a05fc 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnMethodIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnMethodIsKept.cs
@@ -2,9 +2,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	class UsedAttributeTypeOnMethodIsKept {
+	class UsedAttributeTypeOnMethodIsKept
+	{
 		static void Main ()
 		{
 			new Bar ().Method ();
@@ -14,7 +16,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Bar {
+		class Bar
+		{
 			[Foo]
 			[Kept]
 			[KeptAttributeAttribute (typeof (FooAttribute))]
@@ -25,8 +28,9 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		[KeptBaseType (typeof(Attribute))]
-		class FooAttribute : Attribute {
+		[KeptBaseType (typeof (Attribute))]
+		class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnModuleIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnModuleIsKept.cs
index 72e9906df..8046d9b4b 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnModuleIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnModuleIsKept.cs
@@ -6,9 +6,11 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 [module: UsedAttributeTypeOnModuleIsKept.Foo]
 [module: KeptAttributeAttribute (typeof (UsedAttributeTypeOnModuleIsKept.FooAttribute))]
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	class UsedAttributeTypeOnModuleIsKept {
+	class UsedAttributeTypeOnModuleIsKept
+	{
 		static void Main ()
 		{
 			var str = typeof (FooAttribute).ToString ();
@@ -17,7 +19,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Attribute))]
-		public class FooAttribute : Attribute {
+		public class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnParameterIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnParameterIsKept.cs
index 4fb4b134b..1c4e60666 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnParameterIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnParameterIsKept.cs
@@ -2,9 +2,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	class UsedAttributeTypeOnParameterIsKept {
+	class UsedAttributeTypeOnParameterIsKept
+	{
 		static void Main ()
 		{
 			new Bar ().Method ("Hello");
@@ -13,7 +15,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Bar {
+		class Bar
+		{
 			[Kept]
 			public void Method ([Foo] [KeptAttributeAttribute (typeof (FooAttribute))] string arg)
 			{
@@ -22,8 +25,9 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		[KeptBaseType (typeof(Attribute))]
-		class FooAttribute : Attribute {
+		[KeptBaseType (typeof (Attribute))]
+		class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnPropertyIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnPropertyIsKept.cs
index 8932d7252..b255ffc23 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnPropertyIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnPropertyIsKept.cs
@@ -2,9 +2,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	class UsedAttributeTypeOnPropertyIsKept {
+	class UsedAttributeTypeOnPropertyIsKept
+	{
 		static void Main ()
 		{
 			var bar = new Bar ();
@@ -15,7 +17,8 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Bar {
+		class Bar
+		{
 			[Foo]
 			[Kept]
 			[KeptBackingField]
@@ -25,8 +28,9 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		[KeptBaseType (typeof(Attribute))]
-		class FooAttribute : Attribute {
+		[KeptBaseType (typeof (Attribute))]
+		class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnTypeIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnTypeIsKept.cs
index 04dba4d26..07fc53cc4 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnTypeIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/OnlyKeepUsed/UsedAttributeTypeOnTypeIsKept.cs
@@ -2,10 +2,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
+namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed
+{
 
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
-	class UsedAttributeTypeOnTypeIsKept {
+	class UsedAttributeTypeOnTypeIsKept
+	{
 		static void Main ()
 		{
 			var tmp = new Bar ();
@@ -16,13 +18,15 @@ namespace Mono.Linker.Tests.Cases.Attributes.OnlyKeepUsed {
 		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (FooAttribute))]
 		[Foo]
-		class Bar {
+		class Bar
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Attribute))]
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/SecurityAttributesOnUsedMethodAreKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/SecurityAttributesOnUsedMethodAreKept.cs
index 6ffa3845a..31b1d4c38 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/SecurityAttributesOnUsedMethodAreKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/SecurityAttributesOnUsedMethodAreKept.cs
@@ -3,9 +3,11 @@ using System.Security.Permissions;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
 	[SetupLinkerArgument ("--strip-security", "false")]
-	class SecurityAttributesOnUsedMethodAreKept {
+	class SecurityAttributesOnUsedMethodAreKept
+	{
 		static void Main ()
 		{
 			new Foo ().Method ();
@@ -13,7 +15,8 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[SecurityPermission (SecurityAction.LinkDemand)]
 			[Kept]
 			[KeptSecurity (typeof (SecurityPermissionAttribute))]
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/SecurityAttributesOnUsedTypeAreKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/SecurityAttributesOnUsedTypeAreKept.cs
index 080fe2096..526df81ca 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/SecurityAttributesOnUsedTypeAreKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/SecurityAttributesOnUsedTypeAreKept.cs
@@ -3,9 +3,11 @@ using System.Security.Permissions;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Attributes {
-	[SetupLinkerArgument("--strip-security", "false")]
-	class SecurityAttributesOnUsedTypeAreKept {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
+	[SetupLinkerArgument ("--strip-security", "false")]
+	class SecurityAttributesOnUsedTypeAreKept
+	{
 		static void Main ()
 		{
 			new Foo ();
@@ -15,7 +17,8 @@ namespace Mono.Linker.Tests.Cases.Attributes {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptSecurity (typeof (SecurityPermissionAttribute))]
-		class Foo {
+		class Foo
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Attributes/TypeUsedInObjectArrayConstructorArgumentOnAttributeIsKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/TypeUsedInObjectArrayConstructorArgumentOnAttributeIsKept.cs
index ff0678459..763ae29e9 100644
--- a/test/Mono.Linker.Tests.Cases/Attributes/TypeUsedInObjectArrayConstructorArgumentOnAttributeIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Attributes/TypeUsedInObjectArrayConstructorArgumentOnAttributeIsKept.cs
@@ -1,25 +1,31 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Attributes {
+namespace Mono.Linker.Tests.Cases.Attributes
+{
 	[Foo (EnumThatShouldBeKept.Two)]
 	[KeptAttributeAttribute (typeof (FooAttribute))]
-	public class TypeUsedInObjectArrayConstructorArgumentOnAttributeIsKept {
-		public static void Main () {
+	public class TypeUsedInObjectArrayConstructorArgumentOnAttributeIsKept
+	{
+		public static void Main ()
+		{
 		}
 	}
 
 	[KeptBaseType (typeof (System.Attribute))]
-	class FooAttribute : Attribute {
+	class FooAttribute : Attribute
+	{
 		[Kept]
-		public FooAttribute ([KeptAttributeAttribute (typeof (ParamArrayAttribute))] params object[] parameters) {
+		public FooAttribute ([KeptAttributeAttribute (typeof (ParamArrayAttribute))] params object[] parameters)
+		{
 		}
 	}
 
 	[Kept]
 	[KeptMember ("value__")]
 	[KeptBaseType (typeof (Enum))]
-	enum EnumThatShouldBeKept {
+	enum EnumThatShouldBeKept
+	{
 		[Kept]
 		One = 1,
 		[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/BaseRemovedEventSource.cs b/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/BaseRemovedEventSource.cs
index 868ac6d35..f5ad74025 100644
--- a/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/BaseRemovedEventSource.cs
+++ b/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/BaseRemovedEventSource.cs
@@ -3,14 +3,16 @@ using System.Diagnostics.Tracing;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
+namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("--exclude-feature is not supported on .NET Core")]
 #endif
 	[SetupLinkerArgument ("--exclude-feature", "etw")]
 	// Keep framework code that calls EventSource methods like OnEventCommand
 	[SetupLinkerCoreAction ("skip")]
-	public class BaseRemovedEventSource {
+	public class BaseRemovedEventSource
+	{
 		public static void Main ()
 		{
 			var b = CustomCtorEventSource.Log.IsEnabled ();
@@ -24,9 +26,11 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 	[KeptMember (".ctor()")]
 	[KeptMember (".cctor()")]
 	[EventSource (Name = "MyCompany")]
-	class CustomCtorEventSource : EventSource {
-		public class Keywords {
-			public const EventKeywords Page = (EventKeywords)1;
+	class CustomCtorEventSource : EventSource
+	{
+		public class Keywords
+		{
+			public const EventKeywords Page = (EventKeywords) 1;
 
 			public int Unused;
 		}
@@ -35,7 +39,7 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 		public static CustomCtorEventSource Log = new MyEventSourceBasedOnCustomCtorEventSource (1);
 
 		[Kept]
-		[ExpectedInstructionSequence (new []
+		[ExpectedInstructionSequence (new[]
 		{
 			"ldarg.0",
 			"call",
@@ -47,7 +51,7 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new []
+		[ExpectedInstructionSequence (new[]
 		{
 			"ldstr",
 			"newobj",
@@ -63,7 +67,7 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new []
+		[ExpectedInstructionSequence (new[]
 		{
 			"ldstr",
 			"newobj",
@@ -82,7 +86,8 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 
 	[Kept]
 	[KeptBaseType (typeof (CustomCtorEventSource))]
-	class MyEventSourceBasedOnCustomCtorEventSource : CustomCtorEventSource {
+	class MyEventSourceBasedOnCustomCtorEventSource : CustomCtorEventSource
+	{
 		[Kept]
 		public MyEventSourceBasedOnCustomCtorEventSource (int value) : base (value)
 		{
diff --git a/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/BaseRemovedEventSourceEmptyBody.cs b/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/BaseRemovedEventSourceEmptyBody.cs
index 05fc018c6..4270de35c 100644
--- a/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/BaseRemovedEventSourceEmptyBody.cs
+++ b/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/BaseRemovedEventSourceEmptyBody.cs
@@ -2,14 +2,16 @@ using System.Diagnostics.Tracing;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW  {
+namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("--exclude-feature is not supported on .NET Core")]
 #endif
 	[SetupLinkerArgument ("--exclude-feature", "etw")]
 	// Keep framework code that calls EventSource methods like OnEventCommand
 	[SetupLinkerCoreAction ("skip")]
-	public class BaseRemovedEventSourceEmptyBody {
+	public class BaseRemovedEventSourceEmptyBody
+	{
 		public static void Main ()
 		{
 			var b = CustomCtorEventSourceEmptyBody.Log.IsEnabled ();
@@ -17,15 +19,17 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW  {
 				CustomCtorEventSourceEmptyBody.Log.SomeMethod ();
 		}
 	}
-	
+
 	[Kept]
 	[KeptBaseType (typeof (EventSource))]
 	[KeptMember (".ctor()")]
 	[KeptMember (".cctor()")]
 	[EventSource (Name = "MyCompany")]
-	class CustomCtorEventSourceEmptyBody : EventSource {
-		public class Keywords {
-			public const EventKeywords Page = (EventKeywords)1;
+	class CustomCtorEventSourceEmptyBody : EventSource
+	{
+		public class Keywords
+		{
+			public const EventKeywords Page = (EventKeywords) 1;
 
 			public int Unused;
 		}
@@ -34,7 +38,7 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW  {
 		public static CustomCtorEventSourceEmptyBody Log = new MyEventSourceBasedOnCustomCtorEventSourceEmptyBody (1);
 
 		[Kept]
-		[ExpectedInstructionSequence (new []
+		[ExpectedInstructionSequence (new[]
 		{
 			"ldarg.0",
 			"call",
@@ -52,7 +56,7 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW  {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new []
+		[ExpectedInstructionSequence (new[]
 		{
 			"ldstr",
 			"newobj",
@@ -71,7 +75,8 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW  {
 
 	[Kept]
 	[KeptBaseType (typeof (CustomCtorEventSourceEmptyBody))]
-	class MyEventSourceBasedOnCustomCtorEventSourceEmptyBody : CustomCtorEventSourceEmptyBody {
+	class MyEventSourceBasedOnCustomCtorEventSourceEmptyBody : CustomCtorEventSourceEmptyBody
+	{
 		[Kept]
 		public MyEventSourceBasedOnCustomCtorEventSourceEmptyBody (int value) : base (value)
 		{
diff --git a/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/CustomEventSource.cs b/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/CustomEventSource.cs
index 8286f22c5..ebeb48c1c 100644
--- a/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/CustomEventSource.cs
+++ b/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/CustomEventSource.cs
@@ -2,8 +2,10 @@
 using System.Diagnostics.Tracing;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
-	public class CustomEventSource {
+namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW
+{
+	public class CustomEventSource
+	{
 		public static void Main ()
 		{
 			var b = MyCompanyEventSource.Log.IsEnabled ();
@@ -20,19 +22,19 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 	class MyCompanyEventSource : EventSource
 	{
 		[Kept]
-		public class Keywords 
+		public class Keywords
 		{
 			[Kept]
-			public const EventKeywords Page = (EventKeywords)1;
+			public const EventKeywords Page = (EventKeywords) 1;
 
 			public int Unused;
 		}
 
 		[Kept]
-		public class Tasks 
+		public class Tasks
 		{
 			[Kept]
-			public const EventTask Page = (EventTask)1;
+			public const EventTask Page = (EventTask) 1;
 
 			public int Unused;
 		}
diff --git a/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/Excluded.cs b/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/Excluded.cs
index 59be7a22d..9c0a38a25 100644
--- a/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/Excluded.cs
+++ b/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/Excluded.cs
@@ -3,7 +3,8 @@ using System.Diagnostics.Tracing;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
+namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("--exclude-feature is not supported on .NET Core")]
 #endif
@@ -12,7 +13,7 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 	[SetupLinkerCoreAction ("skip")]
 	// Used to avoid different compilers generating different IL which can mess up the instruction asserts
 	[SetupCompileArgument ("/optimize+")]
-	public class Excluded 
+	public class Excluded
 	{
 		public static void Main ()
 		{
@@ -27,9 +28,11 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 	[KeptMember (".ctor()")]
 	[KeptMember (".cctor()")]
 	[EventSource (Name = "MyCompany")]
-	class RemovedEventSource : EventSource {
-		public class Keywords {
-			public const EventKeywords Page = (EventKeywords)1;
+	class RemovedEventSource : EventSource
+	{
+		public class Keywords
+		{
+			public const EventKeywords Page = (EventKeywords) 1;
 
 			public int Unused;
 		}
@@ -38,7 +41,7 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 		public static RemovedEventSource Log = new RemovedEventSource ();
 
 		[Kept]
-		[ExpectedInstructionSequence (new []
+		[ExpectedInstructionSequence (new[]
 		{
 			"ldstr",
 			"newobj",
@@ -54,7 +57,7 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new []
+		[ExpectedInstructionSequence (new[]
 		{
 			"ldstr",
 			"newobj",
diff --git a/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/LocalsOfModifiedMethodAreRemoved.cs b/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/LocalsOfModifiedMethodAreRemoved.cs
index 06ba2b79f..7ba06e22a 100644
--- a/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/LocalsOfModifiedMethodAreRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/LocalsOfModifiedMethodAreRemoved.cs
@@ -2,7 +2,8 @@ using System.Diagnostics.Tracing;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
+namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("--exclude-feature is not supported on .NET Core")]
 #endif
@@ -11,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 	[SetupLinkerCoreAction ("skip")]
 	// Used to avoid different compilers generating different IL which can mess up the instruction asserts
 	[SetupCompileArgument ("/optimize+")]
-	public class LocalsOfModifiedMethodAreRemoved {
+	public class LocalsOfModifiedMethodAreRemoved
+	{
 		public static void Main ()
 		{
 			var b = LocalsAreCleared_RemovedEventSource.Log.IsEnabled ();
@@ -19,22 +21,25 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 				LocalsAreCleared_RemovedEventSource.Log.SomeMethod ();
 		}
 
-		public class ClassForLocal {
+		public class ClassForLocal
+		{
 		}
 
 		public static void CallsToForceALocal (int arg1, int arg2, int arg3)
 		{
 		}
 	}
-	
+
 	[Kept]
 	[KeptBaseType (typeof (EventSource))]
 	[KeptMember (".ctor()")]
 	[KeptMember (".cctor()")]
 	[EventSource (Name = "MyCompany")]
-	class LocalsAreCleared_RemovedEventSource : EventSource {
-		public class Keywords {
-			public const EventKeywords Page = (EventKeywords)1;
+	class LocalsAreCleared_RemovedEventSource : EventSource
+	{
+		public class Keywords
+		{
+			public const EventKeywords Page = (EventKeywords) 1;
 
 			public int Unused;
 		}
@@ -52,7 +57,7 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 			LocalsOfModifiedMethodAreRemoved.CallsToForceALocal (1, 3, 4);
 			LocalsOfModifiedMethodAreRemoved.CallsToForceALocal (1, 4, 4);
 			var hashcode = tmp.GetHashCode ();
-			LocalsOfModifiedMethodAreRemoved.CallsToForceALocal(1, hashcode, 3);
+			LocalsOfModifiedMethodAreRemoved.CallsToForceALocal (1, hashcode, 3);
 		}
 
 		[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/NonEventWithLog.cs b/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/NonEventWithLog.cs
index e6f76bf95..f9ff78fee 100644
--- a/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/NonEventWithLog.cs
+++ b/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/NonEventWithLog.cs
@@ -3,14 +3,16 @@ using System.Diagnostics.Tracing;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
+namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("--exclude-feature is not supported on .NET Core")]
 #endif
 	[SetupLinkerArgument ("--exclude-feature", "etw")]
 	// Used to avoid different compilers generating different IL which can mess up the instruction asserts
 	[SetupCompileArgument ("/optimize+")]
-	public class NonEventWithLog {
+	public class NonEventWithLog
+	{
 		public static void Main ()
 		{
 			var n = new NonEventWithLogSource ();
@@ -23,7 +25,8 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 	[KeptMember (".ctor()")]
 
 	[EventSource (Name = "MyCompany")]
-	class NonEventWithLogSource : EventSource {
+	class NonEventWithLogSource : EventSource
+	{
 
 		[NonEvent]
 		[Kept]
@@ -34,7 +37,7 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new []
+		[ExpectedInstructionSequence (new[]
 		{
 			"ldstr",
 			"newobj",
diff --git a/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/StubbedMethodWithExceptionHandlers.cs b/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/StubbedMethodWithExceptionHandlers.cs
index 68ca8f37c..ac0d4b08e 100644
--- a/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/StubbedMethodWithExceptionHandlers.cs
+++ b/test/Mono.Linker.Tests.Cases/BCLFeatures/ETW/StubbedMethodWithExceptionHandlers.cs
@@ -3,7 +3,8 @@ using System.Diagnostics.Tracing;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
+namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("--exclude-feature is not supported on .NET Core")]
 #endif
@@ -12,7 +13,8 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 	[SetupLinkerCoreAction ("skip")]
 	// Used to avoid different compilers generating different IL which can mess up the instruction asserts
 	[SetupCompileArgument ("/optimize+")]
-	public class StubbedMethodWithExceptionHandlers {
+	public class StubbedMethodWithExceptionHandlers
+	{
 		public static void Main ()
 		{
 			var b = StubbedMethodWithExceptionHandlers_RemovedEventSource.Log.IsEnabled ();
@@ -20,15 +22,17 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 				StubbedMethodWithExceptionHandlers_RemovedEventSource.Log.SomeMethod ();
 		}
 	}
-	
+
 	[Kept]
 	[KeptBaseType (typeof (EventSource))]
 	[KeptMember (".ctor()")]
 	[KeptMember (".cctor()")]
 	[EventSource (Name = "MyCompany")]
-	class StubbedMethodWithExceptionHandlers_RemovedEventSource : EventSource {
-		public class Keywords {
-			public const EventKeywords Page = (EventKeywords)1;
+	class StubbedMethodWithExceptionHandlers_RemovedEventSource : EventSource
+	{
+		public class Keywords
+		{
+			public const EventKeywords Page = (EventKeywords) 1;
 
 			public int Unused;
 		}
@@ -37,7 +41,7 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 		public static StubbedMethodWithExceptionHandlers_RemovedEventSource Log = new StubbedMethodWithExceptionHandlers_RemovedEventSource ();
 
 		[Kept]
-		[ExpectedInstructionSequence (new []
+		[ExpectedInstructionSequence (new[]
 		{
 			"ldstr",
 			"newobj",
@@ -60,7 +64,7 @@ namespace Mono.Linker.Tests.Cases.BCLFeatures.ETW {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new []
+		[ExpectedInstructionSequence (new[]
 		{
 			"ldstr",
 			"newobj",
diff --git a/test/Mono.Linker.Tests.Cases/Basic/ComplexNestedClassesHasUnusedRemoved.cs b/test/Mono.Linker.Tests.Cases/Basic/ComplexNestedClassesHasUnusedRemoved.cs
index fbdbee204..f5a138c10 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/ComplexNestedClassesHasUnusedRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/ComplexNestedClassesHasUnusedRemoved.cs
@@ -1,23 +1,30 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	class ComplexNestedClassesHasUnusedRemoved {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	class ComplexNestedClassesHasUnusedRemoved
+	{
 		public static void Main ()
 		{
 			new A.AB.ABD ();
 		}
 
 		[Kept]
-		public class A {
+		public class A
+		{
 			[Kept]
-			public class AB {
-				public class ABC {
+			public class AB
+			{
+				public class ABC
+				{
 				}
 
 				[Kept]
-				[KeptMember(".ctor()")]
-				public class ABD {
-					public class ABDE {
+				[KeptMember (".ctor()")]
+				public class ABD
+				{
+					public class ABDE
+					{
 					}
 				}
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Basic/InitializerForArrayIsKept.cs b/test/Mono.Linker.Tests.Cases/Basic/InitializerForArrayIsKept.cs
index 7d461c741..5ba4c25d1 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/InitializerForArrayIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/InitializerForArrayIsKept.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	public class InitializerForArrayIsKept {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	public class InitializerForArrayIsKept
+	{
 		public static void Main ()
 		{
 			Method1 ();
@@ -13,27 +15,27 @@ namespace Mono.Linker.Tests.Cases.Basic {
 		[KeptInitializerData]
 		static void Method1 ()
 		{
-			Helper (new [] {1, 2, 3});
-			Helper (new [] {1, 2, 3, 4});
-			Helper (new [] {3, 4, 5});
+			Helper (new[] { 1, 2, 3 });
+			Helper (new[] { 1, 2, 3, 4 });
+			Helper (new[] { 3, 4, 5 });
 		}
 
 		[Kept]
 		[KeptInitializerData]
 		static void Method2 ()
 		{
-			Helper (new [] {10, 11, 12});
+			Helper (new[] { 10, 11, 12 });
 		}
-		
+
 		[Kept]
 		[KeptInitializerData]
 		static void Method3 ()
 		{
-			Helper (new [] {10, 11, 12});
+			Helper (new[] { 10, 11, 12 });
 		}
 
 		[Kept]
-		static void Helper<T> (T [] arr)
+		static void Helper<T> (T[] arr)
 		{
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Basic/InstantiatedTypeWithOverridesFromObject.cs b/test/Mono.Linker.Tests.Cases/Basic/InstantiatedTypeWithOverridesFromObject.cs
index aca4cf892..c29d053a2 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/InstantiatedTypeWithOverridesFromObject.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/InstantiatedTypeWithOverridesFromObject.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	public class InstantiatedTypeWithOverridesFromObject {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	public class InstantiatedTypeWithOverridesFromObject
+	{
 		public static void Main ()
 		{
 			var f = new Foo ();
@@ -9,7 +11,8 @@ namespace Mono.Linker.Tests.Cases.Basic {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			~Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Basic/InterfaceMethodImplementedOnBaseClassDoesNotGetStripped.cs b/test/Mono.Linker.Tests.Cases/Basic/InterfaceMethodImplementedOnBaseClassDoesNotGetStripped.cs
index fa0b762a8..fd9559f06 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/InterfaceMethodImplementedOnBaseClassDoesNotGetStripped.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/InterfaceMethodImplementedOnBaseClassDoesNotGetStripped.cs
@@ -1,14 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	class InterfaceMethodImplementedOnBaseClassDoesNotGetStripped {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	class InterfaceMethodImplementedOnBaseClassDoesNotGetStripped
+	{
 		public static void Main ()
 		{
 			I1 i1 = new Derived ();
 			i1.Used ();
 		}
 
-		public interface I1 {
+		public interface I1
+		{
 			void Unused ();
 
 			[Kept]
@@ -16,7 +19,8 @@ namespace Mono.Linker.Tests.Cases.Basic {
 		}
 
 		[KeptMember (".ctor()")]
-		public class Base {
+		public class Base
+		{
 			public void Unused ()
 			{
 			}
@@ -31,7 +35,8 @@ namespace Mono.Linker.Tests.Cases.Basic {
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Base))]
 		[KeptInterface (typeof (I1))]
-		public class Derived : Base, I1 {
+		public class Derived : Base, I1
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Basic/MultiLevelNestedClassesAllRemovedWhenNonUsed.cs b/test/Mono.Linker.Tests.Cases/Basic/MultiLevelNestedClassesAllRemovedWhenNonUsed.cs
index dd5f8628e..27eb971e4 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/MultiLevelNestedClassesAllRemovedWhenNonUsed.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/MultiLevelNestedClassesAllRemovedWhenNonUsed.cs
@@ -1,17 +1,23 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	class MultiLevelNestedClassesAllRemovedWhenNonUsed {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	class MultiLevelNestedClassesAllRemovedWhenNonUsed
+	{
 		public static void Main ()
 		{
 		}
 
-		public class A {
-			public class AB {
-				public class ABC {
+		public class A
+		{
+			public class AB
+			{
+				public class ABC
+				{
 				}
 
-				public class ABD {
+				public class ABD
+				{
 				}
 			}
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Basic/NestedDelegateInvokeMethodsPreserved.cs b/test/Mono.Linker.Tests.Cases/Basic/NestedDelegateInvokeMethodsPreserved.cs
index c3e231781..f1c81b64e 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/NestedDelegateInvokeMethodsPreserved.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/NestedDelegateInvokeMethodsPreserved.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	class NestedDelegateInvokeMethodsPreserved {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	class NestedDelegateInvokeMethodsPreserved
+	{
 		[Kept]
 		static B.Delegate @delegate;
 
@@ -11,7 +13,8 @@ namespace Mono.Linker.Tests.Cases.Basic {
 		}
 
 		[Kept]
-		public class B {
+		public class B
+		{
 			[Kept]
 			[KeptMember ("Invoke()")]
 			[KeptMember ("BeginInvoke(System.AsyncCallback,System.Object)")]
diff --git a/test/Mono.Linker.Tests.Cases/Basic/NeverInstantiatedTypeWithOverridesFromObject.cs b/test/Mono.Linker.Tests.Cases/Basic/NeverInstantiatedTypeWithOverridesFromObject.cs
index 5303fe69f..62f31c427 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/NeverInstantiatedTypeWithOverridesFromObject.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/NeverInstantiatedTypeWithOverridesFromObject.cs
@@ -1,14 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	public class NeverInstantiatedTypeWithOverridesFromObject {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	public class NeverInstantiatedTypeWithOverridesFromObject
+	{
 		public static void Main ()
 		{
 			typeof (Foo).ToString ();
 		}
 
 		[Kept]
-		class Foo {
+		class Foo
+		{
 			~Foo ()
 			{
 				// Finalize shouldn't be empty
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UninvokedInterfaceMemberGetsRemoved.cs b/test/Mono.Linker.Tests.Cases/Basic/UninvokedInterfaceMemberGetsRemoved.cs
index fb03b0f6d..98dc68f9a 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UninvokedInterfaceMemberGetsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UninvokedInterfaceMemberGetsRemoved.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	class UninvokedInterfaceMemberGetsRemoved {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	class UninvokedInterfaceMemberGetsRemoved
+	{
 		public static void Main ()
 		{
 			I i = new B ();
@@ -9,14 +11,16 @@ namespace Mono.Linker.Tests.Cases.Basic {
 		}
 
 		[Kept]
-		interface I {
+		interface I
+		{
 			void Method ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (I))]
-		class B : I {
+		class B : I
+		{
 			public void Method ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UnusedClassGetsRemoved.cs b/test/Mono.Linker.Tests.Cases/Basic/UnusedClassGetsRemoved.cs
index 85d60e33d..466114046 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UnusedClassGetsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UnusedClassGetsRemoved.cs
@@ -1,10 +1,13 @@
-namespace Mono.Linker.Tests.Cases.Basic {
-	public class UnusedClassGetsRemoved {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	public class UnusedClassGetsRemoved
+	{
 		public static void Main ()
 		{
 		}
 	}
 
-	class Unused {
+	class Unused
+	{
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UnusedDelegateGetsRemoved.cs b/test/Mono.Linker.Tests.Cases/Basic/UnusedDelegateGetsRemoved.cs
index d366e718e..0af0ef7aa 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UnusedDelegateGetsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UnusedDelegateGetsRemoved.cs
@@ -1,7 +1,9 @@
 using System;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	class UnusedDelegateGetsRemoved {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	class UnusedDelegateGetsRemoved
+	{
 		static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UnusedEnumGetsRemoved.cs b/test/Mono.Linker.Tests.Cases/Basic/UnusedEnumGetsRemoved.cs
index e646cfe63..ccf3246a5 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UnusedEnumGetsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UnusedEnumGetsRemoved.cs
@@ -1,12 +1,15 @@
 using System;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	class UnusedEnumGetsRemoved {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	class UnusedEnumGetsRemoved
+	{
 		static void Main ()
 		{
 		}
 
-		enum Unused {
+		enum Unused
+		{
 			One,
 			Two,
 			Three
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UnusedEventGetsRemoved.cs b/test/Mono.Linker.Tests.Cases/Basic/UnusedEventGetsRemoved.cs
index ed9279d08..0332b049c 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UnusedEventGetsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UnusedEventGetsRemoved.cs
@@ -1,8 +1,10 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	class UnusedEventGetsRemoved {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	class UnusedEventGetsRemoved
+	{
 		public static void Main ()
 		{
 			var tmp = new Foo ();
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UnusedFieldGetsRemoved.cs b/test/Mono.Linker.Tests.Cases/Basic/UnusedFieldGetsRemoved.cs
index 6edcf5729..87726f771 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UnusedFieldGetsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UnusedFieldGetsRemoved.cs
@@ -1,14 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	class UnusedFieldGetsRemoved {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	class UnusedFieldGetsRemoved
+	{
 		public static void Main ()
 		{
 			new B ().Method ();
 		}
 
 		[KeptMember (".ctor()")]
-		class B {
+		class B
+		{
 			public int _unused;
 
 			[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UnusedFieldsOfStructsAreKept.cs b/test/Mono.Linker.Tests.Cases/Basic/UnusedFieldsOfStructsAreKept.cs
index a4443a7ff..fb300fe6a 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UnusedFieldsOfStructsAreKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UnusedFieldsOfStructsAreKept.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	public class UnusedFieldsOfStructsAreKept {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	public class UnusedFieldsOfStructsAreKept
+	{
 		public static void Main ()
 		{
 			A a = new A ();
@@ -14,7 +16,8 @@ namespace Mono.Linker.Tests.Cases.Basic {
 		}
 
 		[Kept]
-		struct A {
+		struct A
+		{
 			[Kept]
 			private int UnusedField1;
 			[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UnusedMethodGetsRemoved.cs b/test/Mono.Linker.Tests.Cases/Basic/UnusedMethodGetsRemoved.cs
index eaded4de5..036acf27d 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UnusedMethodGetsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UnusedMethodGetsRemoved.cs
@@ -1,14 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	class UnusedMethodGetsRemoved {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	class UnusedMethodGetsRemoved
+	{
 		public static void Main ()
 		{
 			new UnusedMethodGetsRemoved.B ().Method ();
 		}
 
 		[KeptMember (".ctor()")]
-		class B {
+		class B
+		{
 			public void Unused ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UnusedNestedClassGetsRemoved.cs b/test/Mono.Linker.Tests.Cases/Basic/UnusedNestedClassGetsRemoved.cs
index 7ff2fc3a6..ab6f27f84 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UnusedNestedClassGetsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UnusedNestedClassGetsRemoved.cs
@@ -1,11 +1,14 @@
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	public class UnusedNestedClassGetsRemoved {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	public class UnusedNestedClassGetsRemoved
+	{
 		public static void Main ()
 		{
 		}
 
-		class Unused {
+		class Unused
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UnusedPropertyGetsRemoved.cs b/test/Mono.Linker.Tests.Cases/Basic/UnusedPropertyGetsRemoved.cs
index 63d82842e..863866b0b 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UnusedPropertyGetsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UnusedPropertyGetsRemoved.cs
@@ -1,14 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	class UnusedPropertyGetsRemoved {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	class UnusedPropertyGetsRemoved
+	{
 		public static void Main ()
 		{
 			new UnusedPropertyGetsRemoved.B ().Method ();
 		}
 
-		[KeptMember(".ctor()")]
-		class B {
+		[KeptMember (".ctor()")]
+		class B
+		{
 			public int Unused { get; set; }
 
 			[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UnusedPropertySetterRemoved.cs b/test/Mono.Linker.Tests.Cases/Basic/UnusedPropertySetterRemoved.cs
index 9bf680e77..92a4d26d1 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UnusedPropertySetterRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UnusedPropertySetterRemoved.cs
@@ -1,14 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	class UnusedPropertySetterRemoved {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	class UnusedPropertySetterRemoved
+	{
 		public static void Main ()
 		{
 			var val = new UnusedPropertySetterRemoved.B ().PartiallyUsed;
 		}
 
 		[KeptMember (".ctor()")]
-		class B {
+		class B
+		{
 			[Kept] // FIXME: Should be removed
 			[KeptBackingField]
 			public int PartiallyUsed { [Kept] get; set; }
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UsedEnumIsKept.cs b/test/Mono.Linker.Tests.Cases/Basic/UsedEnumIsKept.cs
index 5320ce63d..ac8526ba8 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UsedEnumIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UsedEnumIsKept.cs
@@ -2,8 +2,10 @@
 using System.Reflection;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	class UsedEnumIsKept {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	class UsedEnumIsKept
+	{
 		static void Main ()
 		{
 			// Use all of the values in case we implement a feature in the future that removes unused values
@@ -24,8 +26,9 @@ namespace Mono.Linker.Tests.Cases.Basic {
 
 		[Kept]
 		[KeptMember ("value__")]
-		[KeptBaseType (typeof(Enum))]
-		enum Used {
+		[KeptBaseType (typeof (Enum))]
+		enum Used
+		{
 			[Kept]
 			One,
 
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UsedEventIsKept.cs b/test/Mono.Linker.Tests.Cases/Basic/UsedEventIsKept.cs
index 0ff3cd573..d729d3ccb 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UsedEventIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UsedEventIsKept.cs
@@ -1,10 +1,12 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
+namespace Mono.Linker.Tests.Cases.Basic
+{
 	[KeptDelegateCacheField ("0")]
 	[KeptDelegateCacheField ("1")]
-	class UsedEventIsKept {
+	class UsedEventIsKept
+	{
 		public static void Main ()
 		{
 			var tmp = new Foo ();
@@ -20,9 +22,10 @@ namespace Mono.Linker.Tests.Cases.Basic {
 		}
 
 		[KeptMember (".ctor()")]
-		public class Foo {
+		public class Foo
+		{
 			[Kept]
-			[KeptBaseType (typeof(MulticastDelegate))]
+			[KeptBaseType (typeof (MulticastDelegate))]
 			[KeptMember (".ctor(System.Object,System.IntPtr)")]
 			[KeptMember ("Invoke()")]
 			[KeptMember ("BeginInvoke(System.AsyncCallback,System.Object)")]
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UsedEventOnInterfaceIsKept.cs b/test/Mono.Linker.Tests.Cases/Basic/UsedEventOnInterfaceIsKept.cs
index 828a76dac..099b92ab2 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UsedEventOnInterfaceIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UsedEventOnInterfaceIsKept.cs
@@ -1,9 +1,11 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
+namespace Mono.Linker.Tests.Cases.Basic
+{
 	[KeptDelegateCacheField ("0")]
-	class UsedEventOnInterfaceIsKept {
+	class UsedEventOnInterfaceIsKept
+	{
 		static void Main ()
 		{
 			IFoo bar = new Bar ();
@@ -18,7 +20,8 @@ namespace Mono.Linker.Tests.Cases.Basic {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			[KeptEventAddMethod]
 			[KeptEventRemoveMethod]
@@ -27,7 +30,8 @@ namespace Mono.Linker.Tests.Cases.Basic {
 
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class Bar : IFoo {
+		class Bar : IFoo
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptEventAddMethod]
@@ -37,7 +41,8 @@ namespace Mono.Linker.Tests.Cases.Basic {
 
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class Jar : IFoo {
+		class Jar : IFoo
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptEventAddMethod]
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UsedEventOnInterfaceIsRemovedWhenUsedFromClass.cs b/test/Mono.Linker.Tests.Cases/Basic/UsedEventOnInterfaceIsRemovedWhenUsedFromClass.cs
index edff204d6..464db7008 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UsedEventOnInterfaceIsRemovedWhenUsedFromClass.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UsedEventOnInterfaceIsRemovedWhenUsedFromClass.cs
@@ -1,9 +1,11 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
+namespace Mono.Linker.Tests.Cases.Basic
+{
 	[KeptDelegateCacheField ("0")]
-	class UsedEventOnInterfaceIsRemovedWhenUsedFromClass {
+	class UsedEventOnInterfaceIsRemovedWhenUsedFromClass
+	{
 		static void Main ()
 		{
 			var bar = new Bar ();
@@ -17,12 +19,14 @@ namespace Mono.Linker.Tests.Cases.Basic {
 		{
 		}
 
-		interface IFoo {
+		interface IFoo
+		{
 			event EventHandler Ping;
 		}
 
 		[KeptMember (".ctor()")]
-		class Bar : IFoo {
+		class Bar : IFoo
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptEventAddMethod]
@@ -31,7 +35,8 @@ namespace Mono.Linker.Tests.Cases.Basic {
 		}
 
 		[KeptMember (".ctor()")]
-		class Jar : IFoo {
+		class Jar : IFoo
+		{
 			public event EventHandler Ping;
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UsedGenericInterfaceIsKept.cs b/test/Mono.Linker.Tests.Cases/Basic/UsedGenericInterfaceIsKept.cs
index 11ff80990..1e49ef2e4 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UsedGenericInterfaceIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UsedGenericInterfaceIsKept.cs
@@ -7,7 +7,7 @@ namespace Mono.Linker.Tests.Cases.Basic
 		public static void Main ()
 		{
 			A<int> a = new A<int> ();
-			var t = typeof (I<>).ToString();
+			var t = typeof (I<>).ToString ();
 		}
 
 		[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UsedInterfaceIsKept.cs b/test/Mono.Linker.Tests.Cases/Basic/UsedInterfaceIsKept.cs
index e399d2c9b..6015b4df0 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UsedInterfaceIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UsedInterfaceIsKept.cs
@@ -7,7 +7,7 @@ namespace Mono.Linker.Tests.Cases.Basic
 		public static void Main ()
 		{
 			A a = new A ();
-			var t = typeof (I).ToString();
+			var t = typeof (I).ToString ();
 		}
 
 		[Kept]
@@ -19,7 +19,7 @@ namespace Mono.Linker.Tests.Cases.Basic
 
 		[Kept]
 		interface I
-		{ 
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UsedPropertyIsKept.cs b/test/Mono.Linker.Tests.Cases/Basic/UsedPropertyIsKept.cs
index 8adc71f27..3487743db 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UsedPropertyIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UsedPropertyIsKept.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Basic {
-	class UsedPropertyIsKept {
+namespace Mono.Linker.Tests.Cases.Basic
+{
+	class UsedPropertyIsKept
+	{
 		public static void Main ()
 		{
 			var obj = new B ();
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Basic {
 		}
 
 		[KeptMember (".ctor()")]
-		class B {
+		class B
+		{
 			[Kept]
 			[KeptBackingField]
 			public int Prop { [Kept] get; [Kept] set; }
diff --git a/test/Mono.Linker.Tests.Cases/Basic/UsedStructIsKept.cs b/test/Mono.Linker.Tests.Cases/Basic/UsedStructIsKept.cs
index 4af518fed..d5a1dfde5 100644
--- a/test/Mono.Linker.Tests.Cases/Basic/UsedStructIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Basic/UsedStructIsKept.cs
@@ -2,8 +2,9 @@
 
 namespace Mono.Linker.Tests.Cases.Basic
 {
-	class UsedStructIsKept {
-		public static void Main()
+	class UsedStructIsKept
+	{
+		public static void Main ()
 		{
 			A a;
 			a.MethodVerifiedByKeptMember ();
@@ -12,7 +13,8 @@ namespace Mono.Linker.Tests.Cases.Basic
 		[Kept]
 		// This KeptMember is here to make sure the test framework's support of KeptMember on value types is working correctly
 		[KeptMember ("MethodVerifiedByKeptMember()")]
-		struct A {
+		struct A
+		{
 			public void MethodVerifiedByKeptMember ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/CodegenAnnotation/ReflectionBlockedTest.cs b/test/Mono.Linker.Tests.Cases/CodegenAnnotation/ReflectionBlockedTest.cs
index 399c72101..60c3f229d 100644
--- a/test/Mono.Linker.Tests.Cases/CodegenAnnotation/ReflectionBlockedTest.cs
+++ b/test/Mono.Linker.Tests.Cases/CodegenAnnotation/ReflectionBlockedTest.cs
@@ -5,28 +5,28 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
 namespace Mono.Linker.Tests.Cases.CodegenAnnotation
 {
-	[SetupLinkerArgument("--explicit-reflection")]
+	[SetupLinkerArgument ("--explicit-reflection")]
 	public class ReflectionBlockedTest
 	{
 		[KeptAttributeAttribute ("System.Runtime.CompilerServices.DisablePrivateReflectionAttribute")]
-		public static void Main()
+		public static void Main ()
 		{
-			var obj = new A();
-			var method = typeof(A).GetMethod("FooPrivRefl", BindingFlags.NonPublic);
+			var obj = new A ();
+			var method = typeof (A).GetMethod ("FooPrivRefl", BindingFlags.NonPublic);
 			method.Invoke (obj, new object[] { });
 
 			obj.FooPub ();
 
-			var obj2 = new All();
+			var obj2 = new All ();
 			obj2.FooPub ();
 		}
 
 		[Kept]
-		[KeptAttributeAttribute("System.Runtime.CompilerServices.DisablePrivateReflectionAttribute")]
+		[KeptAttributeAttribute ("System.Runtime.CompilerServices.DisablePrivateReflectionAttribute")]
 		public class All
 		{
 			[Kept]
-			private int FooPrivSpecializable()
+			private int FooPrivSpecializable ()
 			{
 				return 42;
 			}
@@ -34,11 +34,11 @@ namespace Mono.Linker.Tests.Cases.CodegenAnnotation
 			[Kept]
 			public int FooPub ()
 			{
-				return FooPrivSpecializable();
+				return FooPrivSpecializable ();
 			}
 
 			[Kept]
-			public All()
+			public All ()
 			{
 			}
 		}
@@ -47,10 +47,9 @@ namespace Mono.Linker.Tests.Cases.CodegenAnnotation
 		public class A
 		{
 			[Kept]
-			private int Field
-			{
+			private int Field {
 				[Kept]
-				[KeptAttributeAttribute("System.Runtime.CompilerServices.DisablePrivateReflectionAttribute")]
+				[KeptAttributeAttribute ("System.Runtime.CompilerServices.DisablePrivateReflectionAttribute")]
 				get {
 					return 42;
 				}
@@ -58,20 +57,20 @@ namespace Mono.Linker.Tests.Cases.CodegenAnnotation
 
 			[Kept]
 			[KeptAttributeAttribute ("System.Runtime.CompilerServices.DisablePrivateReflectionAttribute")]
-			public int FooPub()
+			public int FooPub ()
 			{
-				return FooPrivSpecializable();
+				return FooPrivSpecializable ();
 			}
 
 			[Kept]
-			private int FooPrivRefl()
+			private int FooPrivRefl ()
 			{
 				return this.Field;
 			}
 
 			[Kept]
-			[KeptAttributeAttribute("System.Runtime.CompilerServices.DisablePrivateReflectionAttribute")]
-			private int FooPrivSpecializable()
+			[KeptAttributeAttribute ("System.Runtime.CompilerServices.DisablePrivateReflectionAttribute")]
+			private int FooPrivSpecializable ()
 			{
 				return 42;
 			}
diff --git a/test/Mono.Linker.Tests.Cases/CommandLine/Dependencies/CustomStepDummy.cs b/test/Mono.Linker.Tests.Cases/CommandLine/Dependencies/CustomStepDummy.cs
index 8713dc2c1..2ceed46ae 100644
--- a/test/Mono.Linker.Tests.Cases/CommandLine/Dependencies/CustomStepDummy.cs
+++ b/test/Mono.Linker.Tests.Cases/CommandLine/Dependencies/CustomStepDummy.cs
@@ -6,7 +6,7 @@ namespace CustomStep
 {
 	public class CustomStepDummy : IStep
 	{
-		public void Process(LinkContext context)
+		public void Process (LinkContext context)
 		{
 			context.LogMessage ("Custom step added.");
 		}
diff --git a/test/Mono.Linker.Tests.Cases/CommandLine/Dependencies/CustomStepUser.cs b/test/Mono.Linker.Tests.Cases/CommandLine/Dependencies/CustomStepUser.cs
index e14b60d7b..af9665693 100644
--- a/test/Mono.Linker.Tests.Cases/CommandLine/Dependencies/CustomStepUser.cs
+++ b/test/Mono.Linker.Tests.Cases/CommandLine/Dependencies/CustomStepUser.cs
@@ -6,7 +6,7 @@ namespace CustomStep
 {
 	public class CustomStepUser : IStep
 	{
-		public void Process(LinkContext context)
+		public void Process (LinkContext context)
 		{
 			if (context.TryGetCustomData ("NewKey", out var value))
 				context.LogMessage ("Custom step added with custom data of " + value);
diff --git a/test/Mono.Linker.Tests.Cases/CommandLine/Mvid/DefaultMvidBehavior.cs b/test/Mono.Linker.Tests.Cases/CommandLine/Mvid/DefaultMvidBehavior.cs
index c7af96f74..676c382fd 100644
--- a/test/Mono.Linker.Tests.Cases/CommandLine/Mvid/DefaultMvidBehavior.cs
+++ b/test/Mono.Linker.Tests.Cases/CommandLine/Mvid/DefaultMvidBehavior.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.CommandLine.Mvid {
-	public class DefaultMvidBehavior {
+namespace Mono.Linker.Tests.Cases.CommandLine.Mvid
+{
+	public class DefaultMvidBehavior
+	{
 		public static void Main ()
 		{
 			Method ();
diff --git a/test/Mono.Linker.Tests.Cases/CommandLine/Mvid/DeterministicMvidWorks.cs b/test/Mono.Linker.Tests.Cases/CommandLine/Mvid/DeterministicMvidWorks.cs
index 34292b175..d3aa2377f 100644
--- a/test/Mono.Linker.Tests.Cases/CommandLine/Mvid/DeterministicMvidWorks.cs
+++ b/test/Mono.Linker.Tests.Cases/CommandLine/Mvid/DeterministicMvidWorks.cs
@@ -1,9 +1,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.CommandLine.Mvid {
+namespace Mono.Linker.Tests.Cases.CommandLine.Mvid
+{
 	[SetupLinkerArgument ("--deterministic")]
-	public class DeterministicMvidWorks {
+	public class DeterministicMvidWorks
+	{
 		public static void Main ()
 		{
 			Method ();
diff --git a/test/Mono.Linker.Tests.Cases/CommandLine/Mvid/NewMvidWorks.cs b/test/Mono.Linker.Tests.Cases/CommandLine/Mvid/NewMvidWorks.cs
index b11b762c0..9f295972f 100644
--- a/test/Mono.Linker.Tests.Cases/CommandLine/Mvid/NewMvidWorks.cs
+++ b/test/Mono.Linker.Tests.Cases/CommandLine/Mvid/NewMvidWorks.cs
@@ -1,9 +1,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.CommandLine.Mvid {
+namespace Mono.Linker.Tests.Cases.CommandLine.Mvid
+{
 	[SetupLinkerArgument ("--new-mvid", "true")]
-	public class NewMvidWorks {
+	public class NewMvidWorks
+	{
 		public static void Main ()
 		{
 			Method ();
diff --git a/test/Mono.Linker.Tests.Cases/CommandLine/Mvid/RetainMvid.cs b/test/Mono.Linker.Tests.Cases/CommandLine/Mvid/RetainMvid.cs
index 0b866f223..90474f5bc 100644
--- a/test/Mono.Linker.Tests.Cases/CommandLine/Mvid/RetainMvid.cs
+++ b/test/Mono.Linker.Tests.Cases/CommandLine/Mvid/RetainMvid.cs
@@ -1,7 +1,8 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.CommandLine.Mvid {
+namespace Mono.Linker.Tests.Cases.CommandLine.Mvid
+{
 	[SetupLinkerArgument ("--new-mvid", "false")]
 	public class RetainMvid
 	{
diff --git a/test/Mono.Linker.Tests.Cases/CommandLine/ResponseFilesWork.cs b/test/Mono.Linker.Tests.Cases/CommandLine/ResponseFilesWork.cs
index 6f65a2d52..eb250ea87 100644
--- a/test/Mono.Linker.Tests.Cases/CommandLine/ResponseFilesWork.cs
+++ b/test/Mono.Linker.Tests.Cases/CommandLine/ResponseFilesWork.cs
@@ -2,12 +2,14 @@ using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.CommandLine {
+namespace Mono.Linker.Tests.Cases.CommandLine
+{
 	/// <summary>
 	/// This test will use only keep used attributes, which is disabled by default, to infer that the rsp file worked
 	/// </summary>
 	[SetupLinkerResponseFileAttribute ("Dependencies/ResponseFilesWork.rsp")]
-	public class ResponseFilesWork {
+	public class ResponseFilesWork
+	{
 		public static void Main ()
 		{
 			new Bar ();
@@ -16,10 +18,12 @@ namespace Mono.Linker.Tests.Cases.CommandLine {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[Foo]
-		class Bar {
+		class Bar
+		{
 		}
 
-		class FooAttribute : Attribute {
+		class FooAttribute : Attribute
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/ComponentModel/CustomTypeConvertor.cs b/test/Mono.Linker.Tests.Cases/ComponentModel/CustomTypeConvertor.cs
index 4f94ed07e..2d6328746 100644
--- a/test/Mono.Linker.Tests.Cases/ComponentModel/CustomTypeConvertor.cs
+++ b/test/Mono.Linker.Tests.Cases/ComponentModel/CustomTypeConvertor.cs
@@ -16,7 +16,7 @@ namespace Mono.Linker.Tests.Cases.ComponentModel
 		[KeptBaseType (typeof (TypeConverter))]
 		class Custom1 : TypeConverter
 		{
-			[Kept]			
+			[Kept]
 			public Custom1 (Type type)
 			{
 			}
@@ -54,7 +54,7 @@ namespace Mono.Linker.Tests.Cases.ComponentModel
 
 	[Reference ("System.dll")]
 	public class CustomTypeConvertor
-	{		
+	{
 		public static void Main ()
 		{
 			var tc1 = TypeDescriptor.GetConverter (typeof (CustomDataType));
diff --git a/test/Mono.Linker.Tests.Cases/ComponentModel/TypeDescriptionProviderAttributeOnType.cs b/test/Mono.Linker.Tests.Cases/ComponentModel/TypeDescriptionProviderAttributeOnType.cs
index 5b9aeba0e..07de3e5f8 100644
--- a/test/Mono.Linker.Tests.Cases/ComponentModel/TypeDescriptionProviderAttributeOnType.cs
+++ b/test/Mono.Linker.Tests.Cases/ComponentModel/TypeDescriptionProviderAttributeOnType.cs
@@ -24,11 +24,11 @@ namespace Mono.Linker.Tests.Cases.ComponentModel
 			{
 			}
 		}
-	}	
+	}
 
 	[Reference ("System.dll")]
 	public class TypeDescriptionProviderAttributeOnType
-	{		
+	{
 		public static void Main ()
 		{
 			var r1 = new CustomTypeDescriptionProvider_1 ();
diff --git a/test/Mono.Linker.Tests.Cases/CoreLink/CanIncludeI18nAssemblies.cs b/test/Mono.Linker.Tests.Cases/CoreLink/CanIncludeI18nAssemblies.cs
index 92001b04e..702711fc4 100644
--- a/test/Mono.Linker.Tests.Cases/CoreLink/CanIncludeI18nAssemblies.cs
+++ b/test/Mono.Linker.Tests.Cases/CoreLink/CanIncludeI18nAssemblies.cs
@@ -1,26 +1,28 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.CoreLink {
+namespace Mono.Linker.Tests.Cases.CoreLink
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("Don't try to compile with mcs on .NET Core")]
 #endif
 	[SetupLinkerCoreAction ("link")]
 	[Il8n ("all")]
-	
+
 	// i18n assemblies should only be included when processing mono class libs.  By forcing this test to use mcs,
 	// we can ensure the test will be ignored when the test runs against .net fw assemblies.
 	[SetupCSharpCompilerToUse ("mcs")]
-	
+
 	[KeptAssembly ("I18N.dll")]
 	[KeptAssembly ("I18N.CJK.dll")]
 	[KeptAssembly ("I18N.MidEast.dll")]
 	[KeptAssembly ("I18N.Other.dll")]
 	[KeptAssembly ("I18N.Rare.dll")]
 	[KeptAssembly ("I18N.West.dll")]
-	
+
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	public class CanIncludeI18nAssemblies {
+	public class CanIncludeI18nAssemblies
+	{
 		public static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/CoreLink/CopyOfCoreLibrariesKeepsUnusedTypes.cs b/test/Mono.Linker.Tests.Cases/CoreLink/CopyOfCoreLibrariesKeepsUnusedTypes.cs
index 8a3d66e18..133e92b68 100644
--- a/test/Mono.Linker.Tests.Cases/CoreLink/CopyOfCoreLibrariesKeepsUnusedTypes.cs
+++ b/test/Mono.Linker.Tests.Cases/CoreLink/CopyOfCoreLibrariesKeepsUnusedTypes.cs
@@ -13,7 +13,7 @@ namespace Mono.Linker.Tests.Cases.CoreLink
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
 	class CopyOfCoreLibrariesKeepsUnusedTypes
 	{
-		public static void Main()
+		public static void Main ()
 		{
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/CoreLink/DelegateAndMulticastDelegateKeepInstantiatedReqs.cs b/test/Mono.Linker.Tests.Cases/CoreLink/DelegateAndMulticastDelegateKeepInstantiatedReqs.cs
index 08b429106..a44e6806f 100644
--- a/test/Mono.Linker.Tests.Cases/CoreLink/DelegateAndMulticastDelegateKeepInstantiatedReqs.cs
+++ b/test/Mono.Linker.Tests.Cases/CoreLink/DelegateAndMulticastDelegateKeepInstantiatedReqs.cs
@@ -3,7 +3,8 @@ using System.Runtime.Serialization;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.CoreLink {
+namespace Mono.Linker.Tests.Cases.CoreLink
+{
 	/// <summary>
 	/// Delegate and is created from 
 	/// </summary>
@@ -16,16 +17,17 @@ namespace Mono.Linker.Tests.Cases.CoreLink {
 
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (Delegate), "GetHashCode()")]
 	[KeptMemberInAssembly (PlatformAssemblies.CoreLib, typeof (Delegate), "Equals(System.Object)")]
-	[KeptInterfaceOnTypeInAssembly(PlatformAssemblies.CoreLib, typeof (Delegate), PlatformAssemblies.CoreLib, typeof (ICloneable))]
+	[KeptInterfaceOnTypeInAssembly (PlatformAssemblies.CoreLib, typeof (Delegate), PlatformAssemblies.CoreLib, typeof (ICloneable))]
 #if NETCOREAPP
 	[KeptInterfaceOnTypeInAssembly(PlatformAssemblies.CoreLib, typeof (Delegate), "System.Runtime.dll", typeof (ISerializable))]
 #else
-	[KeptInterfaceOnTypeInAssembly(PlatformAssemblies.CoreLib, typeof (Delegate), PlatformAssemblies.CoreLib, typeof (ISerializable))]
+	[KeptInterfaceOnTypeInAssembly (PlatformAssemblies.CoreLib, typeof (Delegate), PlatformAssemblies.CoreLib, typeof (ISerializable))]
 #endif
 
 	// Fails due to Runtime critical type System.Reflection.CustomAttributeData not found.
-	[SkipPeVerify(SkipPeVerifyForToolchian.Pedump)]
-	public class DelegateAndMulticastDelegateKeepInstantiatedReqs {
+	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
+	public class DelegateAndMulticastDelegateKeepInstantiatedReqs
+	{
 		public static void Main ()
 		{
 			typeof (MulticastDelegate).ToString ();
@@ -33,7 +35,7 @@ namespace Mono.Linker.Tests.Cases.CoreLink {
 			// Cause the interfaces to be marked in order to eliminate the possibility of them being removed
 			// due to no code path marking the interface type
 			typeof (ISerializable).ToString ();
-			typeof (ICloneable).ToString();
+			typeof (ICloneable).ToString ();
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/CoreLink/InstantiatedStructWithOverridesFromObject.cs b/test/Mono.Linker.Tests.Cases/CoreLink/InstantiatedStructWithOverridesFromObject.cs
index 0293abf4b..d8255fe44 100644
--- a/test/Mono.Linker.Tests.Cases/CoreLink/InstantiatedStructWithOverridesFromObject.cs
+++ b/test/Mono.Linker.Tests.Cases/CoreLink/InstantiatedStructWithOverridesFromObject.cs
@@ -1,11 +1,13 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.CoreLink {
+namespace Mono.Linker.Tests.Cases.CoreLink
+{
 	[SetupLinkerCoreAction ("link")]
 	// Need to skip due to `Runtime critical type System.Reflection.CustomAttributeData not found` failure
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	public class InstantiatedStructWithOverridesFromObject {
+	public class InstantiatedStructWithOverridesFromObject
+	{
 		public static void Main ()
 		{
 			HelperToUseFoo (new Foo ());
@@ -27,7 +29,8 @@ namespace Mono.Linker.Tests.Cases.CoreLink {
 		}
 
 		[Kept]
-		struct Foo {
+		struct Foo
+		{
 			[Kept]
 			public override bool Equals (object obj)
 			{
diff --git a/test/Mono.Linker.Tests.Cases/CoreLink/InstantiatedTypeWithOverridesFromObject.cs b/test/Mono.Linker.Tests.Cases/CoreLink/InstantiatedTypeWithOverridesFromObject.cs
index 0af5194e8..bb20020a0 100644
--- a/test/Mono.Linker.Tests.Cases/CoreLink/InstantiatedTypeWithOverridesFromObject.cs
+++ b/test/Mono.Linker.Tests.Cases/CoreLink/InstantiatedTypeWithOverridesFromObject.cs
@@ -1,11 +1,13 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.CoreLink {
+namespace Mono.Linker.Tests.Cases.CoreLink
+{
 	[SetupLinkerCoreAction ("link")]
 	// Need to skip due to `Runtime critical type System.Reflection.CustomAttributeData not found` failure
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	public class InstantiatedTypeWithOverridesFromObject {
+	public class InstantiatedTypeWithOverridesFromObject
+	{
 		public static void Main ()
 		{
 			var f = new Foo ();
@@ -13,7 +15,8 @@ namespace Mono.Linker.Tests.Cases.CoreLink {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			~Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/CoreLink/LinkingOfCoreLibrariesRemovesUnusedMethods.cs b/test/Mono.Linker.Tests.Cases/CoreLink/LinkingOfCoreLibrariesRemovesUnusedMethods.cs
index c7e323031..d96e64d1c 100644
--- a/test/Mono.Linker.Tests.Cases/CoreLink/LinkingOfCoreLibrariesRemovesUnusedMethods.cs
+++ b/test/Mono.Linker.Tests.Cases/CoreLink/LinkingOfCoreLibrariesRemovesUnusedMethods.cs
@@ -25,8 +25,9 @@ namespace Mono.Linker.Tests.Cases.CoreLink
 
 	// Can be removed once this bug is fixed https://bugzilla.xamarin.com/show_bug.cgi?id=58168
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	class LinkingOfCoreLibrariesRemovesUnusedMethods {
-		public static void Main()
+	class LinkingOfCoreLibrariesRemovesUnusedMethods
+	{
+		public static void Main ()
 		{
 			Stack stack = new Stack (2);
 			stack.Push (1);
diff --git a/test/Mono.Linker.Tests.Cases/CoreLink/LinkingOfCoreLibrariesRemovesUnusedTypes.cs b/test/Mono.Linker.Tests.Cases/CoreLink/LinkingOfCoreLibrariesRemovesUnusedTypes.cs
index 89cc1ddf8..c15f2c534 100644
--- a/test/Mono.Linker.Tests.Cases/CoreLink/LinkingOfCoreLibrariesRemovesUnusedTypes.cs
+++ b/test/Mono.Linker.Tests.Cases/CoreLink/LinkingOfCoreLibrariesRemovesUnusedTypes.cs
@@ -3,9 +3,10 @@ using System.Collections.Generic;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.CoreLink {
+namespace Mono.Linker.Tests.Cases.CoreLink
+{
 	[SetupLinkerCoreAction ("link")]
-	[Reference("System.dll")]
+	[Reference ("System.dll")]
 
 	[KeptAssembly (PlatformAssemblies.CoreLib)]
 	// We can't check everything that should be removed, but we should be able to check a few niche things that
@@ -18,7 +19,7 @@ namespace Mono.Linker.Tests.Cases.CoreLink {
 	[KeptTypeInAssembly ("System.Collections.dll", typeof (System.Collections.Generic.SortedList<,>))]
 	[RemovedTypeInAssembly ("System.Collections.dll", typeof (System.Collections.Generic.SortedDictionary<,>))]
 #else
-	[KeptAssembly("System.dll")]
+	[KeptAssembly ("System.dll")]
 	[KeptTypeInAssembly ("System.dll", typeof (System.Collections.Generic.SortedList<,>))]
 	[RemovedTypeInAssembly ("System.dll", typeof (System.Collections.Generic.SortedDictionary<,>))]
 #endif
@@ -27,17 +28,18 @@ namespace Mono.Linker.Tests.Cases.CoreLink {
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
 
 	//  All sorts of stuff is flagged as invalid even in the original System.dll and System.Configuration.dll for mono class libraries
-	[SkipPeVerify("System.dll")]
-	[SkipPeVerify("System.Configuration.dll")]
+	[SkipPeVerify ("System.dll")]
+	[SkipPeVerify ("System.Configuration.dll")]
 	// System.Core.dll is referenced by System.dll in the .NET FW class libraries. Our GetType reflection marking code
 	// detects a GetType("SHA256CryptoServiceProvider") in System.dll, which then causes a type in System.Core.dll to be marked.
 	// PeVerify fails on the original GAC copy of System.Core.dll so it's expected that it will also fail on the stripped version we output
 	[SkipPeVerify ("System.Core.dll")]
-	class LinkingOfCoreLibrariesRemovesUnusedTypes {
+	class LinkingOfCoreLibrariesRemovesUnusedTypes
+	{
 		public static void Main ()
 		{
 			// Use something from system that would normally be removed if we didn't use it
-			OtherMethods2 (new SortedList<string, string>());
+			OtherMethods2 (new SortedList<string, string> ());
 		}
 
 		[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/CoreLink/NeverInstantiatedTypeWithOverridesFromObject.cs b/test/Mono.Linker.Tests.Cases/CoreLink/NeverInstantiatedTypeWithOverridesFromObject.cs
index 9d1627aff..8d1b596e4 100644
--- a/test/Mono.Linker.Tests.Cases/CoreLink/NeverInstantiatedTypeWithOverridesFromObject.cs
+++ b/test/Mono.Linker.Tests.Cases/CoreLink/NeverInstantiatedTypeWithOverridesFromObject.cs
@@ -1,18 +1,21 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.CoreLink {
+namespace Mono.Linker.Tests.Cases.CoreLink
+{
 	[SetupLinkerCoreAction ("link")]
 	// Need to skip due to `Runtime critical type System.Reflection.CustomAttributeData not found` failure
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	public class NeverInstantiatedTypeWithOverridesFromObject {
+	public class NeverInstantiatedTypeWithOverridesFromObject
+	{
 		public static void Main ()
 		{
 			typeof (Foo).ToString ();
 		}
 
 		[Kept]
-		class Foo {
+		class Foo
+		{
 			~Foo ()
 			{
 				// Finalize shouldn't be empty
diff --git a/test/Mono.Linker.Tests.Cases/CoreLink/NoSecurityPlusOnlyKeepUsedRemovesAllSecurityAttributesFromCoreLibraries.cs b/test/Mono.Linker.Tests.Cases/CoreLink/NoSecurityPlusOnlyKeepUsedRemovesAllSecurityAttributesFromCoreLibraries.cs
index d57bf41cc..aaf41b317 100644
--- a/test/Mono.Linker.Tests.Cases/CoreLink/NoSecurityPlusOnlyKeepUsedRemovesAllSecurityAttributesFromCoreLibraries.cs
+++ b/test/Mono.Linker.Tests.Cases/CoreLink/NoSecurityPlusOnlyKeepUsedRemovesAllSecurityAttributesFromCoreLibraries.cs
@@ -4,7 +4,8 @@ using System.Security.Permissions;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.CoreLink {
+namespace Mono.Linker.Tests.Cases.CoreLink
+{
 	[SetupLinkerCoreAction ("link")]
 	[SetupLinkerArgument ("--strip-security", "true")]
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
@@ -31,7 +32,8 @@ namespace Mono.Linker.Tests.Cases.CoreLink {
 	// detects a GetType("SHA256CryptoServiceProvider") in System.dll, which then causes a type in System.Core.dll to be marked.
 	// PeVerify fails on the original GAC copy of System.Core.dll so it's expected that it will also fail on the stripped version we output
 	[SkipPeVerify ("System.Core.dll")]
-	public class NoSecurityPlusOnlyKeepUsedRemovesAllSecurityAttributesFromCoreLibraries {
+	public class NoSecurityPlusOnlyKeepUsedRemovesAllSecurityAttributesFromCoreLibraries
+	{
 		public static void Main ()
 		{
 			// Use something that has security attributes to make this test more meaningful
diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/ApplyTypeAnnotations.cs b/test/Mono.Linker.Tests.Cases/DataFlow/ApplyTypeAnnotations.cs
index bb8b246fa..bc9aed4ce 100644
--- a/test/Mono.Linker.Tests.Cases/DataFlow/ApplyTypeAnnotations.cs
+++ b/test/Mono.Linker.Tests.Cases/DataFlow/ApplyTypeAnnotations.cs
@@ -104,9 +104,9 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		private static void RequireCombination (
 			[KeptAttributeAttribute(typeof(DynamicallyAccessedMembersAttribute))]
 			[DynamicallyAccessedMembers(
-				DynamicallyAccessedMemberKinds.DefaultConstructor | 
-				DynamicallyAccessedMemberKinds.PublicFields | 
-				DynamicallyAccessedMemberKinds.PublicMethods | 
+				DynamicallyAccessedMemberKinds.DefaultConstructor |
+				DynamicallyAccessedMemberKinds.PublicFields |
+				DynamicallyAccessedMemberKinds.PublicMethods |
 				DynamicallyAccessedMemberKinds.PublicProperties)]
 			Type type)
 		{
diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/AttributeConstructorDataflow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/AttributeConstructorDataflow.cs
index 47cb0b934..9387ea5cc 100644
--- a/test/Mono.Linker.Tests.Cases/DataFlow/AttributeConstructorDataflow.cs
+++ b/test/Mono.Linker.Tests.Cases/DataFlow/AttributeConstructorDataflow.cs
@@ -14,22 +14,22 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 	[Kept]
 	class AttributeConstructorDataflow
 	{
-		[KeptAttributeAttribute(typeof(KeepsPublicConstructorAttribute))]
+		[KeptAttributeAttribute (typeof (KeepsPublicConstructorAttribute))]
 		[KeptAttributeAttribute (typeof (KeepsPublicMethodsAttribute))]
-		[KeepsPublicConstructor(typeof(ClassWithKeptPublicConstructor))]
-		[KeepsPublicMethods("Mono.Linker.Tests.Cases.DataFlow.AttributeConstructorDataflow+ClassWithKeptPublicMethods")]
-		public static void Main()
+		[KeepsPublicConstructor (typeof (ClassWithKeptPublicConstructor))]
+		[KeepsPublicMethods ("Mono.Linker.Tests.Cases.DataFlow.AttributeConstructorDataflow+ClassWithKeptPublicMethods")]
+		public static void Main ()
 		{
 			typeof (AttributeConstructorDataflow).GetMethod ("Main").GetCustomAttribute (typeof (KeepsPublicConstructorAttribute));
 			typeof (AttributeConstructorDataflow).GetMethod ("Main").GetCustomAttribute (typeof (KeepsPublicMethodsAttribute));
 		}
 
 		[Kept]
-		[KeptBaseType(typeof(Attribute))]
+		[KeptBaseType (typeof (Attribute))]
 		class KeepsPublicConstructorAttribute : Attribute
 		{
 			[Kept]
-			public KeepsPublicConstructorAttribute(
+			public KeepsPublicConstructorAttribute (
 				[KeptAttributeAttribute(typeof(DynamicallyAccessedMembersAttribute))]
 				[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.PublicConstructors)]
 				Type type)
@@ -38,7 +38,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		}
 
 		[Kept]
-		[KeptBaseType(typeof(Attribute))]
+		[KeptBaseType (typeof (Attribute))]
 		class KeepsPublicMethodsAttribute : Attribute
 		{
 			[Kept]
@@ -54,19 +54,19 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		class ClassWithKeptPublicConstructor
 		{
 			[Kept]
-			public ClassWithKeptPublicConstructor(int unused) { }
+			public ClassWithKeptPublicConstructor (int unused) { }
 
-			private ClassWithKeptPublicConstructor(short unused) { }
+			private ClassWithKeptPublicConstructor (short unused) { }
 
-			public void Method() { }
+			public void Method () { }
 		}
 
 		[Kept]
 		class ClassWithKeptPublicMethods
 		{
 			[Kept]
-			public static void KeptMethod() { }
-			static void Method() { }
+			public static void KeptMethod () { }
+			static void Method () { }
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/AttributeFieldDataflow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/AttributeFieldDataflow.cs
index e7585bcec..e5a9d169e 100644
--- a/test/Mono.Linker.Tests.Cases/DataFlow/AttributeFieldDataflow.cs
+++ b/test/Mono.Linker.Tests.Cases/DataFlow/AttributeFieldDataflow.cs
@@ -17,7 +17,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		[KeptAttributeAttribute (typeof (KeepsPublicConstructorsAttribute))]
 		[KeptAttributeAttribute (typeof (KeepsPublicMethodsAttribute))]
 		[KeepsPublicConstructors (Type = typeof (ClassWithKeptPublicConstructor))]
-		[KeepsPublicMethods("Mono.Linker.Tests.Cases.DataFlow.AttributeFieldDataflow+ClassWithKeptPublicMethods")]
+		[KeepsPublicMethods ("Mono.Linker.Tests.Cases.DataFlow.AttributeFieldDataflow+ClassWithKeptPublicMethods")]
 		public static void Main ()
 		{
 			typeof (AttributeFieldDataflow).GetMethod ("Main").GetCustomAttribute (typeof (KeepsPublicConstructorsAttribute));
@@ -40,7 +40,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		}
 
 		[Kept]
-		[KeptBaseType(typeof(Attribute))]
+		[KeptBaseType (typeof (Attribute))]
 		class KeepsPublicMethodsAttribute : Attribute
 		{
 			[Kept]
@@ -67,8 +67,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		class ClassWithKeptPublicMethods
 		{
 			[Kept]
-			public static void KeptMethod() { }
-			static void Method() { }
+			public static void KeptMethod () { }
+			static void Method () { }
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/AttributePropertyDataflow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/AttributePropertyDataflow.cs
index 993a24c87..f2694905f 100644
--- a/test/Mono.Linker.Tests.Cases/DataFlow/AttributePropertyDataflow.cs
+++ b/test/Mono.Linker.Tests.Cases/DataFlow/AttributePropertyDataflow.cs
@@ -17,7 +17,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		[KeptAttributeAttribute (typeof (KeepsPublicConstructorsAttribute))]
 		[KeptAttributeAttribute (typeof (KeepsPublicMethodsAttribute))]
 		[KeepsPublicConstructors (Type = typeof (ClassWithKeptPublicConstructor))]
-		[KeepsPublicMethods("Mono.Linker.Tests.Cases.DataFlow.AttributePropertyDataflow+ClassWithKeptPublicMethods")]
+		[KeepsPublicMethods ("Mono.Linker.Tests.Cases.DataFlow.AttributePropertyDataflow+ClassWithKeptPublicMethods")]
 		public static void Main ()
 		{
 			typeof (AttributePropertyDataflow).GetMethod ("Main").GetCustomAttribute (typeof (KeepsPublicConstructorsAttribute));
@@ -41,7 +41,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		}
 
 		[Kept]
-		[KeptBaseType(typeof(Attribute))]
+		[KeptBaseType (typeof (Attribute))]
 		class KeepsPublicMethodsAttribute : Attribute
 		{
 			[Kept]
@@ -68,8 +68,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		class ClassWithKeptPublicMethods
 		{
 			[Kept]
-			public static void KeptMethod() { }
-			static void Method() { }
+			public static void KeptMethod () { }
+			static void Method () { }
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/ByRefDataflow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/ByRefDataflow.cs
index 7d7e3a011..c010e80cd 100644
--- a/test/Mono.Linker.Tests.Cases/DataFlow/ByRefDataflow.cs
+++ b/test/Mono.Linker.Tests.Cases/DataFlow/ByRefDataflow.cs
@@ -15,7 +15,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 	[Kept]
 	class ByRefDataflow
 	{
-		public static void Main()
+		public static void Main ()
 		{
 			{
 				Type t = typeof (ClassPassedToMethodTakingTypeByRef);
@@ -41,21 +41,21 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		static Type s_typeWithDefaultConstructor;
 
 		[Kept]
-		[UnrecognizedReflectionAccessPattern (typeof (ByRefDataflow), nameof (MethodWithRefParameter), new string [] { "System.Type&" })]
-		public static void PassRefToField()
+		[UnrecognizedReflectionAccessPattern (typeof (ByRefDataflow), nameof (MethodWithRefParameter), new string[] { "System.Type&" })]
+		public static void PassRefToField ()
 		{
 			MethodWithRefParameter (ref s_typeWithDefaultConstructor);
 		}
 
 		[Kept]
-		[UnrecognizedReflectionAccessPattern (typeof (ByRefDataflow), nameof (MethodWithRefParameter), new string [] { "System.Type&" })]
-		public static void PassRefToParameter(Type parameter)
+		[UnrecognizedReflectionAccessPattern (typeof (ByRefDataflow), nameof (MethodWithRefParameter), new string[] { "System.Type&" })]
+		public static void PassRefToParameter (Type parameter)
 		{
 			MethodWithRefParameter (ref parameter);
 		}
 
 		[Kept]
-		public static void MethodWithRefParameter(
+		public static void MethodWithRefParameter (
 			[KeptAttributeAttribute(typeof(DynamicallyAccessedMembersAttribute))]
 			[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.PublicMethods)]
 			ref Type type)
@@ -67,8 +67,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		class ClassPassedToMethodTakingTypeByRef
 		{
 			[Kept]
-			public static void KeptMethod() { }
-			internal static void RemovedMethod() { }
+			public static void KeptMethod () { }
+			internal static void RemovedMethod () { }
 		}
 
 		[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/FieldDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/FieldDataFlow.cs
index b4d25ba0e..d26143acc 100644
--- a/test/Mono.Linker.Tests.Cases/DataFlow/FieldDataFlow.cs
+++ b/test/Mono.Linker.Tests.Cases/DataFlow/FieldDataFlow.cs
@@ -32,19 +32,19 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			instance.WriteToStaticFieldOnADifferentClass ();
 		}
 
-		[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.DefaultConstructor)]
+		[DynamicallyAccessedMembers (DynamicallyAccessedMemberKinds.DefaultConstructor)]
 		Type _typeWithDefaultConstructor;
 
 		[DynamicallyAccessedMembers (DynamicallyAccessedMemberKinds.DefaultConstructor)]
 		static Type _staticTypeWithDefaultConstructor;
 
-		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequirePublicConstructors), new Type [] { typeof (Type) },
+		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) },
 			"The field 'System.Type Mono.Linker.Tests.Cases.DataFlow.FieldDataFlow::_typeWithDefaultConstructor' " +
 			"with dynamically accessed member kinds 'DefaultConstructor' is passed into " +
 			"the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.FieldDataFlow::RequirePublicConstructors(System.Type)' " +
 			"which requires dynamically accessed member kinds `PublicConstructors`. " +
 			"To fix this add DynamicallyAccessedMembersAttribute to it and specify at least these member kinds 'PublicConstructors'.")]
-		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequireConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequireConstructors), new Type[] { typeof (Type) })]
 		private void ReadFromInstanceField ()
 		{
 			RequireDefaultConstructor (_typeWithDefaultConstructor);
@@ -53,7 +53,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireNothing (_typeWithDefaultConstructor);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (WriteToInstanceField), new Type [] { })]
+		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (WriteToInstanceField), new Type[] { })]
 		private void WriteToInstanceField ()
 		{
 			_typeWithDefaultConstructor = GetTypeWithDefaultConstructor ();
@@ -62,8 +62,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			_typeWithDefaultConstructor = GetUnkownType ();
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequirePublicConstructors), new Type [] { typeof (Type) })]
-		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequireConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequireConstructors), new Type[] { typeof (Type) })]
 		private void ReadFromInstanceFieldOnADifferentClass ()
 		{
 			var store = new TypeStore ();
@@ -74,7 +74,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireNothing (store._typeWithDefaultConstructor);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (WriteToInstanceFieldOnADifferentClass), new Type [] { })]
+		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (WriteToInstanceFieldOnADifferentClass), new Type[] { })]
 		private void WriteToInstanceFieldOnADifferentClass ()
 		{
 			var store = new TypeStore ();
@@ -85,8 +85,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			store._typeWithDefaultConstructor = GetUnkownType ();
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequirePublicConstructors), new Type [] { typeof (Type) })]
-		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequireConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequireConstructors), new Type[] { typeof (Type) })]
 		private void ReadFromStaticField ()
 		{
 			RequireDefaultConstructor (_staticTypeWithDefaultConstructor);
@@ -95,7 +95,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireNothing (_staticTypeWithDefaultConstructor);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (WriteToStaticField), new Type [] { })]
+		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (WriteToStaticField), new Type[] { })]
 		private void WriteToStaticField ()
 		{
 			_staticTypeWithDefaultConstructor = GetTypeWithDefaultConstructor ();
@@ -104,8 +104,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			_staticTypeWithDefaultConstructor = GetUnkownType ();
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequirePublicConstructors), new Type [] { typeof (Type) })]
-		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequireConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequireConstructors), new Type[] { typeof (Type) })]
 		private void ReadFromStaticFieldOnADifferentClass ()
 		{
 			RequireDefaultConstructor (TypeStore._staticTypeWithDefaultConstructor);
@@ -114,7 +114,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireNothing (TypeStore._staticTypeWithDefaultConstructor);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (WriteToStaticFieldOnADifferentClass), new Type [] { })]
+		[UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (WriteToStaticFieldOnADifferentClass), new Type[] { })]
 		private void WriteToStaticFieldOnADifferentClass ()
 		{
 			TypeStore._staticTypeWithDefaultConstructor = GetTypeWithDefaultConstructor ();
diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/GetTypeDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/GetTypeDataFlow.cs
index 6e527181f..633edeaf9 100644
--- a/test/Mono.Linker.Tests.Cases/DataFlow/GetTypeDataFlow.cs
+++ b/test/Mono.Linker.Tests.Cases/DataFlow/GetTypeDataFlow.cs
@@ -34,8 +34,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			//    Type.GetType over two params
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequirePublicConstructors), new Type [] { typeof (Type) })]
-		[UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequireConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequireConstructors), new Type[] { typeof (Type) })]
 		static void TestDefaultConstructor ()
 		{
 			Type type = Type.GetType (GetStringTypeWithDefaultConstructor ());
@@ -45,7 +45,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireNothing (type);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequireConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequireConstructors), new Type[] { typeof (Type) })]
 		static void TestPublicConstructors ()
 		{
 			Type type = Type.GetType (GetStringTypeWithPublicConstructors ());
@@ -65,13 +65,13 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireNothing (type);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (Type), nameof (GetType), new Type [] { typeof (string) })]
+		[UnrecognizedReflectionAccessPattern (typeof (Type), nameof (GetType), new Type[] { typeof (string) })]
 		static void TestUnknownType ()
 		{
 			Type type = Type.GetType (GetStringUnkownType ());
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequirePublicConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })]
 		static void TestTypeNameFromParameter (
 			[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.DefaultConstructor)]
 			string typeName)
@@ -79,10 +79,10 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequirePublicConstructors (Type.GetType (typeName));
 		}
 
-		[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.DefaultConstructor)]
+		[DynamicallyAccessedMembers (DynamicallyAccessedMemberKinds.DefaultConstructor)]
 		static string _typeNameWithDefaultConstructor;
 
-		[UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequirePublicConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })]
 		static void TestTypeNameFromField ()
 		{
 			RequirePublicConstructors (Type.GetType (_typeNameWithDefaultConstructor));
@@ -94,47 +94,47 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		{
 			string typeName = null;
 			switch (_switchOnField) {
-				case 0: // valid
-					typeName = "Mono.Linker.Tests.Cases.DataFlow.GetTypeDataFlow";
-					break;
-				case 1: // null
-					typeName = null;
-					break;
-				case 2: // invalid
-					typeName = "UnknownType";
-					break;
-				case 3: // invalid second
-					typeName = "AnotherUnknownType";
-					break;
+			case 0: // valid
+				typeName = "Mono.Linker.Tests.Cases.DataFlow.GetTypeDataFlow";
+				break;
+			case 1: // null
+				typeName = null;
+				break;
+			case 2: // invalid
+				typeName = "UnknownType";
+				break;
+			case 3: // invalid second
+				typeName = "AnotherUnknownType";
+				break;
 			}
 
 			Type.GetType (typeName);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequireConstructors), new Type [] { typeof (Type) },
+		[UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequireConstructors), new Type[] { typeof (Type) },
 			"The method return value with dynamically accessed member kinds 'DefaultConstructor' is passed into " +
 			"the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.GetTypeDataFlow::RequireConstructors(System.Type)' " +
 			"which requires dynamically accessed member kinds `Constructors`. " +
 			"To fix this add DynamicallyAccessedMembersAttribute to it and specify at least these member kinds 'Constructors'.")]
-		[UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetType), new Type [] { typeof (string) },
+		[UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetType), new Type[] { typeof (string) },
 			"Reflection call 'System.Type System.Type::GetType(System.String)' inside 'System.Void Mono.Linker.Tests.Cases.DataFlow.GetTypeDataFlow::TestMultipleMixedValues()' " +
 			"was detected with unknown value for the type name.")]
 		static void TestMultipleMixedValues ()
 		{
 			string typeName = null;
 			switch (_switchOnField) {
-				case 0:
-					typeName = GetStringTypeWithDefaultConstructor ();
-					break;
-				case 1:
-					typeName = GetStringTypeWithConstructors ();
-					break;
-				case 2:
-					typeName = "Mono.Linker.Tests.Cases.DataFlow.GetTypeDataFlow";
-					break;
-				case 3:
-					typeName = GetStringUnkownType ();
-					break;
+			case 0:
+				typeName = GetStringTypeWithDefaultConstructor ();
+				break;
+			case 1:
+				typeName = GetStringTypeWithConstructors ();
+				break;
+			case 2:
+				typeName = "Mono.Linker.Tests.Cases.DataFlow.GetTypeDataFlow";
+				break;
+			case 3:
+				typeName = GetStringUnkownType ();
+				break;
 			}
 
 			RequireConstructors (Type.GetType (typeName));
diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/JsonAnnotations.cs b/test/Mono.Linker.Tests.Cases/DataFlow/JsonAnnotations.cs
index fa344561f..fb3584d30 100644
--- a/test/Mono.Linker.Tests.Cases/DataFlow/JsonAnnotations.cs
+++ b/test/Mono.Linker.Tests.Cases/DataFlow/JsonAnnotations.cs
@@ -15,7 +15,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 	[SetupLinkerAttributeDefinitionsFile ("JsonAnnotations.json")]
 	class JsonAnnotations
 	{
-		public static void Main()
+		public static void Main ()
 		{
 			var instance = new JsonAnnotations ();
 
@@ -29,8 +29,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 
 		Type PropertyWithDefaultConstructor { get; set; }
 
-		[UnrecognizedReflectionAccessPattern (typeof (JsonAnnotations), nameof (RequirePublicConstructors), new Type [] { typeof (Type) })]
-		[UnrecognizedReflectionAccessPattern (typeof (JsonAnnotations), nameof (RequireConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (JsonAnnotations), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (JsonAnnotations), nameof (RequireConstructors), new Type[] { typeof (Type) })]
 		private void ReadFromInstanceField ()
 		{
 			RequireDefaultConstructor (_typeWithDefaultConstructor);
@@ -38,7 +38,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireConstructors (_typeWithDefaultConstructor);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (JsonAnnotations), nameof (RequirePublicConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (JsonAnnotations), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })]
 		private void TwoAnnotatedParameters (
 			Type type,
 			Type type2)
@@ -49,15 +49,15 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequirePublicConstructors (type2);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (JsonAnnotations), nameof (ReturnConstructorsFailure), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (JsonAnnotations), nameof (ReturnConstructorsFailure), new Type[] { typeof (Type) })]
 		private Type ReturnConstructorsFailure (
 			Type defaultConstructorType)
 		{
 			return defaultConstructorType;
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (JsonAnnotations), nameof (RequirePublicConstructors), new Type [] { typeof (Type) })]
-		[UnrecognizedReflectionAccessPattern (typeof (JsonAnnotations), nameof (RequireConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (JsonAnnotations), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (JsonAnnotations), nameof (RequireConstructors), new Type[] { typeof (Type) })]
 		private void ReadFromInstanceProperty ()
 		{
 			RequireDefaultConstructor (PropertyWithDefaultConstructor);
diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/LocalDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/LocalDataFlow.cs
index cbd110385..819d5ca24 100644
--- a/test/Mono.Linker.Tests.Cases/DataFlow/LocalDataFlow.cs
+++ b/test/Mono.Linker.Tests.Cases/DataFlow/LocalDataFlow.cs
@@ -37,13 +37,13 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			TestBackwardsEdgeLoop ();
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type [] { typeof (string) },
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type[] { typeof (string) },
 			"The return value of method 'System.String Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::GetWithMethods()' " +
 			"with dynamically accessed member kinds 'Methods' " +
 			"is passed into the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::RequireFields(System.String)' " +
 			"which requires dynamically accessed member kinds `Fields`. " +
 			"To fix this add DynamicallyAccessedMembersAttribute to it and specify at least these member kinds 'Fields'.")]
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type [] { typeof (string) },
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type[] { typeof (string) },
 			"The return value of method 'System.String Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::GetWithFields()' " +
 			"with dynamically accessed member kinds 'Fields' " +
 			"is passed into the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::RequireMethods(System.String)' " +
@@ -56,18 +56,18 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 				goto End;
 			str = GetWithFields ();
 
-			End:
+		End:
 			RequireFields (str); // warns for GetWithMethods
 			RequireMethods (str); // warns for GetWithFields
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type [] { typeof (string) },
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type[] { typeof (string) },
 			"The return value of method 'System.String Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::GetWithMethods()' " +
 			"with dynamically accessed member kinds 'Methods' " +
 			"is passed into the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::RequireFields(System.String)' " +
 			"which requires dynamically accessed member kinds `Fields`. " +
 			"To fix this add DynamicallyAccessedMembersAttribute to it and specify at least these member kinds 'Fields'.")]
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type [] { typeof (string) },
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type[] { typeof (string) },
 			"The return value of method 'System.String Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::GetWithFields()' " +
 			"with dynamically accessed member kinds 'Fields' " +
 			"is passed into the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::RequireMethods(System.String)' " +
@@ -83,13 +83,13 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireMethods (str); // warns for GetWithFields
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type [] { typeof (string) },
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type[] { typeof (string) },
 			"The return value of method 'System.String Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::GetWithMethods()' " +
 			"with dynamically accessed member kinds 'Methods' " +
 			"is passed into the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::RequireFields(System.String)' " +
 			"which requires dynamically accessed member kinds `Fields`. " +
 			"To fix this add DynamicallyAccessedMembersAttribute to it and specify at least these member kinds 'Fields'.")]
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type [] { typeof (string) },
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type[] { typeof (string) },
 			"The return value of method 'System.String Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::GetWithFields()' " +
 			"with dynamically accessed member kinds 'Fields' " +
 			"is passed into the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::RequireMethods(System.String)' " +
@@ -109,19 +109,19 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 
 		static int _switchOnField;
 
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type [] { typeof (string) },
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type[] { typeof (string) },
 			"The return value of method 'System.String Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::GetWithFields()' " +
 			"with dynamically accessed member kinds 'Fields' " +
 			"is passed into the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::RequireMethods(System.String)' " +
 			"which requires dynamically accessed member kinds `Methods`. " +
 			"To fix this add DynamicallyAccessedMembersAttribute to it and specify at least these member kinds 'Methods'.")]
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type [] { typeof (string) },
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type[] { typeof (string) },
 			"The return value of method 'System.String Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::GetWithPublicMethods()' " +
 			"with dynamically accessed member kinds 'PublicMethods' " +
 			"is passed into the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::RequireMethods(System.String)' " +
 			"which requires dynamically accessed member kinds `Methods`. " +
 			"To fix this add DynamicallyAccessedMembersAttribute to it and specify at least these member kinds 'Methods'.")]
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type [] { typeof (string) },
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type[] { typeof (string) },
 			"The return value of method 'System.String Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::GetWithConstructors()' " +
 			"with dynamically accessed member kinds 'Constructors' " +
 			"is passed into the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::RequireMethods(System.String)' " +
@@ -147,13 +147,13 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireMethods (str); // warns for GetWithFields, GetWithPublicMethods, and GetWithConstructors
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type [] { typeof (string) },
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type[] { typeof (string) },
 			"The return value of method 'System.String Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::GetWithMethods()' " +
 			"with dynamically accessed member kinds 'Methods' " +
 			"is passed into the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::RequireFields(System.String)' " +
 			"which requires dynamically accessed member kinds `Fields`. " +
 			"To fix this add DynamicallyAccessedMembersAttribute to it and specify at least these member kinds 'Fields'.")]
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type [] { typeof (string) },
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type[] { typeof (string) },
 			"The return value of method 'System.String Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::GetWithFields()' " +
 			"with dynamically accessed member kinds 'Fields' " +
 			"is passed into the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::RequireMethods(System.String)' " +
@@ -173,13 +173,13 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireMethods (str); // warns for GetWithFields
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type [] { typeof (string) },
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type[] { typeof (string) },
 			"The return value of method 'System.String Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::GetWithMethods()' " +
 			"with dynamically accessed member kinds 'Methods' " +
 			"is passed into the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::RequireFields(System.String)' " +
 			"which requires dynamically accessed member kinds `Fields`. " +
 			"To fix this add DynamicallyAccessedMembersAttribute to it and specify at least these member kinds 'Fields'.")]
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type [] { typeof (string) },
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type[] { typeof (string) },
 			"The return value of method 'System.String Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::GetWithFields()' " +
 			"with dynamically accessed member kinds 'Fields' " +
 			"is passed into the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::RequireMethods(System.String)' " +
@@ -198,13 +198,13 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireMethods (str); // warns for GetWithFields
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type [] { typeof (string) },
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type[] { typeof (string) },
 			"The return value of method 'System.String Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::GetWithMethods()' " +
 			"with dynamically accessed member kinds 'Methods' " +
 			"is passed into the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::RequireFields(System.String)' " +
 			"which requires dynamically accessed member kinds `Fields`. " +
 			"To fix this add DynamicallyAccessedMembersAttribute to it and specify at least these member kinds 'Fields'.")]
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type [] { typeof (string) },
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type[] { typeof (string) },
 			"The return value of method 'System.String Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::GetWithFields()' " +
 			"with dynamically accessed member kinds 'Fields' " +
 			"is passed into the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow::RequireMethods(System.String)' " +
@@ -224,7 +224,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireMethods (str); // warns for GetWithFields
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type [] { typeof (string) })]
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type[] { typeof (string) })]
 		public static void TestBranchGoto ()
 		{
 			string str = GetWithMethods ();
@@ -232,11 +232,11 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 				goto End;
 			str = GetWithFields ();
 			RequireFields (str); // produces a warning
-			End:
+		End:
 			return;
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type [] { typeof (string) })]
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type[] { typeof (string) })]
 		public static void TestBranchIf ()
 		{
 			string str = GetWithMethods ();
@@ -246,7 +246,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			}
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type [] { typeof (string) })]
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type[] { typeof (string) })]
 		public static void TestBranchIfElse ()
 		{
 			string str;
@@ -261,11 +261,11 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			}
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type [] { typeof (string) })]
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicMethods), new Type [] { typeof (string) })]
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireConstructors), new Type [] { typeof (string) })]
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireConstructors), new Type [] { typeof (string) })]
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireConstructors), new Type [] { typeof (string) })]
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireMethods), new Type[] { typeof (string) })]
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicMethods), new Type[] { typeof (string) })]
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireConstructors), new Type[] { typeof (string) })]
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireConstructors), new Type[] { typeof (string) })]
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireConstructors), new Type[] { typeof (string) })]
 		public static void TestBranchSwitch ()
 		{
 			string str = null;
@@ -289,7 +289,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			}
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type [] { typeof (string) })]
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type[] { typeof (string) })]
 		public static void TestBranchTry ()
 		{
 			string str = GetWithMethods ();
@@ -303,7 +303,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			}
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type [] { typeof (string) })]
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type[] { typeof (string) })]
 		public static void TestBranchCatch ()
 		{
 			string str = GetWithMethods ();
@@ -316,7 +316,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			}
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type [] { typeof (string) })]
+		[UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireFields), new Type[] { typeof (string) })]
 		public static void TestBranchFinally ()
 		{
 			string str = GetWithMethods ();
@@ -349,11 +349,11 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		{
 			string str = null;
 			goto ForwardTarget;
-			BackwardTarget:
+		BackwardTarget:
 			RequireMethods (str); // should warn for the value that comes from GetWithFields, but it doesn't.
 			return;
 
-			ForwardTarget:
+		ForwardTarget:
 			str = GetWithFields ();
 			goto BackwardTarget;
 		}
@@ -381,23 +381,27 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		{
 		}
 
-		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.Fields)]
-		public static string GetWithFields () {
+		[return: DynamicallyAccessedMembers (DynamicallyAccessedMemberKinds.Fields)]
+		public static string GetWithFields ()
+		{
 			return null;
 		}
 
-		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.Methods)]
-		public static string GetWithMethods () {
+		[return: DynamicallyAccessedMembers (DynamicallyAccessedMemberKinds.Methods)]
+		public static string GetWithMethods ()
+		{
 			return null;
 		}
 
-		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.PublicMethods)]
-		public static string GetWithPublicMethods () {
+		[return: DynamicallyAccessedMembers (DynamicallyAccessedMemberKinds.PublicMethods)]
+		public static string GetWithPublicMethods ()
+		{
 			return null;
 		}
 
-		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.Constructors)]
-		public static string GetWithConstructors () {
+		[return: DynamicallyAccessedMembers (DynamicallyAccessedMemberKinds.Constructors)]
+		public static string GetWithConstructors ()
+		{
 			return null;
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/LocalDataFlowKeptMembers.cs b/test/Mono.Linker.Tests.Cases/DataFlow/LocalDataFlowKeptMembers.cs
index 94738961f..82edc7f32 100644
--- a/test/Mono.Linker.Tests.Cases/DataFlow/LocalDataFlowKeptMembers.cs
+++ b/test/Mono.Linker.Tests.Cases/DataFlow/LocalDataFlowKeptMembers.cs
@@ -29,7 +29,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 				goto End;
 			t = typeof (BranchMergeGotoType2);
 
-			End:
+		End:
 			RequireFields (t); // keeps fields for both types
 		}
 
@@ -129,7 +129,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 				goto End;
 			t = typeof (BranchGotoType2);
 			RequireFields (t);
-			End:
+		End:
 			return;
 		}
 
diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/MethodParametersDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/MethodParametersDataFlow.cs
index 22ccca8b7..45c721e0a 100644
--- a/test/Mono.Linker.Tests.Cases/DataFlow/MethodParametersDataFlow.cs
+++ b/test/Mono.Linker.Tests.Cases/DataFlow/MethodParametersDataFlow.cs
@@ -27,7 +27,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			LongWriteToParameterOnStaticMethod (0, 0, 0, 0, null);
 			instance.InstanceMethod (typeof (TestType));
 			instance.TwoAnnotatedParameters (typeof (TestType), typeof (TestType));
-			instance.TwoAnnotatedParametersIntoOneValue(typeof (TestType), typeof (TestType));
+			instance.TwoAnnotatedParametersIntoOneValue (typeof (TestType), typeof (TestType));
 			instance.NoAnnotation (typeof (TestType));
 			instance.UnknownValue ();
 			instance.AnnotatedValueToUnAnnotatedParameter (typeof (TestType));
@@ -38,13 +38,13 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		}
 
 		// Validate the error message when annotated parameter is passed to another annotated parameter
-		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequirePublicConstructors), new Type [] { typeof (Type) },
+		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) },
 			"The parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.MethodParametersDataFlow::DefaultConstructorParameter(System.Type)' " +
 			"with dynamically accessed member kinds 'DefaultConstructor' is passed into the parameter 'type' " +
 			"of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.MethodParametersDataFlow::RequirePublicConstructors(System.Type)' " +
 			"which requires dynamically accessed member kinds `PublicConstructors`. " +
 			"To fix this add DynamicallyAccessedMembersAttribute to it and specify at least these member kinds 'PublicConstructors'.")]
-		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequireConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequireConstructors), new Type[] { typeof (Type) })]
 		private static void DefaultConstructorParameter (
 			[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.DefaultConstructor)]
 			Type type)
@@ -54,7 +54,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireConstructors (type);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequireConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequireConstructors), new Type[] { typeof (Type) })]
 		private static void PublicConstructorsParameter (
 			[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.PublicConstructors)]
 			Type type)
@@ -74,7 +74,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireConstructors (type);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequirePublicConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })]
 		private void InstanceMethod (
 			[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.DefaultConstructor)]
 			Type type)
@@ -83,7 +83,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequirePublicConstructors (type);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (WriteToParameterOnInstanceMethod), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (WriteToParameterOnInstanceMethod), new Type[] { typeof (Type) })]
 		private void WriteToParameterOnInstanceMethod (
 			[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.Constructors)]
 			Type type)
@@ -91,7 +91,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			type = ReturnThingsWithDefaultConstructor ();
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (WriteToParameterOnStaticMethod), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (WriteToParameterOnStaticMethod), new Type[] { typeof (Type) })]
 		private static void WriteToParameterOnStaticMethod (
 			[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.Constructors)]
 			Type type)
@@ -99,7 +99,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			type = ReturnThingsWithDefaultConstructor ();
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (LongWriteToParameterOnInstanceMethod), new Type [] { typeof(int), typeof (int), typeof (int), typeof (int), typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (LongWriteToParameterOnInstanceMethod), new Type[] { typeof (int), typeof (int), typeof (int), typeof (int), typeof (Type) })]
 		private void LongWriteToParameterOnInstanceMethod (
 			int a, int b, int c, int d,
 			[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.Constructors)]
@@ -108,7 +108,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			type = ReturnThingsWithDefaultConstructor ();
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (LongWriteToParameterOnStaticMethod), new Type [] { typeof (int), typeof (int), typeof (int), typeof (int), typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (LongWriteToParameterOnStaticMethod), new Type[] { typeof (int), typeof (int), typeof (int), typeof (int), typeof (Type) })]
 		private static void LongWriteToParameterOnStaticMethod (
 			int a, int b, int c, int d,
 			[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.Constructors)]
@@ -118,12 +118,12 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		}
 
 		[return: DynamicallyAccessedMembers (DynamicallyAccessedMemberKinds.DefaultConstructor)]
-		static private Type ReturnThingsWithDefaultConstructor()
+		static private Type ReturnThingsWithDefaultConstructor ()
 		{
 			return null;
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequirePublicConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })]
 		private void TwoAnnotatedParameters (
 			[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.DefaultConstructor)]
 			Type type,
@@ -136,7 +136,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequirePublicConstructors (type2);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequirePublicConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })]
 		private void TwoAnnotatedParametersIntoOneValue (
 			[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.DefaultConstructor)]
 			Type type,
@@ -149,7 +149,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		}
 
 		// Validate the error message for the case of unannotated method return value passed to an annotated parameter.
-		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequireDefaultConstructor), new Type [] { typeof (Type) },
+		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequireDefaultConstructor), new Type[] { typeof (Type) },
 			"The parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.MethodParametersDataFlow::NoAnnotation(System.Type)' " +
 			"with dynamically accessed member kinds 'None' is passed into " +
 			"the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.MethodParametersDataFlow::RequireDefaultConstructor(System.Type)' " +
@@ -161,16 +161,16 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		}
 
 		// Validate error message when untracable value is passed to an annotated parameter.
-		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequireDefaultConstructor), new Type [] { typeof (Type) },
+		[UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequireDefaultConstructor), new Type[] { typeof (Type) },
 			"A value from unknown source is passed " +
 			"into the parameter 'type' of method 'System.Void Mono.Linker.Tests.Cases.DataFlow.MethodParametersDataFlow::RequireDefaultConstructor(System.Type)' " +
 			"which requires dynamically accessed member kinds `DefaultConstructor`. " +
 			"It's not possible to guarantee that these requirements are met by the application.")]
 		private void UnknownValue ()
 		{
-			var array = new object [1];
-			array [0] = this.GetType ();
-			RequireDefaultConstructor ((Type)array [0]);
+			var array = new object[1];
+			array[0] = this.GetType ();
+			RequireDefaultConstructor ((Type) array[0]);
 		}
 
 		[RecognizedReflectionAccessPattern]
@@ -184,7 +184,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		[RecognizedReflectionAccessPattern]
 		private void UnknownValueToUnAnnotatedParameter ()
 		{
-			RequireNothing (this.GetType());
+			RequireNothing (this.GetType ());
 		}
 
 		[RecognizedReflectionAccessPattern]
@@ -224,7 +224,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 
 		class TestType
 		{
-			public TestType() { }
+			public TestType () { }
 			public TestType (int arg) { }
 			private TestType (int arg1, int arg2) { }
 		}
diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/MethodReturnParameterDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/MethodReturnParameterDataFlow.cs
index 2ab732604..a4d036181 100644
--- a/test/Mono.Linker.Tests.Cases/DataFlow/MethodReturnParameterDataFlow.cs
+++ b/test/Mono.Linker.Tests.Cases/DataFlow/MethodReturnParameterDataFlow.cs
@@ -16,7 +16,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 	[SkipKeptItemsValidation]
 	public class MethodReturnParameterDataFlow
 	{
-		public static void Main()
+		public static void Main ()
 		{
 			var instance = new MethodReturnParameterDataFlow ();
 
@@ -50,20 +50,20 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			Type constructorsType)
 		{
 			switch (GetHashCode ()) {
-				case 1:
-					return defaultConstructorType;
-				case 2:
-					return publicConstructorsType;
-				case 3:
-					return constructorsType;
-				case 4:
-					return typeof (TestType);
-				default:
-					return null;
+			case 1:
+				return defaultConstructorType;
+			case 2:
+				return publicConstructorsType;
+			case 3:
+				return constructorsType;
+			case 4:
+				return typeof (TestType);
+			default:
+				return null;
 			}
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (ReturnDefaultConstructorFromUnknownType), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (ReturnDefaultConstructorFromUnknownType), new Type[] { typeof (Type) })]
 		[return: DynamicallyAccessedMembers (DynamicallyAccessedMemberKinds.DefaultConstructor)]
 		private Type ReturnDefaultConstructorFromUnknownType (Type unknownType)
 		{
@@ -85,7 +85,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		}
 
 		// Validate error message when insufficiently annotated value is returned from a method
-		[UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (ReturnPublicConstructorsFailure), new Type [] { typeof (Type) },
+		[UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (ReturnPublicConstructorsFailure), new Type[] { typeof (Type) },
 			"The parameter 'defaultConstructorType' of method 'System.Type Mono.Linker.Tests.Cases.DataFlow.MethodReturnParameterDataFlow::ReturnPublicConstructorsFailure(System.Type)' " +
 			"with dynamically accessed member kinds 'DefaultConstructor' is " +
 			"passed into the return value of method 'System.Type Mono.Linker.Tests.Cases.DataFlow.MethodReturnParameterDataFlow::ReturnPublicConstructorsFailure(System.Type)' " +
@@ -99,7 +99,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			return defaultConstructorType;
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (ReturnConstructorsFailure), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (ReturnConstructorsFailure), new Type[] { typeof (Type) })]
 		[return: DynamicallyAccessedMembers (DynamicallyAccessedMemberKinds.Constructors)]
 		private Type ReturnConstructorsFailure (
 			[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.PublicConstructors)]
@@ -108,9 +108,9 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			return publicConstructorsType;
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (RequirePublicConstructors), new Type [] { typeof (Type) })]
-		[UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (RequireConstructors), new Type [] { typeof (Type) })]
-		private void PropagateReturnDefaultConstructor()
+		[UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (RequireConstructors), new Type[] { typeof (Type) })]
+		private void PropagateReturnDefaultConstructor ()
 		{
 			Type t = ReturnDefaultConstructor (typeof (TestType), typeof (TestType), typeof (TestType));
 			RequireDefaultConstructor (t);
@@ -119,8 +119,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireNothing (t);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (RequirePublicConstructors), new Type [] { typeof (Type) })]
-		[UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (RequireConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (RequireConstructors), new Type[] { typeof (Type) })]
 		private void PropagateReturnDefaultConstructorFromConstant ()
 		{
 			Type t = ReturnDefaultConstructorFromConstant ();
diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/MethodThisDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/MethodThisDataFlow.cs
index f1ef1d0b8..90ad367f5 100644
--- a/test/Mono.Linker.Tests.Cases/DataFlow/MethodThisDataFlow.cs
+++ b/test/Mono.Linker.Tests.Cases/DataFlow/MethodThisDataFlow.cs
@@ -22,7 +22,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			PropagateToThisWithSetters ();
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (TypeTest), nameof (TypeTest.RequireThisMethods), new Type [] { },
+		[UnrecognizedReflectionAccessPattern (typeof (TypeTest), nameof (TypeTest.RequireThisMethods), new Type[] { },
 			"The return value of method 'System.TypeTest Mono.Linker.Tests.Cases.DataFlow.MethodThisDataFlow::GetWithPublicMethods()' " +
 			"with dynamically accessed member kinds 'PublicMethods' " +
 			"is passed into the implicit 'this' parameter of method 'System.Void System.TypeTest::RequireThisMethods()' " +
@@ -37,7 +37,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			GetWithMethods ().RequireThisMethods ();
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (TypeTest), "get_" + nameof (TypeTest.PropertyRequireThisMethods), new Type [] { },
+		[UnrecognizedReflectionAccessPattern (typeof (TypeTest), "get_" + nameof (TypeTest.PropertyRequireThisMethods), new Type[] { },
  			"The return value of method 'System.TypeTest Mono.Linker.Tests.Cases.DataFlow.MethodThisDataFlow::GetWithPublicMethods()' " +
  			"with dynamically accessed member kinds 'PublicMethods' " +
  			"is passed into the implicit 'this' parameter of method 'System.Object System.TypeTest::get_PropertyRequireThisMethods()' " +
@@ -52,7 +52,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			_ = GetWithMethods ().PropertyRequireThisMethods;
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (TypeTest), "set_" + nameof (TypeTest.PropertyRequireThisMethods), new Type [] { typeof(Object) },
+		[UnrecognizedReflectionAccessPattern (typeof (TypeTest), "set_" + nameof (TypeTest.PropertyRequireThisMethods), new Type[] { typeof (Object) },
  			"The return value of method 'System.TypeTest Mono.Linker.Tests.Cases.DataFlow.MethodThisDataFlow::GetWithPublicMethods()' " +
  			"with dynamically accessed member kinds 'PublicMethods' " +
  			"is passed into the implicit 'this' parameter of method 'System.Void System.TypeTest::set_PropertyRequireThisMethods(System.Object)' " +
@@ -85,7 +85,7 @@ namespace System
 	class TypeTest : Type
 	{
 		[DynamicallyAccessedMembers (DynamicallyAccessedMemberKinds.PublicMethods)]
-		[UnrecognizedReflectionAccessPattern (typeof (TypeTest), nameof (RequireMethods), new Type [] { typeof (Type) },
+		[UnrecognizedReflectionAccessPattern (typeof (TypeTest), nameof (RequireMethods), new Type[] { typeof (Type) },
 			"The implicit 'this' parameter of method 'System.Void System.TypeTest::RequireThisPublicMethods()' " +
 			"with dynamically accessed member kinds 'PublicMethods' " +
 			"is passed into the parameter 'type' of method 'System.Void System.TypeTest::RequireMethods(System.Type)' " +
@@ -157,17 +157,17 @@ namespace System
 
 		public override string Name => throw new NotImplementedException ();
 
-		public override ConstructorInfo [] GetConstructors (BindingFlags bindingAttr)
+		public override ConstructorInfo[] GetConstructors (BindingFlags bindingAttr)
 		{
 			throw new NotImplementedException ();
 		}
 
-		public override object [] GetCustomAttributes (bool inherit)
+		public override object[] GetCustomAttributes (bool inherit)
 		{
 			throw new NotImplementedException ();
 		}
 
-		public override object [] GetCustomAttributes (Type attributeType, bool inherit)
+		public override object[] GetCustomAttributes (Type attributeType, bool inherit)
 		{
 			throw new NotImplementedException ();
 		}
@@ -182,7 +182,7 @@ namespace System
 			throw new NotImplementedException ();
 		}
 
-		public override EventInfo [] GetEvents (BindingFlags bindingAttr)
+		public override EventInfo[] GetEvents (BindingFlags bindingAttr)
 		{
 			throw new NotImplementedException ();
 		}
@@ -192,7 +192,7 @@ namespace System
 			throw new NotImplementedException ();
 		}
 
-		public override FieldInfo [] GetFields (BindingFlags bindingAttr)
+		public override FieldInfo[] GetFields (BindingFlags bindingAttr)
 		{
 			throw new NotImplementedException ();
 		}
@@ -202,17 +202,17 @@ namespace System
 			throw new NotImplementedException ();
 		}
 
-		public override Type [] GetInterfaces ()
+		public override Type[] GetInterfaces ()
 		{
 			throw new NotImplementedException ();
 		}
 
-		public override MemberInfo [] GetMembers (BindingFlags bindingAttr)
+		public override MemberInfo[] GetMembers (BindingFlags bindingAttr)
 		{
 			throw new NotImplementedException ();
 		}
 
-		public override MethodInfo [] GetMethods (BindingFlags bindingAttr)
+		public override MethodInfo[] GetMethods (BindingFlags bindingAttr)
 		{
 			throw new NotImplementedException ();
 		}
@@ -222,17 +222,17 @@ namespace System
 			throw new NotImplementedException ();
 		}
 
-		public override Type [] GetNestedTypes (BindingFlags bindingAttr)
+		public override Type[] GetNestedTypes (BindingFlags bindingAttr)
 		{
 			throw new NotImplementedException ();
 		}
 
-		public override PropertyInfo [] GetProperties (BindingFlags bindingAttr)
+		public override PropertyInfo[] GetProperties (BindingFlags bindingAttr)
 		{
 			throw new NotImplementedException ();
 		}
 
-		public override object InvokeMember (string name, BindingFlags invokeAttr, Binder binder, object target, object [] args, ParameterModifier [] modifiers, CultureInfo culture, string [] namedParameters)
+		public override object InvokeMember (string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters)
 		{
 			throw new NotImplementedException ();
 		}
@@ -247,17 +247,17 @@ namespace System
 			throw new NotImplementedException ();
 		}
 
-		protected override ConstructorInfo GetConstructorImpl (BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type [] types, ParameterModifier [] modifiers)
+		protected override ConstructorInfo GetConstructorImpl (BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
 		{
 			throw new NotImplementedException ();
 		}
 
-		protected override MethodInfo GetMethodImpl (string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type [] types, ParameterModifier [] modifiers)
+		protected override MethodInfo GetMethodImpl (string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
 		{
 			throw new NotImplementedException ();
 		}
 
-		protected override PropertyInfo GetPropertyImpl (string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type [] types, ParameterModifier [] modifiers)
+		protected override PropertyInfo GetPropertyImpl (string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
 		{
 			throw new NotImplementedException ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/PropertyDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/PropertyDataFlow.cs
index 676ba6523..99e47f754 100644
--- a/test/Mono.Linker.Tests.Cases/DataFlow/PropertyDataFlow.cs
+++ b/test/Mono.Linker.Tests.Cases/DataFlow/PropertyDataFlow.cs
@@ -40,7 +40,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		[DynamicallyAccessedMembers (DynamicallyAccessedMemberKinds.PublicConstructors)]
 		static Type StaticPropertyWithPublicConstructor { get; set; }
 
-		[UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), nameof (RequireConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), nameof (RequireConstructors), new Type[] { typeof (Type) })]
 		private void ReadFromInstanceProperty ()
 		{
 			RequireDefaultConstructor (PropertyWithPublicConstructor);
@@ -49,7 +49,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireNothing (PropertyWithPublicConstructor);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), nameof (RequireConstructors), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), nameof (RequireConstructors), new Type[] { typeof (Type) })]
 		private void ReadFromStaticProperty ()
 		{
 			RequireDefaultConstructor (StaticPropertyWithPublicConstructor);
@@ -58,8 +58,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			RequireNothing (StaticPropertyWithPublicConstructor);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), "set_" + nameof (PropertyWithPublicConstructor), new Type [] { typeof (Type) })]
-		[UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), "set_" + nameof (PropertyWithPublicConstructor), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), "set_" + nameof (PropertyWithPublicConstructor), new Type[] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), "set_" + nameof (PropertyWithPublicConstructor), new Type[] { typeof (Type) })]
 		private void WriteToInstanceProperty ()
 		{
 			PropertyWithPublicConstructor = GetTypeWithDefaultConstructor ();
@@ -68,8 +68,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 			PropertyWithPublicConstructor = GetUnkownType ();
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), "set_" + nameof (StaticPropertyWithPublicConstructor), new Type [] { typeof (Type) })]
-		[UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), "set_" + nameof (StaticPropertyWithPublicConstructor), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), "set_" + nameof (StaticPropertyWithPublicConstructor), new Type[] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), "set_" + nameof (StaticPropertyWithPublicConstructor), new Type[] { typeof (Type) })]
 		private void WriteToStaticProperty ()
 		{
 			StaticPropertyWithPublicConstructor = GetTypeWithDefaultConstructor ();
@@ -102,7 +102,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 				return _fieldWithPublicConstructors;
 			}
 
-			[UnrecognizedReflectionAccessPattern(typeof (PropertyDataFlow), "set_" + nameof (PropertyDefaultConstructorWithExplicitAccessors), new Type [] { typeof (Type) })]
+			[UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), "set_" + nameof (PropertyDefaultConstructorWithExplicitAccessors), new Type[] { typeof (Type) })]
 			[param: DynamicallyAccessedMembers (DynamicallyAccessedMemberKinds.DefaultConstructor)]
 			set {
 				_fieldWithPublicConstructors = value;
@@ -110,7 +110,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow
 		}
 
 		Type PropertyConstructorsWithExplicitAccessors {
-			[UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), "get_" + nameof (PropertyConstructorsWithExplicitAccessors), new Type [] { })]
+			[UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), "get_" + nameof (PropertyConstructorsWithExplicitAccessors), new Type[] { })]
 			[return: DynamicallyAccessedMembers (DynamicallyAccessedMemberKinds.Constructors)]
 			get {
 				return _fieldWithPublicConstructors;
diff --git a/test/Mono.Linker.Tests.Cases/Generics/CorrectOverloadedMethodGetsStrippedInGenericClass.cs b/test/Mono.Linker.Tests.Cases/Generics/CorrectOverloadedMethodGetsStrippedInGenericClass.cs
index 362c3bb3d..0da7862c2 100644
--- a/test/Mono.Linker.Tests.Cases/Generics/CorrectOverloadedMethodGetsStrippedInGenericClass.cs
+++ b/test/Mono.Linker.Tests.Cases/Generics/CorrectOverloadedMethodGetsStrippedInGenericClass.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Generics {
-	class CorrectOverloadedMethodGetsStrippedInGenericClass {
+namespace Mono.Linker.Tests.Cases.Generics
+{
+	class CorrectOverloadedMethodGetsStrippedInGenericClass
+	{
 		public static void Main ()
 		{
 			// Call overloaded method through the abstract base class
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Generics {
 		}
 
 		[KeptMember (".ctor()")]
-		public abstract class GenericClassWithTwoOverloadedAbstractMethods<T> {
+		public abstract class GenericClassWithTwoOverloadedAbstractMethods<T>
+		{
 			public abstract string OverloadedMethod (T thing); // Don't call this one, it should be stripped
 
 			[Kept]
@@ -19,7 +22,8 @@ namespace Mono.Linker.Tests.Cases.Generics {
 
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (GenericClassWithTwoOverloadedAbstractMethods<System.Single>))]
-		public class SpecializedClassWithTwoOverloadedVirtualMethods : GenericClassWithTwoOverloadedAbstractMethods<float> {
+		public class SpecializedClassWithTwoOverloadedVirtualMethods : GenericClassWithTwoOverloadedAbstractMethods<float>
+		{
 			// Don't call this one, it should be stripped
 			public override string OverloadedMethod (float thing)
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Generics/DerivedClassWithMethodOfSameNameAsBaseButDifferentNumberOfGenericParametersUnusedBaseWillGetStripped.cs b/test/Mono.Linker.Tests.Cases/Generics/DerivedClassWithMethodOfSameNameAsBaseButDifferentNumberOfGenericParametersUnusedBaseWillGetStripped.cs
index b13f8267e..9a58584d9 100644
--- a/test/Mono.Linker.Tests.Cases/Generics/DerivedClassWithMethodOfSameNameAsBaseButDifferentNumberOfGenericParametersUnusedBaseWillGetStripped.cs
+++ b/test/Mono.Linker.Tests.Cases/Generics/DerivedClassWithMethodOfSameNameAsBaseButDifferentNumberOfGenericParametersUnusedBaseWillGetStripped.cs
@@ -1,8 +1,10 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Generics {
-	class DerivedClassWithMethodOfSameNameAsBaseButDifferentNumberOfGenericParametersUnusedBaseWillGetStripped {
-		public static void Main (string [] args)
+namespace Mono.Linker.Tests.Cases.Generics
+{
+	class DerivedClassWithMethodOfSameNameAsBaseButDifferentNumberOfGenericParametersUnusedBaseWillGetStripped
+	{
+		public static void Main (string[] args)
 		{
 			MyDerived obj = new MyDerived ();
 			obj.Method<int, int> (1);
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Generics {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class MyBase {
+		class MyBase
+		{
 			public virtual T Method<T> (T arg1)
 			{
 				return arg1;
@@ -19,7 +22,8 @@ namespace Mono.Linker.Tests.Cases.Generics {
 
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (MyBase))]
-		class MyDerived : MyBase {
+		class MyDerived : MyBase
+		{
 			[Kept]
 			public virtual T Method<T, K> (T arg1)
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Generics/GenericInstanceInterfaceMethodImplementedWithDifferentGenericArgumentNameDoesNotGetStripped.cs b/test/Mono.Linker.Tests.Cases/Generics/GenericInstanceInterfaceMethodImplementedWithDifferentGenericArgumentNameDoesNotGetStripped.cs
index 4a912d678..068189694 100644
--- a/test/Mono.Linker.Tests.Cases/Generics/GenericInstanceInterfaceMethodImplementedWithDifferentGenericArgumentNameDoesNotGetStripped.cs
+++ b/test/Mono.Linker.Tests.Cases/Generics/GenericInstanceInterfaceMethodImplementedWithDifferentGenericArgumentNameDoesNotGetStripped.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Generics {
-	class GenericInstanceInterfaceMethodImplementedWithDifferentGenericArgumentNameDoesNotGetStripped {
+namespace Mono.Linker.Tests.Cases.Generics
+{
+	class GenericInstanceInterfaceMethodImplementedWithDifferentGenericArgumentNameDoesNotGetStripped
+	{
 		public static void Main ()
 		{
 			ISomething it = new Concrete ();
@@ -9,17 +11,20 @@ namespace Mono.Linker.Tests.Cases.Generics {
 		}
 
 		[Kept]
-		public class GenericType<T> {
+		public class GenericType<T>
+		{
 		}
 
-		public interface ISomething {
+		public interface ISomething
+		{
 			[Kept]
 			GenericType<TInInterface> ShouldNotGetStripped<TInInterface> ();
 		}
 
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (ISomething))]
-		public class Concrete : ISomething {
+		public class Concrete : ISomething
+		{
 			[Kept]
 			public GenericType<TInConcrete> ShouldNotGetStripped<TInConcrete> ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Generics/MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameter.cs b/test/Mono.Linker.Tests.Cases/Generics/MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameter.cs
index 5f8a4389e..da2d562b0 100644
--- a/test/Mono.Linker.Tests.Cases/Generics/MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameter.cs
+++ b/test/Mono.Linker.Tests.Cases/Generics/MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameter.cs
@@ -1,23 +1,27 @@
 using System.Collections.Generic;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Generics {
-	class MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameter {
-		public static void Main (string [] args)
+namespace Mono.Linker.Tests.Cases.Generics
+{
+	class MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameter
+	{
+		public static void Main (string[] args)
 		{
 			Derived<int, int> tmp = new Derived<int, int> ();
 			tmp.Method<int> (null);
 		}
 
 		[KeptMember (".ctor()")]
-		public abstract class Base<TSource> {
+		public abstract class Base<TSource>
+		{
 			[Kept]
 			public abstract TResult1 Method<TResult1> (IDictionary<TSource, TResult1> arg);
 		}
 
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Base<>), "TResult1")]
-		public class Derived<TSource, TResult1> : Base<TResult1> {
+		public class Derived<TSource, TResult1> : Base<TResult1>
+		{
 			[Kept]
 			public override TResult2 Method<TResult2> (IDictionary<TResult1, TResult2> arg)
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Generics/MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameterNestedCase.cs b/test/Mono.Linker.Tests.Cases/Generics/MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameterNestedCase.cs
index 37d1305dc..f737196de 100644
--- a/test/Mono.Linker.Tests.Cases/Generics/MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameterNestedCase.cs
+++ b/test/Mono.Linker.Tests.Cases/Generics/MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameterNestedCase.cs
@@ -1,19 +1,23 @@
 using System.Collections.Generic;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Generics {
-	class MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameterNestedCase {
-		public static void Main (string [] args)
+namespace Mono.Linker.Tests.Cases.Generics
+{
+	class MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameterNestedCase
+	{
+		public static void Main (string[] args)
 		{
 			Derived<int, int> tmp = new Derived<int, int> ();
 			tmp.Method<int> (null);
 		}
 
 		[Kept]
-		public class Base<TSource> {
+		public class Base<TSource>
+		{
 
 			[KeptMember (".ctor()")]
-			public abstract class Nested {
+			public abstract class Nested
+			{
 				[Kept]
 				public abstract TResult1 Method<TResult1> (IDictionary<TSource, TResult1> arg);
 			}
@@ -21,7 +25,8 @@ namespace Mono.Linker.Tests.Cases.Generics {
 
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Base<>.Nested), "TResult1")]
-		public class Derived<TSource, TResult1> : Base<TResult1>.Nested {
+		public class Derived<TSource, TResult1> : Base<TResult1>.Nested
+		{
 			[Kept]
 			public override TResult2 Method<TResult2> (IDictionary<TResult1, TResult2> arg)
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Generics/MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameterNestedCase2.cs b/test/Mono.Linker.Tests.Cases/Generics/MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameterNestedCase2.cs
index f6e1370a3..8bd0af0dd 100644
--- a/test/Mono.Linker.Tests.Cases/Generics/MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameterNestedCase2.cs
+++ b/test/Mono.Linker.Tests.Cases/Generics/MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameterNestedCase2.cs
@@ -1,19 +1,23 @@
 using System.Collections.Generic;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Generics {
-	class MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameterNestedCase2 {
-		public static void Main (string [] args)
+namespace Mono.Linker.Tests.Cases.Generics
+{
+	class MethodWithParameterWhichHasGenericParametersAndOverrideUsesADifferentNameForGenericParameterNestedCase2
+	{
+		public static void Main (string[] args)
 		{
 			Derived<int, int> tmp = new Derived<int, int> ();
 			tmp.Method<int> (null);
 		}
 
 		[Kept]
-		public class Base<TSource> {
+		public class Base<TSource>
+		{
 
 			[KeptMember (".ctor()")]
-			public abstract class Nested<T1, T2, T3> {
+			public abstract class Nested<T1, T2, T3>
+			{
 				[Kept]
 				public abstract TResult1 Method<TResult1> (IDictionary<TSource, TResult1> arg);
 			}
@@ -21,7 +25,8 @@ namespace Mono.Linker.Tests.Cases.Generics {
 
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Base<>.Nested<,,>), "TResult1", typeof (int), typeof (int), typeof (string))]
-		public class Derived<TSource, TResult1> : Base<TResult1>.Nested<int, int, string> {
+		public class Derived<TSource, TResult1> : Base<TResult1>.Nested<int, int, string>
+		{
 			[Kept]
 			public override TResult2 Method<TResult2> (IDictionary<TResult1, TResult2> arg)
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Generics/NewConstraintOnClass.cs b/test/Mono.Linker.Tests.Cases/Generics/NewConstraintOnClass.cs
index 2d644e5c3..ae4991e16 100644
--- a/test/Mono.Linker.Tests.Cases/Generics/NewConstraintOnClass.cs
+++ b/test/Mono.Linker.Tests.Cases/Generics/NewConstraintOnClass.cs
@@ -30,7 +30,7 @@ namespace Mono.Linker.Tests.Cases.Generics
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class G1<T> where T : G1Ctor, new ()
+		class G1<T> where T : G1Ctor, new()
 		{
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Generics/OverrideWithAnotherVirtualMethodOfSameNameWithDifferentParameterType.cs b/test/Mono.Linker.Tests.Cases/Generics/OverrideWithAnotherVirtualMethodOfSameNameWithDifferentParameterType.cs
index ba81282b8..8b67e179d 100644
--- a/test/Mono.Linker.Tests.Cases/Generics/OverrideWithAnotherVirtualMethodOfSameNameWithDifferentParameterType.cs
+++ b/test/Mono.Linker.Tests.Cases/Generics/OverrideWithAnotherVirtualMethodOfSameNameWithDifferentParameterType.cs
@@ -1,14 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Generics {
-	class OverrideWithAnotherVirtualMethodOfSameNameWithDifferentParameterType {
-		public static void Main (string [] args)
+namespace Mono.Linker.Tests.Cases.Generics
+{
+	class OverrideWithAnotherVirtualMethodOfSameNameWithDifferentParameterType
+	{
+		public static void Main (string[] args)
 		{
 			new Derived<double, int> ().Method (1.0);
 		}
 
 		[KeptMember (".ctor()")]
-		public class Base<S> {
+		public class Base<S>
+		{
 			[Kept]
 			public virtual S Method (S arg)
 			{
@@ -18,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.Generics {
 
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Base<>), "K")]
-		public class Derived<K, S> : Base<K> {
+		public class Derived<K, S> : Base<K>
+		{
 			[Kept]
 			public override K Method (K arg)
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Generics/UsedOverloadedGenericMethodInGenericClassIsNotStripped.cs b/test/Mono.Linker.Tests.Cases/Generics/UsedOverloadedGenericMethodInGenericClassIsNotStripped.cs
index 908e0d50d..bd64bd73f 100644
--- a/test/Mono.Linker.Tests.Cases/Generics/UsedOverloadedGenericMethodInGenericClassIsNotStripped.cs
+++ b/test/Mono.Linker.Tests.Cases/Generics/UsedOverloadedGenericMethodInGenericClassIsNotStripped.cs
@@ -1,13 +1,16 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Generics {
-	public class UsedOverloadedGenericMethodInGenericClassIsNotStripped {
+namespace Mono.Linker.Tests.Cases.Generics
+{
+	public class UsedOverloadedGenericMethodInGenericClassIsNotStripped
+	{
 		public static void Main ()
 		{
 			B<int>.Method (true);
 		}
 
-		class B<TBase> {
+		class B<TBase>
+		{
 			[Kept]
 			public static void Method<T> (T value)
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Generics/UsedOverloadedGenericMethodInstanceInGenericClassIsNotStripped.cs b/test/Mono.Linker.Tests.Cases/Generics/UsedOverloadedGenericMethodInstanceInGenericClassIsNotStripped.cs
index a565d4cf5..5ddd31ea0 100644
--- a/test/Mono.Linker.Tests.Cases/Generics/UsedOverloadedGenericMethodInstanceInGenericClassIsNotStripped.cs
+++ b/test/Mono.Linker.Tests.Cases/Generics/UsedOverloadedGenericMethodInstanceInGenericClassIsNotStripped.cs
@@ -1,13 +1,16 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Generics {
-	public class UsedOverloadedGenericMethodInstanceInGenericClassIsNotStripped {
+namespace Mono.Linker.Tests.Cases.Generics
+{
+	public class UsedOverloadedGenericMethodInstanceInGenericClassIsNotStripped
+	{
 		public static void Main ()
 		{
 			B<int>.Method (1);
 		}
 
-		class B<TBase> {
+		class B<TBase>
+		{
 			public static void Method<T> (T value)
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Generics/UsedOverloadedGenericMethodWithNoParametersIsNotStripped.cs b/test/Mono.Linker.Tests.Cases/Generics/UsedOverloadedGenericMethodWithNoParametersIsNotStripped.cs
index 52e1ff7b2..99e462bf9 100644
--- a/test/Mono.Linker.Tests.Cases/Generics/UsedOverloadedGenericMethodWithNoParametersIsNotStripped.cs
+++ b/test/Mono.Linker.Tests.Cases/Generics/UsedOverloadedGenericMethodWithNoParametersIsNotStripped.cs
@@ -1,13 +1,16 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Generics {
-	public class UsedOverloadedGenericMethodWithNoParametersIsNotStripped {
+namespace Mono.Linker.Tests.Cases.Generics
+{
+	public class UsedOverloadedGenericMethodWithNoParametersIsNotStripped
+	{
 		public static void Main ()
 		{
 			B.Call<string, int> ();
 		}
 
-		public class B {
+		public class B
+		{
 			public static void Method<T> ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly2_Base.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly2_Base.cs
index 22b9f378f..ee5b3a26e 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly2_Base.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly2_Base.cs
@@ -1,10 +1,14 @@
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies {
-	public class TypeWithBaseInCopiedAssembly2_Base {
-		public abstract class Base : IBase {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies
+{
+	public class TypeWithBaseInCopiedAssembly2_Base
+	{
+		public abstract class Base : IBase
+		{
 			public abstract void Method ();
 		}
-		
-		public interface IBase {
+
+		public interface IBase
+		{
 			void Method ();
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly3_Base.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly3_Base.cs
index 6e6f39d15..a549cb14d 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly3_Base.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly3_Base.cs
@@ -1,6 +1,9 @@
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies {
-	public class TypeWithBaseInCopiedAssembly3_Base {
-		public abstract class Base {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies
+{
+	public class TypeWithBaseInCopiedAssembly3_Base
+	{
+		public abstract class Base
+		{
 			public abstract void Method ();
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly4_Base.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly4_Base.cs
index 60b64a755..125b8553d 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly4_Base.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly4_Base.cs
@@ -1,10 +1,14 @@
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies {
-	public class TypeWithBaseInCopiedAssembly4_Base {
-		public abstract class Base {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies
+{
+	public class TypeWithBaseInCopiedAssembly4_Base
+	{
+		public abstract class Base
+		{
 			public abstract void Method ();
 		}
 
-		public class Base2 : Base {
+		public class Base2 : Base
+		{
 			public override void Method ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly6_Base.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly6_Base.cs
index 8c12c7322..63c3306d4 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly6_Base.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly6_Base.cs
@@ -1,10 +1,14 @@
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies {
-	public class TypeWithBaseInCopiedAssembly6_Base {
-		public abstract class Base {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies
+{
+	public class TypeWithBaseInCopiedAssembly6_Base
+	{
+		public abstract class Base
+		{
 			public abstract void Method ();
 		}
-		
-		public interface IBase {
+
+		public interface IBase
+		{
 			void Method ();
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly_Base.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly_Base.cs
index e2e3b8fa3..67db14291 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly_Base.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/Dependencies/TypeWithBaseInCopiedAssembly_Base.cs
@@ -1,8 +1,10 @@
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies {
-	public class TypeWithBaseInCopiedAssembly_Base {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies
+{
+	public class TypeWithBaseInCopiedAssembly_Base
+	{
 		public abstract class Base
 		{
-			public abstract void Method();
+			public abstract void Method ();
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/CanDisableOverrideRemoval.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/CanDisableOverrideRemoval.cs
index b1ce753f3..697f86d00 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/CanDisableOverrideRemoval.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/CanDisableOverrideRemoval.cs
@@ -1,9 +1,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval
+{
 	[SetupLinkerArgument ("--disable-opt", "overrideremoval")]
-	public class CanDisableOverrideRemoval {
+	public class CanDisableOverrideRemoval
+	{
 		public static void Main ()
 		{
 			Base b = HelperToMarkFooAndRequireBase ();
@@ -17,7 +19,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 		}
 
 		[Kept]
-		class Base {
+		class Base
+		{
 			[Kept]
 			public virtual void Method ()
 			{
@@ -26,7 +29,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 
 		[Kept]
 		[KeptBaseType (typeof (Base))]
-		class Foo : Base {
+		class Foo : Base
+		{
 			[Kept]
 			public override void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfAbstractIsKept.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfAbstractIsKept.cs
index 9cbb14504..7bf782a21 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfAbstractIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfAbstractIsKept.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval {
-	public class OverrideOfAbstractIsKept {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval
+{
+	public class OverrideOfAbstractIsKept
+	{
 		public static void Main ()
 		{
 			Base b = HelperToMarkFooAndRequireBase ();
@@ -15,24 +17,28 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 		}
 
 		[Kept]
-		abstract class Base {
+		abstract class Base
+		{
 			[Kept]
 			public abstract void Method ();
 		}
-		
+
 		[Kept]
-		[KeptBaseType (typeof(Base))]
-		abstract class Base2 : Base {
+		[KeptBaseType (typeof (Base))]
+		abstract class Base2 : Base
+		{
 		}
 
 		[Kept]
 		[KeptBaseType (typeof (Base2))]
-		abstract class Base3 : Base2 {
+		abstract class Base3 : Base2
+		{
 		}
 
 		[Kept]
 		[KeptBaseType (typeof (Base3))]
-		class Foo : Base3 {
+		class Foo : Base3
+		{
 			[Kept]
 			public override void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfAbstractIsKeptNonEmpty.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfAbstractIsKeptNonEmpty.cs
index 39299f902..b2a3d5f2b 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfAbstractIsKeptNonEmpty.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfAbstractIsKeptNonEmpty.cs
@@ -1,9 +1,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class OverrideOfAbstractIsKeptNonEmpty {
+	public class OverrideOfAbstractIsKeptNonEmpty
+	{
 		public static void Main ()
 		{
 			Base b = HelperToMarkFooAndRequireBase ();
@@ -17,24 +19,28 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 		}
 
 		[Kept]
-		abstract class Base {
+		abstract class Base
+		{
 			[Kept]
 			public abstract void Method ();
 		}
-		
+
 		[Kept]
-		[KeptBaseType (typeof(Base))]
-		abstract class Base2 : Base {
+		[KeptBaseType (typeof (Base))]
+		abstract class Base2 : Base
+		{
 		}
 
 		[Kept]
 		[KeptBaseType (typeof (Base2))]
-		abstract class Base3 : Base2 {
+		abstract class Base3 : Base2
+		{
 		}
 
 		[Kept]
 		[KeptBaseType (typeof (Base3))]
-		class Foo : Base3 {
+		class Foo : Base3
+		{
 			[Kept]
 			[ExpectBodyModified]
 			public override void Method ()
@@ -42,7 +48,7 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 				Other ();
 			}
 
-			static void Other()
+			static void Other ()
 			{
 			}
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfVirtualCanBeRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfVirtualCanBeRemoved.cs
index 6277e8338..d356a4586 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfVirtualCanBeRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfVirtualCanBeRemoved.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval {
-	public class OverrideOfVirtualCanBeRemoved {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval
+{
+	public class OverrideOfVirtualCanBeRemoved
+	{
 		public static void Main ()
 		{
 			Base b = HelperToMarkFooAndRequireBase ();
@@ -15,7 +17,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 		}
 
 		[Kept]
-		class Base {
+		class Base
+		{
 			[Kept]
 			public virtual void Method ()
 			{
@@ -24,7 +27,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 
 		[Kept]
 		[KeptBaseType (typeof (Base))]
-		class Foo : Base {
+		class Foo : Base
+		{
 			public override void Method ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfVirtualCanBeRemoved2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfVirtualCanBeRemoved2.cs
index 4bb4df93c..9e86edbb0 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfVirtualCanBeRemoved2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfVirtualCanBeRemoved2.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval {
-	public class OverrideOfVirtualCanBeRemoved2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval
+{
+	public class OverrideOfVirtualCanBeRemoved2
+	{
 		public static void Main ()
 		{
 			Base b = HelperToMarkFooAndRequireBase ();
@@ -15,11 +17,12 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 		}
 
 		[Kept]
-		abstract class Base {
+		abstract class Base
+		{
 			[Kept]
 			public abstract void Method ();
 		}
-		
+
 		[Kept]
 		[KeptBaseType (typeof (Base))]
 		abstract class Base2 : Base
@@ -28,7 +31,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 
 		[Kept]
 		[KeptBaseType (typeof (Base2))]
-		class Base3 : Base2 {
+		class Base3 : Base2
+		{
 			[Kept]
 			public override void Method ()
 			{
@@ -37,7 +41,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 
 		[Kept]
 		[KeptBaseType (typeof (Base3))]
-		class Foo : Base3 {
+		class Foo : Base3
+		{
 			public override void Method ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfVirtualCanBeRemoved3.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfVirtualCanBeRemoved3.cs
index 1f376e05c..46fa14569 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfVirtualCanBeRemoved3.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideOfVirtualCanBeRemoved3.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval {
-	public class OverrideOfVirtualCanBeRemoved3 {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval
+{
+	public class OverrideOfVirtualCanBeRemoved3
+	{
 		public static void Main ()
 		{
-			HelperToMarkFoo2AndRequireBase();
+			HelperToMarkFoo2AndRequireBase ();
 			Base b = HelperToMarkFooAndRequireBase ();
 			b.Method ();
 		}
@@ -14,7 +16,7 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 		{
 			return null;
 		}
-		
+
 		[Kept]
 		static Foo2 HelperToMarkFoo2AndRequireBase ()
 		{
@@ -22,7 +24,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 		}
 
 		[Kept]
-		class Base {
+		class Base
+		{
 			[Kept]
 			public virtual void Method ()
 			{
@@ -31,7 +34,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 
 		[Kept]
 		[KeptBaseType (typeof (Base))]
-		class Foo : Base {
+		class Foo : Base
+		{
 			public override void Method ()
 			{
 			}
@@ -39,7 +43,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 
 		[Kept]
 		[KeptBaseType (typeof (Foo))]
-		class Foo2 : Foo {
+		class Foo2 : Foo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideThatAlsoFulfilsInterface.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideThatAlsoFulfilsInterface.cs
index 428310dad..232babdf0 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideThatAlsoFulfilsInterface.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/OverrideThatAlsoFulfilsInterface.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval {
-	public class OverrideThatAlsoFulfilsInterface {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval
+{
+	public class OverrideThatAlsoFulfilsInterface
+	{
 		public static void Main ()
 		{
 			Base b = HelperToMarkFooAndRequireBase ();
@@ -25,7 +27,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 		}
 
 		[Kept]
-		class Base {
+		class Base
+		{
 			[Kept]
 			public virtual void Method ()
 			{
@@ -33,7 +36,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Method ();
 		}
@@ -41,7 +45,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class Bar : IFoo {
+		class Bar : IFoo
+		{
 			[Kept]
 			public void Method ()
 			{
@@ -50,7 +55,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 
 		[Kept]
 		[KeptBaseType (typeof (Base))]
-		class Foo : Base, IFoo {
+		class Foo : Base, IFoo
+		{
 			public override void Method ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/PreservesOverriddenMethodOverrideOfUsedVirtualStillRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/PreservesOverriddenMethodOverrideOfUsedVirtualStillRemoved.cs
index d21678797..6cfa000bf 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/PreservesOverriddenMethodOverrideOfUsedVirtualStillRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/PreservesOverriddenMethodOverrideOfUsedVirtualStillRemoved.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval {
-	public class PreservesOverriddenMethodOverrideOfUsedVirtualStillRemoved {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval
+{
+	public class PreservesOverriddenMethodOverrideOfUsedVirtualStillRemoved
+	{
 		public static void Main ()
 		{
 			Base j = new Jar ();
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		abstract class Base {
+		abstract class Base
+		{
 			[Kept]
 			public abstract void Foo ();
 
@@ -22,7 +25,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 
 		[Kept]
 		[KeptBaseType (typeof (Base))]
-		class Bar : Base {
+		class Bar : Base
+		{
 			[Kept]
 			public override void Foo ()
 			{
@@ -36,7 +40,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Base))]
-		class Jar : Base {
+		class Jar : Base
+		{
 			[Kept]
 			public override void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/PreservesOverriddenMethodOverrideOfUsedVirtualStillRemoved2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/PreservesOverriddenMethodOverrideOfUsedVirtualStillRemoved2.cs
index a1ddd7c30..9fede77ea 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/PreservesOverriddenMethodOverrideOfUsedVirtualStillRemoved2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NoKeptCtor/OverrideRemoval/PreservesOverriddenMethodOverrideOfUsedVirtualStillRemoved2.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval {
-	public class PreservesOverriddenMethodOverrideOfUsedVirtualStillRemoved2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.OverrideRemoval
+{
+	public class PreservesOverriddenMethodOverrideOfUsedVirtualStillRemoved2
+	{
 		public static void Main ()
 		{
 			Base j = new Jar ();
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		abstract class Base {
+		abstract class Base
+		{
 			[Kept]
 			public abstract void Foo ();
 
@@ -31,7 +34,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 
 		[Kept]
 		[KeptBaseType (typeof (Base2))]
-		class Bar : Base2 {
+		class Bar : Base2
+		{
 			[Kept]
 			public override void Foo ()
 			{
@@ -45,7 +49,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NoKeptCtor.Overrid
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Base2))]
-		class Jar : Base2 {
+		class Jar : Base2
+		{
 			[Kept]
 			public override void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly.cs
index c55a4b349..05e580904 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly.cs
@@ -2,11 +2,13 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor
+{
 	[SetupLinkerAction ("copy", "base")]
-	[SetupCompileBefore ("base.dll", new [] {typeof (TypeWithBaseInCopiedAssembly_Base)})]
+	[SetupCompileBefore ("base.dll", new[] { typeof (TypeWithBaseInCopiedAssembly_Base) })]
 	[KeptMemberInAssembly ("base.dll", typeof (TypeWithBaseInCopiedAssembly_Base.Base), "Method()")]
-	public class NeverInstantiatedTypeWithBaseInCopiedAssembly {
+	public class NeverInstantiatedTypeWithBaseInCopiedAssembly
+	{
 		public static void Main ()
 		{
 			Helper (null);
@@ -19,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor {
 
 		[Kept]
 		[KeptBaseType (typeof (TypeWithBaseInCopiedAssembly_Base.Base))]
-		class Foo : TypeWithBaseInCopiedAssembly_Base.Base {
+		class Foo : TypeWithBaseInCopiedAssembly_Base.Base
+		{
 			[Kept]
 			public override void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly2.cs
index e659a8544..674831a94 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly2.cs
@@ -2,12 +2,14 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor
+{
 	[SetupLinkerAction ("copy", "base2")]
-	[SetupCompileBefore ("base2.dll", new [] { typeof (TypeWithBaseInCopiedAssembly2_Base)})]
+	[SetupCompileBefore ("base2.dll", new[] { typeof (TypeWithBaseInCopiedAssembly2_Base) })]
 	[KeptMemberInAssembly ("base2.dll", typeof (TypeWithBaseInCopiedAssembly2_Base.Base), "Method()")]
 	[KeptMemberInAssembly ("base2.dll", typeof (TypeWithBaseInCopiedAssembly2_Base.IBase), "Method()")]
-	public class NeverInstantiatedTypeWithBaseInCopiedAssembly2 {
+	public class NeverInstantiatedTypeWithBaseInCopiedAssembly2
+	{
 		public static void Main ()
 		{
 			Helper (null);
@@ -20,7 +22,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor {
 
 		[Kept]
 		[KeptBaseType (typeof (TypeWithBaseInCopiedAssembly2_Base.Base))]
-		class Foo : TypeWithBaseInCopiedAssembly2_Base.Base {
+		class Foo : TypeWithBaseInCopiedAssembly2_Base.Base
+		{
 			[Kept]
 			public override void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly3.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly3.cs
index 7eb99e773..f54a7571a 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly3.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly3.cs
@@ -2,11 +2,13 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor
+{
 	[SetupLinkerAction ("copy", "base3")]
-	[SetupCompileBefore ("base3.dll", new [] {typeof (TypeWithBaseInCopiedAssembly3_Base)})]
+	[SetupCompileBefore ("base3.dll", new[] { typeof (TypeWithBaseInCopiedAssembly3_Base) })]
 	[KeptMemberInAssembly ("base3.dll", typeof (TypeWithBaseInCopiedAssembly3_Base.Base), "Method()")]
-	public class NeverInstantiatedTypeWithBaseInCopiedAssembly3 {
+	public class NeverInstantiatedTypeWithBaseInCopiedAssembly3
+	{
 		public static void Main ()
 		{
 			Helper (null);
@@ -19,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor {
 
 		[Kept]
 		[KeptBaseType (typeof (Base2))]
-		class Foo : Base2 {
+		class Foo : Base2
+		{
 			// This method can be removed because the type is never instantiated and the base class
 			// will keep it's override in order to keep the IL valid
 			public override void Method ()
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly4.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly4.cs
index 1eb532a7f..5199685ea 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly4.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly4.cs
@@ -2,11 +2,13 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor
+{
 	[SetupLinkerAction ("copy", "base4")]
-	[SetupCompileBefore ("base4.dll", new [] {typeof (TypeWithBaseInCopiedAssembly4_Base)})]
+	[SetupCompileBefore ("base4.dll", new[] { typeof (TypeWithBaseInCopiedAssembly4_Base) })]
 	[KeptMemberInAssembly ("base4.dll", typeof (TypeWithBaseInCopiedAssembly4_Base.Base), "Method()")]
-	public class NeverInstantiatedTypeWithBaseInCopiedAssembly4 {
+	public class NeverInstantiatedTypeWithBaseInCopiedAssembly4
+	{
 		public static void Main ()
 		{
 			Helper (null);
@@ -19,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor {
 
 		[Kept]
 		[KeptBaseType (typeof (TypeWithBaseInCopiedAssembly4_Base.Base2))]
-		class Foo : TypeWithBaseInCopiedAssembly4_Base.Base2 {
+		class Foo : TypeWithBaseInCopiedAssembly4_Base.Base2
+		{
 			// This method can be removed because the type is never instantiated and the base class
 			// overrides the original abstract method
 			public override void Method ()
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly5.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly5.cs
index c802d4f99..ec3312afd 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly5.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly5.cs
@@ -2,11 +2,13 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor
+{
 	[SetupLinkerAction ("copy", "base5")]
-	[SetupCompileBefore ("base5.dll", new [] {typeof (TypeWithBaseInCopiedAssembly4_Base)})]
+	[SetupCompileBefore ("base5.dll", new[] { typeof (TypeWithBaseInCopiedAssembly4_Base) })]
 	[KeptMemberInAssembly ("base5.dll", typeof (TypeWithBaseInCopiedAssembly4_Base.Base), "Method()")]
-	public class NeverInstantiatedTypeWithBaseInCopiedAssembly5 {
+	public class NeverInstantiatedTypeWithBaseInCopiedAssembly5
+	{
 		public static void Main ()
 		{
 			Helper (null, null);
@@ -19,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor {
 
 		[Kept]
 		[KeptBaseType (typeof (TypeWithBaseInCopiedAssembly4_Base.Base2))]
-		class Foo : TypeWithBaseInCopiedAssembly4_Base.Base2 {
+		class Foo : TypeWithBaseInCopiedAssembly4_Base.Base2
+		{
 			// This method can be removed because the type is never instantiated and the base class
 			// overrides the original abstract method
 			public override void Method ()
@@ -28,7 +31,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor {
 		}
 		[Kept]
 		[KeptBaseType (typeof (TypeWithBaseInCopiedAssembly4_Base.Base2))]
-		class Bar : TypeWithBaseInCopiedAssembly4_Base.Base2 {
+		class Bar : TypeWithBaseInCopiedAssembly4_Base.Base2
+		{
 			// This method can be removed because the type is never instantiated and the base class
 			// overrides the original abstract method
 			public override void Method ()
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly6.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly6.cs
index 26822469f..f03cc0fb5 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly6.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly6.cs
@@ -2,12 +2,14 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor
+{
 	[SetupLinkerAction ("copy", "base6")]
-	[SetupCompileBefore ("base6.dll", new [] { typeof (TypeWithBaseInCopiedAssembly6_Base)})]
+	[SetupCompileBefore ("base6.dll", new[] { typeof (TypeWithBaseInCopiedAssembly6_Base) })]
 	[KeptMemberInAssembly ("base6.dll", typeof (TypeWithBaseInCopiedAssembly6_Base.Base), "Method()")]
 	[KeptMemberInAssembly ("base6.dll", typeof (TypeWithBaseInCopiedAssembly6_Base.IBase), "Method()")]
-	public class NeverInstantiatedTypeWithBaseInCopiedAssembly6 {
+	public class NeverInstantiatedTypeWithBaseInCopiedAssembly6
+	{
 		public static void Main ()
 		{
 			Helper (null);
@@ -20,7 +22,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.NotKeptCtor {
 
 		[Kept]
 		[KeptBaseType (typeof (TypeWithBaseInCopiedAssembly6_Base.Base))]
-		class Foo : TypeWithBaseInCopiedAssembly6_Base.Base, TypeWithBaseInCopiedAssembly6_Base.IBase {
+		class Foo : TypeWithBaseInCopiedAssembly6_Base.Base, TypeWithBaseInCopiedAssembly6_Base.IBase
+		{
 			// Must be kept because there is an abstract base method
 			[Kept]
 			public override void Method ()
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly.cs
index 234bcccb8..a239b57db 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly.cs
@@ -2,11 +2,13 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses
+{
 	[SetupLinkerAction ("copy", "base")]
-	[SetupCompileBefore ("base.dll", new [] {typeof (TypeWithBaseInCopiedAssembly_Base)})]
+	[SetupCompileBefore ("base.dll", new[] { typeof (TypeWithBaseInCopiedAssembly_Base) })]
 	[KeptMemberInAssembly ("base.dll", typeof (TypeWithBaseInCopiedAssembly_Base.Base), "Method()")]
-	public class TypeWithBaseInCopiedAssembly {
+	public class TypeWithBaseInCopiedAssembly
+	{
 		public static void Main ()
 		{
 			new Foo ();
@@ -15,7 +17,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (TypeWithBaseInCopiedAssembly_Base.Base))]
-		class Foo : TypeWithBaseInCopiedAssembly_Base.Base {
+		class Foo : TypeWithBaseInCopiedAssembly_Base.Base
+		{
 			[Kept]
 			public override void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly2.cs
index acbec20fe..534ead4d3 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly2.cs
@@ -2,12 +2,14 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses
+{
 	[SetupLinkerAction ("copy", "base2")]
-	[SetupCompileBefore ("base2.dll", new [] { typeof (TypeWithBaseInCopiedAssembly2_Base)})]
+	[SetupCompileBefore ("base2.dll", new[] { typeof (TypeWithBaseInCopiedAssembly2_Base) })]
 	[KeptMemberInAssembly ("base2.dll", typeof (TypeWithBaseInCopiedAssembly2_Base.Base), "Method()")]
-	[KeptMemberInAssembly ("base2.dll", typeof(TypeWithBaseInCopiedAssembly2_Base.IBase), "Method()")]
-	public class TypeWithBaseInCopiedAssembly2 {
+	[KeptMemberInAssembly ("base2.dll", typeof (TypeWithBaseInCopiedAssembly2_Base.IBase), "Method()")]
+	public class TypeWithBaseInCopiedAssembly2
+	{
 		public static void Main ()
 		{
 			new Foo ();
@@ -16,7 +18,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (TypeWithBaseInCopiedAssembly2_Base.Base))]
-		class Foo : TypeWithBaseInCopiedAssembly2_Base.Base {
+		class Foo : TypeWithBaseInCopiedAssembly2_Base.Base
+		{
 			[Kept]
 			public override void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly3.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly3.cs
index 17bf06475..bb2d0fa14 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly3.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly3.cs
@@ -2,11 +2,13 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses
+{
 	[SetupLinkerAction ("copy", "base3")]
-	[SetupCompileBefore ("base3.dll", new [] {typeof (TypeWithBaseInCopiedAssembly3_Base)})]
+	[SetupCompileBefore ("base3.dll", new[] { typeof (TypeWithBaseInCopiedAssembly3_Base) })]
 	[KeptMemberInAssembly ("base3.dll", typeof (TypeWithBaseInCopiedAssembly3_Base.Base), "Method()")]
-	public class TypeWithBaseInCopiedAssembly3 {
+	public class TypeWithBaseInCopiedAssembly3
+	{
 		public static void Main ()
 		{
 			new Foo ();
@@ -15,7 +17,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Base2))]
-		class Foo : Base2 {
+		class Foo : Base2
+		{
 			[Kept]
 			public override void Method ()
 			{
@@ -25,7 +28,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (TypeWithBaseInCopiedAssembly3_Base.Base))]
-		class Base2 : TypeWithBaseInCopiedAssembly3_Base.Base {
+		class Base2 : TypeWithBaseInCopiedAssembly3_Base.Base
+		{
 			[Kept]
 			public override void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly4.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly4.cs
index 3c95a907d..c24123691 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly4.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly4.cs
@@ -2,11 +2,13 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses
+{
 	[SetupLinkerAction ("copy", "base4")]
-	[SetupCompileBefore ("base4.dll", new [] {typeof (TypeWithBaseInCopiedAssembly4_Base)})]
+	[SetupCompileBefore ("base4.dll", new[] { typeof (TypeWithBaseInCopiedAssembly4_Base) })]
 	[KeptMemberInAssembly ("base4.dll", typeof (TypeWithBaseInCopiedAssembly4_Base.Base), "Method()")]
-	public class TypeWithBaseInCopiedAssembly4 {
+	public class TypeWithBaseInCopiedAssembly4
+	{
 		public static void Main ()
 		{
 			new Foo ();
@@ -15,7 +17,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (TypeWithBaseInCopiedAssembly4_Base.Base2))]
-		class Foo : TypeWithBaseInCopiedAssembly4_Base.Base2 {
+		class Foo : TypeWithBaseInCopiedAssembly4_Base.Base2
+		{
 			[Kept]
 			public override void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly5.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly5.cs
index 8311ca706..d3bcf9176 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly5.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly5.cs
@@ -2,11 +2,13 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses
+{
 	[SetupLinkerAction ("copy", "base5")]
-	[SetupCompileBefore ("base5.dll", new [] {typeof (TypeWithBaseInCopiedAssembly4_Base)})]
+	[SetupCompileBefore ("base5.dll", new[] { typeof (TypeWithBaseInCopiedAssembly4_Base) })]
 	[KeptMemberInAssembly ("base5.dll", typeof (TypeWithBaseInCopiedAssembly4_Base.Base), "Method()")]
-	public class TypeWithBaseInCopiedAssembly5 {
+	public class TypeWithBaseInCopiedAssembly5
+	{
 		public static void Main ()
 		{
 			new Foo ();
@@ -16,17 +18,19 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (TypeWithBaseInCopiedAssembly4_Base.Base2))]
-		class Foo : TypeWithBaseInCopiedAssembly4_Base.Base2 {
+		class Foo : TypeWithBaseInCopiedAssembly4_Base.Base2
+		{
 			[Kept]
 			public override void Method ()
 			{
 			}
 		}
-		
+
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (TypeWithBaseInCopiedAssembly4_Base.Base2))]
-		class Bar : TypeWithBaseInCopiedAssembly4_Base.Base2 {
+		class Bar : TypeWithBaseInCopiedAssembly4_Base.Base2
+		{
 			[Kept]
 			public override void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly6.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly6.cs
index 650c4bb97..5066a0037 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly6.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/TypeWithBaseInCopiedAssembly6.cs
@@ -2,12 +2,14 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.AbstractClasses.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses
+{
 	[SetupLinkerAction ("copy", "base6")]
-	[SetupCompileBefore ("base6.dll", new [] { typeof (TypeWithBaseInCopiedAssembly6_Base)})]
+	[SetupCompileBefore ("base6.dll", new[] { typeof (TypeWithBaseInCopiedAssembly6_Base) })]
 	[KeptMemberInAssembly ("base6.dll", typeof (TypeWithBaseInCopiedAssembly6_Base.Base), "Method()")]
 	[KeptMemberInAssembly ("base6.dll", typeof (TypeWithBaseInCopiedAssembly6_Base.IBase), "Method()")]
-	public class TypeWithBaseInCopiedAssembly6 {
+	public class TypeWithBaseInCopiedAssembly6
+	{
 		public static void Main ()
 		{
 			Helper (new Foo ());
@@ -22,7 +24,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (TypeWithBaseInCopiedAssembly6_Base.Base))]
 		[KeptInterface (typeof (TypeWithBaseInCopiedAssembly6_Base.IBase))]
-		class Foo : TypeWithBaseInCopiedAssembly6_Base.Base, TypeWithBaseInCopiedAssembly6_Base.IBase {
+		class Foo : TypeWithBaseInCopiedAssembly6_Base.Base, TypeWithBaseInCopiedAssembly6_Base.IBase
+		{
 			[Kept]
 			public override void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/UnusedAbstractMethodRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/UnusedAbstractMethodRemoved.cs
index 452493a97..b5b2a4c9c 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/UnusedAbstractMethodRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/UnusedAbstractMethodRemoved.cs
@@ -1,21 +1,25 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
-	public class UnusedAbstractMethodRemoved {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses
+{
+	public class UnusedAbstractMethodRemoved
+	{
 		public static void Main ()
 		{
 			var tmp = new B ();
 		}
 
 		[KeptMember (".ctor()")]
-		abstract class Base {
+		abstract class Base
+		{
 			public abstract void Call ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Base))]
-		class B : Base {
+		class B : Base
+		{
 			public override void Call ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/UnusedVirtualMethodRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/UnusedVirtualMethodRemoved.cs
index 82f5d6729..1fbc769d7 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/UnusedVirtualMethodRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/UnusedVirtualMethodRemoved.cs
@@ -1,14 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
-	public class UnusedVirtualMethodRemoved {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses
+{
+	public class UnusedVirtualMethodRemoved
+	{
 		public static void Main ()
 		{
 			var tmp = new B ();
 		}
 
 		[KeptMember (".ctor()")]
-		abstract class Base {
+		abstract class Base
+		{
 			public virtual void Call ()
 			{
 			}
@@ -17,7 +20,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Base))]
-		class B : Base {
+		class B : Base
+		{
 			public override void Call ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/UsedOverrideOfAbstractMethodIsKept.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/UsedOverrideOfAbstractMethodIsKept.cs
index f2362aef6..a76b3feed 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/UsedOverrideOfAbstractMethodIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/UsedOverrideOfAbstractMethodIsKept.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
-	public class UsedOverrideOfAbstractMethodIsKept {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses
+{
+	public class UsedOverrideOfAbstractMethodIsKept
+	{
 		public static void Main ()
 		{
 			var tmp = new B ();
@@ -9,7 +11,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
 		}
 
 		[KeptMember (".ctor()")]
-		abstract class Base {
+		abstract class Base
+		{
 			[Kept]
 			public abstract void Call ();
 		}
@@ -17,7 +20,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Base))]
-		class B : Base {
+		class B : Base
+		{
 			[Kept]
 			public override void Call ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/UsedOverrideOfVirtualMethodIsKept.cs b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/UsedOverrideOfVirtualMethodIsKept.cs
index e27049e36..7612c805e 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/UsedOverrideOfVirtualMethodIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.AbstractClasses/UsedOverrideOfVirtualMethodIsKept.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
-	public class UsedOverrideOfVirtualMethodIsKept {
+namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses
+{
+	public class UsedOverrideOfVirtualMethodIsKept
+	{
 		public static void Main ()
 		{
 			var tmp = new B ();
@@ -9,7 +11,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
 		}
 
 		[KeptMember (".ctor()")]
-		abstract class Base {
+		abstract class Base
+		{
 			[Kept]
 			public virtual void Call ()
 			{
@@ -19,7 +22,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.AbstractClasses {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Base))]
-		class B : Base {
+		class B : Base
+		{
 			[Kept]
 			public override void Call ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Complex/NoKeptCtor/OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Complex/NoKeptCtor/OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved.cs
index 2461fa5ba..6a3e9ade7 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Complex/NoKeptCtor/OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Complex/NoKeptCtor/OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Complex.NoKeptCtor {
-	public class OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved {
+namespace Mono.Linker.Tests.Cases.Inheritance.Complex.NoKeptCtor
+{
+	public class OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved
+	{
 		public static void Main ()
 		{
 			Foo b = HelperToMarkFooAndRequireBase ();
@@ -16,25 +18,27 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Complex.NoKeptCtor {
 		}
 
 		[Kept]
-		static void HelperToMarkIBar()
+		static void HelperToMarkIBar ()
 		{
-			GetAnIBar().Method();
+			GetAnIBar ().Method ();
 		}
 
 		[Kept]
-		static IBar GetAnIBar()
+		static IBar GetAnIBar ()
 		{
 			return null;
 		}
 
 		[Kept]
-		abstract class Base {
+		abstract class Base
+		{
 			public abstract void Method ();
 		}
 
 		[Kept]
 		[KeptBaseType (typeof (Base))]
-		class Foo : Base, IBar {
+		class Foo : Base, IBar
+		{
 			public override void Method ()
 			{
 				UsedByOverride ();
@@ -46,7 +50,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Complex.NoKeptCtor {
 		}
 
 		[Kept]
-		interface IBar {
+		interface IBar
+		{
 			[Kept]
 			void Method ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Complex/NoKeptCtor/OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Complex/NoKeptCtor/OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved2.cs
index bddcd0459..daef4a248 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Complex/NoKeptCtor/OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Complex/NoKeptCtor/OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved2.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Complex.NoKeptCtor {
-	public class OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Complex.NoKeptCtor
+{
+	public class OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved2
+	{
 		public static void Main ()
 		{
 			Foo b = null;
@@ -16,25 +18,27 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Complex.NoKeptCtor {
 		}
 
 		[Kept]
-		static void HelperToMarkIBar()
+		static void HelperToMarkIBar ()
 		{
-			GetAnIBar().Method();
+			GetAnIBar ().Method ();
 		}
 
 		[Kept]
-		static IBar GetAnIBar()
+		static IBar GetAnIBar ()
 		{
 			return null;
 		}
 
 		[Kept]
-		abstract class Base {
+		abstract class Base
+		{
 			public abstract void Method ();
 		}
 
 		[Kept]
 		[KeptBaseType (typeof (Base))]
-		class Foo : Base, IBar {
+		class Foo : Base, IBar
+		{
 			public override void Method ()
 			{
 				UsedByOverride ();
@@ -46,7 +50,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Complex.NoKeptCtor {
 		}
 
 		[Kept]
-		interface IBar {
+		interface IBar
+		{
 			[Kept]
 			void Method ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/CanDisableUnusedInterfaces.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/CanDisableUnusedInterfaces.cs
index 45286fa5e..c5b80afbf 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/CanDisableUnusedInterfaces.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/CanDisableUnusedInterfaces.cs
@@ -1,21 +1,25 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces
+{
 	[SetupLinkerArgument ("--disable-opt", "unusedinterfaces")]
-	public class CanDisableUnusedInterfaces {
+	public class CanDisableUnusedInterfaces
+	{
 		public static void Main ()
 		{
 			IFoo i = new A ();
 			i.Foo ();
 		}
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
 		[Kept]
-		interface IBar {
+		interface IBar
+		{
 			// interface methods may still be removed
 			void Bar ();
 		}
@@ -23,7 +27,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces {
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
 		[KeptInterface (typeof (IBar))]
-		class A : IFoo, IBar {
+		class A : IFoo, IBar
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Copy.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Copy.cs
index 72d30becd..de1a710ab 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Copy.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Copy.cs
@@ -1,10 +1,13 @@
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.Dependencies {
-	public class InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Copy {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.Dependencies
+{
+	public class InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Copy
+	{
 		public static void ToKeepReferenceAtCompileTime ()
 		{
 		}
-		
-		public class A : InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link.IFoo {
+
+		public class A : InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link.IFoo
+		{
 			void InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link.IFoo.Method ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link.cs
index cf093a8d7..b4eb14368 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link.cs
@@ -1,6 +1,9 @@
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.Dependencies {
-	public class InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link {
-		public interface IFoo {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.Dependencies
+{
+	public class InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link
+	{
+		public interface IFoo
+		{
 			void Method ();
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Copy.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Copy.cs
index 62eb61d3a..1c9535eae 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Copy.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Copy.cs
@@ -1,10 +1,13 @@
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.Dependencies {
-	public class InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Copy {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.Dependencies
+{
+	public class InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Copy
+	{
 		public static void ToKeepReferenceAtCompileTime ()
 		{
 		}
-		
-		public class A : InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Link.IFoo {
+
+		public class A : InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Link.IFoo
+		{
 			public void Method ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Link.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Link.cs
index a03e2708f..cf6a32bf0 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Link.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Link.cs
@@ -1,6 +1,9 @@
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.Dependencies {
-	public class InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Link {
-		public interface IFoo {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.Dependencies
+{
+	public class InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Link
+	{
+		public interface IFoo
+		{
 			void Method ();
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceWithInterfaceFromOtherAssemblyWhenExplicitMethodUsed_Lib.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceWithInterfaceFromOtherAssemblyWhenExplicitMethodUsed_Lib.cs
index e4ca903cb..4b6ec7990 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceWithInterfaceFromOtherAssemblyWhenExplicitMethodUsed_Lib.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/Dependencies/InterfaceWithInterfaceFromOtherAssemblyWhenExplicitMethodUsed_Lib.cs
@@ -4,7 +4,7 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.Dependencies
 	{
 		public interface IFoo
 		{
-			bool ExplicitMethod();
+			bool ExplicitMethod ();
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/InterfaceOnUninstantiatedTypeRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/InterfaceOnUninstantiatedTypeRemoved.cs
index e07ec42f3..6b2cbd511 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/InterfaceOnUninstantiatedTypeRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/InterfaceOnUninstantiatedTypeRemoved.cs
@@ -1,9 +1,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces
+{
 	[SetupLinkerArgument ("--disable-opt", "unusedinterfaces")]
-	public class InterfaceOnUninstantiatedTypeRemoved {
+	public class InterfaceOnUninstantiatedTypeRemoved
+	{
 		public static void Main ()
 		{
 			A a = HelperToMarkA ();
@@ -13,13 +15,15 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
 
 		[Kept]
-		class A : IFoo {
+		class A : IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
@@ -27,12 +31,14 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces {
 		}
 
 		[Kept]
-		static A HelperToMarkA () {
+		static A HelperToMarkA ()
+		{
 			return null;
 		}
 
 		[Kept]
-		static void StandaloneHelperToMarkIFoo () {
+		static void StandaloneHelperToMarkIFoo ()
+		{
 			// Reference IFoo outside Main to prevent it from being
 			// kept by the body stack logic
 			IFoo i = HelperToMarkIFoo ();
@@ -40,7 +46,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces {
 		}
 
 		[Kept]
-		static IFoo HelperToMarkIFoo () {
+		static IFoo HelperToMarkIFoo ()
+		{
 			return null;
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithEvent.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithEvent.cs
index 74c0f271e..dccfc6033 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithEvent.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithEvent.cs
@@ -1,9 +1,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
 	[KeptDelegateCacheField ("0")]
-	public class GenericInterfaceWithEvent {
-		public static void Main()
+	public class GenericInterfaceWithEvent
+	{
+		public static void Main ()
 		{
 			IFoo<object> f = new ClassFoo ();
 			f.Foo += EventMethod;
@@ -33,7 +35,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptEventAddMethod]
@@ -45,7 +48,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class ClassFoo : BaseFoo, IFoo<object> {
+		class ClassFoo : BaseFoo, IFoo<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericBaseMethod.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericBaseMethod.cs
index d77720ae2..fbf09d1fe 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericBaseMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericBaseMethod.cs
@@ -1,12 +1,14 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
 	// mcs silently generates an explicit interface `Method` on `FooWithBase` that calls `BaseFoo.Method`, this leads to a failure
 	// because the explicit interface `Method` needs a `[Kept]` on it.
 	// To work around this, use csc so that the IL that is produced matches the test assertions we define
 	[SetupCSharpCompilerToUse ("csc")]
-	public class GenericInterfaceWithGenericBaseMethod {
+	public class GenericInterfaceWithGenericBaseMethod
+	{
 		public static void Main ()
 		{
 			IFoo<object, int> f = new FooWithBase<object, int> ();
@@ -14,14 +16,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo<T1, T2> {
+		interface IFoo<T1, T2>
+		{
 			[Kept]
 			void Method (T1 arg, T2 arg2);
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo<T1, T2> {
+		class BaseFoo<T1, T2>
+		{
 			[Kept]
 			public void Method (T1 arg, T2 arg2)
 			{
@@ -32,7 +36,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo<,>), "T1", "T2")]
 		[KeptInterface (typeof (IFoo<,>), "T1", "T2")]
-		class FooWithBase<T1, T2> : BaseFoo<T1, T2>, IFoo<T1, T2> {
+		class FooWithBase<T1, T2> : BaseFoo<T1, T2>, IFoo<T1, T2>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericBaseMethodWithExplicit.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericBaseMethodWithExplicit.cs
index 2add98807..35252bb27 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericBaseMethodWithExplicit.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericBaseMethodWithExplicit.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithGenericBaseMethodWithExplicit {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithGenericBaseMethodWithExplicit
+	{
 		public static void Main ()
 		{
 			IFoo<object, int> f = new FooWithBase<object, int> ();
@@ -9,14 +11,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo<T1, T2> {
+		interface IFoo<T1, T2>
+		{
 			[Kept]
 			void Method (T1 arg, T2 arg2);
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo<T1, T2> {
+		class BaseFoo<T1, T2>
+		{
 			public void Method (T1 arg, T2 arg2)
 			{
 			}
@@ -26,7 +30,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo<,>), "T1", "T2")]
 		[KeptInterface (typeof (IFoo<,>), "T1", "T2")]
-		class FooWithBase<T1, T2> : BaseFoo<T1, T2>, IFoo<T1, T2> {
+		class FooWithBase<T1, T2> : BaseFoo<T1, T2>, IFoo<T1, T2>
+		{
 			[Kept]
 			void IFoo<T1, T2>.Method (T1 arg, T2 arg2)
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericMethod.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericMethod.cs
index 0cace5bbd..42d62e635 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericMethod.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithGenericMethod {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithGenericMethod
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new FooWithBase ();
@@ -9,18 +11,20 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo<TType> {
+		interface IFoo<TType>
+		{
 			[Kept]
 			TMethod Method<TMethod> (TType arg);
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			public TMethod Method<TMethod> (object arg)
 			{
-				return default(TMethod);
+				return default (TMethod);
 			}
 		}
 
@@ -28,7 +32,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo, IFoo<object> {
+		class FooWithBase : BaseFoo, IFoo<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericMethod2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericMethod2.cs
index 9c4a9d63c..2ba99c07d 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericMethod2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericMethod2.cs
@@ -1,27 +1,32 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithGenericMethod2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithGenericMethod2
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new FooWithBase ();
 			var result = f.Method<object> (null);
 		}
-		
+
 		[Kept]
 		[KeptMember (".ctor()")]
-		class GenericType<T> {
+		class GenericType<T>
+		{
 		}
 
 		[Kept]
-		interface IFoo<TType> {
+		interface IFoo<TType>
+		{
 			[Kept]
 			GenericType<TMethod> Method<TMethod> (GenericType<TType> arg);
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			public GenericType<TMethod> Method<TMethod> (GenericType<object> arg)
 			{
@@ -33,7 +38,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo, IFoo<object> {
+		class FooWithBase : BaseFoo, IFoo<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericMethod3.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericMethod3.cs
index f62ba7bca..2a68fcb8d 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericMethod3.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithGenericMethod3.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithGenericMethod3 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithGenericMethod3
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new FooWithBase ();
@@ -9,14 +11,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo<TType> {
+		interface IFoo<TType>
+		{
 			[Kept]
 			void Method<TMethod> (TType arg, TMethod arg2);
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			public void Method<TMethod> (object arg, TMethod arg2)
 			{
@@ -27,7 +31,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo, IFoo<object> {
+		class FooWithBase : BaseFoo, IFoo<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethod.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethod.cs
index cb0cdb95c..ea7148263 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethod.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithMethod {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithMethod
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new FooWithBase ();
@@ -9,14 +11,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			void Method (T arg);
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			public void Method (object arg)
 			{
@@ -27,7 +31,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo, IFoo<object> {
+		class FooWithBase : BaseFoo, IFoo<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethod2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethod2.cs
index 283764abf..9d0dcf395 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethod2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethod2.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithMethod2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithMethod2
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new FooWithBase ();
@@ -9,18 +11,21 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		class GenericType<T> {
+		class GenericType<T>
+		{
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			void Method (GenericType<T> arg);
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			public void Method (GenericType<object> arg)
 			{
@@ -31,7 +36,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo, IFoo<object> {
+		class FooWithBase : BaseFoo, IFoo<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethod3.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethod3.cs
index 8e69856bd..ac1004cc8 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethod3.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethod3.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithMethod3 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithMethod3
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new FooWithBase ();
@@ -9,18 +11,21 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		class GenericType<T> {
+		class GenericType<T>
+		{
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			void Method (GenericType<GenericType<GenericType<T>>> arg);
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			public void Method (GenericType<GenericType<GenericType<object>>> arg)
 			{
@@ -31,7 +36,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo, IFoo<object> {
+		class FooWithBase : BaseFoo, IFoo<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodComplex.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodComplex.cs
index ece8352ce..9286f79a4 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodComplex.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodComplex.cs
@@ -1,12 +1,14 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
 	// mcs silently generates an explicit interface `Method` on `FooWithBase` that calls `BaseFoo.Method`, this leads to a failure
 	// because the explicit interface `Method` needs a `[Kept]` on it.
 	// To work around this, use csc so that the IL that is produced matches the test assertions we define
 	[SetupCSharpCompilerToUse ("csc")]
-	public class GenericInterfaceWithMethodComplex {
+	public class GenericInterfaceWithMethodComplex
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new FooWithBase ();
@@ -14,14 +16,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			void Method (T arg, int arg2);
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo<T1> {
+		class BaseFoo<T1>
+		{
 			[Kept]
 			public void Method (object arg, T1 arg2)
 			{
@@ -31,26 +35,30 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo<>), "T1")]
-		class BaseFoo2<T1> : BaseFoo<T1> {
+		class BaseFoo2<T1> : BaseFoo<T1>
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo2<>), "T1")]
-		class BaseFoo3<T1> : BaseFoo2<T1> {
+		class BaseFoo3<T1> : BaseFoo2<T1>
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo3<>), "T1")]
-		class BaseFoo4<T1> : BaseFoo3<T1> {
+		class BaseFoo4<T1> : BaseFoo3<T1>
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo4<int>))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo4<int>, IFoo<object> {
+		class FooWithBase : BaseFoo4<int>, IFoo<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodComplex2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodComplex2.cs
index 64b560f07..c121ca5a1 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodComplex2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodComplex2.cs
@@ -2,12 +2,14 @@ using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
 	// mcs silently generates an explicit interface `Method` on `FooWithBase` that calls `BaseFoo.Method`, this leads to a failure
 	// because the explicit interface `Method` needs a `[Kept]` on it.
 	// To work around this, use csc so that the IL that is produced matches the test assertions we define
 	[SetupCSharpCompilerToUse ("csc")]
-	public class GenericInterfaceWithMethodComplex2 {
+	public class GenericInterfaceWithMethodComplex2
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new FooWithBase ();
@@ -15,14 +17,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			void Method (T arg, int arg2);
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo<T1> {
+		class BaseFoo<T1>
+		{
 			[Kept]
 			public void Method (object arg, T1 arg2)
 			{
@@ -38,26 +42,30 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo<>), "T1")]
-		class BaseFoo2<T1> : BaseFoo<T1> {
+		class BaseFoo2<T1> : BaseFoo<T1>
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo2<>), "T1")]
-		class BaseFoo3<T1> : BaseFoo2<T1> {
+		class BaseFoo3<T1> : BaseFoo2<T1>
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo3<>), "T1")]
-		class BaseFoo4<T1> : BaseFoo3<T1> {
+		class BaseFoo4<T1> : BaseFoo3<T1>
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo4<int>))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo4<int>, IFoo<object> {
+		class FooWithBase : BaseFoo4<int>, IFoo<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyBaseInterfaces.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyBaseInterfaces.cs
index ac5cc4cb4..f9b338ead 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyBaseInterfaces.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyBaseInterfaces.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithMethodManyBaseInterfaces {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithMethodManyBaseInterfaces
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new FooWithBase ();
@@ -9,20 +11,24 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			void Method (T arg);
 		}
-		
-		interface IFoo2<T> : IFoo<T> {
+
+		interface IFoo2<T> : IFoo<T>
+		{
 		}
-		
-		interface IFoo3<T> : IFoo2<T> {
+
+		interface IFoo3<T> : IFoo2<T>
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			public void Method (object arg)
 			{
@@ -33,7 +39,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo, IFoo3<object> {
+		class FooWithBase : BaseFoo, IFoo3<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyBases.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyBases.cs
index b39dfe14f..fb2ed835a 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyBases.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyBases.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithMethodManyBases {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithMethodManyBases
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new FooWithBase ();
@@ -9,14 +11,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			void Method (T arg);
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			public void Method (object arg)
 			{
@@ -26,26 +30,30 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
-		class BaseFoo2 : BaseFoo {
+		class BaseFoo2 : BaseFoo
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo2))]
-		class BaseFoo3 : BaseFoo2 {
+		class BaseFoo3 : BaseFoo2
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo3))]
-		class BaseFoo4 : BaseFoo3 {
+		class BaseFoo4 : BaseFoo3
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo4))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo4, IFoo<object> {
+		class FooWithBase : BaseFoo4, IFoo<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyBases2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyBases2.cs
index 4370698f0..17a59bedc 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyBases2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyBases2.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithMethodManyBases2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithMethodManyBases2
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new FooWithBase ();
@@ -9,14 +11,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			void Method (T arg);
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			public void Method (object arg)
 			{
 			}
@@ -25,13 +29,15 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
-		class BaseFoo2 : BaseFoo {
+		class BaseFoo2 : BaseFoo
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo2))]
-		class BaseFoo3 : BaseFoo2 {
+		class BaseFoo3 : BaseFoo2
+		{
 			[Kept]
 			public void Method (object arg)
 			{
@@ -41,14 +47,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo3))]
-		class BaseFoo4 : BaseFoo3 {
+		class BaseFoo4 : BaseFoo3
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo4))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo4, IFoo<object> {
+		class FooWithBase : BaseFoo4, IFoo<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyBases3.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyBases3.cs
index fc7de4e8b..c546cdd5a 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyBases3.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyBases3.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithMethodManyBases3 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithMethodManyBases3
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new FooWithBase ();
@@ -9,14 +11,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			void Method (T arg);
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			public virtual void Method (object arg)
 			{
@@ -26,13 +30,15 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
-		class BaseFoo2 : BaseFoo {
+		class BaseFoo2 : BaseFoo
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo2))]
-		class BaseFoo3 : BaseFoo2 {
+		class BaseFoo3 : BaseFoo2
+		{
 			[Kept]
 			public override void Method (object arg)
 			{
@@ -42,14 +48,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo3))]
-		class BaseFoo4 : BaseFoo3 {
+		class BaseFoo4 : BaseFoo3
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo4))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo4, IFoo<object> {
+		class FooWithBase : BaseFoo4, IFoo<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyVariations.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyVariations.cs
index 965976403..078f4b94c 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyVariations.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodManyVariations.cs
@@ -1,26 +1,30 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithMethodManyVariations {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithMethodManyVariations
+	{
 		public static void Main ()
 		{
 			var fb = new FooWithBase ();
 			IFoo<object> fo = fb;
 			fo.Method (null);
-			
+
 			IFoo<int> fi = fb;
 			fi.Method (0);
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			void Method (T arg);
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			public void Method (object arg)
 			{
@@ -55,11 +59,13 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptInterface (typeof (IFoo<int>))]
 		[KeptInterface (typeof (IFoo<string>))] // FIXME : Should be removed
 		[KeptInterface (typeof (IFoo<Bar>))] // FIXME : Should be removed
-		class FooWithBase : BaseFoo, IFoo<object>, IFoo<int>, IFoo<string>, IFoo<Bar> {
+		class FooWithBase : BaseFoo, IFoo<object>, IFoo<int>, IFoo<string>, IFoo<Bar>
+		{
 		}
 
 		[Kept] // FIXME : Should be removed
-		class Bar {
+		class Bar
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodNested.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodNested.cs
index 9704459c6..7da82eb78 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodNested.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodNested.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithMethodNested {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithMethodNested
+	{
 		public static void Main ()
 		{
 			IFoo<IFoo<IFoo<IFoo<object>>>> f = new FooWithBase ();
@@ -9,14 +11,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			void Method (T arg);
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			public void Method (IFoo<IFoo<IFoo<object>>> arg)
 			{
@@ -27,7 +31,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo<IFoo<IFoo<IFoo<object>>>>))]
-		class FooWithBase : BaseFoo, IFoo<IFoo<IFoo<IFoo<object>>>> {
+		class FooWithBase : BaseFoo, IFoo<IFoo<IFoo<IFoo<object>>>>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodOnNoInstanceCtor.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodOnNoInstanceCtor.cs
index 56e268295..b47644959 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodOnNoInstanceCtor.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodOnNoInstanceCtor.cs
@@ -1,12 +1,14 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithMethodOnNoInstanceCtor {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithMethodOnNoInstanceCtor
+	{
 		public static void Main ()
 		{
-			IFoo<object> f = new OtherWithFoo();
+			IFoo<object> f = new OtherWithFoo ();
 			f.Method (null);
-			UsedToMarkTypeOnly(null);
+			UsedToMarkTypeOnly (null);
 		}
 
 		[Kept]
@@ -15,13 +17,15 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			void Method (T arg);
 		}
 
 		[Kept]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			public void Method (object arg)
 			{
@@ -31,13 +35,15 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[Kept]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo, IFoo<object> {
+		class FooWithBase : BaseFoo, IFoo<object>
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo<object>))]
-		class OtherWithFoo : IFoo<object> {
+		class OtherWithFoo : IFoo<object>
+		{
 			[Kept]
 			public void Method (object arg)
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodOnNoInstanceCtor2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodOnNoInstanceCtor2.cs
index a20c64add..04d942029 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodOnNoInstanceCtor2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithMethodOnNoInstanceCtor2.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
 	/// <summary>
 	/// Interface must remain in this case due to the possible types on the stack
 	/// </summary>
-	public class GenericInterfaceWithMethodOnNoInstanceCtor2 {
+	public class GenericInterfaceWithMethodOnNoInstanceCtor2
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new OtherWithFoo ();
@@ -13,13 +15,15 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			void Method (T arg);
 		}
 
 		[Kept]
-		class BaseFoo {
+		class BaseFoo
+		{
 			public void Method (object arg)
 			{
 			}
@@ -27,7 +31,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 
 		[Kept]
 		[KeptBaseType (typeof (BaseFoo))]
-		class FooWithBase : BaseFoo, IFoo<object> {
+		class FooWithBase : BaseFoo, IFoo<object>
+		{
 			[Kept]
 			public static void UsedToMarkTypeOnly ()
 			{
@@ -37,7 +42,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo<object>))]
-		class OtherWithFoo : IFoo<object> {
+		class OtherWithFoo : IFoo<object>
+		{
 			[Kept]
 			public void Method (object arg)
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithPropertyGetter.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithPropertyGetter.cs
index e21f2d439..dd75b0f42 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithPropertyGetter.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithPropertyGetter.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithPropertyGetter {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithPropertyGetter
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new FooWithBase ();
@@ -9,14 +11,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			T Property { get; [Kept] set; }
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			[KeptBackingField]
 			public object Property { get; [Kept] set; }
@@ -26,7 +30,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo, IFoo<object> {
+		class FooWithBase : BaseFoo, IFoo<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithPropertyGetter2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithPropertyGetter2.cs
index 95cfbe973..d6ea52171 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithPropertyGetter2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithPropertyGetter2.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithPropertyGetter2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithPropertyGetter2
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new FooWithBase ();
@@ -10,18 +12,21 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class GenericType<T> {
+		class GenericType<T>
+		{
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			GenericType<T> Property { get; [Kept] set; }
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			[KeptBackingField]
 			public GenericType<object> Property { get; [Kept] set; }
@@ -31,7 +36,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo, IFoo<object> {
+		class FooWithBase : BaseFoo, IFoo<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithPropertySetter.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithPropertySetter.cs
index 19233b630..9bc7ffaa2 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithPropertySetter.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithPropertySetter.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithPropertySetter {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithPropertySetter
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new FooWithBase ();
@@ -9,14 +11,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			T Property { [Kept] get; set; }
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			[KeptBackingField]
 			public object Property { [Kept] get; set; }
@@ -26,7 +30,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo, IFoo<object> {
+		class FooWithBase : BaseFoo, IFoo<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithPropertySetter2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithPropertySetter2.cs
index c8907671e..897841e7d 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithPropertySetter2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/GenericInterfaceWithPropertySetter2.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class GenericInterfaceWithPropertySetter2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class GenericInterfaceWithPropertySetter2
+	{
 		public static void Main ()
 		{
 			IFoo<object> f = new FooWithBase ();
@@ -9,18 +11,21 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		class GenericType<T> {
+		class GenericType<T>
+		{
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			GenericType<T> Property { [Kept] get; set; }
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			[KeptBackingField]
 			public GenericType<object> Property { [Kept] get; set; }
@@ -30,7 +35,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo<object>))]
-		class FooWithBase : BaseFoo, IFoo<object> {
+		class FooWithBase : BaseFoo, IFoo<object>
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/InterfaceRemovedWhenMethodUsedDirectly.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/InterfaceRemovedWhenMethodUsedDirectly.cs
index de61e3b3c..a78d14d4e 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/InterfaceRemovedWhenMethodUsedDirectly.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/InterfaceRemovedWhenMethodUsedDirectly.cs
@@ -1,20 +1,24 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class InterfaceRemovedWhenMethodUsedDirectly {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class InterfaceRemovedWhenMethodUsedDirectly
+	{
 		public static void Main ()
 		{
 			var f = new FooWithBase ();
 			f.Method ();
 		}
 
-		interface IFoo {
+		interface IFoo
+		{
 			void Method ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			public void Method ()
 			{
@@ -24,7 +28,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
-		class FooWithBase : BaseFoo, IFoo {
+		class FooWithBase : BaseFoo, IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleEvent.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleEvent.cs
index c5ce60059..7aed0ec79 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleEvent.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleEvent.cs
@@ -1,9 +1,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
 	[KeptDelegateCacheField ("0")]
-	public class SimpleEvent {
-		public static void Main()
+	public class SimpleEvent
+	{
+		public static void Main ()
 		{
 			IFoo f = new FooWithBase ();
 			f.Foo += EventMethod;
@@ -23,7 +25,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		delegate void CustomDelegate ();
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			[KeptEventAddMethod]
 			[KeptEventRemoveMethod]
@@ -32,7 +35,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptEventAddMethod]
@@ -44,7 +48,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo))]
-		class FooWithBase : BaseFoo, IFoo {
+		class FooWithBase : BaseFoo, IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleMethod.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleMethod.cs
index 8d0efab53..a395d4197 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleMethod.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class SimpleMethod {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class SimpleMethod
+	{
 		public static void Main ()
 		{
 			IFoo f = new FooWithBase ();
@@ -9,14 +11,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Method ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			public void Method ()
 			{
@@ -27,7 +31,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo))]
-		class FooWithBase : BaseFoo, IFoo {
+		class FooWithBase : BaseFoo, IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleMethodOnNoInstanceCtor.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleMethodOnNoInstanceCtor.cs
index b232ee2ea..1e75863e8 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleMethodOnNoInstanceCtor.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleMethodOnNoInstanceCtor.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
 	/// <summary>
 	/// Interface must remain in this case due to the possible types on the stack
 	/// </summary>
-	public class SimpleMethodOnNoInstanceCtor {
+	public class SimpleMethodOnNoInstanceCtor
+	{
 		public static void Main ()
 		{
 			IFoo f = new OtherWithFoo ();
@@ -18,13 +20,15 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Method ();
 		}
 
 		[Kept]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			public void Method ()
 			{
@@ -34,13 +38,15 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[Kept]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo))]
-		class FooWithBase : BaseFoo, IFoo {
+		class FooWithBase : BaseFoo, IFoo
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class OtherWithFoo : IFoo  {
+		class OtherWithFoo : IFoo
+		{
 			[Kept]
 			public void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleMethodOnNoInstanceCtor2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleMethodOnNoInstanceCtor2.cs
index 5b83c990b..631816d05 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleMethodOnNoInstanceCtor2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleMethodOnNoInstanceCtor2.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class SimpleMethodOnNoInstanceCtor2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class SimpleMethodOnNoInstanceCtor2
+	{
 		public static void Main ()
 		{
 			IFoo f = new OtherWithFoo ();
@@ -10,13 +12,15 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Method ();
 		}
 
 		[Kept]
-		class BaseFoo {
+		class BaseFoo
+		{
 			public void Method ()
 			{
 			}
@@ -24,9 +28,10 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 
 		[Kept]
 		[KeptBaseType (typeof (BaseFoo))]
-		class FooWithBase : BaseFoo, IFoo {
+		class FooWithBase : BaseFoo, IFoo
+		{
 			[Kept]
-			public static void UsedToMarkTypeOnly()
+			public static void UsedToMarkTypeOnly ()
 			{
 			}
 		}
@@ -34,7 +39,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class OtherWithFoo : IFoo {
+		class OtherWithFoo : IFoo
+		{
 			[Kept]
 			public void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleProperty.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleProperty.cs
index 969746e53..20f196c7d 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleProperty.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/BaseProvidesInterfaceMember/SimpleProperty.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember {
-	public class SimpleProperty {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BaseProvidesInterfaceMember
+{
+	public class SimpleProperty
+	{
 		public static void Main ()
 		{
 			IFoo f = new FooWithBase ();
@@ -9,14 +11,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			int Property { get; [Kept] set; }
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class BaseFoo {
+		class BaseFoo
+		{
 			[Kept]
 			[KeptBackingField]
 			public int Property { get; [Kept] set; }
@@ -26,7 +30,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.BasePro
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (BaseFoo))]
 		[KeptInterface (typeof (IFoo))]
-		class FooWithBase : BaseFoo, IFoo {
+		class FooWithBase : BaseFoo, IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplementingInterfaceMethodsNested.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplementingInterfaceMethodsNested.cs
index 3a4b3b197..c449911f6 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplementingInterfaceMethodsNested.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplementingInterfaceMethodsNested.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	public class ClassImplementingInterfaceMethodsNested {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	public class ClassImplementingInterfaceMethodsNested
+	{
 		public static void Main ()
 		{
 			IFoo i = new A ();
@@ -9,19 +11,22 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
 
-		interface IBar : IFoo {
+		interface IBar : IFoo
+		{
 			void Bar ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class A : IBar {
+		class A : IBar
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplementingInterfaceMethodsNested2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplementingInterfaceMethodsNested2.cs
index aba1ed062..db1ee8d82 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplementingInterfaceMethodsNested2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplementingInterfaceMethodsNested2.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	public class ClassImplementingInterfaceMethodsNested2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	public class ClassImplementingInterfaceMethodsNested2
+	{
 		public static void Main ()
 		{
 			IBar b = new A ();
@@ -10,22 +12,25 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
-		
+
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		interface IBar : IFoo {
+		interface IBar : IFoo
+		{
 			void Bar ();
 		}
-		
+
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IBar))]
 		[KeptInterface (typeof (IFoo))]
-		class A : IBar {
+		class A : IBar
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass2.cs
index 0d7f9353e..773d19a42 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass2.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	class ClassImplemtingInterfaceMethodsThroughBaseClass2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	class ClassImplemtingInterfaceMethodsThroughBaseClass2
+	{
 		public static void Main ()
 		{
 			new B ();
@@ -9,20 +11,23 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 			i.Foo ();
 		}
 
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
 
 		[KeptMember (".ctor()")]
-		class B {
+		class B
+		{
 			[Kept] // FIXME: Should be removed
 			public void Foo ()
 			{
 			}
 		}
 
-		class A : B, IFoo {
+		class A : B, IFoo
+		{
 			//my IFoo.Foo() is actually implemented by B which doesn't know about it.
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass3.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass3.cs
index 1154be592..a0aa654cd 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass3.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass3.cs
@@ -1,25 +1,30 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	class ClassImplemtingInterfaceMethodsThroughBaseClass3 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	class ClassImplemtingInterfaceMethodsThroughBaseClass3
+	{
 		public static void Main ()
 		{
 			new B ().Foo ();
 		}
 
-		interface IFoo {
+		interface IFoo
+		{
 			void Foo ();
 		}
 
 		[KeptMember (".ctor()")]
-		class B {
+		class B
+		{
 			[Kept]
 			public void Foo ()
 			{
 			}
 		}
 
-		class A : B, IFoo {
+		class A : B, IFoo
+		{
 			//my IFoo.Foo() is actually implemented by B which doesn't know about it.
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass4.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass4.cs
index 7a01c07ac..0568a083d 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass4.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass4.cs
@@ -1,18 +1,22 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	class ClassImplemtingInterfaceMethodsThroughBaseClass4 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	class ClassImplemtingInterfaceMethodsThroughBaseClass4
+	{
 		public static void Main ()
 		{
 			new A ().Foo ();
 		}
 
-		interface IFoo {
+		interface IFoo
+		{
 			void Foo ();
 		}
 
 		[KeptMember (".ctor()")]
-		class B {
+		class B
+		{
 			[Kept]
 			public void Foo ()
 			{
@@ -21,7 +25,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (B))]
-		class A : B, IFoo {
+		class A : B, IFoo
+		{
 			//my IFoo.Foo() is actually implemented by B which doesn't know about it.
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass5.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass5.cs
index f7ebfda35..c68047a41 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass5.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass5.cs
@@ -1,18 +1,22 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	class ClassImplemtingInterfaceMethodsThroughBaseClass5 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	class ClassImplemtingInterfaceMethodsThroughBaseClass5
+	{
 		public static void Main ()
 		{
 			new A ();
 		}
 
-		interface IFoo {
+		interface IFoo
+		{
 			void Foo ();
 		}
 
 		[KeptMember (".ctor()")]
-		class B {
+		class B
+		{
 			public void Foo ()
 			{
 			}
@@ -20,7 +24,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (B))]
-		class A : B, IFoo {
+		class A : B, IFoo
+		{
 			//my IFoo.Foo() is actually implemented by B which doesn't know about it.
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass6.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass6.cs
index 1f43d756f..7e4f29dbd 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass6.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassImplemtingInterfaceMethodsThroughBaseClass6.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	class ClassImplemtingInterfaceMethodsThroughBaseClass6 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	class ClassImplemtingInterfaceMethodsThroughBaseClass6
+	{
 		public static void Main ()
 		{
 			B tmp = new B ();
@@ -9,26 +11,30 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 			i.Foo ();
 		}
 
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
 
 		[KeptMember (".ctor()")]
-		class B {
+		class B
+		{
 			[Kept] // FIXME: Needs to be removed
 			public void Foo ()
 			{
 			}
 		}
 
-		class A : B, IFoo {
+		class A : B, IFoo
+		{
 			//my IFoo.Foo() is actually implemented by B which doesn't know about it.
 		}
 
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class C : IFoo {
+		class C : IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassUsedFromConcreteTypeHasInterfaceMethodRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassUsedFromConcreteTypeHasInterfaceMethodRemoved.cs
index 8c9212981..dae63399b 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassUsedFromConcreteTypeHasInterfaceMethodRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassUsedFromConcreteTypeHasInterfaceMethodRemoved.cs
@@ -2,7 +2,8 @@
 
 namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
 {
-	class ClassUsedFromConcreteTypeHasInterfaceMethodRemoved {
+	class ClassUsedFromConcreteTypeHasInterfaceMethodRemoved
+	{
 		public static void Main ()
 		{
 			A a = new A ();
@@ -11,14 +12,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class A : IFoo {
+		class A : IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
 			}
 		}
 
-		public interface IFoo {
+		public interface IFoo
+		{
 			void Foo ();
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassUsedFromConcreteTypeHasInterfaceMethodRemoved2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassUsedFromConcreteTypeHasInterfaceMethodRemoved2.cs
index f754047ca..2562faf27 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassUsedFromConcreteTypeHasInterfaceMethodRemoved2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassUsedFromConcreteTypeHasInterfaceMethodRemoved2.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	public class ClassUsedFromConcreteTypeHasInterfaceMethodRemoved2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	public class ClassUsedFromConcreteTypeHasInterfaceMethodRemoved2
+	{
 		public static void Main ()
 		{
 			A a = new A ();
@@ -14,7 +16,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class A : IFoo {
+		class A : IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
@@ -22,7 +25,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		}
 
 		[Kept]
-		public interface IFoo {
+		public interface IFoo
+		{
 			void Foo ();
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassUsedFromInterfaceHasInterfaceMethodKept.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassUsedFromInterfaceHasInterfaceMethodKept.cs
index a04dcb72c..613290a62 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassUsedFromInterfaceHasInterfaceMethodKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ClassUsedFromInterfaceHasInterfaceMethodKept.cs
@@ -2,7 +2,8 @@
 
 namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
 {
-	class ClassUsedFromInterfaceHasInterfaceMethodKept {
+	class ClassUsedFromInterfaceHasInterfaceMethodKept
+	{
 		public static void Main ()
 		{
 			IFoo a = new A ();
@@ -12,7 +13,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class A : IFoo {
+		class A : IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
@@ -20,7 +22,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
 		}
 
 		[Kept]
-		public interface IFoo {
+		public interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ExplicitInterfaceMethodWhichCreatesInstanceOfParentType.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ExplicitInterfaceMethodWhichCreatesInstanceOfParentType.cs
index a9f3729d0..e7eacad3d 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ExplicitInterfaceMethodWhichCreatesInstanceOfParentType.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ExplicitInterfaceMethodWhichCreatesInstanceOfParentType.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	public class ExplicitInterfaceMethodWhichCreatesInstanceOfParentType {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	public class ExplicitInterfaceMethodWhichCreatesInstanceOfParentType
+	{
 		public static void Main ()
 		{
 			IFoo b = new B ();
@@ -9,7 +11,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Method ();
 		}
@@ -17,14 +20,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class B : IFoo {
+		class B : IFoo
+		{
 			[Kept]
 			public void Method ()
 			{
 			}
 		}
-		
-		class C : IFoo {
+
+		class C : IFoo
+		{
 			void IFoo.Method () { new C (); }
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceMarkOrderingDoesNotMatter.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceMarkOrderingDoesNotMatter.cs
index 6a2597c8c..c8f145f63 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceMarkOrderingDoesNotMatter.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceMarkOrderingDoesNotMatter.cs
@@ -1,18 +1,20 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	public class InterfaceMarkOrderingDoesNotMatter {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	public class InterfaceMarkOrderingDoesNotMatter
+	{
 		public static void Main ()
 		{
 			CauseAToBeMarked ().AMethod ();
 			CauseZToBeMarked ().ZMethod ();
-			
+
 			MMarked m = new MMarked ();
 
 			B b = m;
 			Y y = m;
 			Nested.F f = m;
-			
+
 			b.BMethod ();
 			y.YMethod ();
 			f.FMethod ();
@@ -23,7 +25,7 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		{
 			return null;
 		}
-		
+
 		[Kept]
 		static Z CauseZToBeMarked ()
 		{
@@ -31,19 +33,22 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		}
 
 		[Kept]
-		interface A {
+		interface A
+		{
 			[Kept]
 			void AMethod ();
 		}
 
 		[Kept]
-		interface Z {
+		interface Z
+		{
 			[Kept]
 			void ZMethod ();
 		}
-		
+
 		[Kept]
-		interface C {
+		interface C
+		{
 			[Kept]
 			void CMethod ();
 		}
@@ -58,9 +63,10 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		[KeptInterface (typeof (Y))]
 		[KeptInterface (typeof (Z))]
 		[KeptInterface (typeof (E))]
-		class MMarked : A, B, Y, Z, C, D, Nested.F, E {
+		class MMarked : A, B, Y, Z, C, D, Nested.F, E
+		{
 			[Kept]
-			public void AMethod()
+			public void AMethod ()
 			{
 			}
 
@@ -101,34 +107,40 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		}
 
 		[Kept]
-		public static class Nested {
+		public static class Nested
+		{
 			[Kept]
-			public interface F {
+			public interface F
+			{
 				[Kept]
 				void FMethod ();
 			}
 		}
 
 		[Kept]
-		interface B {
+		interface B
+		{
 			[Kept]
 			void BMethod ();
 		}
 
 		[Kept]
-		interface Y {
+		interface Y
+		{
 			[Kept]
 			void YMethod ();
 		}
 
 		[Kept]
-		interface D {
+		interface D
+		{
 			[Kept]
 			void DMethod ();
 		}
 
 		[Kept]
-		interface E {
+		interface E
+		{
 			[Kept]
 			void EMethod ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceMarkOrderingDoesNotMatter2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceMarkOrderingDoesNotMatter2.cs
index 1831dcd57..a2f3aff82 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceMarkOrderingDoesNotMatter2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceMarkOrderingDoesNotMatter2.cs
@@ -15,9 +15,10 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
 	[KeptInterface (typeof (InterfaceMarkOrderingDoesNotMatter2_Z.E))]
 	class InterfaceMarkOrderingDoesNotMatter2_A : InterfaceMarkOrderingDoesNotMatter2_Z.A, InterfaceMarkOrderingDoesNotMatter2_Z.B, InterfaceMarkOrderingDoesNotMatter2_Z.Y,
 		InterfaceMarkOrderingDoesNotMatter2_Z.Z, InterfaceMarkOrderingDoesNotMatter2_Z.C, InterfaceMarkOrderingDoesNotMatter2_Z.D,
-		InterfaceMarkOrderingDoesNotMatter2_Z.Nested.F, InterfaceMarkOrderingDoesNotMatter2_Z.E {
+		InterfaceMarkOrderingDoesNotMatter2_Z.Nested.F, InterfaceMarkOrderingDoesNotMatter2_Z.E
+	{
 		[Kept]
-		public void AMethod()
+		public void AMethod ()
 		{
 		}
 
@@ -59,84 +60,94 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
 
 	public class InterfaceMarkOrderingDoesNotMatter2
 	{
-		public static void Main()
+		public static void Main ()
 		{
-			CauseAToBeMarked().AMethod();
-			CauseZToBeMarked().ZMethod();
+			CauseAToBeMarked ().AMethod ();
+			CauseZToBeMarked ().ZMethod ();
 
-			InterfaceMarkOrderingDoesNotMatter2_A mUsedInCode = new InterfaceMarkOrderingDoesNotMatter2_A();
+			InterfaceMarkOrderingDoesNotMatter2_A mUsedInCode = new InterfaceMarkOrderingDoesNotMatter2_A ();
 
 			InterfaceMarkOrderingDoesNotMatter2_Z.B b = mUsedInCode;
 			InterfaceMarkOrderingDoesNotMatter2_Z.Y y = mUsedInCode;
 			InterfaceMarkOrderingDoesNotMatter2_Z.Nested.F f = mUsedInCode;
 
-			b.BMethod();
-			y.YMethod();
-			f.FMethod();
+			b.BMethod ();
+			y.YMethod ();
+			f.FMethod ();
 		}
-		
+
 		[Kept]
 		static InterfaceMarkOrderingDoesNotMatter2_Z.A CauseAToBeMarked ()
 		{
 			return null;
 		}
-		
+
 		[Kept]
 		static InterfaceMarkOrderingDoesNotMatter2_Z.Z CauseZToBeMarked ()
 		{
 			return null;
 		}
 	}
-	
+
 	[Kept]
-	public class InterfaceMarkOrderingDoesNotMatter2_Z {
+	public class InterfaceMarkOrderingDoesNotMatter2_Z
+	{
 		[Kept]
-		public interface A {
+		public interface A
+		{
 			[Kept]
 			void AMethod ();
 		}
 
 		[Kept]
-		public interface Z {
+		public interface Z
+		{
 			[Kept]
 			void ZMethod ();
 		}
-		
+
 		[Kept]
-		public interface C {
+		public interface C
+		{
 			[Kept]
 			void CMethod ();
 		}
 
 		[Kept]
-		public static class Nested {
+		public static class Nested
+		{
 			[Kept]
-			public interface F {
+			public interface F
+			{
 				[Kept]
 				void FMethod ();
 			}
 		}
 
 		[Kept]
-		public interface B {
+		public interface B
+		{
 			[Kept]
 			void BMethod ();
 		}
 
 		[Kept]
-		public interface Y {
+		public interface Y
+		{
 			[Kept]
 			void YMethod ();
 		}
 
 		[Kept]
-		public interface D {
+		public interface D
+		{
 			[Kept]
 			void DMethod ();
 		}
 
 		[Kept]
-		public interface E {
+		public interface E
+		{
 			[Kept]
 			void EMethod ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceMarkOrderingDoesNotMatter3.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceMarkOrderingDoesNotMatter3.cs
index 5c658dedc..a5b5e4039 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceMarkOrderingDoesNotMatter3.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceMarkOrderingDoesNotMatter3.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	public class InterfaceMarkOrderingDoesNotMatter3 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	public class InterfaceMarkOrderingDoesNotMatter3
+	{
 		public static void Main ()
 		{
 			CauseAToBeMarked ().AMethod ();
@@ -9,7 +11,7 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 			CauseBToBeMarked ().BMethod ();
 			CauseYToBeMarked ().YMethod ();
 			CauseFToBeMarked ().FMethod ();
-			var c = CauseCToBeMarked();
+			var c = CauseCToBeMarked ();
 		}
 
 		[Kept]
@@ -17,31 +19,31 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		{
 			return null;
 		}
-		
+
 		[Kept]
 		static Z CauseZToBeMarked ()
 		{
 			return null;
 		}
-		
+
 		[Kept]
 		static B CauseBToBeMarked ()
 		{
 			return null;
 		}
-		
+
 		[Kept]
 		static Y CauseYToBeMarked ()
 		{
 			return null;
 		}
-		
+
 		[Kept]
 		static Nested.F CauseFToBeMarked ()
 		{
 			return null;
 		}
-		
+
 		[Kept]
 		static C CauseCToBeMarked ()
 		{
@@ -49,19 +51,22 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		}
 
 		[Kept]
-		interface A {
+		interface A
+		{
 			[Kept]
 			void AMethod ();
 		}
 
 		[Kept]
-		interface Z {
+		interface Z
+		{
 			[Kept]
 			void ZMethod ();
 		}
 
 		[Kept]
-		interface C {
+		interface C
+		{
 			void CMethod ();
 		}
 
@@ -73,9 +78,10 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		[KeptInterface (typeof (Nested.F))]
 		[KeptInterface (typeof (Y))]
 		[KeptInterface (typeof (Z))]
-		class MMarked : A, B, Y, Z, C, D, Nested.F, E {
+		class MMarked : A, B, Y, Z, C, D, Nested.F, E
+		{
 			[Kept]
-			public void AMethod()
+			public void AMethod ()
 			{
 			}
 
@@ -113,31 +119,37 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		}
 
 		[Kept]
-		public static class Nested {
+		public static class Nested
+		{
 			[Kept]
-			public interface F {
+			public interface F
+			{
 				[Kept]
 				void FMethod ();
 			}
 		}
 
 		[Kept]
-		interface B {
+		interface B
+		{
 			[Kept]
 			void BMethod ();
 		}
 
 		[Kept]
-		interface Y {
+		interface Y
+		{
 			[Kept]
 			void YMethod ();
 		}
 
-		interface D {
+		interface D
+		{
 			void DMethod ();
 		}
 
-		interface E {
+		interface E
+		{
 			void EMethod ();
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeInOtherUsedOnlyByCopiedAssembly.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeInOtherUsedOnlyByCopiedAssembly.cs
index ba22206b3..885654646 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeInOtherUsedOnlyByCopiedAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeInOtherUsedOnlyByCopiedAssembly.cs
@@ -2,17 +2,19 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.Interfaces.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	[SetupCompileBefore ("linked.dll", new [] {typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Link)})]
-	[SetupCompileBefore ("copy.dll", new [] {typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Copy)}, new [] {"linked.dll"})]
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	[SetupCompileBefore ("linked.dll", new[] { typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Link) })]
+	[SetupCompileBefore ("copy.dll", new[] { typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Copy) }, new[] { "linked.dll" })]
 
 	[SetupLinkerAction ("copy", "copy")]
 	[SetupLinkerArgument ("-a", "copy")]
-	
+
 	[KeptTypeInAssembly ("linked.dll", typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Link.IFoo))]
 	[KeptMemberInAssembly ("copy.dll", typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Copy.A), "Method()")]
 	[KeptInterfaceOnTypeInAssembly ("copy.dll", typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Copy.A), "linked.dll", typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Link.IFoo))]
-	public class InterfaceTypeInOtherUsedOnlyByCopiedAssembly {
+	public class InterfaceTypeInOtherUsedOnlyByCopiedAssembly
+	{
 		public static void Main ()
 		{
 			InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Copy.ToKeepReferenceAtCompileTime ();
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit.cs
index df3936a70..ee74998a0 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit.cs
@@ -2,9 +2,10 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.Interfaces.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	[SetupCompileBefore ("linked.dll", new [] {typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link)})]
-	[SetupCompileBefore ("copy.dll", new [] {typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Copy)}, new [] {"linked.dll"})]
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	[SetupCompileBefore ("linked.dll", new[] { typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link) })]
+	[SetupCompileBefore ("copy.dll", new[] { typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Copy) }, new[] { "linked.dll" })]
 
 	[SetupLinkerAction ("copy", "copy")]
 	[SetupLinkerArgument ("-a", "copy")]
@@ -12,7 +13,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 	[KeptMemberInAssembly ("linked.dll", typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link.IFoo), "Method()")]
 	[KeptMemberInAssembly ("copy.dll", typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Copy.A), "Mono.Linker.Tests.Cases.Inheritance.Interfaces.Dependencies.InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link.IFoo.Method()")]
 	[KeptInterfaceOnTypeInAssembly ("copy.dll", typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Copy.A), "linked.dll", typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link.IFoo))]
-	public class InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit {
+	public class InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit
+	{
 		public static void Main ()
 		{
 			InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Copy.ToKeepReferenceAtCompileTime ();
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeInOtherUsedOnlyBySavedAssembly.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeInOtherUsedOnlyBySavedAssembly.cs
index 549ab7ecd..258a38b26 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeInOtherUsedOnlyBySavedAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeInOtherUsedOnlyBySavedAssembly.cs
@@ -2,17 +2,19 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.Interfaces.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	[SetupCompileBefore ("linked.dll", new [] {typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Link)})]
-	[SetupCompileBefore ("save.dll", new [] {typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Copy)}, new [] {"linked.dll"})]
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	[SetupCompileBefore ("linked.dll", new[] { typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Link) })]
+	[SetupCompileBefore ("save.dll", new[] { typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Copy) }, new[] { "linked.dll" })]
 
 	[SetupLinkerAction ("save", "save")]
 	[SetupLinkerArgument ("-a", "save")]
-	
+
 	[KeptTypeInAssembly ("linked.dll", typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Link.IFoo))]
 	[KeptMemberInAssembly ("save.dll", typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Copy.A), "Method()")]
 	[KeptInterfaceOnTypeInAssembly ("save.dll", typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Copy.A), "linked.dll", typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Link.IFoo))]
-	public class InterfaceTypeInOtherUsedOnlyBySavedAssembly {
+	public class InterfaceTypeInOtherUsedOnlyBySavedAssembly
+	{
 		public static void Main ()
 		{
 			InterfaceTypeInOtherUsedOnlyByCopiedAssembly_Copy.ToKeepReferenceAtCompileTime ();
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeInOtherUsedOnlyBySavedAssemblyExplicit.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeInOtherUsedOnlyBySavedAssemblyExplicit.cs
index fba04116d..49808a86f 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeInOtherUsedOnlyBySavedAssemblyExplicit.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeInOtherUsedOnlyBySavedAssemblyExplicit.cs
@@ -2,9 +2,10 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.Interfaces.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	[SetupCompileBefore ("linked.dll", new [] {typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link)})]
-	[SetupCompileBefore ("save.dll", new [] {typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Copy)}, new [] {"linked.dll"})]
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	[SetupCompileBefore ("linked.dll", new[] { typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link) })]
+	[SetupCompileBefore ("save.dll", new[] { typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Copy) }, new[] { "linked.dll" })]
 
 	[SetupLinkerAction ("save", "save")]
 	[SetupLinkerArgument ("-a", "save")]
@@ -12,7 +13,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 	[KeptMemberInAssembly ("linked.dll", typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link.IFoo), "Method()")]
 	[KeptMemberInAssembly ("save.dll", typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Copy.A), "Mono.Linker.Tests.Cases.Inheritance.Interfaces.Dependencies.InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link.IFoo.Method()")]
 	[KeptInterfaceOnTypeInAssembly ("save.dll", typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Copy.A), "linked.dll", typeof (InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Link.IFoo))]
-	public class InterfaceTypeInOtherUsedOnlyBySavedAssemblyExplicit {
+	public class InterfaceTypeInOtherUsedOnlyBySavedAssemblyExplicit
+	{
 		public static void Main ()
 		{
 			InterfaceTypeInOtherUsedOnlyByCopiedAssemblyExplicit_Copy.ToKeepReferenceAtCompileTime ();
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeOnlyUsedHasInterfacesRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeOnlyUsedHasInterfacesRemoved.cs
index 2a444ac3d..246c1986e 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeOnlyUsedHasInterfacesRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceTypeOnlyUsedHasInterfacesRemoved.cs
@@ -1,20 +1,25 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	public class InterfaceTypeOnlyUsedHasInterfacesRemoved {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	public class InterfaceTypeOnlyUsedHasInterfacesRemoved
+	{
 		public static void Main ()
 		{
 			var tmp = typeof (IUsed).ToString ();
 		}
 
-		interface IRemovable1 {
+		interface IRemovable1
+		{
 		}
 
-		interface IRemovable2 {
+		interface IRemovable2
+		{
 		}
 
 		[Kept]
-		interface IUsed : IRemovable1, IRemovable2 {
+		interface IUsed : IRemovable1, IRemovable2
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceUsedOnlyAsConstraintIsKept.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceUsedOnlyAsConstraintIsKept.cs
index b5fe34bd5..f8a84d687 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceUsedOnlyAsConstraintIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceUsedOnlyAsConstraintIsKept.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	public class InterfaceUsedOnlyAsConstraintIsKept {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	public class InterfaceUsedOnlyAsConstraintIsKept
+	{
 		public static void Main ()
 		{
 			var a = new A ();
@@ -14,14 +16,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			void Foo ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class A : IFoo {
+		class A : IFoo
+		{
 			public void Foo ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceWithInterfaceFromOtherAssemblyWhenExplicitMethodUsed.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceWithInterfaceFromOtherAssemblyWhenExplicitMethodUsed.cs
index 5a7ff36f2..6b30418d9 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceWithInterfaceFromOtherAssemblyWhenExplicitMethodUsed.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/InterfaceWithInterfaceFromOtherAssemblyWhenExplicitMethodUsed.cs
@@ -2,9 +2,11 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.Interfaces.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	[SetupCompileBefore("library.dll", new []{"../Dependencies/InterfaceWithInterfaceFromOtherAssemblyWhenExplicitMethodUsed_Lib.cs"})]
-	public class InterfaceWithInterfaceFromOtherAssemblyWhenExplicitMethodUsed {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	[SetupCompileBefore ("library.dll", new[] { "../Dependencies/InterfaceWithInterfaceFromOtherAssemblyWhenExplicitMethodUsed_Lib.cs" })]
+	public class InterfaceWithInterfaceFromOtherAssemblyWhenExplicitMethodUsed
+	{
 		public static void Main ()
 		{
 			Helper (null);
@@ -17,7 +19,7 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		}
 
 		[Kept]
-		[KeptInterface (typeof(InterfaceWithInterfaceFromOtherAssemblyWhenExplicitMethodUsed_Lib.IFoo))]
+		[KeptInterface (typeof (InterfaceWithInterfaceFromOtherAssemblyWhenExplicitMethodUsed_Lib.IFoo))]
 		interface IBar : InterfaceWithInterfaceFromOtherAssemblyWhenExplicitMethodUsed_Lib.IFoo
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndAssemblyPreserveAll.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndAssemblyPreserveAll.cs
index 2b4dfd2e8..7cd596e42 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndAssemblyPreserveAll.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndAssemblyPreserveAll.cs
@@ -3,7 +3,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
 namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor
 {
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/NoInstanceCtorAndAssemblyPreserveAll_Lib.il" })]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/NoInstanceCtorAndAssemblyPreserveAll_Lib.il" })]
 	[KeptInterfaceOnTypeInAssemblyAttribute ("library",
 		"Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor.Dependencies.NoInstanceCtorAndAssemblyPreserveAll_Lib/A",
 		"library",
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveAll.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveAll.cs
index 32bbe139f..28bf841f6 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveAll.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveAll.cs
@@ -1,8 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor {
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/NoInstanceCtorAndAssemblyPreserveAll_Lib.il" })]
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor
+{
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/NoInstanceCtorAndAssemblyPreserveAll_Lib.il" })]
 	[KeptInterfaceOnTypeInAssembly ("library",
 		"Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor.Dependencies.NoInstanceCtorAndAssemblyPreserveAll_Lib/A",
 		"library",
@@ -17,7 +18,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInsta
 	[KeptMemberInAssembly ("library",
 		"Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor.Dependencies.NoInstanceCtorAndAssemblyPreserveAll_Lib/A",
 		"Bar()")]
-	public class NoInstanceCtorAndTypePreserveAll {
+	public class NoInstanceCtorAndTypePreserveAll
+	{
 		public static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveFields.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveFields.cs
index 22b2bed90..69f9973d5 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveFields.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveFields.cs
@@ -1,8 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor {
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/NoInstanceCtorAndAssemblyPreserveAll_Lib.il" })]
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor
+{
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/NoInstanceCtorAndAssemblyPreserveAll_Lib.il" })]
 
 	// The interfaces should be removed because the interface types are not marked
 	[RemovedInterfaceOnTypeInAssembly ("library",
@@ -20,14 +21,15 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInsta
 	[RemovedMemberInAssembly ("library",
 		"Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor.Dependencies.NoInstanceCtorAndAssemblyPreserveAll_Lib/A",
 		"Bar()")]
-	
+
 	// pedump reports this is valid with the following error.
 	//
 	// Assertion at metadata.c:1073, condition `index < meta->heap_blob.size' not met
 	//
 	// Not worried about it since this is already a niche edge case.  Let's just skip verify for pedump
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	public class NoInstanceCtorAndTypePreserveFields {
+	public class NoInstanceCtorAndTypePreserveFields
+	{
 		public static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveFieldsWithInterfacesMarked.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveFieldsWithInterfacesMarked.cs
index 6bcaaa651..9a03244f2 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveFieldsWithInterfacesMarked.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveFieldsWithInterfacesMarked.cs
@@ -1,9 +1,10 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor {
-	[Define("IL_ASSEMBLY_COMPILED")]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/NoInstanceCtorAndAssemblyPreserveAll_Lib.il" })]
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor
+{
+	[Define ("IL_ASSEMBLY_COMPILED")]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/NoInstanceCtorAndAssemblyPreserveAll_Lib.il" })]
 
 	// Interfaces should be removed because preserve fields would not normally cause an instance ctor to be marked.  This means that no instance ctor
 	// sweeping logic should kick in and remove interfaces
@@ -23,14 +24,15 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInsta
 	[RemovedMemberInAssembly ("library",
 		"Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor.Dependencies.NoInstanceCtorAndAssemblyPreserveAll_Lib/A",
 		"Bar()")]
-	
+
 	// pedump reports this is valid with the following error.
 	//
 	// Assertion at metadata.c:1073, condition `index < meta->heap_blob.size' not met
 	//
 	// Not worried about it since this is already a niche edge case.  Let's just skip verify for pedump
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	public class NoInstanceCtorAndTypePreserveFieldsWithInterfacesMarked {
+	public class NoInstanceCtorAndTypePreserveFieldsWithInterfacesMarked
+	{
 		public static void Main ()
 		{
 #if IL_ASSEMBLY_COMPILED
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveMethods.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveMethods.cs
index 045aa2dcb..072a716c3 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveMethods.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveMethods.cs
@@ -1,8 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor {
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/NoInstanceCtorAndAssemblyPreserveAll_Lib.il" })]
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor
+{
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/NoInstanceCtorAndAssemblyPreserveAll_Lib.il" })]
 
 	// The interfaces should be removed because the interface types are not marked
 	[RemovedInterfaceOnTypeInAssembly ("library",
@@ -21,7 +22,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInsta
 	[KeptMemberInAssembly ("library",
 		"Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor.Dependencies.NoInstanceCtorAndAssemblyPreserveAll_Lib/A",
 		"Bar()")]
-	public class NoInstanceCtorAndTypePreserveMethods {
+	public class NoInstanceCtorAndTypePreserveMethods
+	{
 		public static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveMethodsWithInterfacesMarked.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveMethodsWithInterfacesMarked.cs
index 419eae41c..9b9f471c0 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveMethodsWithInterfacesMarked.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveMethodsWithInterfacesMarked.cs
@@ -1,9 +1,10 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor {
-	[Define("IL_ASSEMBLY_COMPILED")]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/NoInstanceCtorAndAssemblyPreserveAll_Lib.il" })]
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor
+{
+	[Define ("IL_ASSEMBLY_COMPILED")]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/NoInstanceCtorAndAssemblyPreserveAll_Lib.il" })]
 
 	// Interfaces will be removed because there is no instance ctor that is marked.
 	[RemovedInterfaceOnTypeInAssembly ("library",
@@ -24,7 +25,7 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInsta
 		"Bar()")]
 	public class NoInstanceCtorAndTypePreserveMethodsWithInterfacesMarked
 	{
-		public static void Main()
+		public static void Main ()
 		{
 			// We'll mark one interface in code and one via xml, the end result should be the same
 #if IL_ASSEMBLY_COMPILED
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveNone.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveNone.cs
index 670d45e43..ec968ced9 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveNone.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoInstanceCtor/NoInstanceCtorAndTypePreserveNone.cs
@@ -1,8 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor {
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/NoInstanceCtorAndAssemblyPreserveAll_Lib.il" })]
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor
+{
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/NoInstanceCtorAndAssemblyPreserveAll_Lib.il" })]
 	[RemovedInterfaceOnTypeInAssembly ("library",
 		"Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInstanceCtor.Dependencies.NoInstanceCtorAndAssemblyPreserveAll_Lib/A",
 		"library",
@@ -17,7 +18,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoInsta
 	//
 	// Not worried about it since this is already a niche edge case.  Let's just skip verify for pedump
 	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
-	public class NoInstanceCtorAndTypePreserveNone {
+	public class NoInstanceCtorAndTypePreserveNone
+	{
 		public static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/ComInterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/ComInterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod.cs
index 62da67caf..eee5d3f92 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/ComInterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/ComInterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod.cs
@@ -1,8 +1,10 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
-	public class ComInterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
+	public class ComInterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod
+	{
 		public static void Main ()
 		{
 			StaticMethodOnlyUsed.StaticMethod ();
@@ -10,12 +12,14 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 
 		[ComImport]
 		[Guid ("D7BB1889-3AB7-4681-A115-60CA9158FECA")]
-		interface IUnusedInterface {
+		interface IUnusedInterface
+		{
 			void Foo ();
 		}
 
 		[Kept]
-		class StaticMethodOnlyUsed : IUnusedInterface {
+		class StaticMethodOnlyUsed : IUnusedInterface
+		{
 			public void Foo ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/ExplicitInterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/ExplicitInterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed.cs
index f3bb78c8f..8908c6440 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/ExplicitInterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/ExplicitInterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
-	public class ExplicitInterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
+	public class ExplicitInterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed
+	{
 		public static void Main ()
 		{
 			IUsedInterface p = new UsedClass ();
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		interface IUsedInterface {
+		interface IUsedInterface
+		{
 			[Kept]
 			void Foo ();
 		}
@@ -18,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IUsedInterface))]
-		class UsedClass : IUsedInterface {
+		class UsedClass : IUsedInterface
+		{
 			[Kept]
 			public void Foo ()
 			{
@@ -26,7 +30,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		class StaticMethodOnlyUsed : IUsedInterface {
+		class StaticMethodOnlyUsed : IUsedInterface
+		{
 			void IUsedInterface.Foo ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/GenericType.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/GenericType.cs
index b6dff2fde..0abb060b7 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/GenericType.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/GenericType.cs
@@ -1,22 +1,27 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
-	public class GenericType {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
+	public class GenericType
+	{
 		public static void Main ()
 		{
 			object o = new Bar<Foo> ();
 		}
 
 		[Kept]
-		[KeptMember(".ctor()")]
-		class Bar<T> {
+		[KeptMember (".ctor()")]
+		class Bar<T>
+		{
 		}
 
 		[Kept]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 		}
 
-		interface IFoo {
+		interface IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/GenericWithConstraintDoesNotCauseOtherTypesToKeepInterface.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/GenericWithConstraintDoesNotCauseOtherTypesToKeepInterface.cs
index 7255cac2c..0b004bf43 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/GenericWithConstraintDoesNotCauseOtherTypesToKeepInterface.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/GenericWithConstraintDoesNotCauseOtherTypesToKeepInterface.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
-	public class GenericWithConstraintDoesNotCauseOtherTypesToKeepInterface {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
+	public class GenericWithConstraintDoesNotCauseOtherTypesToKeepInterface
+	{
 		public static void Main ()
 		{
 			Foo f = null;
@@ -27,15 +29,18 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 		}
-		
+
 		[Kept]
-		class Foo2 : IFoo {
+		class Foo2 : IFoo
+		{
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed.cs
index bddacb9d5..2c76dca61 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
-	public class InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
+	public class InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed
+	{
 		public static void Main ()
 		{
 			IUsedInterface p = new UsedClass ();
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		interface IUsedInterface {
+		interface IUsedInterface
+		{
 			[Kept]
 			void Foo ();
 		}
@@ -18,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IUsedInterface))]
-		class UsedClass : IUsedInterface {
+		class UsedClass : IUsedInterface
+		{
 			[Kept]
 			public void Foo ()
 			{
@@ -26,7 +30,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		class StaticMethodOnlyUsed : IUsedInterface {
+		class StaticMethodOnlyUsed : IUsedInterface
+		{
 			public void Foo ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsedWithCctor.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsedWithCctor.cs
index 9d79e5e0b..bf310873b 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsedWithCctor.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsedWithCctor.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
-	public class InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsedWithCctor {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
+	public class InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsedWithCctor
+	{
 		public static void Main ()
 		{
 			IUsedInterface p = new UsedClass ();
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		interface IUsedInterface {
+		interface IUsedInterface
+		{
 			[Kept]
 			void Foo ();
 		}
@@ -18,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IUsedInterface))]
-		class UsedClass : IUsedInterface {
+		class UsedClass : IUsedInterface
+		{
 			[Kept]
 			public void Foo ()
 			{
@@ -26,7 +30,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		class StaticMethodOnlyUsed : IUsedInterface {
+		class StaticMethodOnlyUsed : IUsedInterface
+		{
 			[Kept]
 			static StaticMethodOnlyUsed ()
 			{
@@ -37,7 +42,7 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 			static void UsedByStaticCctor ()
 			{
 			}
-			
+
 			public void Foo ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceFromCopiedAssemblyCanBeRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceFromCopiedAssemblyCanBeRemoved.cs
index b8001883e..77391f5e4 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceFromCopiedAssemblyCanBeRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceFromCopiedAssemblyCanBeRemoved.cs
@@ -1,15 +1,18 @@
 using System.Collections;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
-	public class InterfaceFromCopiedAssemblyCanBeRemoved {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
+	public class InterfaceFromCopiedAssemblyCanBeRemoved
+	{
 		public static void Main ()
 		{
 			Foo.StaticMethod ();
 		}
 
 		[Kept]
-		class Foo : IComparer {
+		class Foo : IComparer
+		{
 			public int Compare (object x, object y)
 			{
 				throw new System.NotImplementedException ();
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod.cs
index 828376342..6e4d3e4a3 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod.cs
@@ -1,18 +1,22 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
-	public class InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
+	public class InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod
+	{
 		public static void Main ()
 		{
 			StaticMethodOnlyUsed.StaticMethod ();
 		}
 
-		interface IUnusedInterface {
+		interface IUnusedInterface
+		{
 			void Foo ();
 		}
 
 		[Kept]
-		class StaticMethodOnlyUsed : IUnusedInterface {
+		class StaticMethodOnlyUsed : IUnusedInterface
+		{
 			public void Foo ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethodMultiple.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethodMultiple.cs
index fea5b9954..5c833d82b 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethodMultiple.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethodMultiple.cs
@@ -1,13 +1,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
-	public class InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethodMultiple {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
+	public class InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethodMultiple
+	{
 		public static void Main ()
 		{
 			IUsedInterface p = new UsedClass ();
 			StaticMethodOnlyUsed.StaticMethod ();
 			p.Foo ();
-			
+
 			// We are testing removing interfaces when no instance is created, we need to mark the interface types
 			// so that we don't end up testing unused interface types being swept
 			var tmp = typeof (IRemovable1).ToString ();
@@ -15,23 +17,27 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		interface IUsedInterface {
+		interface IUsedInterface
+		{
 			[Kept]
 			void Foo ();
 		}
 
 		[Kept]
-		interface IRemovable1 {
+		interface IRemovable1
+		{
 		}
-		
+
 		[Kept]
-		interface IRemovable2 {
+		interface IRemovable2
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IUsedInterface))]
-		class UsedClass : IUsedInterface {
+		class UsedClass : IUsedInterface
+		{
 			[Kept]
 			public void Foo ()
 			{
@@ -39,7 +45,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		class StaticMethodOnlyUsed : IUsedInterface, IRemovable1, IRemovable2 {
+		class StaticMethodOnlyUsed : IUsedInterface, IRemovable1, IRemovable2
+		{
 			public void Foo ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/LocalDowncastDoesNotCuaseOtherTypesToKeepInterface.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/LocalDowncastDoesNotCuaseOtherTypesToKeepInterface.cs
index 00ad89fd2..89409937e 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/LocalDowncastDoesNotCuaseOtherTypesToKeepInterface.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/LocalDowncastDoesNotCuaseOtherTypesToKeepInterface.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
-	public class LocalDowncastDoesNotCuaseOtherTypesToKeepInterface {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
+	public class LocalDowncastDoesNotCuaseOtherTypesToKeepInterface
+	{
 		public static void Main ()
 		{
 			Foo f = null;
@@ -23,7 +25,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 			[Kept] // TODO : It should be safe to stub this.  It can't actually be called because no instance of Foo ever exists
 			public void Method ()
 			{
@@ -31,7 +34,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Method ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/ObjectHardCastedToInterface.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/ObjectHardCastedToInterface.cs
index 84b9b6c16..fd4870faa 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/ObjectHardCastedToInterface.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/ObjectHardCastedToInterface.cs
@@ -1,13 +1,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
-	public class ObjectHardCastedToInterface {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
+	public class ObjectHardCastedToInterface
+	{
 		public static void Main ()
 		{
 			object o = GetAnObject ();
-			IFoo i = (IFoo)o;
+			IFoo i = (IFoo) o;
 			UseAnIFoo (i);
-			
+
 			// Here to mark Foo so that we can verify the interface is removed
 			Foo.Helper ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/PreserveDependencyPreservesInterfaceMethod.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/PreserveDependencyPreservesInterfaceMethod.cs
index f20e50010..db4a57a84 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/PreserveDependencyPreservesInterfaceMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/PreserveDependencyPreservesInterfaceMethod.cs
@@ -2,23 +2,27 @@ using System.Runtime.CompilerServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
 	/// <summary>
 	/// The interface can still be removed in this case because PreserveDependency is just preserving Foo() on the current type
 	/// </summary>
-	[SetupCompileBefore ("FakeSystemAssembly.dll", new [] { "../../../PreserveDependencies/Dependencies/PreserveDependencyAttribute.cs" })]
-	public class PreserveDependencyPreservesInterfaceMethod {
+	[SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "../../../PreserveDependencies/Dependencies/PreserveDependencyAttribute.cs" })]
+	public class PreserveDependencyPreservesInterfaceMethod
+	{
 		public static void Main ()
 		{
 			StaticMethodOnlyUsed.StaticMethod ();
 		}
 
-		interface IUnusedInterface {
+		interface IUnusedInterface
+		{
 			void Foo ();
 		}
 
 		[Kept]
-		class StaticMethodOnlyUsed : IUnusedInterface {
+		class StaticMethodOnlyUsed : IUnusedInterface
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeHasExplicitInterfaceMethodPreservedViaXml.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeHasExplicitInterfaceMethodPreservedViaXml.cs
index fef505898..2fa2dbb5d 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeHasExplicitInterfaceMethodPreservedViaXml.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeHasExplicitInterfaceMethodPreservedViaXml.cs
@@ -1,25 +1,30 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
-	public class UnusedTypeHasExplicitInterfaceMethodPreservedViaXml {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
+	public class UnusedTypeHasExplicitInterfaceMethodPreservedViaXml
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
 
-		interface IBar {
+		interface IBar
+		{
 			void Bar ();
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class A : IBar, IFoo {
-			
+		class A : IBar, IFoo
+		{
+
 			// Because an explicit interface method was preserved via xml, we need to now mark the interface implementation
 			[Kept]
 			void IFoo.Foo ()
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeHasExplicitInterfacePropertyPreservedViaXml.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeHasExplicitInterfacePropertyPreservedViaXml.cs
index 500841363..55ae78580 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeHasExplicitInterfacePropertyPreservedViaXml.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeHasExplicitInterfacePropertyPreservedViaXml.cs
@@ -1,26 +1,31 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class UnusedTypeHasExplicitInterfacePropertyPreservedViaXml {
+	public class UnusedTypeHasExplicitInterfacePropertyPreservedViaXml
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			int Foo { [Kept] get; [Kept] set; }
 		}
 
-		interface IBar {
+		interface IBar
+		{
 			int Bar { get; set; }
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class A : IBar, IFoo {
+		class A : IBar, IFoo
+		{
 			[Kept]
 			int IFoo.Foo { [Kept] [ExpectBodyModified] get; [Kept] [ExpectBodyModified] set; }
 
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeHasInterfaceMethodPreservedViaXml.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeHasInterfaceMethodPreservedViaXml.cs
index eef586956..6f609f27d 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeHasInterfaceMethodPreservedViaXml.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeHasInterfaceMethodPreservedViaXml.cs
@@ -1,21 +1,26 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
-	public class UnusedTypeHasInterfaceMethodPreservedViaXml {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
+	public class UnusedTypeHasInterfaceMethodPreservedViaXml
+	{
 		public static void Main ()
 		{
 		}
 
-		interface IFoo {
+		interface IFoo
+		{
 			void Foo ();
 		}
 
-		interface IBar {
+		interface IBar
+		{
 			void Bar ();
 		}
 
 		[Kept]
-		class A : IBar, IFoo {
+		class A : IBar, IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeWithPreserveFields.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeWithPreserveFields.cs
index 7c7b3b49a..759e39f97 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeWithPreserveFields.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeWithPreserveFields.cs
@@ -1,21 +1,26 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
-	public class UnusedTypeWithPreserveFields {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
+	public class UnusedTypeWithPreserveFields
+	{
 		public static void Main ()
 		{
 		}
 
-		interface IFoo {
+		interface IFoo
+		{
 			void Foo ();
 		}
 
-		interface IBar {
+		interface IBar
+		{
 			void Bar ();
 		}
 
 		[Kept]
-		class A : IBar, IFoo {
+		class A : IBar, IFoo
+		{
 			public void Foo ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeWithPreserveMethods.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeWithPreserveMethods.cs
index d729f60df..caeaac31b 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeWithPreserveMethods.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeWithPreserveMethods.cs
@@ -1,22 +1,27 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
-	public class UnusedTypeWithPreserveMethods {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
+	public class UnusedTypeWithPreserveMethods
+	{
 		public static void Main ()
 		{
 		}
 
-		interface IFoo {
+		interface IFoo
+		{
 			void Foo ();
 		}
 
-		interface IBar {
+		interface IBar
+		{
 			void Bar ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class A : IBar, IFoo {
+		class A : IBar, IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeWithPreserveMethodsAndInterfaceTypeMarked.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeWithPreserveMethodsAndInterfaceTypeMarked.cs
index 183bac795..b4efe2e79 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeWithPreserveMethodsAndInterfaceTypeMarked.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtor/UnusedTypeWithPreserveMethodsAndInterfaceTypeMarked.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor {
-	public class UnusedTypeWithPreserveMethodsAndInterfaceTypeMarked {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtor
+{
+	public class UnusedTypeWithPreserveMethodsAndInterfaceTypeMarked
+	{
 		public static void Main ()
 		{
 			// We'll mark one interface in code and one via xml, the end result should be the same
@@ -9,12 +11,14 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			void Foo ();
 		}
 
 		[Kept]
-		interface IBar {
+		interface IBar
+		{
 			void Bar ();
 		}
 
@@ -22,7 +26,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
 		[KeptInterface (typeof (IBar))]
-		class A : IBar, IFoo {
+		class A : IBar, IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ArrayWithIndexAssignedToReturnValue.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ArrayWithIndexAssignedToReturnValue.cs
index 179b7577b..1c5409a02 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ArrayWithIndexAssignedToReturnValue.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ArrayWithIndexAssignedToReturnValue.cs
@@ -1,11 +1,13 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class ArrayWithIndexAssignedToReturnValue {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class ArrayWithIndexAssignedToReturnValue
+	{
 		public static void Main ()
 		{
-			IFoo [] arr = new IFoo [5];
-			arr [0] = GetAFoo ();
+			IFoo[] arr = new IFoo[5];
+			arr[0] = GetAFoo ();
 		}
 
 		[Kept]
@@ -16,11 +18,13 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/FieldDowncastedToInterface.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/FieldDowncastedToInterface.cs
index 84ff1a1c7..98fc4db72 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/FieldDowncastedToInterface.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/FieldDowncastedToInterface.cs
@@ -1,12 +1,14 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class FieldDowncastedToInterface {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class FieldDowncastedToInterface
+	{
 		[Kept]
 		private static Foo f;
 		[Kept]
 		private static IFoo i;
-		
+
 		public static void Main ()
 		{
 			f = null;
@@ -16,7 +18,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 			[Kept] // TODO : It should be safe to stub this.  It can't actually be called because no instance of Foo ever exists
 			public void Method ()
 			{
@@ -24,7 +27,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Method ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/GenericType.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/GenericType.cs
index 7e8e8ffa9..9f895a88a 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/GenericType.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/GenericType.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class GenericType {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class GenericType
+	{
 		public static void Main ()
 		{
 			Foo f = null;
@@ -10,8 +12,9 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		[KeptMember(".ctor()")]
-		class Bar<T> {
+		[KeptMember (".ctor()")]
+		class Bar<T>
+		{
 			[Kept]
 			public void Method (T arg)
 			{
@@ -20,11 +23,13 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/GenericTypeWithConstraint.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/GenericTypeWithConstraint.cs
index 48051732a..b4a4987e7 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/GenericTypeWithConstraint.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/GenericTypeWithConstraint.cs
@@ -1,24 +1,29 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class GenericTypeWithConstraint {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class GenericTypeWithConstraint
+	{
 		public static void Main ()
 		{
 			object o = new Bar<Foo> ();
 		}
 
 		[Kept]
-		[KeptMember(".ctor()")]
-		class Bar<T> where T : IFoo {
+		[KeptMember (".ctor()")]
+		class Bar<T> where T : IFoo
+		{
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/GenericTypeWithConstraint2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/GenericTypeWithConstraint2.cs
index 0fb889ae8..2d74534ba 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/GenericTypeWithConstraint2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/GenericTypeWithConstraint2.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class GenericTypeWithConstraint2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class GenericTypeWithConstraint2
+	{
 		public static void Main ()
 		{
 			Foo f = null;
@@ -9,7 +11,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		static class Bar<T> where T : IFoo {
+		static class Bar<T> where T : IFoo
+		{
 			[Kept]
 			public static void Helper (T arg)
 			{
@@ -18,11 +21,13 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/GenericTypeWithConstraint3.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/GenericTypeWithConstraint3.cs
index bc170287e..90545fa1c 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/GenericTypeWithConstraint3.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/GenericTypeWithConstraint3.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class GenericTypeWithConstraint3 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class GenericTypeWithConstraint3
+	{
 		public static void Main ()
 		{
 			Foo f = null;
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		static class Bar<T, K> where T : IFoo where K : IBar {
+		static class Bar<T, K> where T : IFoo where K : IBar
+		{
 			[Kept]
 			public static void Helper (T arg, K arg2)
 			{
@@ -19,40 +22,48 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		abstract class BaseFoo : IFoo {
+		abstract class BaseFoo : IFoo
+		{
 		}
 
 		[Kept]
 		[KeptBaseType (typeof (BaseFoo))]
-		abstract class BaseFoo2 : BaseFoo {
+		abstract class BaseFoo2 : BaseFoo
+		{
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IBar))]
-		abstract class BaseBar : IBar {
+		abstract class BaseBar : IBar
+		{
 		}
 
 		[Kept]
 		[KeptBaseType (typeof (BaseBar))]
-		abstract class BaseBar2 : BaseBar {
+		abstract class BaseBar2 : BaseBar
+		{
 		}
 
 		[Kept]
 		[KeptBaseType (typeof (BaseFoo2))]
-		class Foo : BaseFoo2 {
+		class Foo : BaseFoo2
+		{
 		}
-		
+
 		[Kept]
 		[KeptBaseType (typeof (BaseBar2))]
-		class Bar : BaseBar2 {
+		class Bar : BaseBar2
+		{
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 		}
 
 		[Kept]
-		interface IBar {
+		interface IBar
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/InterfaceOnMultipleBases.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/InterfaceOnMultipleBases.cs
index 6b303e24f..3a997c981 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/InterfaceOnMultipleBases.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/InterfaceOnMultipleBases.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class InterfaceOnMultipleBases {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class InterfaceOnMultipleBases
+	{
 		public static void Main ()
 		{
 			Foo f = null;
@@ -15,28 +17,33 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Base : IFoo {
+		class Base : IFoo
+		{
 		}
-		
+
 		[Kept]
 		[KeptBaseType (typeof (Base))]
 		[KeptInterface (typeof (IFoo))]
-		class Base2 : Base, IFoo {
+		class Base2 : Base, IFoo
+		{
 		}
-		
+
 		[Kept]
 		[KeptBaseType (typeof (Base2))]
-		class Base3 : Base2 {
+		class Base3 : Base2
+		{
 		}
-		
+
 		[Kept]
 		[KeptBaseType (typeof (Base3))]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : Base3, IFoo {
+		class Foo : Base3, IFoo
+		{
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalAndNestedInterfaces.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalAndNestedInterfaces.cs
index da7af0a82..333f8334d 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalAndNestedInterfaces.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalAndNestedInterfaces.cs
@@ -1,13 +1,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class LocalAndNestedInterfaces {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class LocalAndNestedInterfaces
+	{
 		public static void Main ()
 		{
 			Foo f = null;
 			IFoo i = f;
 			IBase2 b = i;
-			
+
 			Helper (b);
 		}
 
@@ -19,19 +21,23 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
 		[KeptInterface (typeof (IBase2))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 		}
 
-		interface IBase {
+		interface IBase
+		{
 		}
 
 		[Kept]
-		interface IBase2 : IBase {
+		interface IBase2 : IBase
+		{
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IBase2))]
-		interface IFoo : IBase2 {
+		interface IFoo : IBase2
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalArrayPassedAsParameter.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalArrayPassedAsParameter.cs
index 0a9aacc0c..c8e07b705 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalArrayPassedAsParameter.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalArrayPassedAsParameter.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class LocalArrayPassedAsParameter {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class LocalArrayPassedAsParameter
+	{
 		public static void Main ()
 		{
-			Foo [] arr = null;
+			Foo[] arr = null;
 			Helper (arr);
 		}
 
@@ -15,11 +17,13 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalDowncastedToInterface.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalDowncastedToInterface.cs
index dc63d99a3..d17dede47 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalDowncastedToInterface.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalDowncastedToInterface.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class LocalDowncastedToInterface {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class LocalDowncastedToInterface
+	{
 		public static void Main ()
 		{
 			Foo f = null;
@@ -11,7 +13,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 			[Kept] // TODO : It should be safe to stub this.  It can't actually be called because no instance of Foo ever exists
 			public void Method ()
 			{
@@ -19,7 +22,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Method ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalPassedAsParameter.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalPassedAsParameter.cs
index 5338cc6ba..4efcfd249 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalPassedAsParameter.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalPassedAsParameter.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class LocalPassedAsParameter {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class LocalPassedAsParameter
+	{
 		public static void Main ()
 		{
 			Foo f = null;
@@ -15,11 +17,13 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalPassedAsParameterToGeneric.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalPassedAsParameterToGeneric.cs
index 475ac098a..757cde132 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalPassedAsParameterToGeneric.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalPassedAsParameterToGeneric.cs
@@ -1,25 +1,29 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class LocalPassedAsParameterToGeneric {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class LocalPassedAsParameterToGeneric
+	{
 		public static void Main ()
 		{
 			Foo f = null;
-			Helper<IFoo>(f);
+			Helper<IFoo> (f);
 		}
 
 		[Kept]
-		static void Helper <T> (T f)
+		static void Helper<T> (T f)
 		{
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalPassedAsParameterToGenericWithConstraint.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalPassedAsParameterToGenericWithConstraint.cs
index e00229264..46e7c416c 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalPassedAsParameterToGenericWithConstraint.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalPassedAsParameterToGenericWithConstraint.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class LocalPassedAsParameterToGenericWithConstraint {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class LocalPassedAsParameterToGenericWithConstraint
+	{
 		public static void Main ()
 		{
 			Foo f = null;
@@ -15,11 +17,13 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalPassedAsParameterToGenericWithConstraint2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalPassedAsParameterToGenericWithConstraint2.cs
index cecf742e4..46b2ae8c8 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalPassedAsParameterToGenericWithConstraint2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/LocalPassedAsParameterToGenericWithConstraint2.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class LocalPassedAsParameterToGenericWithConstraint2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class LocalPassedAsParameterToGenericWithConstraint2
+	{
 		public static void Main ()
 		{
 			Foo f = null;
@@ -16,17 +18,20 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 		}
-		
+
 		[Kept]
 		[KeptInterface (typeof (IFoo))] // technically this can be removed, but it would require more complex knowledge of the stack to do so
-		class Foo2 : IFoo {
+		class Foo2 : IFoo
+		{
 		}
 
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfaces1.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfaces1.cs
index b42a1ea16..434a4174b 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfaces1.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfaces1.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class NestedInterfaces1 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class NestedInterfaces1
+	{
 		public static void Main ()
 		{
 			MarkBase1AndBase3 (null, null);
@@ -20,12 +22,14 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		interface IBase {
+		interface IBase
+		{
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IBase))]
-		interface IBase2 : IBase {
+		interface IBase2 : IBase
+		{
 			[Kept]
 			void Method ();
 		}
@@ -33,7 +37,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		[Kept]
 		[KeptInterface (typeof (IBase2))]
 		[KeptInterface (typeof (IBase))]
-		interface IBase3 : IBase2 {
+		interface IBase3 : IBase2
+		{
 		}
 
 		/// <summary>
@@ -42,7 +47,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		[Kept]
 		[KeptInterface (typeof (IBase3))]
 		[KeptInterface (typeof (IBase))]
-		class Foo : IBase3 {
+		class Foo : IBase3
+		{
 			[Kept]
 			public void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfaces2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfaces2.cs
index 0bd591b3d..93f50acca 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfaces2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfaces2.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class NestedInterfaces2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class NestedInterfaces2
+	{
 		public static void Main ()
 		{
 			MarkBase1AndBase3 (null, null);
@@ -19,22 +21,26 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		interface IBase {
+		interface IBase
+		{
 		}
 
-		interface IBase2 : IBase {
+		interface IBase2 : IBase
+		{
 			void Method ();
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IBase))]
-		interface IBase3 : IBase2 {
+		interface IBase3 : IBase2
+		{
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IBase3))]
 		[KeptInterface (typeof (IBase))]
-		class Foo : IBase3 {
+		class Foo : IBase3
+		{
 			public void Method ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfaces3.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfaces3.cs
index 2669daf37..5bc09dc62 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfaces3.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfaces3.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class NestedInterfaces3 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class NestedInterfaces3
+	{
 		public static void Main ()
 		{
 			MarkBase1AndBase3 (null, null);
@@ -19,31 +21,36 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		interface IBase {
+		interface IBase
+		{
 		}
 
-		interface IBase2 : IBase {
+		interface IBase2 : IBase
+		{
 			void Method ();
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IBase))]
-		interface IBase3 : IBase2 {
+		interface IBase3 : IBase2
+		{
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IBase))]
-		class Base : IBase2 {
+		class Base : IBase2
+		{
 			public void Method ()
 			{
 			}
 		}
 
 		[Kept]
-		[KeptBaseType(typeof(Base))]
+		[KeptBaseType (typeof (Base))]
 		[KeptInterface (typeof (IBase3))]
 		[KeptInterface (typeof (IBase))]
-		class Foo : Base, IBase3, IBase2 {
+		class Foo : Base, IBase3, IBase2
+		{
 			public void Method ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfacesWithExplicit1.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfacesWithExplicit1.cs
index 18e717198..0ea1e369b 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfacesWithExplicit1.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfacesWithExplicit1.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class NestedInterfacesWithExplicit1 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class NestedInterfacesWithExplicit1
+	{
 		public static void Main ()
 		{
 			MarkBase1AndBase3 (null, null);
@@ -20,12 +22,14 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		interface IBase {
+		interface IBase
+		{
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IBase))]
-		interface IBase2 : IBase {
+		interface IBase2 : IBase
+		{
 			[Kept]
 			void Method ();
 		}
@@ -33,14 +37,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		[Kept]
 		[KeptInterface (typeof (IBase2))]
 		[KeptInterface (typeof (IBase))]
-		interface IBase3 : IBase2 {
+		interface IBase3 : IBase2
+		{
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IBase3))]
 		[KeptInterface (typeof (IBase2))]
 		[KeptInterface (typeof (IBase))]
-		class Foo : IBase3 {
+		class Foo : IBase3
+		{
 			[Kept]
 			void IBase2.Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfacesWithExplicitAndNormal1.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfacesWithExplicitAndNormal1.cs
index 6f5373463..a676cb64b 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfacesWithExplicitAndNormal1.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/NestedInterfacesWithExplicitAndNormal1.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class NestedInterfacesWithExplicitAndNormal1 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class NestedInterfacesWithExplicitAndNormal1
+	{
 		public static void Main ()
 		{
 			MarkBase1AndBase3 (null, null);
@@ -20,12 +22,14 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		interface IBase {
+		interface IBase
+		{
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IBase))]
-		interface IBase2 : IBase {
+		interface IBase2 : IBase
+		{
 			[Kept]
 			void Method ();
 		}
@@ -33,14 +37,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		[Kept]
 		[KeptInterface (typeof (IBase2))]
 		[KeptInterface (typeof (IBase))]
-		interface IBase3 : IBase2 {
+		interface IBase3 : IBase2
+		{
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IBase3))]
 		[KeptInterface (typeof (IBase2))]
 		[KeptInterface (typeof (IBase))]
-		class Foo : IBase3 {
+		class Foo : IBase3
+		{
 			[Kept]
 			void IBase2.Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ParameterAndLocal.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ParameterAndLocal.cs
index 3d31fe038..431653cac 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ParameterAndLocal.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ParameterAndLocal.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class ParameterAndLocal {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class ParameterAndLocal
+	{
 		public static void Main ()
 		{
 			Helper (null);
@@ -15,14 +17,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Method ();
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 			[Kept]
 			public void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ParameterOutAndLocal.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ParameterOutAndLocal.cs
index 5703d03e2..65d483770 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ParameterOutAndLocal.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ParameterOutAndLocal.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class ParameterOutAndLocal {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class ParameterOutAndLocal
+	{
 		public static void Main ()
 		{
 			Foo f;
@@ -17,14 +19,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Method ();
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 			[Kept]
 			public void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ParameterRefAndLocal.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ParameterRefAndLocal.cs
index a292c7b33..1bf66c1dd 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ParameterRefAndLocal.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ParameterRefAndLocal.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class ParameterRefAndLocal {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class ParameterRefAndLocal
+	{
 		public static void Main ()
 		{
 			Foo f = null;
@@ -16,14 +18,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Method ();
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 			[Kept]
 			public void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ReturnValueDowncastedToInterface.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ReturnValueDowncastedToInterface.cs
index 0aef967a5..3fb6ed2db 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ReturnValueDowncastedToInterface.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/NoKeptCtorButInterfaceNeeded/ReturnValueDowncastedToInterface.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded {
-	public class ReturnValueDowncastedToInterface {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptCtorButInterfaceNeeded
+{
+	public class ReturnValueDowncastedToInterface
+	{
 		public static void Main ()
 		{
 			UseAnIFoo (GetAFoo ());
@@ -20,11 +22,13 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType.NoKeptC
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ObjectCastedToSecondInterfaceHasMemberRemovedButInterfaceKept.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ObjectCastedToSecondInterfaceHasMemberRemovedButInterfaceKept.cs
index 95fd8b266..a3222443e 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ObjectCastedToSecondInterfaceHasMemberRemovedButInterfaceKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/ObjectCastedToSecondInterfaceHasMemberRemovedButInterfaceKept.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	public class ObjectCastedToSecondInterfaceHasMemberRemovedButInterfaceKept {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	public class ObjectCastedToSecondInterfaceHasMemberRemovedButInterfaceKept
+	{
 		public static void Main ()
 		{
 			IFoo i = new A ();
@@ -10,13 +12,15 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
-		
+
 		[Kept]
-		interface IBar {
+		interface IBar
+		{
 			void Bar ();
 		}
 
@@ -24,7 +28,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
 		[KeptInterface (typeof (IBar))]
-		class A : IBar, IFoo {
+		class A : IBar, IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/TypeGetsMarkedThatImplementsAlreadyMarkedInterfaceMethod.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/TypeGetsMarkedThatImplementsAlreadyMarkedInterfaceMethod.cs
index 85f1c855a..944efb46d 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/TypeGetsMarkedThatImplementsAlreadyMarkedInterfaceMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/TypeGetsMarkedThatImplementsAlreadyMarkedInterfaceMethod.cs
@@ -1,21 +1,25 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	class TypeGetsMarkedThatImplementsAlreadyMarkedInterfaceMethod {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	class TypeGetsMarkedThatImplementsAlreadyMarkedInterfaceMethod
+	{
 		public static void Main ()
 		{
 			IFoo i = new A ();
 			i.Foo ();
 		}
 
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
 
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class B : IFoo {
+		class B : IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
@@ -24,7 +28,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class A : IFoo {
+		class A : IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedComInterfaceIsKept.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedComInterfaceIsKept.cs
index 4e7212bef..61ebdf89c 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedComInterfaceIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedComInterfaceIsKept.cs
@@ -1,12 +1,14 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
 	/// <summary>
 	/// It's much harder to know if a com interface will be needed since so much can be on the native side.
 	/// As a precaution we will not apply the unused interface rules to com interfaces
 	/// </summary>
-	public class UnusedComInterfaceIsKept {
+	public class UnusedComInterfaceIsKept
+	{
 		public static void Main ()
 		{
 			var i = new A ();
@@ -17,14 +19,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		[KeptAttributeAttribute (typeof (GuidAttribute))]
 		[ComImport]
 		[Guid ("D7BB1889-3AB7-4681-A115-60CA9158FECA")]
-		interface IBar {
+		interface IBar
+		{
 			void Bar ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IBar))]
-		class A : IBar {
+		class A : IBar
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedComInterfaceIsRemovedWhenComFeatureExcluded.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedComInterfaceIsRemovedWhenComFeatureExcluded.cs
index 597da0c7b..3f0d5b8ca 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedComInterfaceIsRemovedWhenComFeatureExcluded.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedComInterfaceIsRemovedWhenComFeatureExcluded.cs
@@ -2,12 +2,14 @@ using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("--exclude-feature is not supported on .NET Core")]
 #endif
 	[SetupLinkerArgument ("--exclude-feature", "com")]
-	public class UnusedComInterfaceIsRemovedWhenComFeatureExcluded {
+	public class UnusedComInterfaceIsRemovedWhenComFeatureExcluded
+	{
 		public static void Main ()
 		{
 			var i = new A ();
@@ -16,13 +18,15 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 
 		[ComImport]
 		[Guid ("D7BB1889-3AB7-4681-A115-60CA9158FECA")]
-		interface IBar {
+		interface IBar
+		{
 			void Bar ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class A : IBar {
+		class A : IBar
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedExplicitInterfaceHasMethodPreservedViaXml.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedExplicitInterfaceHasMethodPreservedViaXml.cs
index 1a97b7836..bc8e3226f 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedExplicitInterfaceHasMethodPreservedViaXml.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedExplicitInterfaceHasMethodPreservedViaXml.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	public class UnusedExplicitInterfaceHasMethodPreservedViaXml {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	public class UnusedExplicitInterfaceHasMethodPreservedViaXml
+	{
 		public static void Main ()
 		{
 			IFoo i = new A ();
@@ -9,13 +11,15 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
 
 		[Kept]
-		interface IBar {
+		interface IBar
+		{
 			[Kept]
 			void Bar ();
 		}
@@ -24,7 +28,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
 		[KeptInterface (typeof (IBar))]
-		class A : IBar, IFoo {
+		class A : IBar, IFoo
+		{
 			[Kept]
 			void IFoo.Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedExplicitInterfaceIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedExplicitInterfaceIsRemoved.cs
index 7afcd6056..cdfb7c9e2 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedExplicitInterfaceIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedExplicitInterfaceIsRemoved.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	public class UnusedExplicitInterfaceIsRemoved {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	public class UnusedExplicitInterfaceIsRemoved
+	{
 		public static void Main ()
 		{
 			IFoo i = new A ();
@@ -9,19 +11,22 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
 
-		interface IBar {
+		interface IBar
+		{
 			void Bar ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class A : IBar, IFoo {
+		class A : IBar, IFoo
+		{
 			[Kept]
 			void IFoo.Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedGenericInterfaceIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedGenericInterfaceIsRemoved.cs
index 5801525cc..7c2f1378c 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedGenericInterfaceIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedGenericInterfaceIsRemoved.cs
@@ -1,19 +1,22 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	public class UnusedGenericInterfaceIsRemoved {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	public class UnusedGenericInterfaceIsRemoved
+	{
 		public static void Main ()
 		{
 			var fb = new Foo ();
 			IFoo<object> fo = fb;
 			fo.Method (null);
-			
+
 			IFoo<int> fi = fb;
 			fi.Method (0);
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 			[Kept]
 			void Method (T arg);
 		}
@@ -24,7 +27,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		[KeptInterface (typeof (IFoo<int>))]
 		[KeptInterface (typeof (IFoo<string>))] // FIXME : Should be removed
 		[KeptInterface (typeof (IFoo<Bar>))] // FIXME : Should be removed
-		class Foo : IFoo<object>, IFoo<int>, IFoo<string>, IFoo<Bar> {
+		class Foo : IFoo<object>, IFoo<int>, IFoo<string>, IFoo<Bar>
+		{
 			[Kept]
 			public void Method (object arg)
 			{
@@ -53,7 +57,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		}
 
 		[Kept] // FIXME : Should be removed
-		class Bar {
+		class Bar
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedInterfaceHasMethodPreservedViaXml.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedInterfaceHasMethodPreservedViaXml.cs
index 2b5e7ea2f..bcacfa101 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedInterfaceHasMethodPreservedViaXml.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedInterfaceHasMethodPreservedViaXml.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	public class UnusedInterfaceHasMethodPreservedViaXml {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	public class UnusedInterfaceHasMethodPreservedViaXml
+	{
 		public static void Main ()
 		{
 			IFoo i = new A ();
@@ -9,19 +11,22 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
 
-		interface IBar {
+		interface IBar
+		{
 			void Bar ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class A : IBar, IFoo {
+		class A : IBar, IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedInterfaceTypeIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedInterfaceTypeIsRemoved.cs
index 69e55bead..a5d1a89fd 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedInterfaceTypeIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnReferenceType/UnusedInterfaceTypeIsRemoved.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
-	public class UnusedInterfaceTypeIsRemoved {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType
+{
+	public class UnusedInterfaceTypeIsRemoved
+	{
 		public static void Main ()
 		{
 			IFoo i = new A ();
@@ -9,19 +11,22 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnReferenceType {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
 
-		interface IBar {
+		interface IBar
+		{
 			void Bar ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class A : IBar, IFoo {
+		class A : IBar, IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/NoKeptCtor/InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/NoKeptCtor/InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed.cs
index 260dcb92e..431951898 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/NoKeptCtor/InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/NoKeptCtor/InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType.NoKeptCtor {
-	public class InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType.NoKeptCtor
+{
+	public class InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsed
+	{
 		public static void Main ()
 		{
 			IUsedInterface p = new UsedClass ();
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType.NoKeptCtor
 		}
 
 		[Kept]
-		interface IUsedInterface {
+		interface IUsedInterface
+		{
 			[Kept]
 			void Foo ();
 		}
@@ -18,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType.NoKeptCtor
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IUsedInterface))]
-		class UsedClass : IUsedInterface {
+		class UsedClass : IUsedInterface
+		{
 			[Kept]
 			public void Foo ()
 			{
@@ -27,7 +31,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType.NoKeptCtor
 
 		[Kept]
 		[KeptInterface (typeof (IUsedInterface))] // Could be removed in the future with improved handling of value types
-		struct StaticMethodOnlyUsed : IUsedInterface {
+		struct StaticMethodOnlyUsed : IUsedInterface
+		{
 			[Kept] // Could be removed in the future with improved handling of value types
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/NoKeptCtor/InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsedWithCctor.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/NoKeptCtor/InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsedWithCctor.cs
index 0ce19620b..94e099e60 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/NoKeptCtor/InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsedWithCctor.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/NoKeptCtor/InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsedWithCctor.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType.NoKeptCtor {
-	public class InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsedWithCctor {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType.NoKeptCtor
+{
+	public class InterfaceCanBeRemovedFromClassWithOnlyStaticMethodUsedWithCctor
+	{
 		public static void Main ()
 		{
 			IUsedInterface p = new UsedClass ();
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType.NoKeptCtor
 		}
 
 		[Kept]
-		interface IUsedInterface {
+		interface IUsedInterface
+		{
 			[Kept]
 			void Foo ();
 		}
@@ -18,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType.NoKeptCtor
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IUsedInterface))]
-		class UsedClass : IUsedInterface {
+		class UsedClass : IUsedInterface
+		{
 			[Kept]
 			public void Foo ()
 			{
@@ -27,7 +31,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType.NoKeptCtor
 
 		[Kept]
 		[KeptInterface (typeof (IUsedInterface))] // Could be removed in the future with improved handling of value types
-		struct StaticMethodOnlyUsed : IUsedInterface {
+		struct StaticMethodOnlyUsed : IUsedInterface
+		{
 			[Kept]
 			static StaticMethodOnlyUsed ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/NoKeptCtor/InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/NoKeptCtor/InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod.cs
index 54680898a..0a387937b 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/NoKeptCtor/InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/NoKeptCtor/InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod.cs
@@ -1,24 +1,28 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType.NoKeptCtor {
-	public class InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType.NoKeptCtor
+{
+	public class InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethod
+	{
 		public static void Main ()
 		{
 			StaticMethodOnlyUsed.StaticMethod ();
-			
+
 			// We are testing removing interfaces when no instance is created, we need to mark the interface types
 			// so that we don't end up testing unused interface types being swept
 			var tmp = typeof (IUsedInterface).ToString ();
 		}
 
 		[Kept] // Could be removed in the future with improved handling of value types
-		interface IUsedInterface {
+		interface IUsedInterface
+		{
 			void Foo ();
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IUsedInterface))] // Could be removed in the future with improved handling of value types
-		struct StaticMethodOnlyUsed : IUsedInterface {
+		struct StaticMethodOnlyUsed : IUsedInterface
+		{
 			public void Foo ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/NoKeptCtor/InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethodMultiple.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/NoKeptCtor/InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethodMultiple.cs
index a6eadcabf..4874b0edc 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/NoKeptCtor/InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethodMultiple.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/NoKeptCtor/InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethodMultiple.cs
@@ -1,13 +1,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType.NoKeptCtor {
-	public class InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethodMultiple {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType.NoKeptCtor
+{
+	public class InterfaceTypeRemovedWhenOnlyUsedByClassWithOnlyStaticMethodMultiple
+	{
 		public static void Main ()
 		{
 			IUsedInterface p = new UsedClass ();
 			StaticMethodOnlyUsed.StaticMethod ();
 			p.Foo ();
-			
+
 			// We are testing removing interfaces when no instance is created, we need to mark the interface types
 			// so that we don't end up testing unused interface types being swept
 			var tmp = typeof (IRemovable1).ToString ();
@@ -15,23 +17,27 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType.NoKeptCtor
 		}
 
 		[Kept]
-		interface IUsedInterface {
+		interface IUsedInterface
+		{
 			[Kept]
 			void Foo ();
 		}
 
 		[Kept] // Could be removed in the future with improved handling of value types
-		interface IRemovable1 {
+		interface IRemovable1
+		{
 		}
-		
+
 		[Kept] // Could be removed in the future with improved handling of value types
-		interface IRemovable2 {
+		interface IRemovable2
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IUsedInterface))]
-		class UsedClass : IUsedInterface {
+		class UsedClass : IUsedInterface
+		{
 			[Kept]
 			public void Foo ()
 			{
@@ -42,7 +48,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType.NoKeptCtor
 		[KeptInterface (typeof (IUsedInterface))] // Could be removed in the future with improved handling of value types
 		[KeptInterface (typeof (IRemovable1))] // Could be removed in the future with improved handling of value types
 		[KeptInterface (typeof (IRemovable2))] // Could be removed in the future with improved handling of value types
-		struct StaticMethodOnlyUsed : IUsedInterface, IRemovable1, IRemovable2 {
+		struct StaticMethodOnlyUsed : IUsedInterface, IRemovable1, IRemovable2
+		{
 			[Kept] // Could be removed in the future with improved handling of value types
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructImplementingInterfaceMethodsNested.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructImplementingInterfaceMethodsNested.cs
index 1108175bf..8e438aeda 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructImplementingInterfaceMethodsNested.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructImplementingInterfaceMethodsNested.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
-	public class StructImplementingInterfaceMethodsNested {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType
+{
+	public class StructImplementingInterfaceMethodsNested
+	{
 		public static void Main ()
 		{
 			IFoo i = new A ();
@@ -9,18 +11,21 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
 
-		interface IBar : IFoo {
+		interface IBar : IFoo
+		{
 			void Bar ();
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		struct A : IBar {
+		struct A : IBar
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructImplementingInterfaceMethodsNested2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructImplementingInterfaceMethodsNested2.cs
index f7a701dc1..6ae4c15ea 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructImplementingInterfaceMethodsNested2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructImplementingInterfaceMethodsNested2.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
-	public class StructImplementingInterfaceMethodsNested2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType
+{
+	public class StructImplementingInterfaceMethodsNested2
+	{
 		public static void Main ()
 		{
 			IBar b = new A ();
@@ -10,21 +12,24 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
-		
+
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		interface IBar : IFoo {
+		interface IBar : IFoo
+		{
 			void Bar ();
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IBar))]
 		[KeptInterface (typeof (IFoo))]
-		struct A : IBar {
+		struct A : IBar
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructUsedFromConcreteTypeHasInterfaceMethodRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructUsedFromConcreteTypeHasInterfaceMethodRemoved.cs
index a1996be28..3149f92aa 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructUsedFromConcreteTypeHasInterfaceMethodRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructUsedFromConcreteTypeHasInterfaceMethodRemoved.cs
@@ -2,7 +2,8 @@
 
 namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType
 {
-	class StructUsedFromConcreteTypeHasInterfaceMethodRemoved {
+	class StructUsedFromConcreteTypeHasInterfaceMethodRemoved
+	{
 		public static void Main ()
 		{
 			A a = new A ();
@@ -10,14 +11,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType
 		}
 
 		[Kept]
-		struct A : IFoo {
+		struct A : IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
 			}
 		}
 
-		public interface IFoo {
+		public interface IFoo
+		{
 			void Foo ();
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructUsedFromConcreteTypeHasInterfaceMethodRemoved2.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructUsedFromConcreteTypeHasInterfaceMethodRemoved2.cs
index 246f682a8..092805b5e 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructUsedFromConcreteTypeHasInterfaceMethodRemoved2.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructUsedFromConcreteTypeHasInterfaceMethodRemoved2.cs
@@ -1,19 +1,22 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
-	public class StructUsedFromConcreteTypeHasInterfaceMethodRemoved2 {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType
+{
+	public class StructUsedFromConcreteTypeHasInterfaceMethodRemoved2
+	{
 		public static void Main ()
 		{
 			A a = new A ();
 			a.Foo ();
-			
+
 			// If IFoo is marked for any reason then all of a sudden we do need to keep IFoo on A
 			var tmp = typeof (IFoo).ToString ();
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		struct A : IFoo {
+		struct A : IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
@@ -21,7 +24,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
 		}
 
 		[Kept]
-		public interface IFoo {
+		public interface IFoo
+		{
 			void Foo ();
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructUsedFromInterfaceHasInterfaceMethodKept.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructUsedFromInterfaceHasInterfaceMethodKept.cs
index 83935642d..a077e2827 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructUsedFromInterfaceHasInterfaceMethodKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructUsedFromInterfaceHasInterfaceMethodKept.cs
@@ -2,7 +2,8 @@
 
 namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType
 {
-	class StructUsedFromInterfaceHasInterfaceMethodKept {
+	class StructUsedFromInterfaceHasInterfaceMethodKept
+	{
 		public static void Main ()
 		{
 			IFoo a = new A ();
@@ -11,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		struct A : IFoo {
+		struct A : IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
@@ -19,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType
 		}
 
 		[Kept]
-		public interface IFoo {
+		public interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructWithNestedStructImplementingInterface.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructWithNestedStructImplementingInterface.cs
index 3c369c1b1..0bdc4a2a4 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructWithNestedStructImplementingInterface.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/StructWithNestedStructImplementingInterface.cs
@@ -1,12 +1,14 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType
+{
 	/// <summary>
 	/// This is a specially crafted cases that was able to hit a 'Collection was modified; enumeration operation may not execute.' exception during
 	/// MarkStep.ProcessMarkedTypesWithInterfaces
 	/// </summary>
-	public class StructWithNestedStructImplementingInterface {
+	public class StructWithNestedStructImplementingInterface
+	{
 		public static void Main ()
 		{
 			var type = typeof (IBuildable<>);
@@ -16,37 +18,46 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
 		}
 
 		[Kept]
-		public interface IRunner {
+		public interface IRunner
+		{
 		}
 
-		public interface IBuildable {
+		public interface IBuildable
+		{
 		}
 
 		[Kept]
-		public interface IBuilder {
+		public interface IBuilder
+		{
 			Result<IRunner> Build (Node node, Node root, World world);
 		}
 
 		[Kept]
-		public interface IBuildable<T> : IBuildable where T : IBuilder, new() {
+		public interface IBuildable<T> : IBuildable where T : IBuilder, new()
+		{
 		}
 
-		public struct Result<T> : IResult {
+		public struct Result<T> : IResult
+		{
 		}
 
-		public class Node {
+		public class Node
+		{
 		}
 
-		public class World {
+		public class World
+		{
 		}
 
-		public interface IResult {
+		public interface IResult
+		{
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IBuilder))]
 		[KeptMember (".ctor()")]
-		public abstract class Builder<T> : IBuilder where T : IRunner {
+		public abstract class Builder<T> : IBuilder where T : IRunner
+		{
 			public abstract Result<T> Build (Node node, Node root, World world);
 
 			Result<IRunner> IBuilder.Build (Node node, Node root, World world)
@@ -57,7 +68,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
 
 		[Kept]
 		[KeptInterface (typeof (IBuildable<Profile.Builder>))]
-		public struct Profile : IBuildable<Profile.Builder> {
+		public struct Profile : IBuildable<Profile.Builder>
+		{
 			[Kept]
 			public void Foo ()
 			{
@@ -65,13 +77,15 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
 
 			[Kept]
 			[KeptInterface (typeof (IRunner))]
-			private sealed class Runner : IRunner {
+			private sealed class Runner : IRunner
+			{
 			}
 
 			[Kept]
-			[KeptBaseType (typeof(Builder<Runner>))]
+			[KeptBaseType (typeof (Builder<Runner>))]
 			[KeptMember (".ctor()")]
-			private sealed class Builder : Builder<Runner> {
+			private sealed class Builder : Builder<Runner>
+			{
 				public override Result<Runner> Build (Node node, Node root, World world)
 				{
 					return default (Result<Runner>);
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/UnusedExplicitInterfaceHasMethodPreservedViaXml.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/UnusedExplicitInterfaceHasMethodPreservedViaXml.cs
index 4e76aa1a5..160d0fa83 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/UnusedExplicitInterfaceHasMethodPreservedViaXml.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/UnusedExplicitInterfaceHasMethodPreservedViaXml.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
-	public class UnusedExplicitInterfaceHasMethodPreservedViaXml {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType
+{
+	public class UnusedExplicitInterfaceHasMethodPreservedViaXml
+	{
 		public static void Main ()
 		{
 			IFoo i = new A ();
@@ -9,13 +11,15 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
 
 		[Kept]
-		interface IBar {
+		interface IBar
+		{
 			[Kept]
 			void Bar ();
 		}
@@ -24,7 +28,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
 		[KeptInterface (typeof (IBar))]
-		struct A : IBar, IFoo {
+		struct A : IBar, IFoo
+		{
 			[Kept]
 			void IFoo.Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/UnusedExplicitInterfaceIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/UnusedExplicitInterfaceIsRemoved.cs
index f731e3bdc..fa6d6d344 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/UnusedExplicitInterfaceIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/UnusedExplicitInterfaceIsRemoved.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
-	public class UnusedExplicitInterfaceIsRemoved {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType
+{
+	public class UnusedExplicitInterfaceIsRemoved
+	{
 		public static void Main ()
 		{
 			IFoo i = new A ();
@@ -9,19 +11,22 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
 
-		interface IBar {
+		interface IBar
+		{
 			void Bar ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		struct A : IBar, IFoo {
+		struct A : IBar, IFoo
+		{
 			[Kept]
 			void IFoo.Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/UnusedInterfaceHasMethodPreservedViaXml.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/UnusedInterfaceHasMethodPreservedViaXml.cs
index 89cf4d264..550b3abf7 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/UnusedInterfaceHasMethodPreservedViaXml.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/UnusedInterfaceHasMethodPreservedViaXml.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
-	public class UnusedInterfaceHasMethodPreservedViaXml {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType
+{
+	public class UnusedInterfaceHasMethodPreservedViaXml
+	{
 		public static void Main ()
 		{
 			IFoo i = new A ();
@@ -9,19 +11,22 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
 
-		interface IBar {
+		interface IBar
+		{
 			void Bar ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		struct A : IBar, IFoo {
+		struct A : IBar, IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/UnusedInterfaceTypeIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/UnusedInterfaceTypeIsRemoved.cs
index 82ececac1..f79f6d5e0 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/UnusedInterfaceTypeIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.Interfaces/OnValueType/UnusedInterfaceTypeIsRemoved.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
-	public class UnusedInterfaceTypeIsRemoved {
+namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType
+{
+	public class UnusedInterfaceTypeIsRemoved
+	{
 		public static void Main ()
 		{
 			IFoo i = new A ();
@@ -9,19 +11,22 @@ namespace Mono.Linker.Tests.Cases.Inheritance.Interfaces.OnValueType {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Foo ();
 		}
 
-		interface IBar {
+		interface IBar
+		{
 			void Bar ();
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		struct A : IBar, IFoo {
+		struct A : IBar, IFoo
+		{
 			[Kept]
 			public void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/Dependencies/TypeWithBaseInCopiedAssembly_Base.cs b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/Dependencies/TypeWithBaseInCopiedAssembly_Base.cs
index 7702d827f..337279c98 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/Dependencies/TypeWithBaseInCopiedAssembly_Base.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/Dependencies/TypeWithBaseInCopiedAssembly_Base.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods.Dependencies {
-	public class TypeWithBaseInCopiedAssembly_Base {
+namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods.Dependencies
+{
+	public class TypeWithBaseInCopiedAssembly_Base
+	{
 		public virtual void Method ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/HarderToDetectUnusedVirtualMethodGetsRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/HarderToDetectUnusedVirtualMethodGetsRemoved.cs
index 8348dbd09..b9885e8ac 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/HarderToDetectUnusedVirtualMethodGetsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/HarderToDetectUnusedVirtualMethodGetsRemoved.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
-	class HarderToDetectUnusedVirtualMethodGetsRemoved {
+namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods
+{
+	class HarderToDetectUnusedVirtualMethodGetsRemoved
+	{
 		public static void Main ()
 		{
 			new Base ().Call ();
@@ -14,14 +16,16 @@ namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Base {
+		class Base
+		{
 			[Kept]
 			public virtual void Call ()
 			{
 			}
 		}
 
-		class B : Base {
+		class B : Base
+		{
 			public override void Call ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/NeverInstantiatedTypeWithBaseInCopiedAssembly.cs b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/NeverInstantiatedTypeWithBaseInCopiedAssembly.cs
index 50a91dace..162a5c48c 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/NeverInstantiatedTypeWithBaseInCopiedAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/NeverInstantiatedTypeWithBaseInCopiedAssembly.cs
@@ -2,20 +2,23 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.VirtualMethods.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
+namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods
+{
 	[SetupLinkerAction ("copy", "base")]
-	[SetupCompileBefore ("base.dll", new [] {typeof (TypeWithBaseInCopiedAssembly_Base)})]
+	[SetupCompileBefore ("base.dll", new[] { typeof (TypeWithBaseInCopiedAssembly_Base) })]
 	[KeptMemberInAssembly ("base.dll", typeof (TypeWithBaseInCopiedAssembly_Base), "Method()")]
-	public class NeverInstantiatedTypeWithBaseInCopiedAssembly {
+	public class NeverInstantiatedTypeWithBaseInCopiedAssembly
+	{
 		public static void Main ()
 		{
 			new Foo ();
 		}
 
 		[Kept]
-		[KeptMember(".ctor()")]
+		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (TypeWithBaseInCopiedAssembly_Base))]
-		class Foo : TypeWithBaseInCopiedAssembly_Base {
+		class Foo : TypeWithBaseInCopiedAssembly_Base
+		{
 			[Kept]
 			public override void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly.cs b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly.cs
index 0b58b67fb..266f21769 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/NotKeptCtor/NeverInstantiatedTypeWithBaseInCopiedAssembly.cs
@@ -2,11 +2,13 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Inheritance.VirtualMethods.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods.NotKeptCtor {
+namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods.NotKeptCtor
+{
 	[SetupLinkerAction ("copy", "base")]
-	[SetupCompileBefore ("base.dll", new [] {typeof (TypeWithBaseInCopiedAssembly_Base)})]
+	[SetupCompileBefore ("base.dll", new[] { typeof (TypeWithBaseInCopiedAssembly_Base) })]
 	[KeptMemberInAssembly ("base.dll", typeof (TypeWithBaseInCopiedAssembly_Base), "Method()")]
-	public class NeverInstantiatedTypeWithBaseInCopiedAssembly {
+	public class NeverInstantiatedTypeWithBaseInCopiedAssembly
+	{
 		public static void Main ()
 		{
 			Helper (null);
@@ -19,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods.NotKeptCtor {
 
 		[Kept]
 		[KeptBaseType (typeof (TypeWithBaseInCopiedAssembly_Base))]
-		class Foo : TypeWithBaseInCopiedAssembly_Base {
+		class Foo : TypeWithBaseInCopiedAssembly_Base
+		{
 			// It's safe to remove this because the type is never instantiated and the base method is virtual
 			public override void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/UnusedTypeWithOverrideOfVirtualMethodIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/UnusedTypeWithOverrideOfVirtualMethodIsRemoved.cs
index 57e84bca1..a9d71c772 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/UnusedTypeWithOverrideOfVirtualMethodIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/UnusedTypeWithOverrideOfVirtualMethodIsRemoved.cs
@@ -1,21 +1,25 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
-	class UnusedTypeWithOverrideOfVirtualMethodIsRemoved {
+namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods
+{
+	class UnusedTypeWithOverrideOfVirtualMethodIsRemoved
+	{
 		public static void Main ()
 		{
 			new Base ().Call ();
 		}
 
 		[KeptMember (".ctor()")]
-		class Base {
+		class Base
+		{
 			[Kept]
 			public virtual void Call ()
 			{
 			}
 		}
 
-		class B : Base {
+		class B : Base
+		{
 			public override void Call ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/UnusedVirtualMethodRemoved.cs b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/UnusedVirtualMethodRemoved.cs
index 88bd1f8ec..615e7f290 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/UnusedVirtualMethodRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/UnusedVirtualMethodRemoved.cs
@@ -1,14 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
-	public class UnusedVirtualMethodRemoved {
+namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods
+{
+	public class UnusedVirtualMethodRemoved
+	{
 		public static void Main ()
 		{
 			var tmp = new B ();
 		}
 
 		[KeptMember (".ctor()")]
-		class Base {
+		class Base
+		{
 			public virtual void Call ()
 			{
 			}
@@ -17,7 +20,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Base))]
-		class B : Base {
+		class B : Base
+		{
 			public override void Call ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/UsedOverrideOfVirtualMethodIsKept.cs b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/UsedOverrideOfVirtualMethodIsKept.cs
index 27b3c90dd..a1b996d41 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/UsedOverrideOfVirtualMethodIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/UsedOverrideOfVirtualMethodIsKept.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
-	public class UsedOverrideOfVirtualMethodIsKept {
+namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods
+{
+	public class UsedOverrideOfVirtualMethodIsKept
+	{
 		public static void Main ()
 		{
 			var tmp = new B ();
@@ -9,7 +11,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
 		}
 
 		[KeptMember (".ctor()")]
-		class Base {
+		class Base
+		{
 			[Kept]
 			public virtual void Call ()
 			{
@@ -19,7 +22,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Base))]
-		class B : Base {
+		class B : Base
+		{
 			[Kept]
 			public override void Call ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/UsedTypeWithOverrideOfVirtualMethodHasOverrideKept.cs b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/UsedTypeWithOverrideOfVirtualMethodHasOverrideKept.cs
index 2474d8dfa..29af6cfea 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/UsedTypeWithOverrideOfVirtualMethodHasOverrideKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/UsedTypeWithOverrideOfVirtualMethodHasOverrideKept.cs
@@ -1,8 +1,10 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
-	public class UsedTypeWithOverrideOfVirtualMethodHasOverrideKept {
+namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods
+{
+	public class UsedTypeWithOverrideOfVirtualMethodHasOverrideKept
+	{
 		public static void Main ()
 		{
 			new B ();
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
 		}
 
 		[KeptMember (".ctor()")]
-		class Base {
+		class Base
+		{
 			[Kept]
 			public virtual void Call ()
 			{
@@ -19,7 +22,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
 
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (Base))]
-		class B : Base {
+		class B : Base
+		{
 			[Kept]
 			public override void Call ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/VirtualMethodGetsPerservedIfBaseMethodGetsInvoked.cs b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/VirtualMethodGetsPerservedIfBaseMethodGetsInvoked.cs
index 0b1d75d75..4ae1aa52a 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/VirtualMethodGetsPerservedIfBaseMethodGetsInvoked.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/VirtualMethodGetsPerservedIfBaseMethodGetsInvoked.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
-	class VirtualMethodGetsPerservedIfBaseMethodGetsInvoked {
+namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods
+{
+	class VirtualMethodGetsPerservedIfBaseMethodGetsInvoked
+	{
 		public static void Main ()
 		{
 			new A ();
@@ -9,7 +11,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
 		}
 
 		[KeptMember (".ctor()")]
-		class B {
+		class B
+		{
 			[Kept]
 			public virtual void Foo ()
 			{
@@ -18,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
 
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (B))]
-		class A : B {
+		class A : B
+		{
 			[Kept]
 			public override void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/VirtualMethodGetsStrippedIfImplementingMethodGetsInvokedDirectly.cs b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/VirtualMethodGetsStrippedIfImplementingMethodGetsInvokedDirectly.cs
index d6b4969fe..76457ce53 100644
--- a/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/VirtualMethodGetsStrippedIfImplementingMethodGetsInvokedDirectly.cs
+++ b/test/Mono.Linker.Tests.Cases/Inheritance.VirtualMethods/VirtualMethodGetsStrippedIfImplementingMethodGetsInvokedDirectly.cs
@@ -1,14 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
-	class VirtualMethodGetsStrippedIfImplementingMethodGetsInvokedDirectly {
+namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods
+{
+	class VirtualMethodGetsStrippedIfImplementingMethodGetsInvokedDirectly
+	{
 		public static void Main ()
 		{
 			new A ().Foo ();
 		}
 
 		[KeptMember (".ctor()")]
-		class B {
+		class B
+		{
 			[Kept] // TODO: Would be nice to be removed
 			public virtual void Foo ()
 			{
@@ -17,7 +20,8 @@ namespace Mono.Linker.Tests.Cases.Inheritance.VirtualMethods {
 
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (B))]
-		class A : B {
+		class A : B
+		{
 			[Kept]
 			public override void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/DefaultConstructorOfParameterIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/DefaultConstructorOfParameterIsRemoved.cs
index 304a78553..8dbaf9566 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/DefaultConstructorOfParameterIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/DefaultConstructorOfParameterIsRemoved.cs
@@ -2,8 +2,10 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.InternalCalls.Com {
-	class DefaultConstructorOfParameterIsRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.InternalCalls.Com
+{
+	class DefaultConstructorOfParameterIsRemoved
+	{
 		public static void Main ()
 		{
 			SomeMethod (null);
@@ -13,7 +15,8 @@ namespace Mono.Linker.Tests.Cases.Interop.InternalCalls.Com {
 		[KeptAttributeAttribute (typeof (GuidAttribute))]
 		[ComImport]
 		[Guid ("D7BB1889-3AB7-4681-A115-60CA9158FECA")]
-		class A {
+		class A
+		{
 		}
 
 		[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/DefaultConstructorOfReturnTypeIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/DefaultConstructorOfReturnTypeIsRemoved.cs
index f9b3fc51d..73295df73 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/DefaultConstructorOfReturnTypeIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/DefaultConstructorOfReturnTypeIsRemoved.cs
@@ -2,8 +2,10 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.InternalCalls.Com {
-	class DefaultConstructorOfReturnTypeIsRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.InternalCalls.Com
+{
+	class DefaultConstructorOfReturnTypeIsRemoved
+	{
 		public static void Main ()
 		{
 			var a = SomeMethod ();
@@ -13,7 +15,8 @@ namespace Mono.Linker.Tests.Cases.Interop.InternalCalls.Com {
 		[KeptAttributeAttribute (typeof (GuidAttribute))]
 		[ComImport]
 		[Guid ("D7BB1889-3AB7-4681-A115-60CA9158FECA")]
-		class A {
+		class A
+		{
 		}
 
 		[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/FieldsOfParameterAreRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/FieldsOfParameterAreRemoved.cs
index 287b00c78..b5d8d6271 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/FieldsOfParameterAreRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/FieldsOfParameterAreRemoved.cs
@@ -2,8 +2,10 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.InternalCalls.Com {
-	class FieldsOfParameterAreRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.InternalCalls.Com
+{
+	class FieldsOfParameterAreRemoved
+	{
 		public static void Main ()
 		{
 			SomeMethod (null);
@@ -13,7 +15,8 @@ namespace Mono.Linker.Tests.Cases.Interop.InternalCalls.Com {
 		[KeptAttributeAttribute (typeof (GuidAttribute))]
 		[ComImport]
 		[Guid ("D7BB1889-3AB7-4681-A115-60CA9158FECA")]
-		class A {
+		class A
+		{
 			private int field;
 		}
 
diff --git a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/FieldsOfReturnTypeAreRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/FieldsOfReturnTypeAreRemoved.cs
index d1c0a7ecf..4a907d64b 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/FieldsOfReturnTypeAreRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/FieldsOfReturnTypeAreRemoved.cs
@@ -2,8 +2,10 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.InternalCalls.Com {
-	class FieldsOfReturnTypeAreRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.InternalCalls.Com
+{
+	class FieldsOfReturnTypeAreRemoved
+	{
 		public static void Main ()
 		{
 			var a = SomeMethod ();
@@ -13,7 +15,8 @@ namespace Mono.Linker.Tests.Cases.Interop.InternalCalls.Com {
 		[KeptAttributeAttribute (typeof (GuidAttribute))]
 		[ComImport]
 		[Guid ("D7BB1889-3AB7-4681-A115-60CA9158FECA")]
-		class A {
+		class A
+		{
 			private int field;
 		}
 
diff --git a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/FieldsOfThisAreRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/FieldsOfThisAreRemoved.cs
index ad4918318..7f34c6474 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/FieldsOfThisAreRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/Com/FieldsOfThisAreRemoved.cs
@@ -2,8 +2,10 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.InternalCalls.Com {
-	class FieldsOfThisAreRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.InternalCalls.Com
+{
+	class FieldsOfThisAreRemoved
+	{
 		public static void Main ()
 		{
 			new A ().SomeMethod ();
@@ -14,7 +16,8 @@ namespace Mono.Linker.Tests.Cases.Interop.InternalCalls.Com {
 		[KeptAttributeAttribute (typeof (GuidAttribute))]
 		[ComImport]
 		[Guid ("D7BB1889-3AB7-4681-A115-60CA9158FECA")]
-		class A {
+		class A
+		{
 			private int field;
 
 			[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/DefaultConstructorOfReturnTypeIsNotRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/DefaultConstructorOfReturnTypeIsNotRemoved.cs
index ecfe75123..fdf91dd93 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/DefaultConstructorOfReturnTypeIsNotRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/DefaultConstructorOfReturnTypeIsNotRemoved.cs
@@ -1,14 +1,17 @@
 using System.Runtime.CompilerServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.InternalCalls {
-	class DefaultConstructorOfReturnTypeIsNotRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.InternalCalls
+{
+	class DefaultConstructorOfReturnTypeIsNotRemoved
+	{
 		public static void Main ()
 		{
 			var a = SomeMethod ();
 		}
 
-		class A {
+		class A
+		{
 			[Kept]
 			public A ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedDefaultConstructorIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedDefaultConstructorIsRemoved.cs
index ab21994f0..089e594fa 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedDefaultConstructorIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedDefaultConstructorIsRemoved.cs
@@ -1,15 +1,18 @@
 using System.Runtime.CompilerServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.InternalCalls {
-	class UnusedDefaultConstructorIsRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.InternalCalls
+{
+	class UnusedDefaultConstructorIsRemoved
+	{
 		public static void Main ()
 		{
 			var a = new A (1);
 			SomeMethod (a);
 		}
 
-		class A {
+		class A
+		{
 			public A ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedDefaultConstructorOfTypePassedByRefIsNotRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedDefaultConstructorOfTypePassedByRefIsNotRemoved.cs
index d181ecd0a..e4a5e66ff 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedDefaultConstructorOfTypePassedByRefIsNotRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedDefaultConstructorOfTypePassedByRefIsNotRemoved.cs
@@ -1,15 +1,18 @@
 using System.Runtime.CompilerServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.InternalCalls {
-	class UnusedDefaultConstructorOfTypePassedByRefIsNotRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.InternalCalls
+{
+	class UnusedDefaultConstructorOfTypePassedByRefIsNotRemoved
+	{
 		public static void Main ()
 		{
 			var a = new A (1);
 			SomeMethod (ref a);
 		}
 
-		class A {
+		class A
+		{
 			[Kept]
 			public A ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedFieldsOfTypesAreNotRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedFieldsOfTypesAreNotRemoved.cs
index 09809a60e..eefdd22af 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedFieldsOfTypesAreNotRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedFieldsOfTypesAreNotRemoved.cs
@@ -1,8 +1,10 @@
 using System.Runtime.CompilerServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.InternalCalls {
-	class UnusedFieldsOfTypesAreNotRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.InternalCalls
+{
+	class UnusedFieldsOfTypesAreNotRemoved
+	{
 		public static void Main ()
 		{
 			var a = new A ();
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Interop.InternalCalls {
 		}
 
 		[KeptMember (".ctor()")]
-		class A {
+		class A
+		{
 			[Kept] private int field1;
 
 			[Kept] private int field2;
diff --git a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedFieldsOfTypesPassedByRefAreNotRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedFieldsOfTypesPassedByRefAreNotRemoved.cs
index d4f3c3779..7659a6486 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedFieldsOfTypesPassedByRefAreNotRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedFieldsOfTypesPassedByRefAreNotRemoved.cs
@@ -1,8 +1,10 @@
 using System.Runtime.CompilerServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.InternalCalls {
-	class UnusedFieldsOfTypesPassedByRefAreNotRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.InternalCalls
+{
+	class UnusedFieldsOfTypesPassedByRefAreNotRemoved
+	{
 		public static void Main ()
 		{
 			var a = new A ();
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Interop.InternalCalls {
 		}
 
 		[KeptMember (".ctor()")]
-		class A {
+		class A
+		{
 			[Kept] private int field1;
 
 			[Kept] private int field2;
diff --git a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedFieldsOfTypesWhenHasThisAreNotRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedFieldsOfTypesWhenHasThisAreNotRemoved.cs
index df77357d6..78bf3a9da 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedFieldsOfTypesWhenHasThisAreNotRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/InternalCalls/UnusedFieldsOfTypesWhenHasThisAreNotRemoved.cs
@@ -1,8 +1,10 @@
 using System.Runtime.CompilerServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.InternalCalls {
-	class UnusedFieldsOfTypesWhenHasThisAreNotRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.InternalCalls
+{
+	class UnusedFieldsOfTypesWhenHasThisAreNotRemoved
+	{
 		public static void Main ()
 		{
 			A a = new A ();
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Interop.InternalCalls {
 		}
 
 		[KeptMember (".ctor()")]
-		class A {
+		class A
+		{
 			[Kept] private int field1;
 
 			[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/DefaultConstructorOfParameterIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/DefaultConstructorOfParameterIsRemoved.cs
index df3d3b552..c17a8eeae 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/DefaultConstructorOfParameterIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/DefaultConstructorOfParameterIsRemoved.cs
@@ -2,8 +2,10 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.PInvoke.Com {
-	class DefaultConstructorOfParameterIsRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.PInvoke.Com
+{
+	class DefaultConstructorOfParameterIsRemoved
+	{
 		public static void Main ()
 		{
 			SomeMethod (null);
@@ -13,7 +15,8 @@ namespace Mono.Linker.Tests.Cases.Interop.PInvoke.Com {
 		[KeptAttributeAttribute (typeof (GuidAttribute))]
 		[ComImport]
 		[Guid ("D7BB1889-3AB7-4681-A115-60CA9158FECA")]
-		class A {
+		class A
+		{
 		}
 
 		[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/DefaultConstructorOfReturnTypeIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/DefaultConstructorOfReturnTypeIsRemoved.cs
index 3cc7df5db..e19ddcc32 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/DefaultConstructorOfReturnTypeIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/DefaultConstructorOfReturnTypeIsRemoved.cs
@@ -2,8 +2,10 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.PInvoke.Com {
-	class DefaultConstructorOfReturnTypeIsRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.PInvoke.Com
+{
+	class DefaultConstructorOfReturnTypeIsRemoved
+	{
 		public static void Main ()
 		{
 			var a = SomeMethod ();
@@ -13,7 +15,8 @@ namespace Mono.Linker.Tests.Cases.Interop.PInvoke.Com {
 		[KeptAttributeAttribute (typeof (GuidAttribute))]
 		[ComImport]
 		[Guid ("D7BB1889-3AB7-4681-A115-60CA9158FECA")]
-		class A {
+		class A
+		{
 		}
 
 		[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/FieldsOfParameterAreRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/FieldsOfParameterAreRemoved.cs
index 73a66b576..fa7dac6df 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/FieldsOfParameterAreRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/FieldsOfParameterAreRemoved.cs
@@ -2,8 +2,10 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.PInvoke.Com {
-	class FieldsOfParameterAreRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.PInvoke.Com
+{
+	class FieldsOfParameterAreRemoved
+	{
 		public static void Main ()
 		{
 			SomeMethod (null);
@@ -13,7 +15,8 @@ namespace Mono.Linker.Tests.Cases.Interop.PInvoke.Com {
 		[KeptAttributeAttribute (typeof (GuidAttribute))]
 		[ComImport]
 		[Guid ("D7BB1889-3AB7-4681-A115-60CA9158FECA")]
-		class A {
+		class A
+		{
 			private int field;
 		}
 
diff --git a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/FieldsOfReturnTypeAreRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/FieldsOfReturnTypeAreRemoved.cs
index 7551d8687..bd7ac773a 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/FieldsOfReturnTypeAreRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/FieldsOfReturnTypeAreRemoved.cs
@@ -2,8 +2,10 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.PInvoke.Com {
-	class FieldsOfReturnTypeAreRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.PInvoke.Com
+{
+	class FieldsOfReturnTypeAreRemoved
+	{
 		public static void Main ()
 		{
 			var a = SomeMethod ();
@@ -13,7 +15,8 @@ namespace Mono.Linker.Tests.Cases.Interop.PInvoke.Com {
 		[KeptAttributeAttribute (typeof (GuidAttribute))]
 		[ComImport]
 		[Guid ("D7BB1889-3AB7-4681-A115-60CA9158FECA")]
-		class A {
+		class A
+		{
 			private int field;
 		}
 
diff --git a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/FieldsOfThisAreRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/FieldsOfThisAreRemoved.cs
index 4c7402063..164030b48 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/FieldsOfThisAreRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Com/FieldsOfThisAreRemoved.cs
@@ -2,8 +2,10 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.PInvoke.Com {
-	class FieldsOfThisAreRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.PInvoke.Com
+{
+	class FieldsOfThisAreRemoved
+	{
 		public static void Main ()
 		{
 			new A ().SomeMethod ();
@@ -14,7 +16,8 @@ namespace Mono.Linker.Tests.Cases.Interop.PInvoke.Com {
 		[KeptAttributeAttribute (typeof (GuidAttribute))]
 		[ComImport]
 		[Guid ("D7BB1889-3AB7-4681-A115-60CA9158FECA")]
-		class A {
+		class A
+		{
 			private int field;
 
 			[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/DefaultConstructorOfReturnTypeIsNotRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/DefaultConstructorOfReturnTypeIsNotRemoved.cs
index d714d0d95..5b7bbbe94 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/DefaultConstructorOfReturnTypeIsNotRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/DefaultConstructorOfReturnTypeIsNotRemoved.cs
@@ -1,14 +1,17 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.PInvoke {
-	class DefaultConstructorOfReturnTypeIsNotRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.PInvoke
+{
+	class DefaultConstructorOfReturnTypeIsNotRemoved
+	{
 		public static void Main ()
 		{
 			var a = SomeMethod ();
 		}
 
-		class A {
+		class A
+		{
 			[Kept]
 			public A ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Individual/CanOutputPInvokes.cs b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Individual/CanOutputPInvokes.cs
index 8f0b28eec..e42acbb9b 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Individual/CanOutputPInvokes.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/Individual/CanOutputPInvokes.cs
@@ -8,9 +8,9 @@ namespace Mono.Linker.Tests.Cases.Interop.PInvoke.Individual
 	[SetupLinkerAction ("link", "linkassembly")]
 	// Prevent dumping of pinvokes from core assemblies
 	[SetupLinkerCoreAction ("skip")]
-	[SetupCompileBefore ("copyassembly.dll", new [] { typeof (CanOutputPInvokes_CopyAssembly) })]
-	[SetupCompileBefore ("linkassembly.dll", new [] { typeof (CanOutputPInvokes_LinkAssembly) })]
-	[SetupLinkerArgument ("--output-pinvokes", new [] { "pinvokes.json" })]
+	[SetupCompileBefore ("copyassembly.dll", new[] { typeof (CanOutputPInvokes_CopyAssembly) })]
+	[SetupCompileBefore ("linkassembly.dll", new[] { typeof (CanOutputPInvokes_LinkAssembly) })]
+	[SetupLinkerArgument ("--output-pinvokes", new[] { "pinvokes.json" })]
 
 	public class CanOutputPInvokes
 	{
diff --git a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/UnusedDefaultConstructorIsRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/UnusedDefaultConstructorIsRemoved.cs
index 041cc9c98..78d07f35c 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/UnusedDefaultConstructorIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/UnusedDefaultConstructorIsRemoved.cs
@@ -1,15 +1,18 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.PInvoke {
-	class UnusedDefaultConstructorIsRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.PInvoke
+{
+	class UnusedDefaultConstructorIsRemoved
+	{
 		public static void Main ()
 		{
 			var a = new A (1);
 			SomeMethod (a);
 		}
 
-		class A {
+		class A
+		{
 			public A ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/UnusedDefaultConstructorOfTypePassedByRefIsNotRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/UnusedDefaultConstructorOfTypePassedByRefIsNotRemoved.cs
index db2514a4a..442a3e84f 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/UnusedDefaultConstructorOfTypePassedByRefIsNotRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/UnusedDefaultConstructorOfTypePassedByRefIsNotRemoved.cs
@@ -1,15 +1,18 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.PInvoke {
-	class UnusedDefaultConstructorOfTypePassedByRefIsNotRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.PInvoke
+{
+	class UnusedDefaultConstructorOfTypePassedByRefIsNotRemoved
+	{
 		public static void Main ()
 		{
 			var a = new A (1);
 			SomeMethod (ref a);
 		}
 
-		class A {
+		class A
+		{
 			[Kept]
 			public A ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/UnusedFieldsOfTypesAreNotRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/UnusedFieldsOfTypesAreNotRemoved.cs
index a34c4d6bb..e801ff55c 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/UnusedFieldsOfTypesAreNotRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/UnusedFieldsOfTypesAreNotRemoved.cs
@@ -1,8 +1,10 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.PInvoke {
-	class UnusedFieldsOfTypesAreNotRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.PInvoke
+{
+	class UnusedFieldsOfTypesAreNotRemoved
+	{
 		public static void Main ()
 		{
 			var a = new A ();
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Interop.PInvoke {
 		}
 
 		[KeptMember (".ctor()")]
-		class A {
+		class A
+		{
 			[Kept] private int field1;
 
 			[Kept] private int field2;
diff --git a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/UnusedFieldsOfTypesPassedByRefAreNotRemoved.cs b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/UnusedFieldsOfTypesPassedByRefAreNotRemoved.cs
index 50ae45fe3..e9bbbf654 100644
--- a/test/Mono.Linker.Tests.Cases/Interop/PInvoke/UnusedFieldsOfTypesPassedByRefAreNotRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Interop/PInvoke/UnusedFieldsOfTypesPassedByRefAreNotRemoved.cs
@@ -1,8 +1,10 @@
 using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Interop.PInvoke {
-	class UnusedFieldsOfTypesPassedByRefAreNotRemoved {
+namespace Mono.Linker.Tests.Cases.Interop.PInvoke
+{
+	class UnusedFieldsOfTypesPassedByRefAreNotRemoved
+	{
 		public static void Main ()
 		{
 			var a = new A ();
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Interop.PInvoke {
 		}
 
 		[KeptMember (".ctor()")]
-		class A {
+		class A
+		{
 			[Kept] private int field1;
 
 			[Kept] private int field2;
diff --git a/test/Mono.Linker.Tests.Cases/Libraries/CanLinkPublicApisOfLibrary.cs b/test/Mono.Linker.Tests.Cases/Libraries/CanLinkPublicApisOfLibrary.cs
index 1bcd525dd..3ec44173f 100644
--- a/test/Mono.Linker.Tests.Cases/Libraries/CanLinkPublicApisOfLibrary.cs
+++ b/test/Mono.Linker.Tests.Cases/Libraries/CanLinkPublicApisOfLibrary.cs
@@ -1,12 +1,14 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Libraries {
+namespace Mono.Linker.Tests.Cases.Libraries
+{
 	[SetupLinkerLinkPublicAndFamily]
 	[SetupCompileAsLibrary]
 	[Kept]
 	[KeptMember (".ctor()")]
-	public class CanLinkPublicApisOfLibrary {
+	public class CanLinkPublicApisOfLibrary
+	{
 		// Kept because by default libraries their action set to copy
 		[Kept]
 		public static void Main ()
diff --git a/test/Mono.Linker.Tests.Cases/Libraries/DefaultLibraryLinkBehavior.cs b/test/Mono.Linker.Tests.Cases/Libraries/DefaultLibraryLinkBehavior.cs
index 5c1e9aba4..19ae1ea1c 100644
--- a/test/Mono.Linker.Tests.Cases/Libraries/DefaultLibraryLinkBehavior.cs
+++ b/test/Mono.Linker.Tests.Cases/Libraries/DefaultLibraryLinkBehavior.cs
@@ -1,11 +1,13 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Libraries {
+namespace Mono.Linker.Tests.Cases.Libraries
+{
 	[SetupCompileAsLibrary]
 	[Kept]
 	[KeptMember (".ctor()")]
-	public class DefaultLibraryLinkBehavior {
+	public class DefaultLibraryLinkBehavior
+	{
 		// Kept because by default libraries their action set to copy
 		[Kept]
 		public static void Main ()
diff --git a/test/Mono.Linker.Tests.Cases/Libraries/Dependencies/UserAssemblyActionWorks_Lib.cs b/test/Mono.Linker.Tests.Cases/Libraries/Dependencies/UserAssemblyActionWorks_Lib.cs
index b9b9e5863..d46e34942 100644
--- a/test/Mono.Linker.Tests.Cases/Libraries/Dependencies/UserAssemblyActionWorks_Lib.cs
+++ b/test/Mono.Linker.Tests.Cases/Libraries/Dependencies/UserAssemblyActionWorks_Lib.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.Libraries.Dependencies {
-	public class UserAssemblyActionWorks_Lib {
+namespace Mono.Linker.Tests.Cases.Libraries.Dependencies
+{
+	public class UserAssemblyActionWorks_Lib
+	{
 		public static void Used ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Libraries/UserAssemblyActionWorks.cs b/test/Mono.Linker.Tests.Cases/Libraries/UserAssemblyActionWorks.cs
index 1337ce066..cf66c9e5a 100644
--- a/test/Mono.Linker.Tests.Cases/Libraries/UserAssemblyActionWorks.cs
+++ b/test/Mono.Linker.Tests.Cases/Libraries/UserAssemblyActionWorks.cs
@@ -2,14 +2,16 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Libraries.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Libraries {
+namespace Mono.Linker.Tests.Cases.Libraries
+{
 	/// <summary>
 	/// We have to check another assembly because the test exe is included with -a and that will cause it to be linked
 	/// </summary>
 	[SetupLinkerUserAction ("copy")]
 	[SetupCompileBefore ("lib.dll", new[] { "Dependencies/UserAssemblyActionWorks_Lib.cs" })]
 	[KeptAllTypesAndMembersInAssembly ("lib.dll")]
-	public class UserAssemblyActionWorks {
+	public class UserAssemblyActionWorks
+	{
 		public static void Main ()
 		{
 			UserAssemblyActionWorks_Lib.Used ();
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/AssemblyWithPreserveAll.cs b/test/Mono.Linker.Tests.Cases/LinkXml/AssemblyWithPreserveAll.cs
index f02913bc5..f9dc8ae88 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/AssemblyWithPreserveAll.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/AssemblyWithPreserveAll.cs
@@ -1,22 +1,25 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
 	[KeptMember (".ctor()")]
-	public class AssemblyWithPreserveAll {
+	public class AssemblyWithPreserveAll
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class UnusedType {
+		class UnusedType
+		{
 			[Kept]
 			public int UnusedField;
 
 			[Kept]
 			[KeptBackingField]
 			public int UnusedProperty { [Kept] get; [Kept] set; }
-			
+
 			[Kept]
 			public void UnusedMethod ()
 			{
@@ -24,7 +27,8 @@ namespace Mono.Linker.Tests.Cases.LinkXml {
 
 			[Kept]
 			[KeptMember (".ctor()")]
-			class UnusedNestedType {
+			class UnusedNestedType
+			{
 			}
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/CanPreserveAnExportedType.cs b/test/Mono.Linker.Tests.Cases/LinkXml/CanPreserveAnExportedType.cs
index bbf26c1d4..f7e7b07da 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/CanPreserveAnExportedType.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/CanPreserveAnExportedType.cs
@@ -12,8 +12,10 @@ namespace Mono.Linker.Tests.Cases.LinkXml
 
 	[RemovedAssembly ("Forwarder.dll")]
 	[KeptMemberInAssembly ("Library.dll", typeof (CanPreserveAnExportedType_Library), "Field1", "Method()", ".ctor()")]
-	class CanPreserveAnExportedType {
-		public static void Main () {
+	class CanPreserveAnExportedType
+	{
+		public static void Main ()
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/CanPreserveExcludedFeatureCom.cs b/test/Mono.Linker.Tests.Cases/LinkXml/CanPreserveExcludedFeatureCom.cs
index df2aeb29f..ba268b9f2 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/CanPreserveExcludedFeatureCom.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/CanPreserveExcludedFeatureCom.cs
@@ -3,13 +3,15 @@ using System.Runtime.InteropServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("--exclude-feature is not supported on .NET Core")]
 #endif
 	[SetupLinkerArgument ("--exclude-feature", "com")]
-	public class CanPreserveExcludedFeatureCom {
-		public static void Main()
+	public class CanPreserveExcludedFeatureCom
+	{
+		public static void Main ()
 		{
 			var a = new A ();
 		}
@@ -17,7 +19,7 @@ namespace Mono.Linker.Tests.Cases.LinkXml {
 
 	[Kept]
 	[KeptMember (".ctor()")]
-	[KeptAttributeAttribute (typeof(GuidAttribute))]
+	[KeptAttributeAttribute (typeof (GuidAttribute))]
 	[ComImport]
 	[Guid ("D7BB1889-3AB7-4681-A115-60CA9158FECA")]
 	class A
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/CanPreserveExportedTypesUsingRegex.cs b/test/Mono.Linker.Tests.Cases/LinkXml/CanPreserveExportedTypesUsingRegex.cs
index d122d98f3..b12e8f6bd 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/CanPreserveExportedTypesUsingRegex.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/CanPreserveExportedTypesUsingRegex.cs
@@ -6,14 +6,16 @@ using Mono.Linker.Tests.Cases.LinkXml.Dependencies;
 namespace Mono.Linker.Tests.Cases.LinkXml
 {
 	[KeepTypeForwarderOnlyAssemblies ("false")]
-	[SetupCompileBefore ("Library.dll", new [] { "Dependencies/CanPreserveAnExportedType_Library.cs" })]
+	[SetupCompileBefore ("Library.dll", new[] { "Dependencies/CanPreserveAnExportedType_Library.cs" })]
 	// Add another assembly in that uses the forwarder just to make things a little more complex
-	[SetupCompileBefore ("Forwarder.dll", new [] { "Dependencies/CanPreserveAnExportedType_Forwarder.cs" }, references: new [] { "Library.dll" })]
+	[SetupCompileBefore ("Forwarder.dll", new[] { "Dependencies/CanPreserveAnExportedType_Forwarder.cs" }, references: new[] { "Library.dll" })]
 
 	[RemovedAssembly ("Forwarder.dll")]
 	[KeptMemberInAssembly ("Library.dll", typeof (CanPreserveAnExportedType_Library), "Field1", "Method()", ".ctor()")]
-	class CanPreserveExportedTypesUsingRegex {
-		public static void Main () {
+	class CanPreserveExportedTypesUsingRegex
+	{
+		public static void Main ()
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/CanPreserveTypesUsingRegex.cs b/test/Mono.Linker.Tests.Cases/LinkXml/CanPreserveTypesUsingRegex.cs
index 0eb9542d2..2c5167dc9 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/CanPreserveTypesUsingRegex.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/CanPreserveTypesUsingRegex.cs
@@ -4,29 +4,36 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 namespace Mono.Linker.Tests.Cases.LinkXml
 {
 	[KeptMember (".ctor()")]
-	class CanPreserveTypesUsingRegex {
-		public static void Main () {
+	class CanPreserveTypesUsingRegex
+	{
+		public static void Main ()
+		{
 		}
 
 		[Kept]
-		void UnusedHelper () {
+		void UnusedHelper ()
+		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Bar {
+		class Bar
+		{
 		}
 	}
 }
 
-namespace Mono.Linker.Tests.Cases.LinkXml.PreserveNamespace {
+namespace Mono.Linker.Tests.Cases.LinkXml.PreserveNamespace
+{
 	[Kept]
 	[KeptMember (".ctor()")]
-	class Type1 {
+	class Type1
+	{
 	}
 
 	[Kept]
 	[KeptMember (".ctor()")]
-	class Type2 {
+	class Type2
+	{
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/CanPreserveAnExportedType_Library.cs b/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/CanPreserveAnExportedType_Library.cs
index 38814d986..83781f887 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/CanPreserveAnExportedType_Library.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/CanPreserveAnExportedType_Library.cs
@@ -2,10 +2,12 @@
 
 namespace Mono.Linker.Tests.Cases.LinkXml.Dependencies
 {
-	public class CanPreserveAnExportedType_Library {
+	public class CanPreserveAnExportedType_Library
+	{
 		public int Field1;
 
-		public void Method () {
+		public void Method ()
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlFromCopyAssemblyIsProcessed/CopyLibrary.cs b/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlFromCopyAssemblyIsProcessed/CopyLibrary.cs
index 0f7fda126..b6ecabd48 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlFromCopyAssemblyIsProcessed/CopyLibrary.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlFromCopyAssemblyIsProcessed/CopyLibrary.cs
@@ -2,7 +2,8 @@ using System;
 
 namespace Mono.Linker.Tests.Cases.LinkXml.Dependencies.EmbeddedLinkXmlFromCopyAssemblyIsProcessed
 {
-	public class CopyLibrary {
+	public class CopyLibrary
+	{
 		public void Method ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlFromCopyAssemblyIsProcessed/OtherLibrary.cs b/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlFromCopyAssemblyIsProcessed/OtherLibrary.cs
index 24f59a2d3..c33cfebaa 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlFromCopyAssemblyIsProcessed/OtherLibrary.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlFromCopyAssemblyIsProcessed/OtherLibrary.cs
@@ -2,7 +2,8 @@ using System;
 
 namespace Mono.Linker.Tests.Cases.LinkXml.Dependencies.EmbeddedLinkXmlFromCopyAssemblyIsProcessed
 {
-	public class OtherLibrary {
+	public class OtherLibrary
+	{
 		public void Method ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Base.cs b/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Base.cs
index d9803fada..b040bf788 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Base.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Base.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.LinkXml.Dependencies.EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod {
-	public class Base {
+namespace Mono.Linker.Tests.Cases.LinkXml.Dependencies.EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod
+{
+	public class Base
+	{
 		public virtual void VirtualMethodFromBase ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Library1.cs b/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Library1.cs
index 3c1158922..4b84325a7 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Library1.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Library1.cs
@@ -1,15 +1,18 @@
-namespace Mono.Linker.Tests.Cases.LinkXml.Dependencies.EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod {
-	public class Library1 : Base {
+namespace Mono.Linker.Tests.Cases.LinkXml.Dependencies.EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod
+{
+	public class Library1 : Base
+	{
 		public override void VirtualMethodFromBase ()
 		{
 		}
 	}
-	
+
 	/// <summary>
 	/// This is here to confirm that derived types in the same assembly as the embedded resource are correctly taken into
 	/// consideration
 	/// </summary>
-	public class Library1Secondary : Base {
+	public class Library1Secondary : Base
+	{
 		public override void VirtualMethodFromBase ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Library2.cs b/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Library2.cs
index b977a5834..e572e1489 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Library2.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Library2.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.LinkXml.Dependencies.EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod {
-	public class Library2 : Base {
+namespace Mono.Linker.Tests.Cases.LinkXml.Dependencies.EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod
+{
+	public class Library2 : Base
+	{
 		public override void VirtualMethodFromBase ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/EmbeddedLinkXmlFromCopyAssemblyIsProcessed.cs b/test/Mono.Linker.Tests.Cases/LinkXml/EmbeddedLinkXmlFromCopyAssemblyIsProcessed.cs
index 9bddcaae3..9a57d8bf3 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/EmbeddedLinkXmlFromCopyAssemblyIsProcessed.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/EmbeddedLinkXmlFromCopyAssemblyIsProcessed.cs
@@ -2,18 +2,20 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.LinkXml.Dependencies.EmbeddedLinkXmlFromCopyAssemblyIsProcessed;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
 	[SetupCompileBefore ("Library.dll",
-		new [] { "Dependencies/EmbeddedLinkXmlFromCopyAssemblyIsProcessed/OtherLibrary.cs" })]
+		new[] { "Dependencies/EmbeddedLinkXmlFromCopyAssemblyIsProcessed/OtherLibrary.cs" })]
 	[SetupCompileBefore ("CopyLibrary.dll",
-		new [] { "Dependencies/EmbeddedLinkXmlFromCopyAssemblyIsProcessed/CopyLibrary.cs" },
-		resources: new [] { "Dependencies/EmbeddedLinkXmlFromCopyAssemblyIsProcessed/CopyLibrary.xml"})]
+		new[] { "Dependencies/EmbeddedLinkXmlFromCopyAssemblyIsProcessed/CopyLibrary.cs" },
+		resources: new[] { "Dependencies/EmbeddedLinkXmlFromCopyAssemblyIsProcessed/CopyLibrary.xml" })]
 	[IncludeBlacklistStep (true)]
 	[SetupLinkerAction ("copy", "CopyLibrary")]
 
 	[KeptTypeInAssembly ("CopyLibrary.dll", typeof (CopyLibrary))]
 	[KeptTypeInAssembly ("Library.dll", typeof (OtherLibrary))]
-	public class EmbeddedLinkXmlFromCopyAssemblyIsProcessed {
+	public class EmbeddedLinkXmlFromCopyAssemblyIsProcessed
+	{
 		public static void Main ()
 		{
 			var tmp = new CopyLibrary ();
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod.cs b/test/Mono.Linker.Tests.Cases/LinkXml/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod.cs
index 6111bc713..77f45d75c 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod.cs
@@ -2,26 +2,28 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.LinkXml.Dependencies.EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
 	[SetupCompileBefore ("Base.dll",
-		new []{"Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Base.cs"})]
+		new[] { "Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Base.cs" })]
 	[SetupCompileBefore ("Library1.dll",
-		new [] { "Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Library1.cs"},
-		new [] { "Base.dll"},
-		resources: new [] { "Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Library1.xml"})]
-	[SetupCompileBefore("Library2.dll",
-		new [] {"Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Library2.cs"},
-		new [] {"Base.dll"},
+		new[] { "Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Library1.cs" },
+		new[] { "Base.dll" },
+		resources: new[] { "Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Library1.xml" })]
+	[SetupCompileBefore ("Library2.dll",
+		new[] { "Dependencies/EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod/Library2.cs" },
+		new[] { "Base.dll" },
 		addAsReference: false)]
 	[IncludeBlacklistStep (true)]
-	
+
 	[KeptMemberInAssembly ("Library1.dll", typeof (Library1), "VirtualMethodFromBase()")]
 	[KeptMemberInAssembly ("Library1.dll", typeof (Library1Secondary), "VirtualMethodFromBase()")]
-	
+
 	// Library1's embedded link xml will preserve the Library2 type.  Because Library2 shares a base class with Library1
 	// Library2's override should be kept as well
 	[KeptMemberInAssembly ("Library2.dll", "Mono.Linker.Tests.Cases.LinkXml.Dependencies.EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod.Library2", "VirtualMethodFromBase()")]
-	public class EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod {
+	public class EmbeddedLinkXmlPreservesAdditionalAssemblyWithOverriddenMethod
+	{
 		public static void Main ()
 		{
 			var tmp = new Library1 ();
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/Dependencies/OnAssembly_Lib1.cs b/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/Dependencies/OnAssembly_Lib1.cs
index 1e0c0a738..ee457792a 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/Dependencies/OnAssembly_Lib1.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/Dependencies/OnAssembly_Lib1.cs
@@ -1,10 +1,13 @@
-namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude.Dependencies {
-    public class OnAssembly_Lib1 {
-        public static void UsedSoCompilerDoesntRemoveReference ()
-        {
-        }
+namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude.Dependencies
+{
+	public class OnAssembly_Lib1
+	{
+		public static void UsedSoCompilerDoesntRemoveReference ()
+		{
+		}
 
-        public class FeatureOneClass {
-        }
-    }
+		public class FeatureOneClass
+		{
+		}
+	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/Dependencies/OnAssembly_Lib2.cs b/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/Dependencies/OnAssembly_Lib2.cs
index 0a7731e79..032ad67f7 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/Dependencies/OnAssembly_Lib2.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/Dependencies/OnAssembly_Lib2.cs
@@ -1,10 +1,13 @@
-namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude.Dependencies {
-    public class OnAssembly_Lib2 {
-        public static void UsedSoCompilerDoesntRemoveReference ()
-        {
-        }
+namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude.Dependencies
+{
+	public class OnAssembly_Lib2
+	{
+		public static void UsedSoCompilerDoesntRemoveReference ()
+		{
+		}
 
-        public class FeatureTwoClass {
-        }
-    }
+		public class FeatureTwoClass
+		{
+		}
+	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnAssembly.cs b/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnAssembly.cs
index 59d546a15..dbe36e943 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnAssembly.cs
@@ -2,20 +2,22 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.LinkXml.FeatureExclude.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude {
+namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("--exclude-feature is not supported on .NET Core")]
 #endif
-    [SetupLinkerArgument ("--exclude-feature", "one")]
-    [SetupCompileBefore ("library1.dll", new[] {typeof (OnAssembly_Lib1)})]
-    [SetupCompileBefore ("library2.dll", new[] {typeof (OnAssembly_Lib2)})]
-    [RemovedTypeInAssembly ("library1.dll", typeof (OnAssembly_Lib1.FeatureOneClass))]
-    [KeptTypeInAssembly ("library2.dll", typeof (OnAssembly_Lib2.FeatureTwoClass))]
-    public class OnAssembly {
-        public static void Main ()
-        {
-            OnAssembly_Lib1.UsedSoCompilerDoesntRemoveReference ();
-            OnAssembly_Lib2.UsedSoCompilerDoesntRemoveReference ();
-        }
-    }
+	[SetupLinkerArgument ("--exclude-feature", "one")]
+	[SetupCompileBefore ("library1.dll", new[] { typeof (OnAssembly_Lib1) })]
+	[SetupCompileBefore ("library2.dll", new[] { typeof (OnAssembly_Lib2) })]
+	[RemovedTypeInAssembly ("library1.dll", typeof (OnAssembly_Lib1.FeatureOneClass))]
+	[KeptTypeInAssembly ("library2.dll", typeof (OnAssembly_Lib2.FeatureTwoClass))]
+	public class OnAssembly
+	{
+		public static void Main ()
+		{
+			OnAssembly_Lib1.UsedSoCompilerDoesntRemoveReference ();
+			OnAssembly_Lib2.UsedSoCompilerDoesntRemoveReference ();
+		}
+	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnEvent.cs b/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnEvent.cs
index 2cf664c5e..1279cfe85 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnEvent.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnEvent.cs
@@ -2,19 +2,21 @@ using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude {
+namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("--exclude-feature is not supported on .NET Core")]
 #endif
-    [SetupLinkerArgument ("--exclude-feature", "one")]
-    public class OnEvent {
-        public static void Main ()
-        {
-        }
+	[SetupLinkerArgument ("--exclude-feature", "one")]
+	public class OnEvent
+	{
+		public static void Main ()
+		{
+		}
 
-        public event EventHandler<EventArgs> FeatureOne;
+		public event EventHandler<EventArgs> FeatureOne;
 
-        [Kept]
-        public event EventHandler<EventArgs> FeatureTwo {[Kept] add {}[Kept] remove {} }
-    }
+		[Kept]
+		public event EventHandler<EventArgs> FeatureTwo { [Kept] add { } [Kept] remove { } }
+	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnField.cs b/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnField.cs
index 466be6199..df2a32af2 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnField.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnField.cs
@@ -1,19 +1,21 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude {
+namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("--exclude-feature is not supported on .NET Core")]
 #endif
-    [SetupLinkerArgument ("--exclude-feature", "one")]
-    public class OnField {
-        public static void Main ()
-        {
-        }
+	[SetupLinkerArgument ("--exclude-feature", "one")]
+	public class OnField
+	{
+		public static void Main ()
+		{
+		}
 
-        private int _featureOne;
+		private int _featureOne;
 
-        [Kept]
-        private int _featureTwo;
-    }
+		[Kept]
+		private int _featureTwo;
+	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnMethod.cs b/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnMethod.cs
index 30741f2a2..1f7a7def8 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnMethod.cs
@@ -1,23 +1,25 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude {
+namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("--exclude-feature is not supported on .NET Core")]
 #endif
-    [SetupLinkerArgument ("--exclude-feature", "one")]
-    public class OnMethod {
-        public static void Main ()
-        {
-        }
+	[SetupLinkerArgument ("--exclude-feature", "one")]
+	public class OnMethod
+	{
+		public static void Main ()
+		{
+		}
 
-        public void FeatureOne ()
-        {
-        }
+		public void FeatureOne ()
+		{
+		}
 
-        [Kept]
-        public void FeatureTwo ()
-        {
-        }
-    }
+		[Kept]
+		public void FeatureTwo ()
+		{
+		}
+	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnProperty.cs b/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnProperty.cs
index c550c605c..105330ea3 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnProperty.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnProperty.cs
@@ -1,12 +1,14 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude { 
+namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("--exclude-feature is not supported on .NET Core")]
 #endif
 	[SetupLinkerArgument ("--exclude-feature", "one")]
-	public class OnProperty {
+	public class OnProperty
+	{
 		public static void Main ()
 		{
 			new Foo (); // Used to avoid lazy body marking
@@ -14,12 +16,13 @@ namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo { 
+		class Foo
+		{
 			public int FeatureOne { get; set; }
-			
-			[Kept] 
-			[KeptBackingField] 
-			public int FeatureTwo {[Kept] get; [Kept] set; }
+
+			[Kept]
+			[KeptBackingField]
+			public int FeatureTwo { [Kept] get; [Kept] set; }
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnType.cs b/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnType.cs
index 731f54080..32b546637 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnType.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/FeatureExclude/OnType.cs
@@ -1,23 +1,26 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude {
+namespace Mono.Linker.Tests.Cases.LinkXml.FeatureExclude
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("--exclude-feature is not supported on .NET Core")]
 #endif
-    [SetupLinkerArgument ("--exclude-feature", "one")]
-    public class OnType {
-        public static void Main ()
-        {
-        }
+	[SetupLinkerArgument ("--exclude-feature", "one")]
+	public class OnType
+	{
+		public static void Main ()
+		{
+		}
 
-        class FeatureOneClass
-        {
-        }
+		class FeatureOneClass
+		{
+		}
 
-        [Kept]
-        [KeptMember(".ctor()")]
-        class FeatureTwoClass {
-        }
-    }
+		[Kept]
+		[KeptMember (".ctor()")]
+		class FeatureTwoClass
+		{
+		}
+	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/PreserveBackingFieldWhenPropertyIsKept.cs b/test/Mono.Linker.Tests.Cases/LinkXml/PreserveBackingFieldWhenPropertyIsKept.cs
index c319c1442..16e302a5f 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/PreserveBackingFieldWhenPropertyIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/PreserveBackingFieldWhenPropertyIsKept.cs
@@ -13,6 +13,6 @@ namespace Mono.Linker.Tests.Cases.LinkXml
 
 		[Kept]
 		[KeptBackingField]
-		public static int Prop { get; [Kept] set; }		
+		public static int Prop { get; [Kept] set; }
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/PreserveSecondLevelMethodsOfNonRequiredType.cs b/test/Mono.Linker.Tests.Cases/LinkXml/PreserveSecondLevelMethodsOfNonRequiredType.cs
index b795e8f24..27dde89b2 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/PreserveSecondLevelMethodsOfNonRequiredType.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/PreserveSecondLevelMethodsOfNonRequiredType.cs
@@ -1,35 +1,37 @@
 using System.Collections.Generic;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	class PreserveSecondLevelMethodsOfNonRequiredType {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	class PreserveSecondLevelMethodsOfNonRequiredType
+	{
 		public static void Main ()
 		{
-            new Unused ();
+			new Unused ();
 		}
 
 		[Kept]
 		class Unused
-        {
-            [Kept]
-            public Unused ()
-            {
-            }
+		{
+			[Kept]
+			public Unused ()
+			{
+			}
 
 			[Kept]
 			private void PreservedMethod ()
 			{
-                new SecondLevel (2);
+				new SecondLevel (2);
 			}
 		}
 
-        [Kept]
-        class SecondLevel
-        {
-            [Kept]
-            public SecondLevel (int arg)
-            {
-            }
-        }
+		[Kept]
+		class SecondLevel
+		{
+			[Kept]
+			public SecondLevel (int arg)
+			{
+			}
+		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/TypeWithPreserveFieldsHasBackingFieldsOfPropertiesRemoved.cs b/test/Mono.Linker.Tests.Cases/LinkXml/TypeWithPreserveFieldsHasBackingFieldsOfPropertiesRemoved.cs
index 623ee17ca..ed0c2afc6 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/TypeWithPreserveFieldsHasBackingFieldsOfPropertiesRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/TypeWithPreserveFieldsHasBackingFieldsOfPropertiesRemoved.cs
@@ -4,12 +4,15 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
 namespace Mono.Linker.Tests.Cases.LinkXml
 {
-	class TypeWithPreserveFieldsHasBackingFieldsOfPropertiesRemoved {
-		public static void Main () {
+	class TypeWithPreserveFieldsHasBackingFieldsOfPropertiesRemoved
+	{
+		public static void Main ()
+		{
 		}
 
 		[Kept]
-		class Unused : IFoo<int>, IFoo<string>, IFoo<Cat>, IFoo2<int>, IFoo3<int, string, char>, IDog, IFoo<IFoo<int>> {
+		class Unused : IFoo<int>, IFoo<string>, IFoo<Cat>, IFoo2<int>, IFoo3<int, string, char>, IDog, IFoo<IFoo<int>>
+		{
 			[Kept]
 			public int Field1;
 
@@ -37,25 +40,30 @@ namespace Mono.Linker.Tests.Cases.LinkXml
 			int IFoo<IFoo<int>>.Bar { get; set; }
 		}
 
-		interface IDog {
+		interface IDog
+		{
 			string Name { get; set; }
 		}
 
 		[Kept]
-		interface IFoo<T> {
+		interface IFoo<T>
+		{
 
 			int Bar { get; set; }
 		}
 
-		interface IFoo2<T> {
+		interface IFoo2<T>
+		{
 			int Bar2 { get; set; }
 		}
 
-		interface IFoo3<T, K, J> {
+		interface IFoo3<T, K, J>
+		{
 			int Bar3 { get; set; }
 		}
 
-		class Cat {
+		class Cat
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedAssemblyWithNoDefinedPreserveHasAllTypesPreserved.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedAssemblyWithNoDefinedPreserveHasAllTypesPreserved.cs
index fb8536a2f..339cc5e49 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedAssemblyWithNoDefinedPreserveHasAllTypesPreserved.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedAssemblyWithNoDefinedPreserveHasAllTypesPreserved.cs
@@ -1,15 +1,18 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
 	[KeptMember (".ctor()")]
-	public class UnusedAssemblyWithNoDefinedPreserveHasAllTypesPreserved {
+	public class UnusedAssemblyWithNoDefinedPreserveHasAllTypesPreserved
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Unused {
+		class Unused
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedEventPreservedByLinkXmlIsKept.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedEventPreservedByLinkXmlIsKept.cs
index b953fdcea..ae02f1ef5 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedEventPreservedByLinkXmlIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedEventPreservedByLinkXmlIsKept.cs
@@ -2,8 +2,10 @@
 
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	class UnusedEventPreservedByLinkXmlIsKept {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	class UnusedEventPreservedByLinkXmlIsKept
+	{
 		public static void Main ()
 		{
 			new Unused (); // Used to avoid lazy body marking
@@ -11,7 +13,8 @@ namespace Mono.Linker.Tests.Cases.LinkXml {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Unused {
+		class Unused
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptEventAddMethod]
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedFieldPreservedByLinkXmlIsKept.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedFieldPreservedByLinkXmlIsKept.cs
index d41e23716..b3f3b2508 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedFieldPreservedByLinkXmlIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedFieldPreservedByLinkXmlIsKept.cs
@@ -1,14 +1,17 @@
 using System.Collections.Generic;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	class UnusedFieldPreservedByLinkXmlIsKept {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	class UnusedFieldPreservedByLinkXmlIsKept
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
-		class Unused {
+		class Unused
+		{
 			[Kept]
 			private int _preserved;
 
@@ -22,7 +25,8 @@ namespace Mono.Linker.Tests.Cases.LinkXml {
 		}
 
 		[Kept]
-		class UnusedWithGenerics<T> {
+		class UnusedWithGenerics<T>
+		{
 			[Kept]
 			private List<T> _preserved1;
 		}
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedGenericTypeWithPreserveAllHasAllMembersPreserved.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedGenericTypeWithPreserveAllHasAllMembersPreserved.cs
index 659d4c5d1..24a0f4b30 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedGenericTypeWithPreserveAllHasAllMembersPreserved.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedGenericTypeWithPreserveAllHasAllMembersPreserved.cs
@@ -1,14 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	public class UnusedGenericTypeWithPreserveAllHasAllMembersPreserved {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	public class UnusedGenericTypeWithPreserveAllHasAllMembersPreserved
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Unused<T1, T2, T3> {
+		class Unused<T1, T2, T3>
+		{
 			[Kept]
 			public int Field1;
 
@@ -29,7 +32,7 @@ namespace Mono.Linker.Tests.Cases.LinkXml {
 
 			[Kept]
 			[KeptBackingField]
-			public string Property1 { [Kept] get; [Kept] set;}
+			public string Property1 { [Kept] get; [Kept] set; }
 
 			[Kept]
 			[KeptBackingField]
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedInterfaceTypeOnTypeWithPreserveAllIsKept.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedInterfaceTypeOnTypeWithPreserveAllIsKept.cs
index 8e362a4d8..749bebc64 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedInterfaceTypeOnTypeWithPreserveAllIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedInterfaceTypeOnTypeWithPreserveAllIsKept.cs
@@ -1,19 +1,23 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	public class UnusedInterfaceTypeOnTypeWithPreserveAllIsKept {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	public class UnusedInterfaceTypeOnTypeWithPreserveAllIsKept
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 		}
-		
+
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptInterface (typeof (IFoo))]
-		class Bar : IFoo {
+		class Bar : IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedInterfaceTypeOnTypeWithPreserveNothingIsRemoved.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedInterfaceTypeOnTypeWithPreserveNothingIsRemoved.cs
index 968d0d1e6..f87deab6a 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedInterfaceTypeOnTypeWithPreserveNothingIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedInterfaceTypeOnTypeWithPreserveNothingIsRemoved.cs
@@ -1,16 +1,20 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	public class UnusedInterfaceTypeOnTypeWithPreserveNothingIsRemoved {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	public class UnusedInterfaceTypeOnTypeWithPreserveNothingIsRemoved
+	{
 		public static void Main ()
 		{
 		}
 
-		interface IFoo {
+		interface IFoo
+		{
 		}
-		
+
 		[Kept]
-		class Bar : IFoo {
+		class Bar : IFoo
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedMethodPreservedByLinkXmlIsKept.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedMethodPreservedByLinkXmlIsKept.cs
index 123afb937..3cfc293cd 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedMethodPreservedByLinkXmlIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedMethodPreservedByLinkXmlIsKept.cs
@@ -1,14 +1,17 @@
 using System.Collections.Generic;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	class UnusedMethodPreservedByLinkXmlIsKept {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	class UnusedMethodPreservedByLinkXmlIsKept
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
-		class Unused {
+		class Unused
+		{
 			[Kept]
 			private void PreservedMethod ()
 			{
@@ -34,7 +37,7 @@ namespace Mono.Linker.Tests.Cases.LinkXml {
 			}
 
 			[Kept]
-			private void PreservedMethod5<T>(T arg)
+			private void PreservedMethod5<T> (T arg)
 			{
 			}
 		}
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedNestedTypePreservedByLinkXmlIsKept.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedNestedTypePreservedByLinkXmlIsKept.cs
index 5e319acfd..bdf36cf2b 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedNestedTypePreservedByLinkXmlIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedNestedTypePreservedByLinkXmlIsKept.cs
@@ -1,14 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	class UnusedNestedTypePreservedByLinkXmlIsKept {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	class UnusedNestedTypePreservedByLinkXmlIsKept
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Unused {
+		class Unused
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedNonRequiredTypeIsRemoved.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedNonRequiredTypeIsRemoved.cs
index 8175ee32e..ca988955a 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedNonRequiredTypeIsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedNonRequiredTypeIsRemoved.cs
@@ -1,10 +1,13 @@
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	public class UnusedNonRequiredTypeIsRemoved {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	public class UnusedNonRequiredTypeIsRemoved
+	{
 		public static void Main ()
 		{
 		}
 
-		class Unused {
+		class Unused
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedPropertyPreservedByLinkXmlIsKept.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedPropertyPreservedByLinkXmlIsKept.cs
index 8d3bb6372..4c6c9834b 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedPropertyPreservedByLinkXmlIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedPropertyPreservedByLinkXmlIsKept.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	class UnusedPropertyPreservedByLinkXmlIsKept {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	class UnusedPropertyPreservedByLinkXmlIsKept
+	{
 		public static void Main ()
 		{
 			new Unused (); // Used to avoid lazy body marking
@@ -9,7 +11,8 @@ namespace Mono.Linker.Tests.Cases.LinkXml {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Unused {
+		class Unused
+		{
 			[Kept]
 			[KeptBackingField]
 			public int PreservedProperty1 { [Kept] get; [Kept] set; }
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeDeclarationPreservedByLinkXmlIsKept.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeDeclarationPreservedByLinkXmlIsKept.cs
index bd2b15ba3..e5c18215d 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeDeclarationPreservedByLinkXmlIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeDeclarationPreservedByLinkXmlIsKept.cs
@@ -1,8 +1,10 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	public class UnusedTypeDeclarationPreservedByLinkXmlIsKept {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	public class UnusedTypeDeclarationPreservedByLinkXmlIsKept
+	{
 		public static void Main ()
 		{
 		}
@@ -10,14 +12,14 @@ namespace Mono.Linker.Tests.Cases.LinkXml {
 
 	[Kept]
 	[KeptBaseType (typeof (UnusedTypeDeclarationPreservedByLinkXmlIsKeptUnusedTypeBase))]
-	class UnusedTypeDeclarationPreservedByLinkXmlIsKeptUnusedType : UnusedTypeDeclarationPreservedByLinkXmlIsKeptUnusedTypeBase 
+	class UnusedTypeDeclarationPreservedByLinkXmlIsKeptUnusedType : UnusedTypeDeclarationPreservedByLinkXmlIsKeptUnusedTypeBase
 	{
 		int field;
 		static void Method ()
 		{
 		}
 
-		string Prop { get; set;  }
+		string Prop { get; set; }
 	}
 
 	[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeIsPresservedWhenEntireAssemblyIsPreserved.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeIsPresservedWhenEntireAssemblyIsPreserved.cs
index 246c80af6..35297246d 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeIsPresservedWhenEntireAssemblyIsPreserved.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeIsPresservedWhenEntireAssemblyIsPreserved.cs
@@ -1,16 +1,19 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
 
-	[KeptMember(".ctor()")]
-	class UnusedTypeIsPresservedWhenEntireAssemblyIsPreserved {
+	[KeptMember (".ctor()")]
+	class UnusedTypeIsPresservedWhenEntireAssemblyIsPreserved
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Unused {
+		class Unused
+		{
 			[Kept]
 			void Foo ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypePreservedByLinkXmlIsKept.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypePreservedByLinkXmlIsKept.cs
index edaff63eb..bc6d19205 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypePreservedByLinkXmlIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypePreservedByLinkXmlIsKept.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	class UnusedTypePreservedByLinkXmlIsKept {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	class UnusedTypePreservedByLinkXmlIsKept
+	{
 		public static void Main ()
 		{
 		}
@@ -9,6 +11,7 @@ namespace Mono.Linker.Tests.Cases.LinkXml {
 
 	[Kept]
 	[KeptMember (".ctor()")]
-	class UnusedTypePreservedByLinkXmlIsKeptUnusedType {
+	class UnusedTypePreservedByLinkXmlIsKeptUnusedType
+	{
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypePreservedByLinkXmlWithCommentIsKept.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypePreservedByLinkXmlWithCommentIsKept.cs
index fe077d530..08d9da69d 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypePreservedByLinkXmlWithCommentIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypePreservedByLinkXmlWithCommentIsKept.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	class UnusedTypePreservedByLinkXmlWithCommentIsKept {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	class UnusedTypePreservedByLinkXmlWithCommentIsKept
+	{
 		public static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithNoDefinedPreserveHasAllMembersPreserved.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithNoDefinedPreserveHasAllMembersPreserved.cs
index 840d7f474..503e2e011 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithNoDefinedPreserveHasAllMembersPreserved.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithNoDefinedPreserveHasAllMembersPreserved.cs
@@ -1,6 +1,7 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
 	class UnusedTypeWithNoDefinedPreserveHasAllMembersPreserved
 	{
 		public static void Main ()
@@ -9,7 +10,8 @@ namespace Mono.Linker.Tests.Cases.LinkXml {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Unused {
+		class Unused
+		{
 			[Kept]
 			public int Field1;
 
@@ -30,7 +32,7 @@ namespace Mono.Linker.Tests.Cases.LinkXml {
 
 			[Kept]
 			[KeptBackingField]
-			public string Property1 { [Kept] get; [Kept] set;}
+			public string Property1 { [Kept] get; [Kept] set; }
 
 			[Kept]
 			[KeptBackingField]
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveAllHasAllMembersPreserved.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveAllHasAllMembersPreserved.cs
index 02fb956f2..f3941efe4 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveAllHasAllMembersPreserved.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveAllHasAllMembersPreserved.cs
@@ -1,14 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	class UnusedTypeWithPreserveAllHasAllMembersPreserved {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	class UnusedTypeWithPreserveAllHasAllMembersPreserved
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Unused {
+		class Unused
+		{
 			[Kept]
 			public int Field1;
 
@@ -29,7 +32,7 @@ namespace Mono.Linker.Tests.Cases.LinkXml {
 
 			[Kept]
 			[KeptBackingField]
-			public string Property1 { [Kept] get; [Kept] set;}
+			public string Property1 { [Kept] get; [Kept] set; }
 
 			[Kept]
 			[KeptBackingField]
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveFieldsHasMethodsRemoved.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveFieldsHasMethodsRemoved.cs
index 1af6f4530..43abdce1e 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveFieldsHasMethodsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveFieldsHasMethodsRemoved.cs
@@ -1,13 +1,16 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	class UnusedTypeWithPreserveFieldsHasMethodsRemoved {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	class UnusedTypeWithPreserveFieldsHasMethodsRemoved
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
-		class Unused {
+		class Unused
+		{
 			[Kept]
 			public int Field1;
 
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveMethodsHasFieldsRemoved.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveMethodsHasFieldsRemoved.cs
index 8a79d2d2b..bcc7e36a9 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveMethodsHasFieldsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveMethodsHasFieldsRemoved.cs
@@ -1,14 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	class UnusedTypeWithPreserveMethodsHasFieldsRemoved {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	class UnusedTypeWithPreserveMethodsHasFieldsRemoved
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Unused {
+		class Unused
+		{
 			public int Field1;
 			private int Field2;
 			internal int Field3;
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveNothingAndPreserveMembers.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveNothingAndPreserveMembers.cs
index b9d404f22..be91373c1 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveNothingAndPreserveMembers.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveNothingAndPreserveMembers.cs
@@ -1,13 +1,16 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	class UnusedTypeWithPreserveNothingAndPreserveMembers {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	class UnusedTypeWithPreserveNothingAndPreserveMembers
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
-		class Unused {
+		class Unused
+		{
 			[Kept]
 			public int Field1;
 
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveNothingHasMembersRemoved.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveNothingHasMembersRemoved.cs
index d6ea29b89..053ba52c0 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveNothingHasMembersRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UnusedTypeWithPreserveNothingHasMembersRemoved.cs
@@ -1,13 +1,16 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	class UnusedTypeWithPreserveNothingHasMembersRemoved {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	class UnusedTypeWithPreserveNothingHasMembersRemoved
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
-		class Unused {
+		class Unused
+		{
 			public int Field1;
 			private int Field2;
 			internal int Field3;
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UsedNonRequiredTypeIsKept.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UsedNonRequiredTypeIsKept.cs
index 37cce219c..7e2272512 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UsedNonRequiredTypeIsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UsedNonRequiredTypeIsKept.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	public class UsedNonRequiredTypeIsKept {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	public class UsedNonRequiredTypeIsKept
+	{
 		public static void Main ()
 		{
 			var tmp = typeof (Used1).ToString ();
@@ -9,7 +11,8 @@ namespace Mono.Linker.Tests.Cases.LinkXml {
 			tmp = typeof (Used3).ToString ();
 		}
 
-		class Used1 {
+		class Used1
+		{
 			[Kept]
 			public int field;
 
@@ -21,7 +24,8 @@ namespace Mono.Linker.Tests.Cases.LinkXml {
 		}
 
 		[KeptMember (".ctor()")]
-		class Used2 {
+		class Used2
+		{
 			public int field;
 
 			[Kept]
@@ -35,7 +39,8 @@ namespace Mono.Linker.Tests.Cases.LinkXml {
 		}
 
 		[KeptMember (".ctor()")]
-		class Used3 {
+		class Used3
+		{
 			[Kept]
 			public int field;
 
diff --git a/test/Mono.Linker.Tests.Cases/LinkXml/UsedNonRequiredTypeIsKeptWithSingleMethod.cs b/test/Mono.Linker.Tests.Cases/LinkXml/UsedNonRequiredTypeIsKeptWithSingleMethod.cs
index 916488183..56f36d2df 100644
--- a/test/Mono.Linker.Tests.Cases/LinkXml/UsedNonRequiredTypeIsKeptWithSingleMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/LinkXml/UsedNonRequiredTypeIsKeptWithSingleMethod.cs
@@ -1,8 +1,10 @@
 using System.Collections.Generic;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.LinkXml {
-	class UsedNonRequiredTypeIsKeptWithSingleMethod {
+namespace Mono.Linker.Tests.Cases.LinkXml
+{
+	class UsedNonRequiredTypeIsKeptWithSingleMethod
+	{
 		public static void Main ()
 		{
 			var t = typeof (Unused);
diff --git a/test/Mono.Linker.Tests.Cases/Logging/Dependencies/LogStep.cs b/test/Mono.Linker.Tests.Cases/Logging/Dependencies/LogStep.cs
index e4a10379b..63b429e80 100644
--- a/test/Mono.Linker.Tests.Cases/Logging/Dependencies/LogStep.cs
+++ b/test/Mono.Linker.Tests.Cases/Logging/Dependencies/LogStep.cs
@@ -6,10 +6,10 @@ namespace Log
 {
 	public class LogStep : IStep
 	{
-		public void Process(LinkContext context)
+		public void Process (LinkContext context)
 		{
 			var msgError = MessageContainer.CreateErrorMessage ("Error", 1004);
-			var msgWarning = MessageContainer.CreateWarningMessage("Warning", 2001, origin: new MessageOrigin("logtest", 1, 1));
+			var msgWarning = MessageContainer.CreateWarningMessage ("Warning", 2001, origin: new MessageOrigin ("logtest", 1, 1));
 			var msgInfo = MessageContainer.CreateInfoMessage ("Info");
 			var msgDiagnostics = MessageContainer.CreateDiagnosticMessage ("Diagnostics");
 			context.LogMessage (msgError);
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyAttribute.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyAttribute.cs
index 33ccf1787..09f7543d3 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyAttribute.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyAttribute.cs
@@ -26,9 +26,11 @@
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
-namespace System.Runtime.CompilerServices {
+namespace System.Runtime.CompilerServices
+{
 	[AttributeUsage (AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Field, AllowMultiple = true)]
-	public sealed class PreserveDependencyAttribute : Attribute {
+	public sealed class PreserveDependencyAttribute : Attribute
+	{
 		public PreserveDependencyAttribute (string memberSignature)
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyInCopyAssembly.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyInCopyAssembly.cs
index 274675630..610cf81a5 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyInCopyAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyInCopyAssembly.cs
@@ -6,8 +6,8 @@ namespace Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies
 	public class PreserveDependencyInCopyAssembly
 	{
 		[PreserveDependency ("ExtraMethod1")]
-		public PreserveDependencyInCopyAssembly()
-		{				
+		public PreserveDependencyInCopyAssembly ()
+		{
 		}
 
 		static void ExtraMethod1 ()
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInAssemblyLibrary.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInAssemblyLibrary.cs
index 8b321a355..5f4f35908 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInAssemblyLibrary.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInAssemblyLibrary.cs
@@ -1,6 +1,8 @@
 using System;
-namespace Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies {
-	public class PreserveDependencyMethodInAssemblyLibrary {
+namespace Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies
+{
+	public class PreserveDependencyMethodInAssemblyLibrary
+	{
 		public PreserveDependencyMethodInAssemblyLibrary ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs
index b64962a85..e76e70c04 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies {
-	public abstract class PreserveDependencyMethodInNonReferencedAssemblyBase {
+namespace Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies
+{
+	public abstract class PreserveDependencyMethodInNonReferencedAssemblyBase
+	{
 		public abstract string Method ();
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase2.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase2.cs
index d5f7883ad..0ead25809 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase2.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase2.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies {
-	public class PreserveDependencyMethodInNonReferencedAssemblyBase2 : PreserveDependencyMethodInNonReferencedAssemblyBase {
+namespace Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies
+{
+	public class PreserveDependencyMethodInNonReferencedAssemblyBase2 : PreserveDependencyMethodInNonReferencedAssemblyBase
+	{
 		public override string Method ()
 		{
 			return "Base2";
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.cs
index 6909b63d9..69897dc76 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.cs
@@ -1,13 +1,15 @@
 using System.Runtime.CompilerServices;
 
-namespace Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies {
-	public class PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary : PreserveDependencyMethodInNonReferencedAssemblyBase {
+namespace Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies
+{
+	public class PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary : PreserveDependencyMethodInNonReferencedAssemblyBase
+	{
 		public override string Method ()
 		{
 			Dependency ();
 			return "Dependency";
 		}
-		
+
 		[PreserveDependency (".ctor()", "Mono.Linker.Tests.Cases.Advanced.Dependencies.PreserveDependencyMethodInNonReferencedAssemblyBase2", "base2")]
 		public static void Dependency ()
 		{
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedReferenceLibrary.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedReferenceLibrary.cs
index 6a796ada6..58492f960 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedReferenceLibrary.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedReferenceLibrary.cs
@@ -1,9 +1,11 @@
-namespace Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies {
-	public class PreserveDependencyMethodInNonReferencedAssemblyChainedReferenceLibrary : PreserveDependencyMethodInNonReferencedAssemblyBase {
+namespace Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies
+{
+	public class PreserveDependencyMethodInNonReferencedAssemblyChainedReferenceLibrary : PreserveDependencyMethodInNonReferencedAssemblyBase
+	{
 		public override string Method ()
 		{
 			PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.Dependency ();
 			return "Dependency";
-		} 
+		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyLibrary.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyLibrary.cs
index 57b5bc788..0a12dbbf1 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyLibrary.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyLibrary.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies {
-	public class PreserveDependencyMethodInNonReferencedAssemblyLibrary : PreserveDependencyMethodInNonReferencedAssemblyBase {
+namespace Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies
+{
+	public class PreserveDependencyMethodInNonReferencedAssemblyLibrary : PreserveDependencyMethodInNonReferencedAssemblyBase
+	{
 		public override string Method ()
 		{
 			return "Dependency";
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithCopyUsedAction_Lib.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithCopyUsedAction_Lib.cs
index 222887fbc..62b050213 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithCopyUsedAction_Lib.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithCopyUsedAction_Lib.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies {
-	public class PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithCopyUsedAction_Lib {
+namespace Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies
+{
+	public class PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithCopyUsedAction_Lib
+	{
 		public static void MethodPreservedViaDependencyAttribute ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyField.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyField.cs
index 1d2289459..ea451e812 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyField.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyField.cs
@@ -2,9 +2,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.PreserveDependencies {
-	[SetupCompileBefore ("FakeSystemAssembly.dll", new [] { "Dependencies/PreserveDependencyAttribute.cs" })]
-	public class PreserveDependencyField {
+namespace Mono.Linker.Tests.Cases.PreserveDependencies
+{
+	[SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "Dependencies/PreserveDependencyAttribute.cs" })]
+	public class PreserveDependencyField
+	{
 		public static void Main ()
 		{
 			var b = new B ();
@@ -12,7 +14,8 @@ namespace Mono.Linker.Tests.Cases.PreserveDependencies {
 		}
 
 		[KeptMember (".ctor()")]
-		class B {
+		class B
+		{
 			[Kept]
 			[PreserveDependency ("ExtraMethod1")]
 			public int field;
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyFromCopiedAssembly.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyFromCopiedAssembly.cs
index 2c1a49192..78e896cd3 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyFromCopiedAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyFromCopiedAssembly.cs
@@ -2,10 +2,11 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.PreserveDependencies {
+namespace Mono.Linker.Tests.Cases.PreserveDependencies
+{
 	[SetupLinkerAction ("copy", "lib")]
-	[SetupCompileBefore ("FakeSystemAssembly.dll", new [] { "Dependencies/PreserveDependencyAttribute.cs" })]
-	[SetupCompileBefore ("lib.dll", new [] { "Dependencies/PreserveDependencyInCopyAssembly.cs" }, new [] { "FakeSystemAssembly.dll" })]
+	[SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "Dependencies/PreserveDependencyAttribute.cs" })]
+	[SetupCompileBefore ("lib.dll", new[] { "Dependencies/PreserveDependencyInCopyAssembly.cs" }, new[] { "FakeSystemAssembly.dll" })]
 	[KeptAllTypesAndMembersInAssembly ("lib.dll")]
 	public class PreserveDependencyFromCopiedAssembly
 	{
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyKeptOption.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyKeptOption.cs
index 0ef4170d8..cc46a7fb6 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyKeptOption.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyKeptOption.cs
@@ -4,9 +4,9 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
 namespace Mono.Linker.Tests.Cases.PreserveDependencies
 {
-	[SetupCompileBefore ("FakeSystemAssembly.dll", new [] { "Dependencies/PreserveDependencyAttribute.cs" })]
+	[SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "Dependencies/PreserveDependencyAttribute.cs" })]
 	[SetupLinkerArgument ("--keep-dep-attributes", "true")]
-	[KeptTypeInAssembly("FakeSystemAssembly.dll", typeof(PreserveDependencyAttribute))]
+	[KeptTypeInAssembly ("FakeSystemAssembly.dll", typeof (PreserveDependencyAttribute))]
 	class PreserveDependencyKeptOption
 	{
 		public static void Main ()
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMemberSignatureWildcard.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMemberSignatureWildcard.cs
index d61b14ea5..61d9d4d76 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMemberSignatureWildcard.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMemberSignatureWildcard.cs
@@ -6,8 +6,8 @@ namespace Mono.Linker.Tests.Cases.PreserveDependencies
 {
 	[KeptMemberInAssembly ("library.dll", "Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies.PreserveDependencyMethodInAssemblyLibrary", ".ctor()")]
 	[KeptMemberInAssembly ("library.dll", "Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies.PreserveDependencyMethodInAssemblyLibrary", "Foo()")]
-	[SetupCompileBefore ("FakeSystemAssembly.dll", new [] { "Dependencies/PreserveDependencyAttribute.cs" })]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/PreserveDependencyMethodInAssemblyLibrary.cs" }, new [] { "FakeSystemAssembly.dll" })]
+	[SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "Dependencies/PreserveDependencyAttribute.cs" })]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/PreserveDependencyMethodInAssemblyLibrary.cs" }, new[] { "FakeSystemAssembly.dll" })]
 	public class PreserveDependencyMemberSignatureWildcard
 	{
 		public static void Main ()
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethod.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethod.cs
index 71702011f..c34ec6842 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethod.cs
@@ -2,20 +2,22 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.PreserveDependencies {
-
-	[SetupCompileBefore ("FakeSystemAssembly.dll", new [] { "Dependencies/PreserveDependencyAttribute.cs" })]
-	[LogContains("Could not resolve 'Mono.Linker.Tests.Cases.PreserveDependencies.MissingType' type dependency")]
-	[LogContains("Could not resolve dependency member 'MissingMethod' declared in type 'Mono.Linker.Tests.Cases.PreserveDependencies.C'")]
-	[LogContains("Could not resolve dependency member 'Dependency2`1' declared in type 'Mono.Linker.Tests.Cases.PreserveDependencies.C'")]
-	[LogContains("Could not resolve dependency member '' declared in type 'Mono.Linker.Tests.Cases.PreserveDependencies.PreserveDependencyMethod/B'")]
-	[LogContains("Could not resolve dependency member '.ctor' declared in type 'Mono.Linker.Tests.Cases.PreserveDependencies.PreserveDependencyMethod/NestedStruct'")]
-	[LogContains("Could not resolve dependency member '.cctor' declared in type 'Mono.Linker.Tests.Cases.PreserveDependencies.C'")]
-	class PreserveDependencyMethod {
+namespace Mono.Linker.Tests.Cases.PreserveDependencies
+{
+
+	[SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "Dependencies/PreserveDependencyAttribute.cs" })]
+	[LogContains ("Could not resolve 'Mono.Linker.Tests.Cases.PreserveDependencies.MissingType' type dependency")]
+	[LogContains ("Could not resolve dependency member 'MissingMethod' declared in type 'Mono.Linker.Tests.Cases.PreserveDependencies.C'")]
+	[LogContains ("Could not resolve dependency member 'Dependency2`1' declared in type 'Mono.Linker.Tests.Cases.PreserveDependencies.C'")]
+	[LogContains ("Could not resolve dependency member '' declared in type 'Mono.Linker.Tests.Cases.PreserveDependencies.PreserveDependencyMethod/B'")]
+	[LogContains ("Could not resolve dependency member '.ctor' declared in type 'Mono.Linker.Tests.Cases.PreserveDependencies.PreserveDependencyMethod/NestedStruct'")]
+	[LogContains ("Could not resolve dependency member '.cctor' declared in type 'Mono.Linker.Tests.Cases.PreserveDependencies.C'")]
+	class PreserveDependencyMethod
+	{
 		public static void Main ()
 		{
 			new B (); // Needed to avoid lazy body marking stubbing
-			
+
 			B.Method ();
 			B.SameContext ();
 			B.Broken ();
@@ -80,7 +82,7 @@ namespace Mono.Linker.Tests.Cases.PreserveDependencies {
 			}
 
 			[Kept]
-			static Nested()
+			static Nested ()
 			{
 
 			}
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInAssembly.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInAssembly.cs
index 45358f0f5..c41022d9d 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInAssembly.cs
@@ -5,8 +5,8 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 namespace Mono.Linker.Tests.Cases.PreserveDependencies
 {
 	[KeptMemberInAssembly ("library.dll", "Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies.PreserveDependencyMethodInAssemblyLibrary", ".ctor()")]
-	[SetupCompileBefore ("FakeSystemAssembly.dll", new [] { "Dependencies/PreserveDependencyAttribute.cs" })]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/PreserveDependencyMethodInAssemblyLibrary.cs" }, new [] { "FakeSystemAssembly.dll" })]
+	[SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "Dependencies/PreserveDependencyAttribute.cs" })]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/PreserveDependencyMethodInAssemblyLibrary.cs" }, new[] { "FakeSystemAssembly.dll" })]
 	public class PreserveDependencyMethodInAssembly
 	{
 		public static void Main ()
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssembly.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssembly.cs
index c9424f893..a035815ea 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssembly.cs
@@ -3,15 +3,17 @@ using Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.PreserveDependencies {
-	[SetupCompileBefore ("FakeSystemAssembly.dll", new [] { "Dependencies/PreserveDependencyAttribute.cs" })]
-	[SetupCompileBefore ("base.dll", new [] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs" })]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyLibrary.cs" }, references: new [] { "base.dll" }, addAsReference: false)]
+namespace Mono.Linker.Tests.Cases.PreserveDependencies
+{
+	[SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "Dependencies/PreserveDependencyAttribute.cs" })]
+	[SetupCompileBefore ("base.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs" })]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyLibrary.cs" }, references: new[] { "base.dll" }, addAsReference: false)]
 	[KeptAssembly ("base.dll")]
 	[KeptAssembly ("library.dll")]
 	[KeptMemberInAssembly ("base.dll", typeof (PreserveDependencyMethodInNonReferencedAssemblyBase), "Method()")]
 	[KeptMemberInAssembly ("library.dll", "Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies.PreserveDependencyMethodInNonReferencedAssemblyLibrary", "Method()")]
-	public class PreserveDependencyMethodInNonReferencedAssembly {
+	public class PreserveDependencyMethodInNonReferencedAssembly
+	{
 		public static void Main ()
 		{
 			var obj = new Foo ();
@@ -28,7 +30,8 @@ namespace Mono.Linker.Tests.Cases.PreserveDependencies {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (PreserveDependencyMethodInNonReferencedAssemblyBase))]
-		class Foo : PreserveDependencyMethodInNonReferencedAssemblyBase {
+		class Foo : PreserveDependencyMethodInNonReferencedAssemblyBase
+		{
 			[Kept]
 			public override string Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyChained.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyChained.cs
index 52eb8334c..9ae7a5973 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyChained.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyChained.cs
@@ -3,19 +3,21 @@ using Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.PreserveDependencies {
+namespace Mono.Linker.Tests.Cases.PreserveDependencies
+{
 	[IgnoreTestCase ("Currently failing")]
-	[SetupCompileBefore ("FakeSystemAssembly.dll", new [] { "Dependencies/PreserveDependencyAttribute.cs" })]
-	[SetupCompileBefore ("base.dll", new [] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs" })]
-	[SetupCompileBefore ("base2.dll", new [] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase2.cs" }, references: new [] { "base.dll" }, addAsReference: false)]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.cs" }, references: new [] { "base.dll" }, addAsReference: false)]
+	[SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "Dependencies/PreserveDependencyAttribute.cs" })]
+	[SetupCompileBefore ("base.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs" })]
+	[SetupCompileBefore ("base2.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase2.cs" }, references: new[] { "base.dll" }, addAsReference: false)]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.cs" }, references: new[] { "base.dll" }, addAsReference: false)]
 	[KeptAssembly ("base.dll")]
 	[KeptAssembly ("base2.dll")]
 	[KeptAssembly ("library.dll")]
 	[KeptMemberInAssembly ("base.dll", typeof (PreserveDependencyMethodInNonReferencedAssemblyBase), "Method()")]
 	[KeptMemberInAssembly ("base2.dll", "Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies.PreserveDependencyMethodInNonReferencedAssemblyBase2", "Method()")]
 	[KeptMemberInAssembly ("library.dll", "Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies.PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary", "Method()")]
-	public class PreserveDependencyMethodInNonReferencedAssemblyChained {
+	public class PreserveDependencyMethodInNonReferencedAssemblyChained
+	{
 		public static void Main ()
 		{
 			var obj = new Foo ();
@@ -32,7 +34,8 @@ namespace Mono.Linker.Tests.Cases.PreserveDependencies {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (PreserveDependencyMethodInNonReferencedAssemblyBase))]
-		class Foo : PreserveDependencyMethodInNonReferencedAssemblyBase {
+		class Foo : PreserveDependencyMethodInNonReferencedAssemblyBase
+		{
 			[Kept]
 			public override string Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedReference.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedReference.cs
index b51e2e286..b447360fb 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedReference.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedReference.cs
@@ -3,13 +3,14 @@ using Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.PreserveDependencies {
+namespace Mono.Linker.Tests.Cases.PreserveDependencies
+{
 	[IgnoreTestCase ("Currently failing")]
-	[SetupCompileBefore ("FakeSystemAssembly.dll", new [] { "Dependencies/PreserveDependencyAttribute.cs" })]
-	[SetupCompileBefore ("base.dll", new [] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs" })]
-	[SetupCompileBefore ("base2.dll", new [] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase2.cs" }, references: new [] { "base.dll" }, addAsReference: false)]
-	[SetupCompileBefore ("reference.dll", new [] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.cs" }, references: new [] { "base.dll" }, addAsReference: false)]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedReferenceLibrary.cs" }, references: new [] { "base.dll", "reference.dll" }, addAsReference: false)]
+	[SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "Dependencies/PreserveDependencyAttribute.cs" })]
+	[SetupCompileBefore ("base.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs" })]
+	[SetupCompileBefore ("base2.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase2.cs" }, references: new[] { "base.dll" }, addAsReference: false)]
+	[SetupCompileBefore ("reference.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.cs" }, references: new[] { "base.dll" }, addAsReference: false)]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedReferenceLibrary.cs" }, references: new[] { "base.dll", "reference.dll" }, addAsReference: false)]
 	[KeptAssembly ("base.dll")]
 	[KeptAssembly ("base2.dll")]
 	[KeptAssembly ("library.dll")]
@@ -18,14 +19,15 @@ namespace Mono.Linker.Tests.Cases.PreserveDependencies {
 	[KeptMemberInAssembly ("base2.dll", "Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies.PreserveDependencyMethodInNonReferencedAssemblyBase2", "Method()")]
 	[KeptMemberInAssembly ("library.dll", "Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies.PreserveDependencyMethodInNonReferencedAssemblyChainedReferenceLibrary", "Method()")]
 	[KeptMemberInAssembly ("reference.dll", "Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies.PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary", "Method()")]
-	public class PreserveDependencyMethodInNonReferencedAssemblyChainedReference {
+	public class PreserveDependencyMethodInNonReferencedAssemblyChainedReference
+	{
 		public static void Main ()
 		{
 			var obj = new Foo ();
 			var val = obj.Method ();
 			Dependency ();
 		}
-		
+
 		[Kept]
 		[PreserveDependency (".ctor()", "Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies.PreserveDependencyMethodInNonReferencedAssemblyChainedReferenceLibrary", "library")]
 		static void Dependency ()
@@ -35,7 +37,8 @@ namespace Mono.Linker.Tests.Cases.PreserveDependencies {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (PreserveDependencyMethodInNonReferencedAssemblyBase))]
-		class Foo : PreserveDependencyMethodInNonReferencedAssemblyBase {
+		class Foo : PreserveDependencyMethodInNonReferencedAssemblyBase
+		{
 			[Kept]
 			public override string Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyWithEmbeddedXml.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyWithEmbeddedXml.cs
index 5577e1cf9..6e93a8edc 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyWithEmbeddedXml.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyWithEmbeddedXml.cs
@@ -3,22 +3,24 @@ using Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.PreserveDependencies {
+namespace Mono.Linker.Tests.Cases.PreserveDependencies
+{
 	/// <summary>
 	/// This is an acceptable bug with the currently implementation.  Embedded link xml files will not be processed
 	/// </summary>
 	[IncludeBlacklistStep (true)]
-	[SetupCompileBefore ("FakeSystemAssembly.dll", new [] { "Dependencies/PreserveDependencyAttribute.cs" })]
-	[SetupCompileBefore ("base.dll", new [] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs" })]
+	[SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "Dependencies/PreserveDependencyAttribute.cs" })]
+	[SetupCompileBefore ("base.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs" })]
 	[SetupCompileBefore (
 		"PreserveDependencyMethodInNonReferencedAssemblyLibrary.dll",
-		new [] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyLibrary.cs" },
-		references: new [] { "base.dll" },
-		resources: new [] {"Dependencies/PreserveDependencyMethodInNonReferencedAssemblyLibrary.xml"},
+		new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyLibrary.cs" },
+		references: new[] { "base.dll" },
+		resources: new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyLibrary.xml" },
 		addAsReference: false)]
 	[KeptAssembly ("base.dll")]
 	[RemovedMemberInAssembly ("PreserveDependencyMethodInNonReferencedAssemblyLibrary.dll", "Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies.PreserveDependencyMethodInNonReferencedAssemblyLibrary", "UnusedMethod()")]
-	public class PreserveDependencyMethodInNonReferencedAssemblyWithEmbeddedXml {
+	public class PreserveDependencyMethodInNonReferencedAssemblyWithEmbeddedXml
+	{
 		public static void Main ()
 		{
 			var obj = new Foo ();
@@ -35,7 +37,8 @@ namespace Mono.Linker.Tests.Cases.PreserveDependencies {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (PreserveDependencyMethodInNonReferencedAssemblyBase))]
-		class Foo : PreserveDependencyMethodInNonReferencedAssemblyBase {
+		class Foo : PreserveDependencyMethodInNonReferencedAssemblyBase
+		{
 			[Kept]
 			public override string Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssembly.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssembly.cs
index 0db5ae13f..3c74c120c 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssembly.cs
@@ -3,14 +3,16 @@ using Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.PreserveDependencies {
-	[SetupCompileBefore ("FakeSystemAssembly.dll", new [] { "Dependencies/PreserveDependencyAttribute.cs" })]
-	[SetupCompileBefore ("base.dll", new [] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs" })]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyLibrary.cs" }, references: new [] { "base.dll" }, addAsReference: false)]
+namespace Mono.Linker.Tests.Cases.PreserveDependencies
+{
+	[SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "Dependencies/PreserveDependencyAttribute.cs" })]
+	[SetupCompileBefore ("base.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs" })]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyLibrary.cs" }, references: new[] { "base.dll" }, addAsReference: false)]
 	[KeptAssembly ("base.dll")]
 	[RemovedAssembly ("library.dll")]
 	[KeptMemberInAssembly ("base.dll", typeof (PreserveDependencyMethodInNonReferencedAssemblyBase), "Method()")]
-	public class PreserveDependencyOnUnusedMethodInNonReferencedAssembly {
+	public class PreserveDependencyOnUnusedMethodInNonReferencedAssembly
+	{
 		public static void Main ()
 		{
 			var obj = new Foo ();
@@ -25,7 +27,8 @@ namespace Mono.Linker.Tests.Cases.PreserveDependencies {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (PreserveDependencyMethodInNonReferencedAssemblyBase))]
-		class Foo : PreserveDependencyMethodInNonReferencedAssemblyBase {
+		class Foo : PreserveDependencyMethodInNonReferencedAssemblyBase
+		{
 			[Kept]
 			public override string Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithCopyUsedAction.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithCopyUsedAction.cs
index 43c967899..f29043cb2 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithCopyUsedAction.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithCopyUsedAction.cs
@@ -2,12 +2,14 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.PreserveDependencies {
+namespace Mono.Linker.Tests.Cases.PreserveDependencies
+{
 	[SetupLinkerUserAction ("copyused")]
-	[SetupCompileBefore ("FakeSystemAssembly.dll", new [] { "Dependencies/PreserveDependencyAttribute.cs" })]
-	[SetupCompileBefore ("library.dll", new [] {"Dependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithCopyUsedAction_Lib.cs"}, addAsReference: false)]
+	[SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "Dependencies/PreserveDependencyAttribute.cs" })]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithCopyUsedAction_Lib.cs" }, addAsReference: false)]
 	[RemovedAssembly ("library.dll")]
-	public class PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithCopyUsedAction {
+	public class PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithCopyUsedAction
+	{
 		public static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithEmbeddedXml.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithEmbeddedXml.cs
index 21e2ca7cc..c53d436af 100644
--- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithEmbeddedXml.cs
+++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithEmbeddedXml.cs
@@ -3,22 +3,24 @@ using Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.PreserveDependencies {
+namespace Mono.Linker.Tests.Cases.PreserveDependencies
+{
 	/// <summary>
 	/// This test is here to ensure that link xml embedded in an assembly used by a [PreserveDependency] is not processed if the dependency is not used
 	/// </summary>
 	[IncludeBlacklistStep (true)]
-	[SetupCompileBefore ("FakeSystemAssembly.dll", new [] { "Dependencies/PreserveDependencyAttribute.cs" })]
-	[SetupCompileBefore ("base.dll", new [] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs" })]
+	[SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "Dependencies/PreserveDependencyAttribute.cs" })]
+	[SetupCompileBefore ("base.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs" })]
 	[SetupCompileBefore (
 		"PreserveDependencyMethodInNonReferencedAssemblyLibrary.dll",
-		new [] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyLibrary.cs" },
-		references: new [] { "base.dll" },
-		resources: new [] {"Dependencies/PreserveDependencyMethodInNonReferencedAssemblyLibrary.xml"},
+		new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyLibrary.cs" },
+		references: new[] { "base.dll" },
+		resources: new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyLibrary.xml" },
 		addAsReference: false)]
 	[KeptAssembly ("base.dll")]
 	[RemovedAssembly ("PreserveDependencyMethodInNonReferencedAssemblyLibrary.dll")]
-	public class PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithEmbeddedXml {
+	public class PreserveDependencyOnUnusedMethodInNonReferencedAssemblyWithEmbeddedXml
+	{
 		public static void Main ()
 		{
 			var obj = new Foo ();
@@ -33,7 +35,8 @@ namespace Mono.Linker.Tests.Cases.PreserveDependencies {
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (PreserveDependencyMethodInNonReferencedAssemblyBase))]
-		class Foo : PreserveDependencyMethodInNonReferencedAssemblyBase {
+		class Foo : PreserveDependencyMethodInNonReferencedAssemblyBase
+		{
 			[Kept]
 			public override string Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/References/AssemblyOnlyUsedByUsingWithCsc.cs b/test/Mono.Linker.Tests.Cases/References/AssemblyOnlyUsedByUsingWithCsc.cs
index 32ef0a3c6..bb7141228 100644
--- a/test/Mono.Linker.Tests.Cases/References/AssemblyOnlyUsedByUsingWithCsc.cs
+++ b/test/Mono.Linker.Tests.Cases/References/AssemblyOnlyUsedByUsingWithCsc.cs
@@ -2,29 +2,31 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.References.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.References {
+namespace Mono.Linker.Tests.Cases.References
+{
 	/// <summary>
 	/// We can't detect the using usage in the assembly.  As a result, nothing in `library` is going to be marked and that assembly will be deleted.
 	/// Because of that, `copied` needs to have it's reference to `library` removed even though we specified an assembly action of `copy`
 	/// </summary>
 	[SetupLinkerAction ("copy", "copied")]
 	[SetupLinkerArgument ("--keep-facades", "false")]
-	[SetupCompileBefore ("library.dll", new [] {"Dependencies/AssemblyOnlyUsedByUsing_Lib.cs"})]
-	
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/AssemblyOnlyUsedByUsing_Lib.cs" })]
+
 	// When csc is used, `copied.dll` will have a reference to `library.dll`
-	[SetupCompileBefore ("copied.dll", new [] {"Dependencies/AssemblyOnlyUsedByUsing_Copied.cs"}, new [] {"library.dll"}, compilerToUse: "csc")]
+	[SetupCompileBefore ("copied.dll", new[] { "Dependencies/AssemblyOnlyUsedByUsing_Copied.cs" }, new[] { "library.dll" }, compilerToUse: "csc")]
 
 	// Here to assert that the test is setup correctly to copy the copied assembly.  This is an important aspect of the bug
 	[KeptMemberInAssembly ("copied.dll", typeof (AssemblyOnlyUsedByUsing_Copied), "Unused()")]
-	
+
 	// We library should be gone.  The `using` statement leaves no traces in the IL so nothing in `library` will be marked
 	[RemovedAssembly ("library.dll")]
 #if NETCOREAPP
 	[KeptReferencesInAssembly ("copied.dll", new [] {"System.Private.CoreLib"})]
 #else
-	[KeptReferencesInAssembly ("copied.dll", new [] {"mscorlib"})]
+	[KeptReferencesInAssembly ("copied.dll", new[] { "mscorlib" })]
 #endif
-	public class AssemblyOnlyUsedByUsingWithCsc {
+	public class AssemblyOnlyUsedByUsingWithCsc
+	{
 		public static void Main ()
 		{
 			// Use something to keep the reference at compile time
diff --git a/test/Mono.Linker.Tests.Cases/References/AssemblyOnlyUsedByUsingWithCscWithKeepFacades.cs b/test/Mono.Linker.Tests.Cases/References/AssemblyOnlyUsedByUsingWithCscWithKeepFacades.cs
index b55f738dd..27deb8bf7 100644
--- a/test/Mono.Linker.Tests.Cases/References/AssemblyOnlyUsedByUsingWithCscWithKeepFacades.cs
+++ b/test/Mono.Linker.Tests.Cases/References/AssemblyOnlyUsedByUsingWithCscWithKeepFacades.cs
@@ -2,7 +2,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.References.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.References {
+namespace Mono.Linker.Tests.Cases.References
+{
 	/// <summary>
 	/// We can't detect the using usage in the assembly.  As a result, nothing in `library` is going to be marked and that assembly will be deleted.
 	/// Because of that, `copied` needs to have it's reference to `library` removed even though we specified an assembly action of `copy`
@@ -11,22 +12,23 @@ namespace Mono.Linker.Tests.Cases.References {
 
 	// --keep-facades sends the sweep step down a different code path that caused problems for this corner case
 	[SetupLinkerArgument ("--keep-facades", "true")]
-	[SetupCompileBefore ("library.dll", new [] {"Dependencies/AssemblyOnlyUsedByUsing_Lib.cs"})]
-	
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/AssemblyOnlyUsedByUsing_Lib.cs" })]
+
 	// When csc is used, `copied.dll` will have a reference to `library.dll`
-	[SetupCompileBefore ("copied.dll", new [] {"Dependencies/AssemblyOnlyUsedByUsing_Copied.cs"}, new [] {"library.dll"}, compilerToUse: "csc")]
+	[SetupCompileBefore ("copied.dll", new[] { "Dependencies/AssemblyOnlyUsedByUsing_Copied.cs" }, new[] { "library.dll" }, compilerToUse: "csc")]
 
 	// Here to assert that the test is setup correctly to copy the copied assembly.  This is an important aspect of the bug
 	[KeptMemberInAssembly ("copied.dll", typeof (AssemblyOnlyUsedByUsing_Copied), "Unused()")]
-	
+
 	// We library should be gone.  The `using` statement leaves no traces in the IL so nothing in `library` will be marked
 	[RemovedAssembly ("library.dll")]
 #if NETCOREAPP
 	[KeptReferencesInAssembly ("copied.dll", new [] {"System.Private.CoreLib"})]
 #else
-	[KeptReferencesInAssembly ("copied.dll", new [] {"mscorlib"})]
+	[KeptReferencesInAssembly ("copied.dll", new[] { "mscorlib" })]
 #endif
-	public class AssemblyOnlyUsedByUsingWithCscWithKeepFacades {
+	public class AssemblyOnlyUsedByUsingWithCscWithKeepFacades
+	{
 		public static void Main ()
 		{
 			// Use something to keep the reference at compile time
diff --git a/test/Mono.Linker.Tests.Cases/References/AssemblyOnlyUsedByUsingWithMcs.cs b/test/Mono.Linker.Tests.Cases/References/AssemblyOnlyUsedByUsingWithMcs.cs
index ced6d4d39..bff891ee6 100644
--- a/test/Mono.Linker.Tests.Cases/References/AssemblyOnlyUsedByUsingWithMcs.cs
+++ b/test/Mono.Linker.Tests.Cases/References/AssemblyOnlyUsedByUsingWithMcs.cs
@@ -2,22 +2,24 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.References.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.References {
+namespace Mono.Linker.Tests.Cases.References
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("Don't try to compile with mcs on .NET Core")]
 #endif
 	[SetupLinkerAction ("copy", "copied")]
-	[SetupCompileBefore ("library.dll", new [] {"Dependencies/AssemblyOnlyUsedByUsing_Lib.cs"})]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/AssemblyOnlyUsedByUsing_Lib.cs" })]
 
 	// When mcs is used, `copied.dll` will not have a reference to `library.dll`
-	[SetupCompileBefore ("copied.dll", new [] {"Dependencies/AssemblyOnlyUsedByUsing_Copied.cs"}, new [] {"library.dll"}, compilerToUse: "mcs")]
+	[SetupCompileBefore ("copied.dll", new[] { "Dependencies/AssemblyOnlyUsedByUsing_Copied.cs" }, new[] { "library.dll" }, compilerToUse: "mcs")]
 
 	// Here to assert that the test is setup correctly to copy the copied assembly.  This is an important aspect of the bug
 	[KeptMemberInAssembly ("copied.dll", typeof (AssemblyOnlyUsedByUsing_Copied), "Unused()")]
 
 	[RemovedAssembly ("library.dll")]
-	[KeptReferencesInAssembly ("copied.dll", new [] {"mscorlib"})]
-	public class AssemblyOnlyUsedByUsingWithMcs {
+	[KeptReferencesInAssembly ("copied.dll", new[] { "mscorlib" })]
+	public class AssemblyOnlyUsedByUsingWithMcs
+	{
 		public static void Main ()
 		{
 			// Use something to keep the reference at compile time
diff --git a/test/Mono.Linker.Tests.Cases/References/CopyUsedAreKeptFully.cs b/test/Mono.Linker.Tests.Cases/References/CopyUsedAreKeptFully.cs
index 418b56556..b36408df3 100644
--- a/test/Mono.Linker.Tests.Cases/References/CopyUsedAreKeptFully.cs
+++ b/test/Mono.Linker.Tests.Cases/References/CopyUsedAreKeptFully.cs
@@ -2,13 +2,14 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.References.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.References {
+namespace Mono.Linker.Tests.Cases.References
+{
 	// Actions:
 	// link - This assembly
 	// copyused - library1.dll
 	[SetupLinkerUserAction ("copyused")]
 
-	[SetupCompileBefore ("library1.dll", new [] { "Dependencies/UserAssembliesAreLinkedByDefault_Library1.cs" })]
+	[SetupCompileBefore ("library1.dll", new[] { "Dependencies/UserAssembliesAreLinkedByDefault_Library1.cs" })]
 
 	[KeptAssembly ("library1.dll")]
 	[KeptMemberInAssembly ("library1.dll", typeof (UserAssembliesAreLinkedByDefault_Library1), "UsedMethod()")]
diff --git a/test/Mono.Linker.Tests.Cases/References/CopyWithLinkedWillHaveAttributeDepsKept.cs b/test/Mono.Linker.Tests.Cases/References/CopyWithLinkedWillHaveAttributeDepsKept.cs
index 9142959e3..7184ea0d1 100644
--- a/test/Mono.Linker.Tests.Cases/References/CopyWithLinkedWillHaveAttributeDepsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/References/CopyWithLinkedWillHaveAttributeDepsKept.cs
@@ -3,10 +3,11 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.References.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.References {
+namespace Mono.Linker.Tests.Cases.References
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
 	[SetupLinkerAction ("copy", "test")]
-	[SetupCompileBefore ("linked.dll", new [] {typeof (WithLinked_Attrs)})]
+	[SetupCompileBefore ("linked.dll", new[] { typeof (WithLinked_Attrs) })]
 
 	[KeptMember (".ctor()")]
 	[KeptMemberInAssembly ("linked.dll", typeof (WithLinked_Attrs.TypeAttribute), ".ctor()")]
@@ -17,7 +18,8 @@ namespace Mono.Linker.Tests.Cases.References {
 	[KeptMemberInAssembly ("linked.dll", typeof (WithLinked_Attrs.ParameterAttribute), ".ctor()")]
 	[KeptTypeInAssembly ("linked.dll", typeof (WithLinked_Attrs.FooEnum))]
 	[KeptTypeInAssembly ("linked.dll", typeof (WithLinked_Attrs.MethodWithEnumValueAttribute))]
-	public class CopyWithLinkedWillHaveAttributeDepsKept {
+	public class CopyWithLinkedWillHaveAttributeDepsKept
+	{
 		public static void Main ()
 		{
 		}
@@ -26,7 +28,8 @@ namespace Mono.Linker.Tests.Cases.References {
 		[KeptMember (".ctor()")]
 		[KeptAttributeAttribute (typeof (WithLinked_Attrs.TypeAttribute))]
 		[WithLinked_Attrs.Type]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptAttributeAttribute (typeof (WithLinked_Attrs.FieldAttribute))]
 			[WithLinked_Attrs.Field]
@@ -36,8 +39,7 @@ namespace Mono.Linker.Tests.Cases.References {
 			[KeptBackingField]
 			[KeptAttributeAttribute (typeof (WithLinked_Attrs.PropertyAttribute))]
 			[WithLinked_Attrs.Property]
-			private static int Property
-			{
+			private static int Property {
 				[Kept]
 				get;
 				[Kept]
@@ -58,16 +60,16 @@ namespace Mono.Linker.Tests.Cases.References {
 			static void Method ()
 			{
 			}
-			
+
 			[Kept]
-			[KeptAttributeAttribute (typeof(WithLinked_Attrs.MethodWithEnumValueAttribute))]
+			[KeptAttributeAttribute (typeof (WithLinked_Attrs.MethodWithEnumValueAttribute))]
 			[WithLinked_Attrs.MethodWithEnumValue (WithLinked_Attrs.FooEnum.Three, typeof (WithLinked_Attrs))]
 			static void MethodWithEnum ()
 			{
 			}
-			
+
 			[Kept]
-			static void MethodWithParameter([KeptAttributeAttribute (typeof (WithLinked_Attrs.ParameterAttribute))] [WithLinked_Attrs.Parameter] int arg)
+			static void MethodWithParameter ([KeptAttributeAttribute (typeof (WithLinked_Attrs.ParameterAttribute))] [WithLinked_Attrs.Parameter] int arg)
 			{
 			}
 		}
diff --git a/test/Mono.Linker.Tests.Cases/References/CopyWithLinkedWillHaveMethodDepsKept.cs b/test/Mono.Linker.Tests.Cases/References/CopyWithLinkedWillHaveMethodDepsKept.cs
index 2ebb67291..5eb6b71ad 100644
--- a/test/Mono.Linker.Tests.Cases/References/CopyWithLinkedWillHaveMethodDepsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/References/CopyWithLinkedWillHaveMethodDepsKept.cs
@@ -2,16 +2,18 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.References.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.References {
+namespace Mono.Linker.Tests.Cases.References
+{
 	[SetupCSharpCompilerToUse ("csc")]
 	[SetupLinkerAction ("copy", "test")]
-	[SetupCompileBefore ("linked.dll", new [] {typeof (WithLinked_Methods)})]
+	[SetupCompileBefore ("linked.dll", new[] { typeof (WithLinked_Methods) })]
 
 	[KeptMember (".ctor()")]
 	[KeptMemberInAssembly ("linked.dll", typeof (WithLinked_Methods), nameof (WithLinked_Methods.UsedByPublic) + "()")]
 	[KeptMemberInAssembly ("linked.dll", typeof (WithLinked_Methods), nameof (WithLinked_Methods.UsedByInternal) + "()")]
 	[KeptMemberInAssembly ("linked.dll", typeof (WithLinked_Methods), nameof (WithLinked_Methods.UsedByPrivate) + "()")]
-	public class CopyWithLinkedWillHaveMethodDepsKept {
+	public class CopyWithLinkedWillHaveMethodDepsKept
+	{
 		public static void Main ()
 		{
 		}
@@ -21,15 +23,15 @@ namespace Mono.Linker.Tests.Cases.References {
 		{
 			WithLinked_Methods.UsedByPublic ();
 		}
-		
+
 		[Kept]
 		internal static void UnusedInternal ()
 		{
 			WithLinked_Methods.UsedByInternal ();
 		}
-		
+
 		[Kept]
-		static void UnusedPrivate()
+		static void UnusedPrivate ()
 		{
 			WithLinked_Methods.UsedByPrivate ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/References/Dependencies/AssemblyOnlyUsedByUsing_Copied.cs b/test/Mono.Linker.Tests.Cases/References/Dependencies/AssemblyOnlyUsedByUsing_Copied.cs
index 31552b32c..caa846e82 100644
--- a/test/Mono.Linker.Tests.Cases/References/Dependencies/AssemblyOnlyUsedByUsing_Copied.cs
+++ b/test/Mono.Linker.Tests.Cases/References/Dependencies/AssemblyOnlyUsedByUsing_Copied.cs
@@ -3,8 +3,10 @@
 // to this assembly because of this whereas mcs will not
 using ImportantForBug = Mono.Linker.Tests.Cases.References.Dependencies.AssemblyOnlyUsedByUsing_Lib;
 
-namespace Mono.Linker.Tests.Cases.References.Dependencies {
-	public class AssemblyOnlyUsedByUsing_Copied {
+namespace Mono.Linker.Tests.Cases.References.Dependencies
+{
+	public class AssemblyOnlyUsedByUsing_Copied
+	{
 		public static void UsedToKeepReference ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/References/Dependencies/AssemblyOnlyUsedByUsing_Lib.cs b/test/Mono.Linker.Tests.Cases/References/Dependencies/AssemblyOnlyUsedByUsing_Lib.cs
index 7ec8becd0..05580f373 100644
--- a/test/Mono.Linker.Tests.Cases/References/Dependencies/AssemblyOnlyUsedByUsing_Lib.cs
+++ b/test/Mono.Linker.Tests.Cases/References/Dependencies/AssemblyOnlyUsedByUsing_Lib.cs
@@ -1,4 +1,6 @@
-namespace Mono.Linker.Tests.Cases.References.Dependencies {
-	public class AssemblyOnlyUsedByUsing_Lib {
+namespace Mono.Linker.Tests.Cases.References.Dependencies
+{
+	public class AssemblyOnlyUsedByUsing_Lib
+	{
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/References/Dependencies/UserAssembliesAreLinkedByDefault_Library1.cs b/test/Mono.Linker.Tests.Cases/References/Dependencies/UserAssembliesAreLinkedByDefault_Library1.cs
index d8a45ab93..55fd8c010 100644
--- a/test/Mono.Linker.Tests.Cases/References/Dependencies/UserAssembliesAreLinkedByDefault_Library1.cs
+++ b/test/Mono.Linker.Tests.Cases/References/Dependencies/UserAssembliesAreLinkedByDefault_Library1.cs
@@ -1,7 +1,9 @@
 using System;
 
-namespace Mono.Linker.Tests.Cases.References.Dependencies {
-	public class UserAssembliesAreLinkedByDefault_Library1 {
+namespace Mono.Linker.Tests.Cases.References.Dependencies
+{
+	public class UserAssembliesAreLinkedByDefault_Library1
+	{
 		public void UsedMethod ()
 		{
 			Console.WriteLine ("Used");
diff --git a/test/Mono.Linker.Tests.Cases/References/Dependencies/WithLinked_Attrs.cs b/test/Mono.Linker.Tests.Cases/References/Dependencies/WithLinked_Attrs.cs
index 04254a958..b20cea475 100644
--- a/test/Mono.Linker.Tests.Cases/References/Dependencies/WithLinked_Attrs.cs
+++ b/test/Mono.Linker.Tests.Cases/References/Dependencies/WithLinked_Attrs.cs
@@ -13,30 +13,30 @@ namespace Mono.Linker.Tests.Cases.References.Dependencies
 		public class MethodAttribute : Attribute
 		{
 		}
-		
+
 		public class MethodWithEnumValueAttribute : Attribute
 		{
-			public MethodWithEnumValueAttribute(FooEnum value, Type t)
+			public MethodWithEnumValueAttribute (FooEnum value, Type t)
 			{
 			}
 		}
-		
+
 		public class FieldAttribute : Attribute
 		{
 		}
-		
+
 		public class EventAttribute : Attribute
 		{
 		}
-		
+
 		public class PropertyAttribute : Attribute
 		{
 		}
-		
+
 		public class TypeAttribute : Attribute
 		{
 		}
-		
+
 		public class ParameterAttribute : Attribute
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/References/Dependencies/WithLinked_Methods.cs b/test/Mono.Linker.Tests.Cases/References/Dependencies/WithLinked_Methods.cs
index ee83cdbdf..5b289c1ea 100644
--- a/test/Mono.Linker.Tests.Cases/References/Dependencies/WithLinked_Methods.cs
+++ b/test/Mono.Linker.Tests.Cases/References/Dependencies/WithLinked_Methods.cs
@@ -2,15 +2,15 @@ namespace Mono.Linker.Tests.Cases.References.Dependencies
 {
 	public class WithLinked_Methods
 	{
-		public static void UsedByPublic()
+		public static void UsedByPublic ()
 		{
 		}
-		
-		public static void UsedByInternal()
+
+		public static void UsedByInternal ()
 		{
 		}
-		
-		public static void UsedByPrivate()
+
+		public static void UsedByPrivate ()
 		{
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/References/Individual/CanSkipUnresolved.cs b/test/Mono.Linker.Tests.Cases/References/Individual/CanSkipUnresolved.cs
index ec502e894..d3af5dde6 100644
--- a/test/Mono.Linker.Tests.Cases/References/Individual/CanSkipUnresolved.cs
+++ b/test/Mono.Linker.Tests.Cases/References/Individual/CanSkipUnresolved.cs
@@ -2,11 +2,13 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.References.Individual.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.References.Individual {
-	[SetupCompileBefore ("library1.dll", new [] { "Dependencies/CanSkipUnresolved_Library.cs" })]
-	[SetupCompileAfter ("library1.dll", new [] { "Dependencies/CanSkipUnresolved_Library.cs" }, defines: new [] { "EXCLUDE_STUFF" })]
+namespace Mono.Linker.Tests.Cases.References.Individual
+{
+	[SetupCompileBefore ("library1.dll", new[] { "Dependencies/CanSkipUnresolved_Library.cs" })]
+	[SetupCompileAfter ("library1.dll", new[] { "Dependencies/CanSkipUnresolved_Library.cs" }, defines: new[] { "EXCLUDE_STUFF" })]
 	[SetupLinkerArgument ("--skip-unresolved", "true")]
-	public class CanSkipUnresolved {
+	public class CanSkipUnresolved
+	{
 		static void Main ()
 		{
 			var t1 = new CanSkipUnresolved_Library.TypeWithMissingMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/References/Individual/Dependencies/CanSkipUnresolved_Library.cs b/test/Mono.Linker.Tests.Cases/References/Individual/Dependencies/CanSkipUnresolved_Library.cs
index 59e5cff44..488cb47a7 100644
--- a/test/Mono.Linker.Tests.Cases/References/Individual/Dependencies/CanSkipUnresolved_Library.cs
+++ b/test/Mono.Linker.Tests.Cases/References/Individual/Dependencies/CanSkipUnresolved_Library.cs
@@ -1,18 +1,22 @@
 using System;
 
-namespace Mono.Linker.Tests.Cases.References.Individual.Dependencies {
-	public class CanSkipUnresolved_Library {
-		public class TypeWithMissingMethod {
+namespace Mono.Linker.Tests.Cases.References.Individual.Dependencies
+{
+	public class CanSkipUnresolved_Library
+	{
+		public class TypeWithMissingMethod
+		{
 #if !EXCLUDE_STUFF
 			public void GoingToBeMissing ()
 			{
-				
+
 			}
 #endif
 		}
 
 #if !EXCLUDE_STUFF
-		public class TypeThatWillBeMissing {
+		public class TypeThatWillBeMissing
+		{
 		}
 #endif
 	}
diff --git a/test/Mono.Linker.Tests.Cases/References/ReferencesAreRemovedWhenAllUsagesAreRemoved.cs b/test/Mono.Linker.Tests.Cases/References/ReferencesAreRemovedWhenAllUsagesAreRemoved.cs
index 7acd8d630..fbabf8ff8 100644
--- a/test/Mono.Linker.Tests.Cases/References/ReferencesAreRemovedWhenAllUsagesAreRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/References/ReferencesAreRemovedWhenAllUsagesAreRemoved.cs
@@ -4,7 +4,8 @@ using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.References {
+namespace Mono.Linker.Tests.Cases.References
+{
 	[SetupLinkerCoreAction ("link")]
 	// Il8n & the blacklist step pollute the results with extra stuff that didn't need to be
 	// preserved for this test case so we need to disable them
@@ -13,12 +14,13 @@ namespace Mono.Linker.Tests.Cases.References {
 	[RemovedAssembly ("System.dll")]
 	[KeptReference (PlatformAssemblies.CoreLib)]
 	// Can be removed once this bug is fixed https://bugzilla.xamarin.com/show_bug.cgi?id=58168
-	[SkipPeVerify(SkipPeVerifyForToolchian.Pedump)]
+	[SkipPeVerify (SkipPeVerifyForToolchian.Pedump)]
 	// System.Core.dll is referenced by System.dll in the .NET FW class libraries. Our GetType reflection marking code
 	// detects a GetType("SHA256CryptoServiceProvider") in System.dll, which then causes a type in System.Core.dll to be marked.
 	// PeVerify fails on the original GAC copy of System.Core.dll so it's expected that it will also fail on the stripped version we output
 	[SkipPeVerify ("System.Core.dll")]
-	class ReferencesAreRemovedWhenAllUsagesAreRemoved {
+	class ReferencesAreRemovedWhenAllUsagesAreRemoved
+	{
 		public static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/References/SavedWithLinkedWillHaveMethodDepsKept.cs b/test/Mono.Linker.Tests.Cases/References/SavedWithLinkedWillHaveMethodDepsKept.cs
index b0ff4dfb5..0e7fb0825 100644
--- a/test/Mono.Linker.Tests.Cases/References/SavedWithLinkedWillHaveMethodDepsKept.cs
+++ b/test/Mono.Linker.Tests.Cases/References/SavedWithLinkedWillHaveMethodDepsKept.cs
@@ -2,17 +2,19 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.References.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.References {
-	[SetupCSharpCompilerToUse("csc")]
-	[SetupLinkerAction("save", "test")]
-	[SetupCompileBefore("linked.dll", new [] {typeof (WithLinked_Methods)})]
+namespace Mono.Linker.Tests.Cases.References
+{
+	[SetupCSharpCompilerToUse ("csc")]
+	[SetupLinkerAction ("save", "test")]
+	[SetupCompileBefore ("linked.dll", new[] { typeof (WithLinked_Methods) })]
 
-	[KeptMember(".ctor()")]
+	[KeptMember (".ctor()")]
 	[KeptMemberInAssembly ("linked.dll", typeof (WithLinked_Methods), nameof (WithLinked_Methods.UsedByPublic) + "()")]
 	[KeptMemberInAssembly ("linked.dll", typeof (WithLinked_Methods), nameof (WithLinked_Methods.UsedByInternal) + "()")]
 	[KeptMemberInAssembly ("linked.dll", typeof (WithLinked_Methods), nameof (WithLinked_Methods.UsedByPrivate) + "()")]
-	public class SavedWithLinkedWillHaveMethodDepsKept {
-		public static void Main()
+	public class SavedWithLinkedWillHaveMethodDepsKept
+	{
+		public static void Main ()
 		{
 		}
 
@@ -27,9 +29,9 @@ namespace Mono.Linker.Tests.Cases.References {
 		{
 			WithLinked_Methods.UsedByInternal ();
 		}
-		
+
 		[Kept]
-		static void UnusedPrivate()
+		static void UnusedPrivate ()
 		{
 			WithLinked_Methods.UsedByPrivate ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/References/UserAssembliesAreLinkedByDefault.cs b/test/Mono.Linker.Tests.Cases/References/UserAssembliesAreLinkedByDefault.cs
index 0c68e127c..348d078a1 100644
--- a/test/Mono.Linker.Tests.Cases/References/UserAssembliesAreLinkedByDefault.cs
+++ b/test/Mono.Linker.Tests.Cases/References/UserAssembliesAreLinkedByDefault.cs
@@ -3,13 +3,15 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.References.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.References {
-	[SetupCompileBefore ("library1.dll", new [] { "Dependencies/UserAssembliesAreLinkedByDefault_Library1.cs" })]
+namespace Mono.Linker.Tests.Cases.References
+{
+	[SetupCompileBefore ("library1.dll", new[] { "Dependencies/UserAssembliesAreLinkedByDefault_Library1.cs" })]
 
 	[KeptAssembly ("library1.dll")]
 	[KeptMemberInAssembly ("library1.dll", typeof (UserAssembliesAreLinkedByDefault_Library1), "UsedMethod()")]
 	[RemovedMemberInAssembly ("library1.dll", typeof (UserAssembliesAreLinkedByDefault_Library1), "UnusedMethod()")]
-	class UserAssembliesAreLinkedByDefault {
+	class UserAssembliesAreLinkedByDefault
+	{
 		public static void Main ()
 		{
 			new UserAssembliesAreLinkedByDefault_Library1 ().UsedMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/ActivatorCreateInstance.cs b/test/Mono.Linker.Tests.Cases/Reflection/ActivatorCreateInstance.cs
index 27ca51a66..d4879e501 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/ActivatorCreateInstance.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/ActivatorCreateInstance.cs
@@ -8,7 +8,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 namespace Mono.Linker.Tests.Cases.Reflection
 {
 	[SetupCSharpCompilerToUse ("csc")]
-	[KeptMember(".ctor()")]
+	[KeptMember (".ctor()")]
 	public class ActivatorCreateInstance
 	{
 		public static void Main ()
@@ -16,7 +16,7 @@ namespace Mono.Linker.Tests.Cases.Reflection
 			Activator.CreateInstance (typeof (Test1));
 			Activator.CreateInstance (typeof (Test2), true);
 			Activator.CreateInstance (typeof (Test3), BindingFlags.NonPublic | BindingFlags.Instance, null, null, null);
-			Activator.CreateInstance (typeof (Test4), new object [] { 1, "ss" });
+			Activator.CreateInstance (typeof (Test4), new object[] { 1, "ss" });
 
 			var p = new ActivatorCreateInstance ();
 
@@ -130,8 +130,8 @@ namespace Mono.Linker.Tests.Cases.Reflection
 			public FromParameterOnStaticMethodTypeB (int arg) { }
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type [] { typeof (Type), typeof (object []) })]
-		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type [] { typeof (Type), typeof (BindingFlags), typeof (Binder), typeof (object []), typeof (CultureInfo) })]
+		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type[] { typeof (Type), typeof (object[]) })]
+		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type[] { typeof (Type), typeof (BindingFlags), typeof (Binder), typeof (object[]), typeof (CultureInfo) })]
 		[Kept]
 		private void FromParameterOnInstanceMethod (
 			[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.DefaultConstructor)]
@@ -140,8 +140,8 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		{
 			// Only default ctor is available from the parameter, so only the first one should work
 			Activator.CreateInstance (type);
-			Activator.CreateInstance (type, new object [] { 1 });
-			Activator.CreateInstance (type, BindingFlags.NonPublic, null, new object [] { 1, 2 }, null);
+			Activator.CreateInstance (type, new object[] { 1 });
+			Activator.CreateInstance (type, BindingFlags.NonPublic, null, new object[] { 1, 2 }, null);
 		}
 
 		[Kept]
@@ -163,8 +163,8 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		{
 			// All ctors are required by the parameter, so all cases should work
 			Activator.CreateInstance (type);
-			Activator.CreateInstance (type, new object [] { 1 });
-			Activator.CreateInstance (type, BindingFlags.NonPublic, new object [] { 1, 2 });
+			Activator.CreateInstance (type, new object[] { 1 });
+			Activator.CreateInstance (type, BindingFlags.NonPublic, new object[] { 1, 2 });
 		}
 
 		[Kept]
@@ -178,7 +178,7 @@ namespace Mono.Linker.Tests.Cases.Reflection
 			private FromParameterWithConstructorsType (int arg, int arg2) { }
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type [] { typeof (Type), typeof (BindingFlags), typeof (Binder), typeof (object []), typeof (CultureInfo) })]
+		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type[] { typeof (Type), typeof (BindingFlags), typeof (Binder), typeof (object[]), typeof (CultureInfo) })]
 		[Kept]
 		private static void FromParameterWithPublicConstructors (
 			[DynamicallyAccessedMembers(DynamicallyAccessedMemberKinds.PublicConstructors)]
@@ -187,8 +187,8 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		{
 			// Only public ctors and default ctor are required, so only those cases should work
 			Activator.CreateInstance (type);
-			Activator.CreateInstance (type, new object [] { 1 });
-			Activator.CreateInstance (type, BindingFlags.NonPublic, null, new object [] { 1, 2 }, null);
+			Activator.CreateInstance (type, new object[] { 1 });
+			Activator.CreateInstance (type, BindingFlags.NonPublic, null, new object[] { 1, 2 }, null);
 		}
 
 		[Kept]
@@ -262,9 +262,9 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		private static void WithAssemblyName ()
 		{
 			Activator.CreateInstance ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+WithAssemblyNameParameterless1");
-			Activator.CreateInstance ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+WithAssemblyNameParameterless2", new object [] { });
-			Activator.CreateInstance ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+WithAssemblyNamePublicOnly", false, BindingFlags.Public, null, new object [] { }, null, new object [] { });
-			Activator.CreateInstance ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+WithAssemblyNamePrivateOnly", false, BindingFlags.NonPublic, null, new object [] { }, null, new object [] { });
+			Activator.CreateInstance ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+WithAssemblyNameParameterless2", new object[] { });
+			Activator.CreateInstance ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+WithAssemblyNamePublicOnly", false, BindingFlags.Public, null, new object[] { }, null, new object[] { });
+			Activator.CreateInstance ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+WithAssemblyNamePrivateOnly", false, BindingFlags.NonPublic, null, new object[] { }, null, new object[] { });
 
 			WithNullAssemblyName ();
 			WithNonExistingAssemblyName ();
@@ -273,14 +273,14 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		}
 
 		[Kept]
-		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type [] { typeof (string), typeof (string) })]
+		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type[] { typeof (string), typeof (string) })]
 		private static void WithNullAssemblyName ()
 		{
 			Activator.CreateInstance (null, "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+WithAssemblyNameParameterless1");
 		}
 
 		[Kept]
-		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type [] { typeof (string), typeof (string) })]
+		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type[] { typeof (string), typeof (string) })]
 		private static void WithNonExistingAssemblyName ()
 		{
 			Activator.CreateInstance ("NonExisting", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+WithAssemblyNameParameterless1");
@@ -290,17 +290,17 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		private static string _typeNameField;
 
 		[Kept]
-		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type [] { typeof (string), typeof (string), typeof (object []) })]
+		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type[] { typeof (string), typeof (string), typeof (object[]) })]
 		private static void WithAssemblyAndUnknownTypeName ()
 		{
-			Activator.CreateInstance ("test", _typeNameField, new object [] { });
+			Activator.CreateInstance ("test", _typeNameField, new object[] { });
 		}
 
 		[Kept]
-		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type [] { typeof (string), typeof (string), typeof (object []) })]
+		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type[] { typeof (string), typeof (string), typeof (object[]) })]
 		private static void WithAssemblyAndNonExistingTypeName ()
 		{
-			Activator.CreateInstance ("test", "NonExisting", new object [] { });
+			Activator.CreateInstance ("test", "NonExisting", new object[] { });
 		}
 
 		[Kept]
@@ -338,34 +338,34 @@ namespace Mono.Linker.Tests.Cases.Reflection
 			// Just a basic test that these are all recognized, we're not testing that it marks correctly as it has the exact same implementation
 			// as the above tested Activator.CreateInstance overloads
 			AppDomain.CurrentDomain.CreateInstance ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+AppDomainCreateInstanceType");
-			AppDomain.CurrentDomain.CreateInstance ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+AppDomainCreateInstanceType", new object [] { });
+			AppDomain.CurrentDomain.CreateInstance ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+AppDomainCreateInstanceType", new object[] { });
 			AppDomain.CurrentDomain.CreateInstance ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+AppDomainCreateInstanceType", false, BindingFlags.Public, null, null, null, null);
 
 			AppDomain.CurrentDomain.CreateInstanceAndUnwrap ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+AppDomainCreateInstanceType");
-			AppDomain.CurrentDomain.CreateInstanceAndUnwrap ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+AppDomainCreateInstanceType", new object [] { });
+			AppDomain.CurrentDomain.CreateInstanceAndUnwrap ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+AppDomainCreateInstanceType", new object[] { });
 			AppDomain.CurrentDomain.CreateInstanceAndUnwrap ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+AppDomainCreateInstanceType", false, BindingFlags.Public, null, null, null, null);
 
 			AppDomain.CurrentDomain.CreateInstanceFrom ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+AppDomainCreateInstanceType");
-			AppDomain.CurrentDomain.CreateInstanceFrom ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+AppDomainCreateInstanceType", new object [] { });
+			AppDomain.CurrentDomain.CreateInstanceFrom ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+AppDomainCreateInstanceType", new object[] { });
 			AppDomain.CurrentDomain.CreateInstanceFrom ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+AppDomainCreateInstanceType", false, BindingFlags.Public, null, null, null, null);
 
 			AppDomain.CurrentDomain.CreateInstanceFromAndUnwrap ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+AppDomainCreateInstanceType");
-			AppDomain.CurrentDomain.CreateInstanceFromAndUnwrap ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+AppDomainCreateInstanceType", new object [] { });
+			AppDomain.CurrentDomain.CreateInstanceFromAndUnwrap ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+AppDomainCreateInstanceType", new object[] { });
 			AppDomain.CurrentDomain.CreateInstanceFromAndUnwrap ("test", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+AppDomainCreateInstanceType", false, BindingFlags.Public, null, null, null, null);
 		}
 
 		[Kept]
-		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance) + "<T>", new Type [0])]
-		[UnrecognizedReflectionAccessPattern (typeof (Assembly), nameof (Assembly.CreateInstance), new Type [] { typeof (string) })]
-		[UnrecognizedReflectionAccessPattern (typeof (Assembly), nameof (Assembly.CreateInstance), new Type [] { typeof (string), typeof (bool) })]
-		[UnrecognizedReflectionAccessPattern (typeof (Assembly), nameof (Assembly.CreateInstance), new Type [] { typeof (string), typeof (bool), typeof (BindingFlags), typeof (Binder), typeof (object []), typeof (CultureInfo), typeof (object []) })]
+		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance) + "<T>", new Type[0])]
+		[UnrecognizedReflectionAccessPattern (typeof (Assembly), nameof (Assembly.CreateInstance), new Type[] { typeof (string) })]
+		[UnrecognizedReflectionAccessPattern (typeof (Assembly), nameof (Assembly.CreateInstance), new Type[] { typeof (string), typeof (bool) })]
+		[UnrecognizedReflectionAccessPattern (typeof (Assembly), nameof (Assembly.CreateInstance), new Type[] { typeof (string), typeof (bool), typeof (BindingFlags), typeof (Binder), typeof (object[]), typeof (CultureInfo), typeof (object[]) })]
 		private static void UnsupportedCreateInstance ()
 		{
 			Activator.CreateInstance<Test1> ();
 
 			typeof (ActivatorCreateInstance).Assembly.CreateInstance ("NonExistent");
 			typeof (ActivatorCreateInstance).Assembly.CreateInstance ("NonExistent", ignoreCase: false);
-			typeof (ActivatorCreateInstance).Assembly.CreateInstance ("NonExistent", false, BindingFlags.Public, null, new object [] { }, null, new object [] { });
+			typeof (ActivatorCreateInstance).Assembly.CreateInstance ("NonExistent", false, BindingFlags.Public, null, new object[] { }, null, new object[] { });
 
 		}
 
@@ -402,7 +402,7 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		}
 
 		[Kept]
-		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance) + "<T>", new Type [0])]
+		[UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance) + "<T>", new Type[0])]
 		private static void TestCreateInstanceOfTWithNoConstraint<T> ()
 		{
 			Activator.CreateInstance<T> ();
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflection.cs
index 147c31c60..99a5ecbf8 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflection.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflection.cs
@@ -6,7 +6,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 namespace Mono.Linker.Tests.Cases.Reflection
 {
 	[IgnoreTestCase ("Requires support for using a type in an unreferences assembly via reflection")]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/AssemblyDependency.cs" }, addAsReference: false)]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/AssemblyDependency.cs" }, addAsReference: false)]
 	[KeptAssembly ("library.dll")]
 	[KeptTypeInAssembly ("library.dll", "Mono.Linker.Tests.Cases.Reflection.Dependencies.AssemblyDependency")]
 	public class AssemblyImportedViaReflection
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithDerivedType.cs b/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithDerivedType.cs
index 5f4e8af1e..b5ba17461 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithDerivedType.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithDerivedType.cs
@@ -6,8 +6,8 @@ using Mono.Linker.Tests.Cases.Reflection.Dependencies;
 namespace Mono.Linker.Tests.Cases.Reflection
 {
 	[IgnoreTestCase ("Requires support for using a type in an unreferences assembly via reflection")]
-	[SetupCompileBefore ("base.dll", new [] { "Dependencies/AssemblyImportedViaReflectionWithDerivedType_Base.cs" })]
-	[SetupCompileBefore ("reflection.dll", new [] { "Dependencies/AssemblyImportedViaReflectionWithDerivedType_Reflect.cs" }, references: new [] {"base.dll"}, addAsReference: false)]
+	[SetupCompileBefore ("base.dll", new[] { "Dependencies/AssemblyImportedViaReflectionWithDerivedType_Base.cs" })]
+	[SetupCompileBefore ("reflection.dll", new[] { "Dependencies/AssemblyImportedViaReflectionWithDerivedType_Reflect.cs" }, references: new[] { "base.dll" }, addAsReference: false)]
 	[KeptAssembly ("base.dll")]
 	[KeptAssembly ("reflection.dll")]
 	[KeptMemberInAssembly ("base.dll", typeof (AssemblyImportedViaReflectionWithDerivedType_Base), "Method()")]
@@ -19,7 +19,7 @@ namespace Mono.Linker.Tests.Cases.Reflection
 			// Cause a the new assembly to be included via reflection usage
 			const string newAssemblyType = "Mono.Linker.Tests.Cases.Reflection.Dependencies.AssemblyImportedViaReflectionWithDerivedType_Reflect, reflection, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null";
 			var res = Type.GetType (newAssemblyType, true);
-			
+
 			// Foo and the reflection assembly both have a class the inherits from the base type.
 			// by using `Method` here and marking the reflection type above, we've introduced a requirement that `Method` be marked on the type in the reflection assembly as well 
 			var obj = new Foo ();
@@ -29,7 +29,8 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		[Kept]
 		[KeptMember (".ctor()")]
 		[KeptBaseType (typeof (AssemblyImportedViaReflectionWithDerivedType_Base))]
-		class Foo : AssemblyImportedViaReflectionWithDerivedType_Base {
+		class Foo : AssemblyImportedViaReflectionWithDerivedType_Base
+		{
 			[Kept]
 			public override string Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithReference.cs b/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithReference.cs
index 716207d22..0cdb848e3 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithReference.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithReference.cs
@@ -5,8 +5,8 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 namespace Mono.Linker.Tests.Cases.Reflection
 {
 	[IgnoreTestCase ("Requires support for using a type in an unreferences assembly via reflection")]
-	[SetupCompileBefore ("reference.dll", new [] { "Dependencies/AssemblyDependency.cs" }, addAsReference: false)]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/AssemblyDependencyWithReference.cs" }, references: new []{"reference.dll"}, addAsReference: false)]
+	[SetupCompileBefore ("reference.dll", new[] { "Dependencies/AssemblyDependency.cs" }, addAsReference: false)]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/AssemblyDependencyWithReference.cs" }, references: new[] { "reference.dll" }, addAsReference: false)]
 	[KeptAssembly ("reference.dll")]
 	[KeptAssembly ("library.dll")]
 	[KeptTypeInAssembly ("library.dll", "Mono.Linker.Tests.Cases.Reflection.Dependencies.AssemblyDependencyWithReference")]
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/ConstructorUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/ConstructorUsedViaReflection.cs
index db94ee618..19ea84a30 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/ConstructorUsedViaReflection.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/ConstructorUsedViaReflection.cs
@@ -19,40 +19,40 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		}
 
 		[RecognizedReflectionAccessPattern (
-					   typeof (Type), nameof (Type.GetConstructor), new Type [] { typeof (Type []) },
-					   typeof (IntegerParameterConstructor), ".ctor", new Type [0])]
+					   typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (Type[]) },
+					   typeof (IntegerParameterConstructor), ".ctor", new Type[0])]
 		[Kept]
 		static void TestWithIntegerParameter ()
 		{
-			var constructor = typeof (IntegerParameterConstructor).GetConstructor (new Type [] { typeof (int) });
-			constructor.Invoke (null, new object [] { });
+			var constructor = typeof (IntegerParameterConstructor).GetConstructor (new Type[] { typeof (int) });
+			constructor.Invoke (null, new object[] { });
 		}
 
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetConstructor), new Type [] { typeof (BindingFlags), typeof (Binder), typeof (Type []), typeof (ParameterModifier []) },
-			typeof (OnlyUsedViaReflection), ".ctor", new Type [0])]
+			typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) },
+			typeof (OnlyUsedViaReflection), ".ctor", new Type[0])]
 		[Kept]
 		static void TestWithBindingFlags ()
 		{
-			var constructor = typeof (OnlyUsedViaReflection).GetConstructor (BindingFlags.Public, GetNullValue ("some argument", 2, 3), new Type [] { }, new ParameterModifier [] { });
-			constructor.Invoke (null, new object [] { });
+			var constructor = typeof (OnlyUsedViaReflection).GetConstructor (BindingFlags.Public, GetNullValue ("some argument", 2, 3), new Type[] { }, new ParameterModifier[] { });
+			constructor.Invoke (null, new object[] { });
 		}
 
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetConstructor), new Type [] { typeof (BindingFlags), typeof (Binder), typeof (CallingConventions), typeof (Type []), typeof (ParameterModifier []) },
-			typeof (CallingConventionConstructor), ".ctor", new Type [0])]
+			typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (BindingFlags), typeof (Binder), typeof (CallingConventions), typeof (Type[]), typeof (ParameterModifier[]) },
+			typeof (CallingConventionConstructor), ".ctor", new Type[0])]
 		[Kept]
 		static void TestWithCallingConvention ()
 		{
-			var constructor = typeof (CallingConventionConstructor).GetConstructor (BindingFlags.Public, GetNullValue ("some argument", 2, 3), CallingConventions.HasThis, new Type [] { }, new ParameterModifier [] { });
-			constructor.Invoke (null, new object [] { });
+			var constructor = typeof (CallingConventionConstructor).GetConstructor (BindingFlags.Public, GetNullValue ("some argument", 2, 3), CallingConventions.HasThis, new Type[] { }, new ParameterModifier[] { });
+			constructor.Invoke (null, new object[] { });
 		}
 
 		[Kept]
 		static void TestNullType ()
 		{
 			Type type = null;
-			var constructor = type.GetConstructor (new Type [] { });
+			var constructor = type.GetConstructor (new Type[] { });
 		}
 
 		[Kept]
@@ -62,21 +62,21 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		}
 
 		[UnrecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetConstructor), new Type [] { typeof (Type []) })]
+			typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (Type[]) })]
 		[Kept]
 		static void TestDataFlowType ()
 		{
 			Type type = FindType ();
-			var constructor = type.GetConstructor (new Type [] { });
+			var constructor = type.GetConstructor (new Type[] { });
 		}
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetConstructor), new Type [] { typeof (BindingFlags), typeof (Binder), typeof (Type []), typeof (ParameterModifier []) },
-			typeof (IfConstructor), ".ctor", new Type [0])]
+			typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) },
+			typeof (IfConstructor), ".ctor", new Type[0])]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetConstructor), new Type [] { typeof (BindingFlags), typeof (Binder), typeof (Type []), typeof (ParameterModifier []) },
-			typeof (ElseConstructor), ".ctor", new Type [0])]
+			typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) },
+			typeof (ElseConstructor), ".ctor", new Type[0])]
 		static void TestIfElse (bool decision)
 		{
 			Type myType;
@@ -85,8 +85,8 @@ namespace Mono.Linker.Tests.Cases.Reflection
 			} else {
 				myType = typeof (ElseConstructor);
 			}
-			var constructor = myType.GetConstructor (BindingFlags.Public, null, new Type [] { }, null);
-			constructor.Invoke (null, new object [] { });
+			var constructor = myType.GetConstructor (BindingFlags.Public, null, new Type[] { }, null);
+			constructor.Invoke (null, new object[] { });
 		}
 
 		[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/CoreLibMessages.cs b/test/Mono.Linker.Tests.Cases/Reflection/CoreLibMessages.cs
index 98af67248..884d5b476 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/CoreLibMessages.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/CoreLibMessages.cs
@@ -5,7 +5,7 @@ namespace Mono.Linker.Tests.Cases.Reflection
 {
 	[SetupCSharpCompilerToUse ("csc")]
 	[SetupLinkerAction ("copy", "CoreLibEmulator")]
-	[SetupCompileBefore ("CoreLibEmulator.dll", new string [] { "Dependencies/CoreLibEmulator.cs" }, null, new string [] { "INCLUDE_CORELIB_IMPL" }, compilerToUse: "csc")]
+	[SetupCompileBefore ("CoreLibEmulator.dll", new string[] { "Dependencies/CoreLibEmulator.cs" }, null, new string[] { "INCLUDE_CORELIB_IMPL" }, compilerToUse: "csc")]
 
 	// Validate that calls from one overload of Type.Get* to another overload of the same method don't produce warning
 	[LogDoesNotContain ("Reflection call 'System.Reflection.ConstructorInfo System.Type::GetConstructor\\([^)]*\\)' inside 'System.Reflection.ConstructorInfo System.Type::GetConstructor\\([^)]*\\)' does not use detectable instance type extraction")]
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/AssemblyDependency.cs b/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/AssemblyDependency.cs
index 84339ad4b..b18cd8975 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/AssemblyDependency.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/AssemblyDependency.cs
@@ -12,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Reflection.Dependencies
 		{
 		}
 
-		class TypeThatIsUsedViaReflection {
+		class TypeThatIsUsedViaReflection
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/AssemblyDependencyWithReference.cs b/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/AssemblyDependencyWithReference.cs
index 889b5e141..551205f70 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/AssemblyDependencyWithReference.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/AssemblyDependencyWithReference.cs
@@ -1,4 +1,6 @@
-namespace Mono.Linker.Tests.Cases.Reflection.Dependencies {
-	public class AssemblyDependencyWithReference : AssemblyDependency {
+namespace Mono.Linker.Tests.Cases.Reflection.Dependencies
+{
+	public class AssemblyDependencyWithReference : AssemblyDependency
+	{
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/AssemblyImportedViaReflectionWithDerivedType_Base.cs b/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/AssemblyImportedViaReflectionWithDerivedType_Base.cs
index 6323951ee..003facce6 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/AssemblyImportedViaReflectionWithDerivedType_Base.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/AssemblyImportedViaReflectionWithDerivedType_Base.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.Reflection.Dependencies {
-	public abstract class AssemblyImportedViaReflectionWithDerivedType_Base {
+namespace Mono.Linker.Tests.Cases.Reflection.Dependencies
+{
+	public abstract class AssemblyImportedViaReflectionWithDerivedType_Base
+	{
 		public abstract string Method ();
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/AssemblyImportedViaReflectionWithDerivedType_Reflect.cs b/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/AssemblyImportedViaReflectionWithDerivedType_Reflect.cs
index e0c1bcb2a..795ee3c22 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/AssemblyImportedViaReflectionWithDerivedType_Reflect.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/AssemblyImportedViaReflectionWithDerivedType_Reflect.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.Reflection.Dependencies {
-	public class AssemblyImportedViaReflectionWithDerivedType_Reflect : AssemblyImportedViaReflectionWithDerivedType_Base {
+namespace Mono.Linker.Tests.Cases.Reflection.Dependencies
+{
+	public class AssemblyImportedViaReflectionWithDerivedType_Reflect : AssemblyImportedViaReflectionWithDerivedType_Base
+	{
 		public override string Method ()
 		{
 			return "Reflect";
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/CoreLibEmulator.cs b/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/CoreLibEmulator.cs
index 09f700547..5b0ddff40 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/CoreLibEmulator.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/Dependencies/CoreLibEmulator.cs
@@ -8,7 +8,7 @@ namespace Mono.Linker.Tests.Cases.Reflection.Dependencies
 {
 	public class CoreLibEmulator
 	{
-		public static void Test()
+		public static void Test ()
 		{
 #if INCLUDE_CORELIB_IMPL
 			Type t = new Type();
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/EventUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/EventUsedViaReflection.cs
index 44dccf6ca..ab843b582 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/EventUsedViaReflection.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/EventUsedViaReflection.cs
@@ -3,9 +3,11 @@ using System.Reflection;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Reflection {
+namespace Mono.Linker.Tests.Cases.Reflection
+{
 	[SetupCSharpCompilerToUse ("csc")]
-	public class EventUsedViaReflection {
+	public class EventUsedViaReflection
+	{
 		public static void Main ()
 		{
 			new Foo (); // Needed to avoid lazy body marking stubbing
@@ -24,7 +26,7 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetEvent), new Type [] { typeof (string) },
+			typeof (Type), nameof (Type.GetEvent), new Type[] { typeof (string) },
 			typeof (Foo), nameof (Foo.Event), (Type[]) null)]
 		static void TestByName ()
 		{
@@ -39,7 +41,7 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 		}
 
 		[Kept]
-		static void TestNameWrongBindingFlags()
+		static void TestNameWrongBindingFlags ()
 		{
 			var eventInfo = typeof (Bar).GetEvent ("PublicEvent", BindingFlags.NonPublic);
 		}
@@ -77,7 +79,7 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[UnrecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetEvent), new Type [] { typeof (string) })]
+			typeof (Type), nameof (Type.GetEvent), new Type[] { typeof (string) })]
 		static void TestDataFlowType ()
 		{
 			Type type = FindType ();
@@ -86,14 +88,14 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetEvent), new Type [] { typeof (string) },
-			typeof (IfClass), nameof (IfClass.IfEvent), (Type [])null)]
+			typeof (Type), nameof (Type.GetEvent), new Type[] { typeof (string) },
+			typeof (IfClass), nameof (IfClass.IfEvent), (Type[]) null)]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetEvent), new Type [] { typeof (string) },
-			typeof (IfClass), nameof (IfClass.ElseEvent), (Type [])null)]
+			typeof (Type), nameof (Type.GetEvent), new Type[] { typeof (string) },
+			typeof (IfClass), nameof (IfClass.ElseEvent), (Type[]) null)]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetEvent), new Type [] { typeof (string) },
-			typeof (ElseClass), nameof (ElseClass.IfEvent), (Type [])null)]
+			typeof (Type), nameof (Type.GetEvent), new Type[] { typeof (string) },
+			typeof (ElseClass), nameof (ElseClass.IfEvent), (Type[]) null)]
 		static void TestIfElse (int i)
 		{
 			Type myType;
@@ -103,7 +105,7 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 				myType = typeof (ElseClass);
 			}
 			String myString;
-			if(i == 1) {
+			if (i == 1) {
 				myString = "IfEvent";
 			} else {
 				myString = "ElseEvent";
@@ -113,8 +115,8 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetEvent), new Type [] { typeof (string) },
-			typeof (BaseClass), nameof (BaseClass.PublicEventOnBase), (Type [])null)]
+			typeof (Type), nameof (Type.GetEvent), new Type[] { typeof (string) },
+			typeof (BaseClass), nameof (BaseClass.PublicEventOnBase), (Type[]) null)]
 		static void TestEventInBaseType ()
 		{
 			typeof (DerivedClass).GetEvent ("ProtectedEventOnBase");
@@ -122,7 +124,8 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 		}
 
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[KeptBackingField]
 			[KeptEventAddMethod]
@@ -141,7 +144,7 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 			private event EventHandler<EventArgs> PrivateEvent;
 			public event EventHandler<EventArgs> PublicEvent;
 		}
-		
+
 		class IfClass
 		{
 			[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionCallString.cs b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionCallString.cs
index 174492323..4316d95a9 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionCallString.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionCallString.cs
@@ -56,7 +56,7 @@ namespace Mono.Linker.Tests.Cases.Reflection
 
 			[Kept]
 			[UnrecognizedReflectionAccessPattern (typeof (Expression), nameof (Expression.Call),
-				new Type [] { typeof (Type), typeof (string), typeof (Type []), typeof (Expression []) })]
+				new Type[] { typeof (Type), typeof (string), typeof (Type[]), typeof (Expression[]) })]
 			public static void Test ()
 			{
 				// Keep all methods of the type that made the call
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionCallStringAndLocals.cs b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionCallStringAndLocals.cs
index b41a023da..24c56f00d 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionCallStringAndLocals.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionCallStringAndLocals.cs
@@ -3,9 +3,11 @@ using System.Linq.Expressions;
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Reflection {
+namespace Mono.Linker.Tests.Cases.Reflection
+{
 	[Reference ("System.Core.dll")]
-	public class ExpressionCallStringAndLocals {
+	public class ExpressionCallStringAndLocals
+	{
 		public static void Main ()
 		{
 			Branch_SystemTypeValueNode_KnownStringValue ();
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionFieldString.cs b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionFieldString.cs
index 8701164f5..aba9bb7c9 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionFieldString.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionFieldString.cs
@@ -10,7 +10,7 @@ namespace Mono.Linker.Tests.Cases.Reflection
 	public class ExpressionFieldString
 	{
 		[UnrecognizedReflectionAccessPattern (typeof (Expression), nameof (Expression.Field),
-			new Type [] { typeof (Expression), typeof (Type), typeof (string) })]
+			new Type[] { typeof (Expression), typeof (Type), typeof (string) })]
 		public static void Main ()
 		{
 			Expression.Field (Expression.Parameter (typeof (int), ""), typeof (ExpressionFieldString), "Field");
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionNewType.cs b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionNewType.cs
index 572a1deb7..a4ed52c76 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionNewType.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionNewType.cs
@@ -27,22 +27,22 @@ namespace Mono.Linker.Tests.Cases.Reflection
 
 		#region RecognizedReflectionAccessPatterns
 		[RecognizedReflectionAccessPattern (
-			typeof (Expression), nameof (Expression.New), new Type [] { typeof (Type) }, typeof (A), ".ctor", new Type [0])]
+			typeof (Expression), nameof (Expression.New), new Type[] { typeof (Type) }, typeof (A), ".ctor", new Type[0])]
 		[RecognizedReflectionAccessPattern (
-			typeof (Expression), nameof (Expression.New), new Type [] { typeof (Type) }, typeof (B), ".ctor", new Type [0])]
+			typeof (Expression), nameof (Expression.New), new Type[] { typeof (Type) }, typeof (B), ".ctor", new Type[0])]
 		[Kept]
 		static void Branch_SystemTypeValueNode (int i)
 		{
-			Type T = (Type)null;
+			Type T = (Type) null;
 			switch (i) {
-				case 0:
-					T = typeof (A);
-					break;
-				case 1:
-					T = typeof (B);
-					break;
-				default:
-					break;
+			case 0:
+				T = typeof (A);
+				break;
+			case 1:
+				T = typeof (B);
+				break;
+			default:
+				break;
 			}
 
 			Expression.New (T);
@@ -50,15 +50,15 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		#endregion
 
 		#region UnrecognizedReflectionAccessPatterns
-		[UnrecognizedReflectionAccessPattern (typeof (Expression), nameof (Expression.New), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (Expression), nameof (Expression.New), new Type[] { typeof (Type) })]
 		[Kept]
 		static void Branch_MethodParameterValueNode (Type T)
 		{
 			Expression.New (T);
 		}
 
-		[UnrecognizedReflectionAccessPattern (typeof (Expression), nameof (Expression.New), new Type [] { typeof (Type) })]
-		[UnrecognizedReflectionAccessPattern (typeof (Expression), nameof (Expression.New), new Type [] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (Expression), nameof (Expression.New), new Type[] { typeof (Type) })]
+		[UnrecognizedReflectionAccessPattern (typeof (Expression), nameof (Expression.New), new Type[] { typeof (Type) })]
 		[Kept]
 		static void Branch_UnrecognizedPatterns ()
 		{
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionPropertyString.cs b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionPropertyString.cs
index b4e4bc391..37b9cdb56 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionPropertyString.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionPropertyString.cs
@@ -12,7 +12,7 @@ namespace Mono.Linker.Tests.Cases.Reflection
 	public class ExpressionPropertyString
 	{
 		[UnrecognizedReflectionAccessPattern (typeof (Expression), nameof (Expression.Property),
-			new Type [] { typeof (Expression), typeof (Type), typeof (string) })]
+			new Type[] { typeof (Expression), typeof (Type), typeof (string) })]
 		public static void Main ()
 		{
 			Expression.Property (Expression.Parameter (typeof (int), ""), typeof (ExpressionPropertyString), "Property");
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/FieldUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/FieldUsedViaReflection.cs
index 08838ec87..e3b76aa4b 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/FieldUsedViaReflection.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/FieldUsedViaReflection.cs
@@ -3,9 +3,11 @@ using System.Reflection;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Reflection {
+namespace Mono.Linker.Tests.Cases.Reflection
+{
 	[SetupCSharpCompilerToUse ("csc")]
-	public class FieldUsedViaReflection {
+	public class FieldUsedViaReflection
+	{
 		public static void Main ()
 		{
 			TestByName ();
@@ -22,8 +24,8 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetField), new Type [] { typeof (string) },
-			typeof (FieldUsedViaReflection), nameof (FieldUsedViaReflection.field), (Type [])null)]
+			typeof (Type), nameof (Type.GetField), new Type[] { typeof (string) },
+			typeof (FieldUsedViaReflection), nameof (FieldUsedViaReflection.field), (Type[]) null)]
 		static void TestByName ()
 		{
 			var field = typeof (FieldUsedViaReflection).GetField ("field");
@@ -32,8 +34,8 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetField), new Type [] { typeof (string), typeof(BindingFlags) },
-			typeof (Foo), nameof (Foo.field), (Type [])null)]
+			typeof (Type), nameof (Type.GetField), new Type[] { typeof (string), typeof (BindingFlags) },
+			typeof (Foo), nameof (Foo.field), (Type[]) null)]
 		static void TestNameBindingFlags ()
 		{
 			var field = typeof (Foo).GetField ("field", BindingFlags.Static);
@@ -78,7 +80,7 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[UnrecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetField), new Type [] { typeof (string) })]
+			typeof (Type), nameof (Type.GetField), new Type[] { typeof (string) })]
 		static void TestDataFlowType ()
 		{
 			Type type = FindType ();
@@ -87,11 +89,11 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetField), new Type [] { typeof (string)},
-			typeof (IfClass), nameof (IfClass.ifField), (Type [])null)]
+			typeof (Type), nameof (Type.GetField), new Type[] { typeof (string) },
+			typeof (IfClass), nameof (IfClass.ifField), (Type[]) null)]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetField), new Type [] { typeof (string) },
-			typeof (ElseClass), nameof (ElseClass.elseField), (Type [])null)]
+			typeof (Type), nameof (Type.GetField), new Type[] { typeof (string) },
+			typeof (ElseClass), nameof (ElseClass.elseField), (Type[]) null)]
 		static void TestIfElse (int i)
 		{
 			Type myType;
@@ -111,19 +113,19 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetField), new Type [] { typeof (string) },
-			typeof (BaseClass), nameof (BaseClass.publicFieldOnBase), (Type [])null)]
+			typeof (Type), nameof (Type.GetField), new Type[] { typeof (string) },
+			typeof (BaseClass), nameof (BaseClass.publicFieldOnBase), (Type[]) null)]
 		static void TestFieldInBaseType ()
 		{
-			var protectedField = typeof(DerivedClass).GetField ("protectedFieldOnBase");
-			var publicField = typeof(DerivedClass).GetField ("publicFieldOnBase");
+			var protectedField = typeof (DerivedClass).GetField ("protectedFieldOnBase");
+			var publicField = typeof (DerivedClass).GetField ("publicFieldOnBase");
 		}
 
 		[Kept]
 		static int field;
 
 		[Kept]
-		private class Foo 
+		private class Foo
 		{
 			[Kept]
 			public static int field;
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflection.cs
index 53a75b624..bab30ae53 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflection.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflection.cs
@@ -3,10 +3,12 @@ using System.Reflection;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Reflection {
+namespace Mono.Linker.Tests.Cases.Reflection
+{
 
 	[SetupCSharpCompilerToUse ("csc")]
-	public class MethodUsedViaReflection {
+	public class MethodUsedViaReflection
+	{
 		public static void Main ()
 		{
 			TestName ();
@@ -30,48 +32,48 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetMethod), new Type [] { typeof (string) },
-			typeof (MethodUsedViaReflection), nameof (MethodUsedViaReflection.OnlyCalledViaReflection), new Type [0])]
+			typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string) },
+			typeof (MethodUsedViaReflection), nameof (MethodUsedViaReflection.OnlyCalledViaReflection), new Type[0])]
 		static void TestName ()
 		{
 			var method = typeof (MethodUsedViaReflection).GetMethod ("OnlyCalledViaReflection");
-			method.Invoke (null, new object [] { });
+			method.Invoke (null, new object[] { });
 		}
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetMethod), new Type [] { typeof (string), typeof (BindingFlags) },
-			typeof (TestNameAndExplicitBindingClass), nameof (TestNameAndExplicitBindingClass.OnlyCalledViaReflection), new Type [0])]
+			typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags) },
+			typeof (TestNameAndExplicitBindingClass), nameof (TestNameAndExplicitBindingClass.OnlyCalledViaReflection), new Type[0])]
 		static void TestNameAndExplicitBindingFlags ()
 		{
 			var method = typeof (TestNameAndExplicitBindingClass).GetMethod ("OnlyCalledViaReflection", BindingFlags.Static | BindingFlags.NonPublic);
-			method.Invoke (null, new object [] { });
+			method.Invoke (null, new object[] { });
 		}
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetMethod), new Type [] { typeof (string), typeof (Type []) },
-			typeof (TestNameAndTypeClass), nameof (TestNameAndTypeClass.OnlyCalledViaReflection), new Type [0])]
+			typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (Type[]) },
+			typeof (TestNameAndTypeClass), nameof (TestNameAndTypeClass.OnlyCalledViaReflection), new Type[0])]
 		static void TestNameAndType ()
 		{
-			var method = typeof (TestNameAndTypeClass).GetMethod ("OnlyCalledViaReflection", new Type [] { });
-			method.Invoke (null, new object [] { });
+			var method = typeof (TestNameAndTypeClass).GetMethod ("OnlyCalledViaReflection", new Type[] { });
+			method.Invoke (null, new object[] { });
 		}
 
 		[Kept]
-		static void TestNameBindingFlagsAndParameterModifier()
+		static void TestNameBindingFlagsAndParameterModifier ()
 		{
-			var method = typeof (TestNameBindingFlagsAndParameterClass).GetMethod ("OnlyCalledViaReflection", BindingFlags.Public, null, new Type [] { }, null);
-			method.Invoke (null, new object [] { });
+			var method = typeof (TestNameBindingFlagsAndParameterClass).GetMethod ("OnlyCalledViaReflection", BindingFlags.Public, null, new Type[] { }, null);
+			method.Invoke (null, new object[] { });
 		}
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetMethod), new Type [] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof(CallingConventions), typeof (Type []), typeof (ParameterModifier []) },
-			typeof (TestNameBindingFlagsCallingConventionParameterClass), nameof (TestNameBindingFlagsCallingConventionParameterClass.OnlyCalledViaReflection), new Type [0])]
-		static void TestNameBindingFlagsCallingConventionParameterModifier()
+			typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (CallingConventions), typeof (Type[]), typeof (ParameterModifier[]) },
+			typeof (TestNameBindingFlagsCallingConventionParameterClass), nameof (TestNameBindingFlagsCallingConventionParameterClass.OnlyCalledViaReflection), new Type[0])]
+		static void TestNameBindingFlagsCallingConventionParameterModifier ()
 		{
-			var method = typeof (TestNameBindingFlagsCallingConventionParameterClass).GetMethod ("OnlyCalledViaReflection", BindingFlags.NonPublic, null, CallingConventions.Standard, new Type [] { }, null);
-			method.Invoke (null, new object [] { });
+			var method = typeof (TestNameBindingFlagsCallingConventionParameterClass).GetMethod ("OnlyCalledViaReflection", BindingFlags.NonPublic, null, CallingConventions.Standard, new Type[] { }, null);
+			method.Invoke (null, new object[] { });
 		}
 #if NETCOREAPP
 		[Kept]
@@ -135,7 +137,7 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[UnrecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetMethod), new Type [] { typeof (string), typeof (BindingFlags) })]
+			typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags) })]
 		static void TestDataFlowType ()
 		{
 			Type type = FindType ();
@@ -144,20 +146,20 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetMethod), new Type [] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (Type []), typeof (ParameterModifier []) },
-			typeof (IfClass), nameof (IfClass.OnlyCalledViaReflection), new Type [0])]
+			typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) },
+			typeof (IfClass), nameof (IfClass.OnlyCalledViaReflection), new Type[0])]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetMethod), new Type [] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (Type []), typeof (ParameterModifier []) },
-			typeof (IfClass), nameof (IfClass.ElseIfCall), new Type [0])]
+			typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) },
+			typeof (IfClass), nameof (IfClass.ElseIfCall), new Type[0])]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetMethod), new Type [] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (Type []), typeof (ParameterModifier []) },
-			typeof (ElseIfClass), nameof (ElseIfClass.OnlyCalledViaReflection), new Type [0])]
+			typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) },
+			typeof (ElseIfClass), nameof (ElseIfClass.OnlyCalledViaReflection), new Type[0])]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetMethod), new Type [] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (Type []), typeof (ParameterModifier []) },
-			typeof (ElseIfClass), nameof (ElseIfClass.ElseIfCall), new Type [0])]
+			typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) },
+			typeof (ElseIfClass), nameof (ElseIfClass.ElseIfCall), new Type[0])]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetMethod), new Type [] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (Type []), typeof (ParameterModifier []) },
-			typeof (ElseClass), nameof (ElseClass.OnlyCalledViaReflection), new Type [0])]
+			typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) },
+			typeof (ElseClass), nameof (ElseClass.OnlyCalledViaReflection), new Type[0])]
 		static void TestIfElse (int i)
 		{
 			Type myType;
@@ -176,18 +178,18 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 			} else {
 				mystring = null;
 			}
-			var method = myType.GetMethod (mystring, BindingFlags.Static, null, new Type [] { typeof (int) }, null);
-			method.Invoke (null, new object [] { });
+			var method = myType.GetMethod (mystring, BindingFlags.Static, null, new Type[] { typeof (int) }, null);
+			method.Invoke (null, new object[] { });
 		}
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetMethod), new Type [] { typeof (string) },
-			typeof (BaseClass), nameof (BaseClass.OnlyCalledViaReflection), new Type [0])]
-		static void TestMethodInBaseType()
+			typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string) },
+			typeof (BaseClass), nameof (BaseClass.OnlyCalledViaReflection), new Type[0])]
+		static void TestMethodInBaseType ()
 		{
 			var method = typeof (DerivedClass).GetMethod ("OnlyCalledViaReflection");
-			method.Invoke (null, new object [] { });
+			method.Invoke (null, new object[] { });
 		}
 
 		[Kept]
@@ -267,7 +269,7 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 			{
 				return 42;
 			}
-			
+
 			private int OnlyCalledViaReflection (int foo)
 			{
 				return 43;
@@ -382,17 +384,17 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 		private class IfClass
 		{
 			[Kept]
-			public static int OnlyCalledViaReflection()
+			public static int OnlyCalledViaReflection ()
 			{
 				return 42;
 			}
-			
-			private int OnlyCalledViaReflection(int foo)
+
+			private int OnlyCalledViaReflection (int foo)
 			{
 				return 43;
 			}
 			[Kept]
-			public static int ElseIfCall()
+			public static int ElseIfCall ()
 			{
 				return 44;
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflectionAndLocal.cs b/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflectionAndLocal.cs
index e5a3dbf1e..5a7f010e8 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflectionAndLocal.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflectionAndLocal.cs
@@ -2,7 +2,8 @@
 using System.Reflection;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Reflection {
+namespace Mono.Linker.Tests.Cases.Reflection
+{
 	public class MethodUsedViaReflectionAndLocal
 	{
 		public static void Main ()
@@ -19,7 +20,8 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		public class A {
+		public class A
+		{
 			[Kept]
 			public int Foo ()
 			{
@@ -29,7 +31,8 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		public class B {
+		public class B
+		{
 			public int Foo ()
 			{
 				return 43;
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflectionWithDefaultBindingFlags.cs b/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflectionWithDefaultBindingFlags.cs
index b27623ac6..d6dd87f73 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflectionWithDefaultBindingFlags.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflectionWithDefaultBindingFlags.cs
@@ -1,8 +1,10 @@
 using System.Reflection;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Reflection {
-	public class MethodUsedViaReflectionWithDefaultBindingFlags {
+namespace Mono.Linker.Tests.Cases.Reflection
+{
+	public class MethodUsedViaReflectionWithDefaultBindingFlags
+	{
 		public static void Main ()
 		{
 			new Foo (); // Needed to avoid lazy body marking stubbing
@@ -11,7 +13,8 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 		}
 
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			private static int OnlyCalledViaReflection ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/PropertyUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/PropertyUsedViaReflection.cs
index 100571fbe..5113151e3 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/PropertyUsedViaReflection.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/PropertyUsedViaReflection.cs
@@ -2,7 +2,8 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Reflection {
+namespace Mono.Linker.Tests.Cases.Reflection
+{
 	[SetupCSharpCompilerToUse ("csc")]
 	public class PropertyUsedViaReflection
 	{
@@ -22,32 +23,32 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetProperty), new Type [] { typeof (string) },
-			typeof (PropertyUsedViaReflection), nameof (PropertyUsedViaReflection.OnlyUsedViaReflection), (Type [])null)]
+			typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) },
+			typeof (PropertyUsedViaReflection), nameof (PropertyUsedViaReflection.OnlyUsedViaReflection), (Type[]) null)]
 		static void TestGetterAndSetter ()
 		{
 			var property = typeof (PropertyUsedViaReflection).GetProperty ("OnlyUsedViaReflection");
-			property.GetValue (null, new object [] { });
+			property.GetValue (null, new object[] { });
 		}
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetProperty), new Type [] { typeof (string) },
-			typeof (PropertyUsedViaReflection), nameof (PropertyUsedViaReflection.SetterOnly), (Type [])null)]
+			typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) },
+			typeof (PropertyUsedViaReflection), nameof (PropertyUsedViaReflection.SetterOnly), (Type[]) null)]
 		static void TestSetterOnly ()
 		{
 			var property = typeof (PropertyUsedViaReflection).GetProperty ("SetterOnly");
-			property.SetValue (null, 42, new object [] { });
+			property.SetValue (null, 42, new object[] { });
 		}
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetProperty), new Type [] { typeof (string) },
-			typeof (PropertyUsedViaReflection), nameof (PropertyUsedViaReflection.GetterOnly), (Type [])null)]
+			typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) },
+			typeof (PropertyUsedViaReflection), nameof (PropertyUsedViaReflection.GetterOnly), (Type[]) null)]
 		static void TestGetterOnly ()
 		{
 			var property = typeof (PropertyUsedViaReflection).GetProperty ("GetterOnly");
-			property.GetValue (null, new object [] { });
+			property.GetValue (null, new object[] { });
 		}
 
 		[Kept]
@@ -83,7 +84,7 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[UnrecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetProperty), new Type [] { typeof (string) })]
+			typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) })]
 		static void TestDataFlowType ()
 		{
 			Type type = FindType ();
@@ -92,22 +93,22 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetProperty), new Type [] { typeof (string) },
-			typeof (IfClass), nameof (IfClass.SetterOnly), (Type [])null)]
+			typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) },
+			typeof (IfClass), nameof (IfClass.SetterOnly), (Type[]) null)]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetProperty), new Type [] { typeof (string) },
-			typeof (IfClass), nameof (IfClass.GetterOnly), (Type [])null)]
+			typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) },
+			typeof (IfClass), nameof (IfClass.GetterOnly), (Type[]) null)]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetProperty), new Type [] { typeof (string) },
-			typeof (ElseClass), nameof (ElseClass.SetterOnly), (Type [])null)]
+			typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) },
+			typeof (ElseClass), nameof (ElseClass.SetterOnly), (Type[]) null)]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetProperty), new Type [] { typeof (string) },
-			typeof (ElseClass), nameof (ElseClass.GetterOnly), (Type [])null)]
+			typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) },
+			typeof (ElseClass), nameof (ElseClass.GetterOnly), (Type[]) null)]
 		static void TestIfElse (int i)
 		{
 			Type myType;
 			if (i == 1) {
-				myType = typeof(IfClass);
+				myType = typeof (IfClass);
 			} else {
 				myType = typeof (ElseClass);
 			}
@@ -122,11 +123,11 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 
 		[Kept]
 		[RecognizedReflectionAccessPattern (
-			typeof (Type), nameof (Type.GetProperty), new Type [] { typeof (string) },
-			typeof (BaseClass), nameof (BaseClass.GetterSetterOnBaseClass), (Type [])null)]
+			typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) },
+			typeof (BaseClass), nameof (BaseClass.GetterSetterOnBaseClass), (Type[]) null)]
 		static void TestPropertyInBaseType ()
 		{
-			var property = typeof(DerivedClass).GetProperty ("GetterSetterOnBaseClass");
+			var property = typeof (DerivedClass).GetProperty ("GetterSetterOnBaseClass");
 		}
 		[Kept]
 		static int _field;
@@ -208,8 +209,8 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 		}
 
 		[Kept]
-		[KeptBaseType (typeof(BaseClass))]
-		class DerivedClass : BaseClass 
+		[KeptBaseType (typeof (BaseClass))]
+		class DerivedClass : BaseClass
 		{
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/RunClassConstructorUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/RunClassConstructorUsedViaReflection.cs
index 92a516dc1..323892588 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/RunClassConstructorUsedViaReflection.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/RunClassConstructorUsedViaReflection.cs
@@ -29,7 +29,7 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		[Kept]
 		static void TestNonKeptStaticConstructor ()
 		{
-			var a = new NonKeptStaticConstructorClass();
+			var a = new NonKeptStaticConstructorClass ();
 		}
 
 		[Kept]
@@ -47,9 +47,9 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		}
 
 		[Kept]
-		[UnrecognizedReflectionAccessPattern (typeof (RuntimeHelpers), nameof (RuntimeHelpers.RunClassConstructor), new Type [] { typeof (RuntimeTypeHandle) },
-			"A value from unknown source is passed into the parameter 'type' of method "+
-			"'System.Void System.Runtime.CompilerServices.RuntimeHelpers::RunClassConstructor(System.RuntimeTypeHandle)'. "+
+		[UnrecognizedReflectionAccessPattern (typeof (RuntimeHelpers), nameof (RuntimeHelpers.RunClassConstructor), new Type[] { typeof (RuntimeTypeHandle) },
+			"A value from unknown source is passed into the parameter 'type' of method " +
+			"'System.Void System.Runtime.CompilerServices.RuntimeHelpers::RunClassConstructor(System.RuntimeTypeHandle)'. " +
 			"It's not possible to guarantee availability of the target static constructor.")]
 
 		static void TestDataFlowType ()
@@ -60,9 +60,9 @@ namespace Mono.Linker.Tests.Cases.Reflection
 
 		[Kept]
 		[RecognizedReflectionAccessPattern]
-		[UnrecognizedReflectionAccessPattern (typeof (RuntimeHelpers), nameof (RuntimeHelpers.RunClassConstructor), new Type [] { typeof (RuntimeTypeHandle) },
-			"A value from unknown source is passed into the parameter 'type' of method "+
-			"'System.Void System.Runtime.CompilerServices.RuntimeHelpers::RunClassConstructor(System.RuntimeTypeHandle)'. "+
+		[UnrecognizedReflectionAccessPattern (typeof (RuntimeHelpers), nameof (RuntimeHelpers.RunClassConstructor), new Type[] { typeof (RuntimeTypeHandle) },
+			"A value from unknown source is passed into the parameter 'type' of method " +
+			"'System.Void System.Runtime.CompilerServices.RuntimeHelpers::RunClassConstructor(System.RuntimeTypeHandle)'. " +
 			"It's not possible to guarantee availability of the target static constructor.")]
 
 		static void TestIfElseUsingRuntimeTypeHandle (int i)
@@ -85,10 +85,9 @@ namespace Mono.Linker.Tests.Cases.Reflection
 			Type myType;
 			if (i == 1) {
 				myType = typeof (IfClass2);
-			}else if (i==2) {
+			} else if (i == 2) {
 				myType = null;
-			} 
-			else {
+			} else {
 				myType = typeof (ElseClass2);
 			}
 			RuntimeHelpers.RunClassConstructor (myType.TypeHandle);
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/RuntimeReflectionExtensionsCalls.cs b/test/Mono.Linker.Tests.Cases/Reflection/RuntimeReflectionExtensionsCalls.cs
index 7d0eb3fd0..593d79f77 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/RuntimeReflectionExtensionsCalls.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/RuntimeReflectionExtensionsCalls.cs
@@ -20,7 +20,7 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		#region GetRuntimeEvent
 		[Kept]
 		[UnrecognizedReflectionAccessPattern (typeof (RuntimeReflectionExtensions), nameof (RuntimeReflectionExtensions.GetRuntimeEvent),
-			new Type [] { typeof (Type), typeof (string) })]
+			new Type[] { typeof (Type), typeof (string) })]
 		public static void TestGetRuntimeEvent ()
 		{
 			typeof (ClassWithKeptMembers).GetRuntimeEvent ("PublicEvent");
@@ -35,7 +35,7 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		#region GetRuntimeField
 		[Kept]
 		[UnrecognizedReflectionAccessPattern (typeof (RuntimeReflectionExtensions), nameof (RuntimeReflectionExtensions.GetRuntimeField),
-			new Type [] { typeof (Type), typeof (string) })]
+			new Type[] { typeof (Type), typeof (string) })]
 		public static void TestGetRuntimeField ()
 		{
 			typeof (ClassWithKeptMembers).GetRuntimeField ("PublicField");
@@ -50,7 +50,7 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		#region GetRuntimeMethod
 		[Kept]
 		[UnrecognizedReflectionAccessPattern (typeof (RuntimeReflectionExtensions), nameof (RuntimeReflectionExtensions.GetRuntimeMethod),
-			new Type [] { typeof (Type), typeof (string), typeof (Type []) })]
+			new Type[] { typeof (Type), typeof (string), typeof (Type[]) })]
 		public static void TestGetRuntimeMethod ()
 		{
 			typeof (ClassWithKeptMembers).GetRuntimeMethod ("PublicMethod", Type.EmptyTypes);
@@ -65,7 +65,7 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		#region GetRuntimeProperty
 		[Kept]
 		[UnrecognizedReflectionAccessPattern (typeof (RuntimeReflectionExtensions), nameof (RuntimeReflectionExtensions.GetRuntimeProperty),
-			new Type [] { typeof (Type), typeof (string) })]
+			new Type[] { typeof (Type), typeof (string) })]
 		public static void TestGetRuntimeProperty ()
 		{
 			typeof (ClassWithKeptMembers).GetRuntimeProperty ("PublicProperty");
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflection.cs
index 667de3320..29725d6e9 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflection.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflection.cs
@@ -2,8 +2,10 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Reflection {
-	public class TypeUsedViaReflection {
+namespace Mono.Linker.Tests.Cases.Reflection
+{
+	public class TypeUsedViaReflection
+	{
 		public static void Main ()
 		{
 			TestNull ();
@@ -86,7 +88,7 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 		[Kept]
 		[RecognizedReflectionAccessPattern (
 			typeof (Type), nameof (Type.GetType), new Type[] { typeof (string), typeof (bool) },
-			typeof (AType), null, (Type []) null)]
+			typeof (AType), null, (Type[]) null)]
 		public static void TestType ()
 		{
 			const string reflectionTypeKeptString = "Mono.Linker.Tests.Cases.Reflection.TypeUsedViaReflection+AType";
@@ -165,11 +167,14 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 		}
 
 		[Kept]
-		class Nested1 {
+		class Nested1
+		{
 			[Kept]
-			class N2 {
+			class N2
+			{
 				[Kept]
-				class N3 {
+				class N3
+				{
 				}
 			}
 		}
@@ -186,7 +191,7 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 		[Kept]
 		static void TestTypeOf ()
 		{
-			var typeKept = typeof(TypeOfToKeep);
+			var typeKept = typeof (TypeOfToKeep);
 		}
 
 		[Kept]
@@ -199,14 +204,14 @@ namespace Mono.Linker.Tests.Cases.Reflection {
 		{
 			string name = null;
 			switch (b) {
-				case 0:
-					name = "Mono.Linker.Tests.Cases.Reflection.TypeUsedViaReflection+TypeFromBranchA";
-					break;
-				case 1:
-					name = "Mono.Linker.Tests.Cases.Reflection.TypeUsedViaReflection+TypeFromBranchB";
-					break;
-				default:
-					break;
+			case 0:
+				name = "Mono.Linker.Tests.Cases.Reflection.TypeUsedViaReflection+TypeFromBranchA";
+				break;
+			case 1:
+				name = "Mono.Linker.Tests.Cases.Reflection.TypeUsedViaReflection+TypeFromBranchB";
+				break;
+			default:
+				break;
 			}
 
 			var typeKept = Type.GetType (name);
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionAssemblyDoesntExist.cs b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionAssemblyDoesntExist.cs
index 1311ac46f..22595875d 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionAssemblyDoesntExist.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionAssemblyDoesntExist.cs
@@ -1,7 +1,9 @@
 using System;
 
-namespace Mono.Linker.Tests.Cases.Reflection {
-	public class TypeUsedViaReflectionAssemblyDoesntExist {
+namespace Mono.Linker.Tests.Cases.Reflection
+{
+	public class TypeUsedViaReflectionAssemblyDoesntExist
+	{
 		public static void Main ()
 		{
 			var typeName = "Mono.Linker.Tests.Cases.Reflection.TypeUsedViaReflectionAssemblyDoesntExist+DoesntExist, test";
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionInDifferentAssembly.cs b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionInDifferentAssembly.cs
index 8df8ee25d..1bf5479a2 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionInDifferentAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionInDifferentAssembly.cs
@@ -3,11 +3,13 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Reflection.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Reflection {
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/AssemblyDependency.cs" })]
+namespace Mono.Linker.Tests.Cases.Reflection
+{
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/AssemblyDependency.cs" })]
 	[KeptAssembly ("library.dll")]
 	[KeptTypeInAssembly ("library.dll", "Mono.Linker.Tests.Cases.Reflection.Dependencies.AssemblyDependency/TypeThatIsUsedViaReflection")]
-	public class TypeUsedViaReflectionInDifferentAssembly {
+	public class TypeUsedViaReflectionInDifferentAssembly
+	{
 		public static void Main ()
 		{
 			AssemblyDependency.UsedToKeepReferenceAtCompileTime ();
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionLdstrIncomplete.cs b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionLdstrIncomplete.cs
index 56c1077bf..7e10e2285 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionLdstrIncomplete.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionLdstrIncomplete.cs
@@ -1,11 +1,13 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Reflection {
+namespace Mono.Linker.Tests.Cases.Reflection
+{
 	/// <summary>
 	/// This case we can't detect and need to gracefully do nothing
 	/// </summary>
-	public class TypeUsedViaReflectionLdstrIncomplete {
+	public class TypeUsedViaReflectionLdstrIncomplete
+	{
 		public static void Main ()
 		{
 			var typePart = GetTypePart ();
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionLdstrValidButChanged.cs b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionLdstrValidButChanged.cs
index e5f4575be..2a53a2454 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionLdstrValidButChanged.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionLdstrValidButChanged.cs
@@ -1,8 +1,10 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Reflection {
-	public class TypeUsedViaReflectionLdstrValidButChanged {
+namespace Mono.Linker.Tests.Cases.Reflection
+{
+	public class TypeUsedViaReflectionLdstrValidButChanged
+	{
 		public static void Main ()
 		{
 			var replace = "Mono.Linker";
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionTypeDoesntExist.cs b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionTypeDoesntExist.cs
index 3a74846e0..b7eee3e09 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionTypeDoesntExist.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionTypeDoesntExist.cs
@@ -2,10 +2,12 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Reflection {
+namespace Mono.Linker.Tests.Cases.Reflection
+{
 	[SetupCSharpCompilerToUse ("csc")]
 	[VerifyAllReflectionAccessPatternsAreValidated]
-	public class TypeUsedViaReflectionTypeDoesntExist {
+	public class TypeUsedViaReflectionTypeDoesntExist
+	{
 		public static void Main ()
 		{
 			var typeName = "Mono.Linker.Tests.Cases.Reflection.TypeUsedViaReflectionTypeDoesntExist+Full, DoesntExist";
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionTypeNameIsSymbol.cs b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionTypeNameIsSymbol.cs
index 70500994e..29ab84946 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionTypeNameIsSymbol.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionTypeNameIsSymbol.cs
@@ -1,7 +1,9 @@
 using System;
 
-namespace Mono.Linker.Tests.Cases.Reflection {
-	public class TypeUsedViaReflectionTypeNameIsSymbol {
+namespace Mono.Linker.Tests.Cases.Reflection
+{
+	public class TypeUsedViaReflectionTypeNameIsSymbol
+	{
 		public static void Main ()
 		{
 			var typeName = "+, test";
diff --git a/test/Mono.Linker.Tests.Cases/Reflection/UsedViaReflectionIntegrationTest.cs b/test/Mono.Linker.Tests.Cases/Reflection/UsedViaReflectionIntegrationTest.cs
index e0f7edd79..dd3ca0370 100644
--- a/test/Mono.Linker.Tests.Cases/Reflection/UsedViaReflectionIntegrationTest.cs
+++ b/test/Mono.Linker.Tests.Cases/Reflection/UsedViaReflectionIntegrationTest.cs
@@ -10,12 +10,12 @@ namespace Mono.Linker.Tests.Cases.Reflection
 		{
 			var test = 42;
 
-			var constructor = typeof (OnlyUsedViaReflection).GetConstructor (BindingFlags.Public, null, new Type [] { }, new ParameterModifier [] { });
-			constructor.Invoke(null, new object[] { });
+			var constructor = typeof (OnlyUsedViaReflection).GetConstructor (BindingFlags.Public, null, new Type[] { }, new ParameterModifier[] { });
+			constructor.Invoke (null, new object[] { });
 
 			if (test == 42) {
 				var method = typeof (OnlyUsedViaReflection).GetMethod ("OnlyCalledViaReflection", BindingFlags.Static | BindingFlags.NonPublic);
-				method.Invoke (null, new object [] { });
+				method.Invoke (null, new object[] { });
 			}
 		}
 
diff --git a/test/Mono.Linker.Tests.Cases/Resources/Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1.cs b/test/Mono.Linker.Tests.Cases/Resources/Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1.cs
index e90010c7b..a4f012e7c 100644
--- a/test/Mono.Linker.Tests.Cases/Resources/Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1.cs
+++ b/test/Mono.Linker.Tests.Cases/Resources/Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.Resources.Dependencies {
-	public class EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1 {
+namespace Mono.Linker.Tests.Cases.Resources.Dependencies
+{
+	public class EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1
+	{
 		public static void Used ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Resources/Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly_Lib1.cs b/test/Mono.Linker.Tests.Cases/Resources/Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly_Lib1.cs
index a1ca4d678..6d568ed35 100644
--- a/test/Mono.Linker.Tests.Cases/Resources/Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly_Lib1.cs
+++ b/test/Mono.Linker.Tests.Cases/Resources/Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly_Lib1.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.Resources.Dependencies {
-	public class EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly_Lib1 {
+namespace Mono.Linker.Tests.Cases.Resources.Dependencies
+{
+	public class EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly_Lib1
+	{
 		public static void Used ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Resources/Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1.cs b/test/Mono.Linker.Tests.Cases/Resources/Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1.cs
index 65e1ef600..8f9bfaa57 100644
--- a/test/Mono.Linker.Tests.Cases/Resources/Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1.cs
+++ b/test/Mono.Linker.Tests.Cases/Resources/Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.Resources.Dependencies {
-	public class EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1 {
+namespace Mono.Linker.Tests.Cases.Resources.Dependencies
+{
+	public class EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1
+	{
 		public static void Used ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy.cs b/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy.cs
index 05cb22124..17b66e74b 100644
--- a/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy.cs
+++ b/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy.cs
@@ -2,17 +2,19 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Resources.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Resources {
+namespace Mono.Linker.Tests.Cases.Resources
+{
 	[SetupCompileBefore (
 		"EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1.dll",
-		new [] { "Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1.cs" },
-		resources: new [] {"Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1.xml"})]
+		new[] { "Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1.cs" },
+		resources: new[] { "Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1.xml" })]
 	[SetupLinkerAction ("copy", "EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1")]
 	[IncludeBlacklistStep (true)]
 
 	[KeptResourceInAssembly ("EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1.dll", "EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1.xml")]
 	[KeptMemberInAssembly ("EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1.dll", typeof (EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1), "Unused()")]
-	public class EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy {
+	public class EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy
+	{
 		public static void Main ()
 		{
 			EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfActionIsCopy_Lib1.Used ();
diff --git a/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly.cs b/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly.cs
index 4259b1c58..dac7038a5 100644
--- a/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly.cs
@@ -2,16 +2,18 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Resources.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Resources {
+namespace Mono.Linker.Tests.Cases.Resources
+{
 	[SetupCompileBefore (
 		"library.dll",
-		new [] { "Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly_Lib1.cs" },
-		resources: new [] {"Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly_Lib1_NotMatchingName.xml"})]
+		new[] { "Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly_Lib1.cs" },
+		resources: new[] { "Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly_Lib1_NotMatchingName.xml" })]
 	[IncludeBlacklistStep (true)]
 
 	[KeptResourceInAssembly ("library.dll", "EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly_Lib1_NotMatchingName.xml")]
 	[RemovedMemberInAssembly ("library.dll", typeof (EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly_Lib1), "Unused()")]
-	public class EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly {
+	public class EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly
+	{
 		public static void Main ()
 		{
 			EmbeddedLinkXmlFileInReferencedAssemblyIsNotProcessedIfNameDoesNotMatchAnAssembly_Lib1.Used ();
diff --git a/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink.cs b/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink.cs
index 8b477c037..080eb1736 100644
--- a/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink.cs
+++ b/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink.cs
@@ -2,17 +2,19 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Resources.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Resources {
+namespace Mono.Linker.Tests.Cases.Resources
+{
 	[SetupCompileBefore (
 		"EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1.dll",
-		new [] { "Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1.cs" },
-		resources: new [] {"Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1.xml"})]
+		new[] { "Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1.cs" },
+		resources: new[] { "Dependencies/EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1.xml" })]
 	[SetupLinkerAction ("link", "EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1")]
 	[IncludeBlacklistStep (true)]
 
 	[RemovedResourceInAssembly ("EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1.dll", "EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1.xml")]
 	[KeptMemberInAssembly ("EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1.dll", typeof (EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1), "Unused()")]
-	public class EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink {
+	public class EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink
+	{
 		public static void Main ()
 		{
 			EmbeddedLinkXmlFileInReferencedAssemblyIsProcessedIfActionIsLink_Lib1.Used ();
diff --git a/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileIsNotProcessedIfNameDoesNotMatchAnAssembly.cs b/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileIsNotProcessedIfNameDoesNotMatchAnAssembly.cs
index 69d1d1dc4..fa9ba66a7 100644
--- a/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileIsNotProcessedIfNameDoesNotMatchAnAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileIsNotProcessedIfNameDoesNotMatchAnAssembly.cs
@@ -2,18 +2,21 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Resources {
+namespace Mono.Linker.Tests.Cases.Resources
+{
 	[SetupLinkerCoreAction ("link")]
 	[IncludeBlacklistStep (true)]
 	[SetupCompileResource ("Dependencies/EmbeddedLinkXmlFileIsNotProcessedIfNameDoesNotMatchAnAssembly.xml", "NotMatchingAnAssemblyName.xml")]
 	[SkipPeVerify]
 	[KeptResource ("NotMatchingAnAssemblyName.xml")]
-	public class EmbeddedLinkXmlFileIsNotProcessedIfNameDoesNotMatchAnAssembly {
+	public class EmbeddedLinkXmlFileIsNotProcessedIfNameDoesNotMatchAnAssembly
+	{
 		public static void Main ()
 		{
 		}
 
-		public class Unused {
+		public class Unused
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileIsNotProcessedWhenBlacklistStepIsDisabled.cs b/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileIsNotProcessedWhenBlacklistStepIsDisabled.cs
index 604520899..2a8227c24 100644
--- a/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileIsNotProcessedWhenBlacklistStepIsDisabled.cs
+++ b/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileIsNotProcessedWhenBlacklistStepIsDisabled.cs
@@ -2,7 +2,8 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Resources {
+namespace Mono.Linker.Tests.Cases.Resources
+{
 	[SetupLinkerCoreAction ("link")]
 	[IncludeBlacklistStep (false)]
 
@@ -10,12 +11,14 @@ namespace Mono.Linker.Tests.Cases.Resources {
 	[SetupCompileResource ("Dependencies/EmbeddedLinkXmlFileIsNotProcessedWhenBlacklistStepIsDisabled.xml", "test.xml")]
 	[SkipPeVerify]
 	[KeptResource ("test.xml")]
-	public class EmbeddedLinkXmlFileIsNotProcessedWhenBlacklistStepIsDisabled {
+	public class EmbeddedLinkXmlFileIsNotProcessedWhenBlacklistStepIsDisabled
+	{
 		public static void Main ()
 		{
 		}
 
-		public class Unused {
+		public class Unused
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileIsProcessed.cs b/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileIsProcessed.cs
index c7a043aaf..c49525f77 100644
--- a/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileIsProcessed.cs
+++ b/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileIsProcessed.cs
@@ -2,21 +2,24 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Resources {
+namespace Mono.Linker.Tests.Cases.Resources
+{
 	[SetupLinkerCoreAction ("link")]
 	[IncludeBlacklistStep (true)]
 
 	// We need to rename the resource so that it matches the name of an assembly being processed.  This is a requriement of the black list step
 	[SetupCompileResource ("Dependencies/EmbeddedLinkXmlFileIsProcessed.xml", "test.xml")]
 	[SkipPeVerify]
-	public class EmbeddedLinkXmlFileIsProcessed {
+	public class EmbeddedLinkXmlFileIsProcessed
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		public class Unused {
+		public class Unused
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileIsProcessedAndKept.cs b/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileIsProcessedAndKept.cs
index a6b25d31b..a93db9e9c 100644
--- a/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileIsProcessedAndKept.cs
+++ b/test/Mono.Linker.Tests.Cases/Resources/EmbeddedLinkXmlFileIsProcessedAndKept.cs
@@ -12,14 +12,16 @@ namespace Mono.Linker.Tests.Cases.Resources
 	[SetupCompileResource ("Dependencies/EmbeddedLinkXmlFileIsProcessedAndKept.xml", "test.xml")]
 	[SkipPeVerify]
 	[KeptResource ("test.xml")]
-	public class EmbeddedLinkXmlFileIsProcessedAndKept {
+	public class EmbeddedLinkXmlFileIsProcessedAndKept
+	{
 		public static void Main ()
 		{
 		}
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		public class Unused {
+		public class Unused
+		{
 		}
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/Resources/NonLinkerEmbeddedResourceHasNoImpact.cs b/test/Mono.Linker.Tests.Cases/Resources/NonLinkerEmbeddedResourceHasNoImpact.cs
index b2112b92f..76797b42d 100644
--- a/test/Mono.Linker.Tests.Cases/Resources/NonLinkerEmbeddedResourceHasNoImpact.cs
+++ b/test/Mono.Linker.Tests.Cases/Resources/NonLinkerEmbeddedResourceHasNoImpact.cs
@@ -2,7 +2,8 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Resources {
+namespace Mono.Linker.Tests.Cases.Resources
+{
 	[SetupLinkerCoreAction ("link")]
 	[IncludeBlacklistStep (true)]
 
@@ -10,7 +11,8 @@ namespace Mono.Linker.Tests.Cases.Resources {
 	[SetupCompileResource ("Dependencies/NonLinkerEmbeddedResourceHasNoImpact.xml", "test.xml")]
 	[SkipPeVerify]
 	[KeptResource ("test.xml")]
-	public class NonLinkerEmbeddedResourceHasNoImpact {
+	public class NonLinkerEmbeddedResourceHasNoImpact
+	{
 		public static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Sealer/MethodsDevirtualization.cs b/test/Mono.Linker.Tests.Cases/Sealer/MethodsDevirtualization.cs
index ecfae8485..12f9c0427 100644
--- a/test/Mono.Linker.Tests.Cases/Sealer/MethodsDevirtualization.cs
+++ b/test/Mono.Linker.Tests.Cases/Sealer/MethodsDevirtualization.cs
@@ -7,7 +7,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 namespace Mono.Linker.Tests.Cases.Sealer
 {
 	[SetupLinkerArgument ("--enable-opt", "sealer")]
-	[AddedPseudoAttributeAttribute ((uint)TypeAttributes.Sealed)]
+	[AddedPseudoAttributeAttribute ((uint) TypeAttributes.Sealed)]
 	public class MethodsDevirtualization
 	{
 		public static void Main ()
@@ -43,12 +43,12 @@ namespace Mono.Linker.Tests.Cases.Sealer.Data
 		}
 
 		[Kept]
-		[AddedPseudoAttributeAttribute ((uint)MethodAttributes.Final)]
+		[AddedPseudoAttributeAttribute ((uint) MethodAttributes.Final)]
 		public virtual bool A () => true;
 		[Kept]
 		public virtual bool B () => false;
 		[Kept]
-		[AddedPseudoAttributeAttribute ((uint)MethodAttributes.Final)]
+		[AddedPseudoAttributeAttribute ((uint) MethodAttributes.Final)]
 		public virtual bool C () => false;
 		[Kept]
 		public virtual bool D () => false;
@@ -56,7 +56,7 @@ namespace Mono.Linker.Tests.Cases.Sealer.Data
 
 	[Kept]
 	[KeptBaseType (typeof (BaseClassMethods))]
-	[AddedPseudoAttributeAttribute ((uint)TypeAttributes.Sealed)]
+	[AddedPseudoAttributeAttribute ((uint) TypeAttributes.Sealed)]
 	public class Sealable : BaseClassMethods
 	{
 		[Kept]
@@ -65,12 +65,12 @@ namespace Mono.Linker.Tests.Cases.Sealer.Data
 		}
 
 		[Kept]
-		[AddedPseudoAttributeAttribute ((uint)MethodAttributes.Final)]
+		[AddedPseudoAttributeAttribute ((uint) MethodAttributes.Final)]
 		public override bool B () => true;
 
 		[Kept]
-		[RemovedPseudoAttributeAttribute ((uint)MethodAttributes.Virtual)]
-		[RemovedPseudoAttributeAttribute ((uint)MethodAttributes.VtableLayoutMask)]
+		[RemovedPseudoAttributeAttribute ((uint) MethodAttributes.Virtual)]
+		[RemovedPseudoAttributeAttribute ((uint) MethodAttributes.VtableLayoutMask)]
 		public virtual bool B2 () => false;
 
 		[Kept]
@@ -94,7 +94,7 @@ namespace Mono.Linker.Tests.Cases.Sealer.Data
 
 	[Kept]
 	[KeptBaseType (typeof (BaseAbstractClassMethods))]
-	[AddedPseudoAttributeAttribute ((uint)TypeAttributes.Sealed)]
+	[AddedPseudoAttributeAttribute ((uint) TypeAttributes.Sealed)]
 	public class SealableAbstract : BaseAbstractClassMethods
 	{
 		[Kept]
@@ -103,7 +103,7 @@ namespace Mono.Linker.Tests.Cases.Sealer.Data
 		}
 
 		[Kept]
-		[AddedPseudoAttributeAttribute ((uint)MethodAttributes.Final)]
+		[AddedPseudoAttributeAttribute ((uint) MethodAttributes.Final)]
 		public override bool A () => true;
 	}
 
@@ -129,12 +129,12 @@ namespace Mono.Linker.Tests.Cases.Sealer.Data
 	[Kept]
 	[KeptBaseType (typeof (BaseA))]
 	[KeptInterface (typeof (IA))]
-	[AddedPseudoAttributeAttribute ((uint)TypeAttributes.Sealed)]
+	[AddedPseudoAttributeAttribute ((uint) TypeAttributes.Sealed)]
 	public class Subclass : BaseA, IA
 	{
 		[Kept]
 		public Subclass ()
 		{
 		}
-	}	
+	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Sealer/TypesCanBeSealed.cs b/test/Mono.Linker.Tests.Cases/Sealer/TypesCanBeSealed.cs
index 93110ab9f..92c366ffa 100644
--- a/test/Mono.Linker.Tests.Cases/Sealer/TypesCanBeSealed.cs
+++ b/test/Mono.Linker.Tests.Cases/Sealer/TypesCanBeSealed.cs
@@ -7,7 +7,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 namespace Mono.Linker.Tests.Cases.Sealer
 {
 	[SetupLinkerArgument ("--enable-opt", "sealer")]
-	[AddedPseudoAttributeAttribute ((uint)TypeAttributes.Sealed)]
+	[AddedPseudoAttributeAttribute ((uint) TypeAttributes.Sealed)]
 	public class TypesCanBeSealed
 	{
 		public static void Main ()
@@ -25,7 +25,7 @@ namespace Mono.Linker.Tests.Cases.Sealer
 		}
 
 		[Kept]
-		[AddedPseudoAttributeAttribute ((uint)TypeAttributes.Sealed)]
+		[AddedPseudoAttributeAttribute ((uint) TypeAttributes.Sealed)]
 		class SimpleNestedClass
 		{
 		}
@@ -40,7 +40,7 @@ namespace Mono.Linker.Tests.Cases.Sealer
 namespace Mono.Linker.Tests.Cases.Sealer.Data
 {
 	[Kept]
-	[AddedPseudoAttributeAttribute ((uint)TypeAttributes.Sealed)]
+	[AddedPseudoAttributeAttribute ((uint) TypeAttributes.Sealed)]
 	class SimpleClass
 	{
 	}
@@ -57,7 +57,7 @@ namespace Mono.Linker.Tests.Cases.Sealer.Data
 
 	[Kept]
 	[KeptBaseType (typeof (Base))]
-	[AddedPseudoAttributeAttribute ((uint)TypeAttributes.Sealed)]
+	[AddedPseudoAttributeAttribute ((uint) TypeAttributes.Sealed)]
 	class Derived : Base
 	{
 	}
@@ -66,7 +66,7 @@ namespace Mono.Linker.Tests.Cases.Sealer.Data
 	class BaseWithNested
 	{
 		[Kept]
-		[AddedPseudoAttributeAttribute ((uint)TypeAttributes.Sealed)]
+		[AddedPseudoAttributeAttribute ((uint) TypeAttributes.Sealed)]
 		internal class Nested
 		{
 		}
@@ -74,7 +74,7 @@ namespace Mono.Linker.Tests.Cases.Sealer.Data
 
 	[Kept]
 	[KeptBaseType (typeof (BaseWithNested))]
-	[AddedPseudoAttributeAttribute ((uint)TypeAttributes.Sealed)]
+	[AddedPseudoAttributeAttribute ((uint) TypeAttributes.Sealed)]
 	class DerivedWithNested : BaseWithNested
 	{
 	}
@@ -84,13 +84,13 @@ namespace Mono.Linker.Tests.Cases.Sealer.Data
 	}
 
 	[Kept]
-	[AddedPseudoAttributeAttribute ((uint)TypeAttributes.Sealed)]
+	[AddedPseudoAttributeAttribute ((uint) TypeAttributes.Sealed)]
 	class BaseWithUnusedDerivedClass
 	{
 
 	}
 
-	class UnusedDerivedClass: BaseWithUnusedDerivedClass
+	class UnusedDerivedClass : BaseWithUnusedDerivedClass
 	{
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/Statics/ExplicitStaticCtor.cs b/test/Mono.Linker.Tests.Cases/Statics/ExplicitStaticCtor.cs
index 5c1d85343..d379e78c1 100644
--- a/test/Mono.Linker.Tests.Cases/Statics/ExplicitStaticCtor.cs
+++ b/test/Mono.Linker.Tests.Cases/Statics/ExplicitStaticCtor.cs
@@ -28,7 +28,7 @@ namespace Mono.Linker.Tests.Cases.Statics
 			}
 		}
 
-		[AddedPseudoAttributeAttribute ((uint)TypeAttributes.BeforeFieldInit)]
+		[AddedPseudoAttributeAttribute ((uint) TypeAttributes.BeforeFieldInit)]
 		static class CEmpty
 		{
 			static CEmpty ()
diff --git a/test/Mono.Linker.Tests.Cases/Statics/StaticFieldInitializer.cs b/test/Mono.Linker.Tests.Cases/Statics/StaticFieldInitializer.cs
index 8e460e091..995ff4375 100644
--- a/test/Mono.Linker.Tests.Cases/Statics/StaticFieldInitializer.cs
+++ b/test/Mono.Linker.Tests.Cases/Statics/StaticFieldInitializer.cs
@@ -9,7 +9,7 @@ namespace Mono.Linker.Tests.Cases.Statics
 			C.Foo ();
 		}
 
-		[KeptMember(".cctor()")]
+		[KeptMember (".cctor()")]
 		static class C
 		{
 			[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/Statics/UnusedStaticConstructorGetsRemoved.cs b/test/Mono.Linker.Tests.Cases/Statics/UnusedStaticConstructorGetsRemoved.cs
index 83c1d1ea8..f9484271b 100644
--- a/test/Mono.Linker.Tests.Cases/Statics/UnusedStaticConstructorGetsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Statics/UnusedStaticConstructorGetsRemoved.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Statics {
-	class UnusedStaticConstructorGetsRemoved {
+namespace Mono.Linker.Tests.Cases.Statics
+{
+	class UnusedStaticConstructorGetsRemoved
+	{
 		public static void Main ()
 		{
 		}
@@ -11,7 +13,8 @@ namespace Mono.Linker.Tests.Cases.Statics {
 			new B ();
 		}
 
-		class B {
+		class B
+		{
 			static B ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/Statics/UnusedStaticMethodGetsRemoved.cs b/test/Mono.Linker.Tests.Cases/Statics/UnusedStaticMethodGetsRemoved.cs
index 31c7c6ef0..47405c80e 100644
--- a/test/Mono.Linker.Tests.Cases/Statics/UnusedStaticMethodGetsRemoved.cs
+++ b/test/Mono.Linker.Tests.Cases/Statics/UnusedStaticMethodGetsRemoved.cs
@@ -1,8 +1,10 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.Statics {
-	public class UnusedStaticMethodGetsRemoved {
+namespace Mono.Linker.Tests.Cases.Statics
+{
+	public class UnusedStaticMethodGetsRemoved
+	{
 		public static void Main ()
 		{
 			A.UsedMethod ();
@@ -10,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Statics {
 	}
 
 	[Kept]
-	class A {
+	class A
+	{
 		[Kept]
 		public static void UsedMethod ()
 		{
diff --git a/test/Mono.Linker.Tests.Cases/Substitutions/EmbeddedSubstitutions.cs b/test/Mono.Linker.Tests.Cases/Substitutions/EmbeddedSubstitutions.cs
index 479be2d6f..3a3d6cef4 100644
--- a/test/Mono.Linker.Tests.Cases/Substitutions/EmbeddedSubstitutions.cs
+++ b/test/Mono.Linker.Tests.Cases/Substitutions/EmbeddedSubstitutions.cs
@@ -13,7 +13,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"ldstr",
 			"newobj",
 			"throw"
diff --git a/test/Mono.Linker.Tests.Cases/Substitutions/FeatureSubstitutions.cs b/test/Mono.Linker.Tests.Cases/Substitutions/FeatureSubstitutions.cs
index 980451da4..a4ec6bf0e 100644
--- a/test/Mono.Linker.Tests.Cases/Substitutions/FeatureSubstitutions.cs
+++ b/test/Mono.Linker.Tests.Cases/Substitutions/FeatureSubstitutions.cs
@@ -10,7 +10,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		[Kept]
 		static bool IsOptionalFeatureEnabled {
 			[Kept]
-			[ExpectedInstructionSequence (new [] {
+			[ExpectedInstructionSequence (new[] {
 				"ldc.i4.0",
 				"ret",
 			})]
@@ -24,7 +24,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 
 		[Kept]
 		[ExpectBodyModified]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"brfalse",
 			"call",
diff --git a/test/Mono.Linker.Tests.Cases/Substitutions/FeatureSubstitutionsNested.cs b/test/Mono.Linker.Tests.Cases/Substitutions/FeatureSubstitutionsNested.cs
index 5e124ee48..a54b37f78 100644
--- a/test/Mono.Linker.Tests.Cases/Substitutions/FeatureSubstitutionsNested.cs
+++ b/test/Mono.Linker.Tests.Cases/Substitutions/FeatureSubstitutionsNested.cs
@@ -14,47 +14,52 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 	[SetupLinkerArgument ("--feature", "FieldCondition", "true")]
 	public class FeatureSubstitutionsNested
 	{
-		public static void Main () {
+		public static void Main ()
+		{
 			GlobalConditionMethod ();
 			AssemblyConditionMethod ();
 			TypeConditionMethod ();
 			MethodConditionMethod ();
 			_ = FieldConditionField;
 		}
-		
+
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"ldc.i4.1",
 			"ret",
 		})]
-		static bool GlobalConditionMethod () {
+		static bool GlobalConditionMethod ()
+		{
 			throw new NotImplementedException ();
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"ldc.i4.0",
 			"ret",
 		})]
-		static bool AssemblyConditionMethod () {
+		static bool AssemblyConditionMethod ()
+		{
 			throw new NotImplementedException ();
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"ldc.i4.1",
 			"ret",
 		})]
-		static bool TypeConditionMethod () {
+		static bool TypeConditionMethod ()
+		{
 			throw new NotImplementedException ();
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"ldc.i4.0",
 			"ret",
 		})]
-		static bool MethodConditionMethod () {
+		static bool MethodConditionMethod ()
+		{
 			throw new NotImplementedException ();
 		}
 
@@ -62,7 +67,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		static readonly bool FieldConditionField;
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"nop",
 			"ldc.i4.1",
 			"stsfld",
diff --git a/test/Mono.Linker.Tests.Cases/Substitutions/InitField.cs b/test/Mono.Linker.Tests.Cases/Substitutions/InitField.cs
index 1cc85c334..9db2951f6 100644
--- a/test/Mono.Linker.Tests.Cases/Substitutions/InitField.cs
+++ b/test/Mono.Linker.Tests.Cases/Substitutions/InitField.cs
@@ -10,7 +10,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		[Kept]
 		static readonly bool BoolValue;
 
-		public static void Main()
+		public static void Main ()
 		{
 			TestField_1 ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Substitutions/InitFieldExistingCctor.cs b/test/Mono.Linker.Tests.Cases/Substitutions/InitFieldExistingCctor.cs
index 4095116a7..a831266e8 100644
--- a/test/Mono.Linker.Tests.Cases/Substitutions/InitFieldExistingCctor.cs
+++ b/test/Mono.Linker.Tests.Cases/Substitutions/InitFieldExistingCctor.cs
@@ -8,7 +8,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 	public class InitFieldExistingCctor
 	{
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.i4.s",
 				"pop",
 				"ldc.i4",
@@ -23,7 +23,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		[Kept]
 		static readonly int IntValue;
 
-		public static void Main()
+		public static void Main ()
 		{
 			TestField_1 ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Substitutions/RemoveBody.cs b/test/Mono.Linker.Tests.Cases/Substitutions/RemoveBody.cs
index cd9f5285c..0ee0e188e 100644
--- a/test/Mono.Linker.Tests.Cases/Substitutions/RemoveBody.cs
+++ b/test/Mono.Linker.Tests.Cases/Substitutions/RemoveBody.cs
@@ -18,7 +18,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		struct NestedType
 		{
 			[Kept]
-			[ExpectedInstructionSequence (new [] {
+			[ExpectedInstructionSequence (new[] {
 				"ldstr",
 				"newobj",
 				"throw"
@@ -29,7 +29,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldarg.0",
 				"call",
 				"ldstr",
@@ -41,7 +41,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldstr",
 				"newobj",
 				"throw"
@@ -51,7 +51,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldstr",
 				"newobj",
 				"throw"
diff --git a/test/Mono.Linker.Tests.Cases/Substitutions/StubBody.cs b/test/Mono.Linker.Tests.Cases/Substitutions/StubBody.cs
index a22e9b9bd..f046b25ff 100644
--- a/test/Mono.Linker.Tests.Cases/Substitutions/StubBody.cs
+++ b/test/Mono.Linker.Tests.Cases/Substitutions/StubBody.cs
@@ -2,9 +2,11 @@ using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Substitutions {
+namespace Mono.Linker.Tests.Cases.Substitutions
+{
 	[SetupLinkerSubstitutionFile ("StubBody.xml")]
-	public class StubBody {
+	public class StubBody
+	{
 		public static void Main ()
 		{
 			new StubBody ();
@@ -25,9 +27,10 @@ namespace Mono.Linker.Tests.Cases.Substitutions {
 			TestMethod_13 ();
 		}
 
-		struct NestedType {
+		struct NestedType
+		{
 			[Kept]
-			[ExpectedInstructionSequence (new [] {
+			[ExpectedInstructionSequence (new[] {
 				"ret",
 			})]
 			public NestedType (int arg)
@@ -37,7 +40,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldarg.0",
 				"call",
 				"ret",
@@ -48,7 +51,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldnull",
 				"ret",
 			})]
@@ -58,7 +61,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.i4.0",
 				"ret",
 			})]
@@ -68,7 +71,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.i4.0",
 				"ret",
 			})]
@@ -78,7 +81,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldloca.s",
 				"initobj",
 				"ldloc.0",
@@ -91,7 +94,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.i4.0",
 				"ret",
 			})]
@@ -101,7 +104,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ret",
 			})]
 		static void TestMethod_6 ()
@@ -110,7 +113,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.r8",
 				"ret",
 			})]
@@ -122,7 +125,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldloca.s",
 				"initobj",
 				"ldloc.0",
@@ -135,7 +138,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.r4",
 				"ret",
 			})]
@@ -147,7 +150,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.i8",
 				"ret",
 			})]
@@ -157,17 +160,17 @@ namespace Mono.Linker.Tests.Cases.Substitutions {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldnull",
 				"ret",
 			})]
-		static long [] TestMethod_11 ()
+		static long[] TestMethod_11 ()
 		{
 			throw new NotImplementedException ();
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldnull",
 				"ret",
 			})]
@@ -177,7 +180,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions {
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldnull",
 				"ret",
 			})]
diff --git a/test/Mono.Linker.Tests.Cases/Substitutions/StubBodyInvalidSyntax.cs b/test/Mono.Linker.Tests.Cases/Substitutions/StubBodyInvalidSyntax.cs
index a5c302d10..a10c02fbe 100644
--- a/test/Mono.Linker.Tests.Cases/Substitutions/StubBodyInvalidSyntax.cs
+++ b/test/Mono.Linker.Tests.Cases/Substitutions/StubBodyInvalidSyntax.cs
@@ -7,7 +7,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 	[SetupLinkerSubstitutionFile ("StubBodyInvalidSyntax.xml")]
 	public class StubBodyInvalidSyntax
 	{
-		public static void Main()
+		public static void Main ()
 		{
 			new StubBodyInvalidSyntax ();
 
@@ -26,7 +26,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		}
 
 		[Kept]
-		public StubBodyInvalidSyntax()
+		public StubBodyInvalidSyntax ()
 		{
 			throw new NotImplementedException ();
 		}
@@ -56,19 +56,19 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		}
 
 		[Kept]
-		static bool TestMethod_5()
+		static bool TestMethod_5 ()
 		{
 			return true;
 		}
 
 		[Kept]
-		static void TestMethod_6()
+		static void TestMethod_6 ()
 		{
 			TestMethod_5 ();
 		}
 
 		[Kept]
-		static double TestMethod_7()
+		static double TestMethod_7 ()
 		{
 			throw new NotImplementedException ();
 		}
@@ -80,25 +80,25 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		}
 
 		[Kept]
-		static float TestMethod_9()
+		static float TestMethod_9 ()
 		{
 			throw new NotImplementedException ();
 		}
 
 		[Kept]
-		static ulong TestMethod_10()
+		static ulong TestMethod_10 ()
 		{
 			throw new NotImplementedException ();
-		}			
+		}
 
 		[Kept]
-		static long[] TestMethod_11()
+		static long[] TestMethod_11 ()
 		{
 			throw new NotImplementedException ();
-		}			
+		}
 
 		[Kept]
-		static object TestMethod_12()
+		static object TestMethod_12 ()
 		{
 			throw new NotImplementedException ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Substitutions/StubBodyUnsafe.cs b/test/Mono.Linker.Tests.Cases/Substitutions/StubBodyUnsafe.cs
index 6b95568b1..184808279 100644
--- a/test/Mono.Linker.Tests.Cases/Substitutions/StubBodyUnsafe.cs
+++ b/test/Mono.Linker.Tests.Cases/Substitutions/StubBodyUnsafe.cs
@@ -2,18 +2,20 @@ using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Substitutions {
+namespace Mono.Linker.Tests.Cases.Substitutions
+{
 	[SetupLinkerSubstitutionFile ("StubBodyUnsafe.xml")]
 	[SetupCompileArgument ("/unsafe")]
 	[SkipPeVerify]
-	public class StubBodyUnsafe {
+	public class StubBodyUnsafe
+	{
 		public static unsafe void Main ()
 		{
 			TestMethod_1 ();
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.i4.0",
 				"conv.i",
 				"ret",
diff --git a/test/Mono.Linker.Tests.Cases/Substitutions/StubBodyWithValue.cs b/test/Mono.Linker.Tests.Cases/Substitutions/StubBodyWithValue.cs
index 77d6716d4..7d5ae69b2 100644
--- a/test/Mono.Linker.Tests.Cases/Substitutions/StubBodyWithValue.cs
+++ b/test/Mono.Linker.Tests.Cases/Substitutions/StubBodyWithValue.cs
@@ -7,7 +7,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 	[SetupLinkerSubstitutionFile ("StubBodyWithValue.xml")]
 	public class StubBodyWithValue
 	{
-		public static void Main()
+		public static void Main ()
 		{
 			TestMethod_1 ();
 			TestMethod_2 ();
@@ -24,7 +24,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldstr",
 				"ret",
 			})]
@@ -34,7 +34,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.i4",
 				"ret",
 			})]
@@ -44,7 +44,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.i4",
 				"ret",
 			})]
@@ -54,7 +54,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.i4",
 				"ret"
 			})]
@@ -64,37 +64,37 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.i4.1",
 				"ret",
 			})]
-		static bool TestMethod_5()
+		static bool TestMethod_5 ()
 		{
 			throw new NotImplementedException ();
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.i4.1",
 				"ret",
 			})]
-		static bool TestMethod_6()
+		static bool TestMethod_6 ()
 		{
 			throw new NotImplementedException ();
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.r8",
 				"ret",
 			})]
-		static double TestMethod_7()
+		static double TestMethod_7 ()
 		{
 			throw new NotImplementedException ();
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.i4",
 				"ret"
 			})]
@@ -104,27 +104,27 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.r4",
 				"ret",
 			})]
-		static float TestMethod_9()
+		static float TestMethod_9 ()
 		{
 			throw new NotImplementedException ();
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.i8",
 				"ret",
 			})]
-		static ulong TestMethod_10()
+		static ulong TestMethod_10 ()
 		{
 			throw new NotImplementedException ();
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.i8",
 				"ret",
 			})]
@@ -134,7 +134,7 @@ namespace Mono.Linker.Tests.Cases.Substitutions
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 				"ldc.i4",
 				"ret",
 			})]
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/AssemblyWithDefaultSymbols.cs b/test/Mono.Linker.Tests.Cases/Symbols/AssemblyWithDefaultSymbols.cs
index 5ce300138..290f1ea11 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/AssemblyWithDefaultSymbols.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/AssemblyWithDefaultSymbols.cs
@@ -1,11 +1,13 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileArgument ("/debug:full")]
 	[SetupLinkerLinkSymbols ("false")]
 	[RemovedSymbols ("test.exe")]
-	public class AssemblyWithDefaultSymbols {
+	public class AssemblyWithDefaultSymbols
+	{
 		static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/AssemblyWithDefaultSymbolsAndSymbolLinkingEnabled.cs b/test/Mono.Linker.Tests.Cases/Symbols/AssemblyWithDefaultSymbolsAndSymbolLinkingEnabled.cs
index 3c9ea4df7..d8bfaf69a 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/AssemblyWithDefaultSymbolsAndSymbolLinkingEnabled.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/AssemblyWithDefaultSymbolsAndSymbolLinkingEnabled.cs
@@ -1,11 +1,13 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileArgument ("/debug:full")]
 	[SetupLinkerLinkSymbols ("true")]
 	[KeptSymbols ("test.exe")]
-	public class AssemblyWithDefaultSymbolsAndSymbolLinkingEnabled {
+	public class AssemblyWithDefaultSymbolsAndSymbolLinkingEnabled
+	{
 		static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithCompilerDefaultSymbols.cs b/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithCompilerDefaultSymbols.cs
index 38de58e93..f54c08cdd 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithCompilerDefaultSymbols.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithCompilerDefaultSymbols.cs
@@ -1,9 +1,11 @@
-namespace Mono.Linker.Tests.Cases.Symbols.Dependencies {
-	public class LibraryWithCompilerDefaultSymbols {
+namespace Mono.Linker.Tests.Cases.Symbols.Dependencies
+{
+	public class LibraryWithCompilerDefaultSymbols
+	{
 		public static void SomeMethod ()
 		{
 		}
-		
+
 		static void NotUsed ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithEmbeddedPdbSymbols.cs b/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithEmbeddedPdbSymbols.cs
index 578d8bf36..6450080e7 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithEmbeddedPdbSymbols.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithEmbeddedPdbSymbols.cs
@@ -1,7 +1,9 @@
 using System;
 
-namespace Mono.Linker.Tests.Cases.Symbols.Dependencies {
-	public class LibraryWithEmbeddedPdbSymbols {
+namespace Mono.Linker.Tests.Cases.Symbols.Dependencies
+{
+	public class LibraryWithEmbeddedPdbSymbols
+	{
 		public static void SomeMethod ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithMdb/LibraryWithMdb.cs b/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithMdb/LibraryWithMdb.cs
index efb2d5481..5712f5ce7 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithMdb/LibraryWithMdb.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithMdb/LibraryWithMdb.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.Symbols.Dependencies {
-	public class LibraryWithMdb {
+namespace Mono.Linker.Tests.Cases.Symbols.Dependencies
+{
+	public class LibraryWithMdb
+	{
 		public static void SomeMethod ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithPdb/LibraryWithPdb.cs b/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithPdb/LibraryWithPdb.cs
index 339c836fe..4584818e7 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithPdb/LibraryWithPdb.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithPdb/LibraryWithPdb.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.Symbols.Dependencies {
-	public class LibraryWithPdb {
+namespace Mono.Linker.Tests.Cases.Symbols.Dependencies
+{
+	public class LibraryWithPdb
+	{
 		public static void SomeMethod ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithPortablePdbSymbols.cs b/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithPortablePdbSymbols.cs
index 0c574f554..39ee56304 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithPortablePdbSymbols.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/Dependencies/LibraryWithPortablePdbSymbols.cs
@@ -1,7 +1,9 @@
 using System;
 
-namespace Mono.Linker.Tests.Cases.Symbols.Dependencies {
-	public class LibraryWithPortablePdbSymbols {
+namespace Mono.Linker.Tests.Cases.Symbols.Dependencies
+{
+	public class LibraryWithPortablePdbSymbols
+	{
 		public static void SomeMethod ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdb.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdb.cs
index d79b85df3..8eb4836ce 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdb.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdb.cs
@@ -3,7 +3,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileBefore ("LibraryWithEmbeddedPdbSymbols.dll", new[] { "Dependencies/LibraryWithEmbeddedPdbSymbols.cs" }, additionalArguments: "/debug:embedded", compilerToUse: "csc")]
 	[SetupLinkerLinkSymbols ("false")]
 
@@ -11,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 
 	[KeptMemberInAssembly ("LibraryWithEmbeddedPdbSymbols.dll", typeof (LibraryWithEmbeddedPdbSymbols), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithEmbeddedPdbSymbols.dll", typeof (LibraryWithEmbeddedPdbSymbols), "NotUsed()")]
-	class ReferenceWithEmbeddedPdb {
+	class ReferenceWithEmbeddedPdb
+	{
 		static void Main ()
 		{
 			LibraryWithEmbeddedPdbSymbols.SomeMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbAndSymbolLinkingEnabled.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbAndSymbolLinkingEnabled.cs
index e99e5701b..1265d927e 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbAndSymbolLinkingEnabled.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbAndSymbolLinkingEnabled.cs
@@ -3,7 +3,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileBefore ("LibraryWithEmbeddedPdbSymbols.dll", new[] { "Dependencies/LibraryWithEmbeddedPdbSymbols.cs" }, additionalArguments: "/debug:embedded", compilerToUse: "csc")]
 	[SetupLinkerLinkSymbols ("true")]
 
@@ -11,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 
 	[KeptMemberInAssembly ("LibraryWithEmbeddedPdbSymbols.dll", typeof (LibraryWithEmbeddedPdbSymbols), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithEmbeddedPdbSymbols.dll", typeof (LibraryWithEmbeddedPdbSymbols), "NotUsed()")]
-	class ReferenceWithEmbeddedPdbAndSymbolLinkingEnabled {
+	class ReferenceWithEmbeddedPdbAndSymbolLinkingEnabled
+	{
 		static void Main ()
 		{
 			LibraryWithEmbeddedPdbSymbols.SomeMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbAndSymbolLinkingEnabledAndDeterministicMvid.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbAndSymbolLinkingEnabledAndDeterministicMvid.cs
index b8beb1abc..228c31fe0 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbAndSymbolLinkingEnabledAndDeterministicMvid.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbAndSymbolLinkingEnabledAndDeterministicMvid.cs
@@ -2,7 +2,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileBefore ("LibraryWithEmbeddedPdbSymbols.dll", new[] { "Dependencies/LibraryWithEmbeddedPdbSymbols.cs" }, additionalArguments: "/debug:embedded", compilerToUse: "csc")]
 	[SetupLinkerLinkSymbols ("true")]
 	[SetupLinkerArgument ("--deterministic")]
@@ -11,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 
 	[KeptMemberInAssembly ("LibraryWithEmbeddedPdbSymbols.dll", typeof (LibraryWithEmbeddedPdbSymbols), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithEmbeddedPdbSymbols.dll", typeof (LibraryWithEmbeddedPdbSymbols), "NotUsed()")]
-	public class ReferenceWithEmbeddedPdbAndSymbolLinkingEnabledAndDeterministicMvid {
+	public class ReferenceWithEmbeddedPdbAndSymbolLinkingEnabledAndDeterministicMvid
+	{
 		static void Main ()
 		{
 			LibraryWithEmbeddedPdbSymbols.SomeMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbAndSymbolLinkingEnabledAndNewMvid.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbAndSymbolLinkingEnabledAndNewMvid.cs
index 17381c954..772ee3635 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbAndSymbolLinkingEnabledAndNewMvid.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbAndSymbolLinkingEnabledAndNewMvid.cs
@@ -2,7 +2,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileBefore ("LibraryWithEmbeddedPdbSymbols.dll", new[] { "Dependencies/LibraryWithEmbeddedPdbSymbols.cs" }, additionalArguments: "/debug:embedded", compilerToUse: "csc")]
 	[SetupLinkerLinkSymbols ("true")]
 	[SetupLinkerArgument ("--deterministic")]
@@ -11,7 +12,8 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 
 	[KeptMemberInAssembly ("LibraryWithEmbeddedPdbSymbols.dll", typeof (LibraryWithEmbeddedPdbSymbols), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithEmbeddedPdbSymbols.dll", typeof (LibraryWithEmbeddedPdbSymbols), "NotUsed()")]
-	public class ReferenceWithEmbeddedPdbAndSymbolLinkingEnabledAndNewMvid {
+	public class ReferenceWithEmbeddedPdbAndSymbolLinkingEnabledAndNewMvid
+	{
 		static void Main ()
 		{
 			LibraryWithEmbeddedPdbSymbols.SomeMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbCopyAction.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbCopyAction.cs
index d58ef3041..15ee534aa 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbCopyAction.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbCopyAction.cs
@@ -2,17 +2,19 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileBefore ("LibraryWithEmbeddedPdbSymbols.dll", new[] { "Dependencies/LibraryWithEmbeddedPdbSymbols.cs" }, additionalArguments: "/debug:embedded", compilerToUse: "csc")]
 	[SetupLinkerLinkSymbols ("false")]
 	[SetupLinkerAction ("copy", "LibraryWithEmbeddedPdbSymbols")]
 
 	[RemovedSymbols ("LibraryWithEmbeddedPdbSymbols.dll")]
-	
+
 	// Copying with symbol linking off is a little more complex for embedded pdbs.
 	// Do a little extra asserting here to make sure the assembly wasn't accidentally linked
 	[KeptMemberInAssembly ("LibraryWithEmbeddedPdbSymbols.dll", typeof (LibraryWithEmbeddedPdbSymbols), "NotUsed()")]
-	public class ReferenceWithEmbeddedPdbCopyAction {
+	public class ReferenceWithEmbeddedPdbCopyAction
+	{
 		static void Main ()
 		{
 			LibraryWithEmbeddedPdbSymbols.SomeMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbCopyActionAndSymbolLinkingEnabled.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbCopyActionAndSymbolLinkingEnabled.cs
index ca173f827..5e2022746 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbCopyActionAndSymbolLinkingEnabled.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbCopyActionAndSymbolLinkingEnabled.cs
@@ -2,13 +2,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileBefore ("LibraryWithEmbeddedPdbSymbols.dll", new[] { "Dependencies/LibraryWithEmbeddedPdbSymbols.cs" }, additionalArguments: "/debug:embedded", compilerToUse: "csc")]
 	[SetupLinkerLinkSymbols ("true")]
 	[SetupLinkerAction ("copy", "LibraryWithEmbeddedPdbSymbols")]
 
 	[KeptSymbols ("LibraryWithEmbeddedPdbSymbols.dll")]
-	public class ReferenceWithEmbeddedPdbCopyActionAndSymbolLinkingEnabled {
+	public class ReferenceWithEmbeddedPdbCopyActionAndSymbolLinkingEnabled
+	{
 		static void Main ()
 		{
 			LibraryWithEmbeddedPdbSymbols.SomeMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbDeleteAction.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbDeleteAction.cs
index ecbe6aa89..a1facb303 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbDeleteAction.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbDeleteAction.cs
@@ -2,13 +2,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileBefore ("LibraryWithEmbeddedPdbSymbols.dll", new[] { "Dependencies/LibraryWithEmbeddedPdbSymbols.cs" }, additionalArguments: "/debug:embedded", compilerToUse: "csc")]
 	[SetupLinkerLinkSymbols ("false")]
 
 	[RemovedAssembly ("LibraryWithEmbeddedPdbSymbols.dll")]
 	[RemovedSymbols ("LibraryWithEmbeddedPdbSymbols.dll")]
-	public class ReferenceWithEmbeddedPdbDeleteAction {
+	public class ReferenceWithEmbeddedPdbDeleteAction
+	{
 		static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbDeleteActionAndSymbolLinkingEnabled.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbDeleteActionAndSymbolLinkingEnabled.cs
index d31e0753f..57ae72a72 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbDeleteActionAndSymbolLinkingEnabled.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithEmbeddedPdbDeleteActionAndSymbolLinkingEnabled.cs
@@ -2,13 +2,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileBefore ("LibraryWithEmbeddedPdbSymbols.dll", new[] { "Dependencies/LibraryWithEmbeddedPdbSymbols.cs" }, additionalArguments: "/debug:embedded", compilerToUse: "csc")]
 	[SetupLinkerLinkSymbols ("true")]
 
 	[RemovedAssembly ("LibraryWithEmbeddedPdbSymbols.dll")]
 	[RemovedSymbols ("LibraryWithEmbeddedPdbSymbols.dll")]
-	public class ReferenceWithEmbeddedPdbDeleteActionAndSymbolLinkingEnabled {
+	public class ReferenceWithEmbeddedPdbDeleteActionAndSymbolLinkingEnabled
+	{
 		static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdb.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdb.cs
index 657317dda..fe2255de2 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdb.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdb.cs
@@ -3,7 +3,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[Reference ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll.mdb")]
 	[SetupLinkerLinkSymbols ("false")]
@@ -12,8 +13,9 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 
 	[KeptMemberInAssembly ("LibraryWithMdb.dll", typeof (LibraryWithMdb), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithMdb.dll", typeof (LibraryWithMdb), "NotUsed()")]
-	public class ReferenceWithMdb {
-		static void Main()
+	public class ReferenceWithMdb
+	{
+		static void Main ()
 		{
 			// Use some stuff so that we can verify that the linker output correct results
 			SomeMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbAndSymbolLinkingEnabled.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbAndSymbolLinkingEnabled.cs
index a30a2d1d9..ae5a3f3b9 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbAndSymbolLinkingEnabled.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbAndSymbolLinkingEnabled.cs
@@ -5,7 +5,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[Reference ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll.mdb")]
 	[SetupLinkerLinkSymbols ("true")]
@@ -14,7 +15,8 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 
 	[KeptMemberInAssembly ("LibraryWithMdb.dll", typeof (LibraryWithMdb), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithMdb.dll", typeof (LibraryWithMdb), "NotUsed()")]
-	public class ReferenceWithMdbAndSymbolLinkingEnabled {
+	public class ReferenceWithMdbAndSymbolLinkingEnabled
+	{
 		static void Main ()
 		{
 			// Use some stuff so that we can verify that the linker output correct results
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbAndSymbolLinkingEnabledAndDeterministicMvid.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbAndSymbolLinkingEnabledAndDeterministicMvid.cs
index e304375b0..b1503ae52 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbAndSymbolLinkingEnabledAndDeterministicMvid.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbAndSymbolLinkingEnabledAndDeterministicMvid.cs
@@ -2,7 +2,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[IgnoreTestCase ("Requires cecil updated with fix for https://github.com/jbevain/cecil/issues/583")]
 	[Reference ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll.mdb")]
@@ -13,7 +14,8 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 
 	[KeptMemberInAssembly ("LibraryWithMdb.dll", typeof (LibraryWithMdb), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithMdb.dll", typeof (LibraryWithMdb), "NotUsed()")]
-	public class ReferenceWithMdbAndSymbolLinkingEnabledAndDeterministicMvid {
+	public class ReferenceWithMdbAndSymbolLinkingEnabledAndDeterministicMvid
+	{
 		static void Main ()
 		{
 			// Use some stuff so that we can verify that the linker output correct results
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbAndSymbolLinkingEnabledAndNewMvid.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbAndSymbolLinkingEnabledAndNewMvid.cs
index 3e124c012..e90df9201 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbAndSymbolLinkingEnabledAndNewMvid.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbAndSymbolLinkingEnabledAndNewMvid.cs
@@ -4,7 +4,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[Reference ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll.mdb")]
 	[SetupLinkerLinkSymbols ("true")]
@@ -14,7 +15,8 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 
 	[KeptMemberInAssembly ("LibraryWithMdb.dll", typeof (LibraryWithMdb), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithMdb.dll", typeof (LibraryWithMdb), "NotUsed()")]
-	public class ReferenceWithMdbAndSymbolLinkingEnabledAndNewMvid {
+	public class ReferenceWithMdbAndSymbolLinkingEnabledAndNewMvid
+	{
 		static void Main ()
 		{
 			// Use some stuff so that we can verify that the linker output correct results
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbCopyAction.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbCopyAction.cs
index 9be79875e..7ca36cb2a 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbCopyAction.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbCopyAction.cs
@@ -2,14 +2,16 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[Reference ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll.mdb")]
 	[SetupLinkerLinkSymbols ("false")]
 	[SetupLinkerAction ("copy", "LibraryWithMdb")]
 
 	[RemovedSymbols ("LibraryWithMdb.dll")]
-	public class ReferenceWithMdbCopyAction {
+	public class ReferenceWithMdbCopyAction
+	{
 		static void Main ()
 		{
 			LibraryWithMdb.SomeMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbCopyActionAndSymbolLinkingEnabled.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbCopyActionAndSymbolLinkingEnabled.cs
index 766da8771..11a0b5e34 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbCopyActionAndSymbolLinkingEnabled.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbCopyActionAndSymbolLinkingEnabled.cs
@@ -4,14 +4,16 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[Reference ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll.mdb")]
 	[SetupLinkerLinkSymbols ("true")]
 	[SetupLinkerAction ("copy", "LibraryWithMdb")]
 
 	[KeptSymbols ("LibraryWithMdb.dll")]
-	public class ReferenceWithMdbCopyActionAndSymbolLinkingEnabled {
+	public class ReferenceWithMdbCopyActionAndSymbolLinkingEnabled
+	{
 		static void Main ()
 		{
 			LibraryWithMdb.SomeMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbDeleteAction.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbDeleteAction.cs
index 7b8ce67d7..16d4f799e 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbDeleteAction.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbDeleteAction.cs
@@ -2,14 +2,16 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[Reference ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll.mdb")]
 	[SetupLinkerLinkSymbols ("false")]
 
 	[RemovedAssembly ("LibraryWithMdb.dll")]
 	[RemovedSymbols ("LibraryWithMdb.dll")]
-	public class ReferenceWithMdbDeleteAction {
+	public class ReferenceWithMdbDeleteAction
+	{
 		static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbDeleteActionAndSymbolLinkingEnabled.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbDeleteActionAndSymbolLinkingEnabled.cs
index 1f32f61ef..34f9be8b1 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbDeleteActionAndSymbolLinkingEnabled.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithMdbDeleteActionAndSymbolLinkingEnabled.cs
@@ -2,14 +2,16 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[Reference ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll.mdb")]
 	[SetupLinkerLinkSymbols ("true")]
 
 	[RemovedAssembly ("LibraryWithMdb.dll")]
 	[RemovedSymbols ("LibraryWithMdb.dll")]
-	public class ReferenceWithMdbDeleteActionAndSymbolLinkingEnabled {
+	public class ReferenceWithMdbDeleteActionAndSymbolLinkingEnabled
+	{
 		static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdb.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdb.cs
index fd51cdb07..6ec054dcd 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdb.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdb.cs
@@ -2,7 +2,8 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[Reference ("Dependencies/LibraryWithPdb/LibraryWithPdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithPdb/LibraryWithPdb.pdb")]
 	[SetupLinkerLinkSymbols ("false")]
@@ -10,8 +11,9 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 	[RemovedSymbols ("LibraryWithPdb.dll")]
 
 	[KeptMemberInAssembly ("LibraryWithPdb.dll", typeof (LibraryWithPdb), "SomeMethod()")]
-	[RemovedMemberInAssembly ("LibraryWithPdb.dll",typeof (LibraryWithPdb), "NotUsed()")]
-	public class ReferenceWithPdb {
+	[RemovedMemberInAssembly ("LibraryWithPdb.dll", typeof (LibraryWithPdb), "NotUsed()")]
+	public class ReferenceWithPdb
+	{
 		static void Main ()
 		{
 			// Use some stuff so that we can verify that the linker output correct results
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbAndSymbolLinkingEnabled.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbAndSymbolLinkingEnabled.cs
index 1749b2e69..d7f9ff889 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbAndSymbolLinkingEnabled.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbAndSymbolLinkingEnabled.cs
@@ -3,10 +3,11 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[Reference ("Dependencies/LibraryWithPdb/LibraryWithPdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithPdb/LibraryWithPdb.pdb")]
-	[SetupLinkerLinkSymbols( "true")]
+	[SetupLinkerLinkSymbols ("true")]
 
 #if WIN32
 	[KeptSymbols ("LibraryWithPdb.dll")]
@@ -15,11 +16,12 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 #endif
 	[KeptMemberInAssembly ("LibraryWithPdb.dll", typeof (LibraryWithPdb), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithPdb.dll", typeof (LibraryWithPdb), "NotUsed()")]
-	class ReferenceWithPdbAndSymbolLinkingEnabled {
+	class ReferenceWithPdbAndSymbolLinkingEnabled
+	{
 		static void Main ()
 		{
 			// Use some stuff so that we can verify that the linker output correct results
-			SomeMethod();
+			SomeMethod ();
 			LibraryWithPdb.SomeMethod ();
 		}
 
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbAndSymbolLinkingEnabledAndDeterministicMvid.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbAndSymbolLinkingEnabledAndDeterministicMvid.cs
index 32f7fb568..bfaf6f9fe 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbAndSymbolLinkingEnabledAndDeterministicMvid.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbAndSymbolLinkingEnabledAndDeterministicMvid.cs
@@ -2,10 +2,11 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[Reference ("Dependencies/LibraryWithPdb/LibraryWithPdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithPdb/LibraryWithPdb.pdb")]
-	[SetupLinkerLinkSymbols( "true")]
+	[SetupLinkerLinkSymbols ("true")]
 	[SetupLinkerArgument ("--deterministic")]
 
 #if WIN32
@@ -15,11 +16,12 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 #endif
 	[KeptMemberInAssembly ("LibraryWithPdb.dll", typeof (LibraryWithPdb), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithPdb.dll", typeof (LibraryWithPdb), "NotUsed()")]
-	public class ReferenceWithPdbAndSymbolLinkingEnabledAndDeterministicMvid {
+	public class ReferenceWithPdbAndSymbolLinkingEnabledAndDeterministicMvid
+	{
 		static void Main ()
 		{
 			// Use some stuff so that we can verify that the linker output correct results
-			SomeMethod();
+			SomeMethod ();
 			LibraryWithPdb.SomeMethod ();
 		}
 
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbAndSymbolLinkingEnabledAndNewMvid.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbAndSymbolLinkingEnabledAndNewMvid.cs
index eda780122..dc26e804c 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbAndSymbolLinkingEnabledAndNewMvid.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbAndSymbolLinkingEnabledAndNewMvid.cs
@@ -2,10 +2,11 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[Reference ("Dependencies/LibraryWithPdb/LibraryWithPdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithPdb/LibraryWithPdb.pdb")]
-	[SetupLinkerLinkSymbols( "true")]
+	[SetupLinkerLinkSymbols ("true")]
 	[SetupLinkerArgument ("--new-mvid", "true")]
 
 #if WIN32
@@ -15,11 +16,12 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 #endif
 	[KeptMemberInAssembly ("LibraryWithPdb.dll", typeof (LibraryWithPdb), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithPdb.dll", typeof (LibraryWithPdb), "NotUsed()")]
-	public class ReferenceWithPdbAndSymbolLinkingEnabledAndNewMvid {
+	public class ReferenceWithPdbAndSymbolLinkingEnabledAndNewMvid
+	{
 		static void Main ()
 		{
 			// Use some stuff so that we can verify that the linker output correct results
-			SomeMethod();
+			SomeMethod ();
 			LibraryWithPdb.SomeMethod ();
 		}
 
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbCopyAction.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbCopyAction.cs
index 18e6c817a..b3cac848c 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbCopyAction.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbCopyAction.cs
@@ -2,14 +2,16 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[Reference ("Dependencies/LibraryWithPdb/LibraryWithPdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithPdb/LibraryWithPdb.pdb")]
 	[SetupLinkerLinkSymbols ("false")]
 	[SetupLinkerAction ("copy", "LibraryWithPdb")]
 
 	[RemovedSymbols ("LibraryWithPdb.dll")]
-	public class ReferenceWithPdbCopyAction {
+	public class ReferenceWithPdbCopyAction
+	{
 		static void Main ()
 		{
 			LibraryWithPdb.SomeMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbCopyActionAndSymbolLinkingEnabled.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbCopyActionAndSymbolLinkingEnabled.cs
index 28e62e1d5..e457b9952 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbCopyActionAndSymbolLinkingEnabled.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbCopyActionAndSymbolLinkingEnabled.cs
@@ -2,7 +2,8 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 #if NETCOREAPP && !WIN32
 	// .NET Core type forwarders cause the assembly action to be
 	// changed from "copy" to "save" (to remove references to removed
@@ -16,7 +17,8 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 	[SetupLinkerAction ("copy", "LibraryWithPdb")]
 
 	[KeptSymbols ("LibraryWithPdb.dll")]
-	public class ReferenceWithPdbCopyActionAndSymbolLinkingEnabled {
+	public class ReferenceWithPdbCopyActionAndSymbolLinkingEnabled
+	{
 		static void Main ()
 		{
 			LibraryWithPdb.SomeMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbDeleteAction.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbDeleteAction.cs
index 8f5e037f8..f691a7c6b 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbDeleteAction.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbDeleteAction.cs
@@ -2,14 +2,16 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[Reference ("Dependencies/LibraryWithPdb/LibraryWithPdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithPdb/LibraryWithPdb.pdb")]
 	[SetupLinkerLinkSymbols ("false")]
 
 	[RemovedAssembly ("LibraryWithPdb.dll")]
 	[RemovedSymbols ("LibraryWithPdb.dll")]
-	public class ReferenceWithPdbDeleteAction {
+	public class ReferenceWithPdbDeleteAction
+	{
 		static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbDeleteActionAndSymbolLinkingEnabled.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbDeleteActionAndSymbolLinkingEnabled.cs
index 44b3df38c..668ed239d 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbDeleteActionAndSymbolLinkingEnabled.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPdbDeleteActionAndSymbolLinkingEnabled.cs
@@ -2,14 +2,16 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[Reference ("Dependencies/LibraryWithPdb/LibraryWithPdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithPdb/LibraryWithPdb.pdb")]
 	[SetupLinkerLinkSymbols ("true")]
 
 	[RemovedAssembly ("LibraryWithPdb.dll")]
 	[RemovedSymbols ("LibraryWithPdb.dll")]
-	public class ReferenceWithPdbDeleteActionAndSymbolLinkingEnabled {
+	public class ReferenceWithPdbDeleteActionAndSymbolLinkingEnabled
+	{
 		static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdb.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdb.cs
index cb16c5dd1..7fa2733ad 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdb.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdb.cs
@@ -3,15 +3,17 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileBefore ("LibraryWithPortablePdbSymbols.dll", new[] { "Dependencies/LibraryWithPortablePdbSymbols.cs" }, additionalArguments: "/debug:portable", compilerToUse: "csc")]
 	[SetupLinkerLinkSymbols ("false")]
 
 	[RemovedSymbols ("LibraryWithPortablePdbSymbols.dll")]
 
-	[KeptMemberInAssembly("LibraryWithPortablePdbSymbols.dll", typeof (LibraryWithPortablePdbSymbols), "SomeMethod()")]
-	[RemovedMemberInAssembly("LibraryWithPortablePdbSymbols.dll", typeof (LibraryWithPortablePdbSymbols), "NotUsed()")]
-	class ReferenceWithPortablePdb {
+	[KeptMemberInAssembly ("LibraryWithPortablePdbSymbols.dll", typeof (LibraryWithPortablePdbSymbols), "SomeMethod()")]
+	[RemovedMemberInAssembly ("LibraryWithPortablePdbSymbols.dll", typeof (LibraryWithPortablePdbSymbols), "NotUsed()")]
+	class ReferenceWithPortablePdb
+	{
 		static void Main ()
 		{
 			LibraryWithPortablePdbSymbols.SomeMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbAndSymbolLinkingEnabled.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbAndSymbolLinkingEnabled.cs
index dd35d6abc..291ec6bdd 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbAndSymbolLinkingEnabled.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbAndSymbolLinkingEnabled.cs
@@ -3,7 +3,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileBefore ("LibraryWithPortablePdbSymbols.dll", new[] { "Dependencies/LibraryWithPortablePdbSymbols.cs" }, additionalArguments: "/debug:portable", compilerToUse: "csc")]
 	[SetupLinkerLinkSymbols ("true")]
 
@@ -11,8 +12,9 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 
 	[KeptMemberInAssembly ("LibraryWithPortablePdbSymbols.dll", typeof (LibraryWithPortablePdbSymbols), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithPortablePdbSymbols.dll", typeof (LibraryWithPortablePdbSymbols), "NotUsed()")]
-	class ReferenceWithPortablePdbAndSymbolLinkingEnabled {
-		static void Main()
+	class ReferenceWithPortablePdbAndSymbolLinkingEnabled
+	{
+		static void Main ()
 		{
 			LibraryWithPortablePdbSymbols.SomeMethod ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbAndSymbolLinkingEnabledAndDeterministicMvid.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbAndSymbolLinkingEnabledAndDeterministicMvid.cs
index 33e9cb8a6..25f9808eb 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbAndSymbolLinkingEnabledAndDeterministicMvid.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbAndSymbolLinkingEnabledAndDeterministicMvid.cs
@@ -2,7 +2,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[IgnoreTestCase ("Requires cecil updated with fix for https://github.com/jbevain/cecil/issues/583")]
 	[SetupCompileBefore ("LibraryWithPortablePdbSymbols.dll", new[] { "Dependencies/LibraryWithPortablePdbSymbols.cs" }, additionalArguments: "/debug:portable", compilerToUse: "csc")]
 	[SetupLinkerLinkSymbols ("true")]
@@ -12,8 +13,9 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 
 	[KeptMemberInAssembly ("LibraryWithPortablePdbSymbols.dll", typeof (LibraryWithPortablePdbSymbols), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithPortablePdbSymbols.dll", typeof (LibraryWithPortablePdbSymbols), "NotUsed()")]
-	public class ReferenceWithPortablePdbAndSymbolLinkingEnabledAndDeterministicMvid {
-		static void Main()
+	public class ReferenceWithPortablePdbAndSymbolLinkingEnabledAndDeterministicMvid
+	{
+		static void Main ()
 		{
 			LibraryWithPortablePdbSymbols.SomeMethod ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbAndSymbolLinkingEnabledAndNewMvid.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbAndSymbolLinkingEnabledAndNewMvid.cs
index 7245433f4..a63248b8a 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbAndSymbolLinkingEnabledAndNewMvid.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbAndSymbolLinkingEnabledAndNewMvid.cs
@@ -2,7 +2,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileBefore ("LibraryWithPortablePdbSymbols.dll", new[] { "Dependencies/LibraryWithPortablePdbSymbols.cs" }, additionalArguments: "/debug:portable", compilerToUse: "csc")]
 	[SetupLinkerLinkSymbols ("true")]
 	[SetupLinkerArgument ("--new-mvid", "true")]
@@ -11,8 +12,9 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 
 	[KeptMemberInAssembly ("LibraryWithPortablePdbSymbols.dll", typeof (LibraryWithPortablePdbSymbols), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithPortablePdbSymbols.dll", typeof (LibraryWithPortablePdbSymbols), "NotUsed()")]
-	public class ReferenceWithPortablePdbAndSymbolLinkingEnabledAndNewMvid {
-		static void Main()
+	public class ReferenceWithPortablePdbAndSymbolLinkingEnabledAndNewMvid
+	{
+		static void Main ()
 		{
 			LibraryWithPortablePdbSymbols.SomeMethod ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbCopyAction.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbCopyAction.cs
index 2f4e428f2..de06cb99d 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbCopyAction.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbCopyAction.cs
@@ -2,13 +2,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileBefore ("LibraryWithPortablePdbSymbols.dll", new[] { "Dependencies/LibraryWithPortablePdbSymbols.cs" }, additionalArguments: "/debug:portable", compilerToUse: "csc")]
 	[SetupLinkerLinkSymbols ("false")]
 	[SetupLinkerAction ("copy", "LibraryWithPortablePdbSymbols")]
 
 	[RemovedSymbols ("LibraryWithPortablePdbSymbols.dll")]
-	public class ReferenceWithPortablePdbCopyAction {
+	public class ReferenceWithPortablePdbCopyAction
+	{
 		static void Main ()
 		{
 			LibraryWithPortablePdbSymbols.SomeMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbCopyActionAndSymbolLinkingEnabled.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbCopyActionAndSymbolLinkingEnabled.cs
index 292ed8bc0..42813cc99 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbCopyActionAndSymbolLinkingEnabled.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbCopyActionAndSymbolLinkingEnabled.cs
@@ -2,13 +2,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileBefore ("LibraryWithPortablePdbSymbols.dll", new[] { "Dependencies/LibraryWithPortablePdbSymbols.cs" }, additionalArguments: "/debug:portable", compilerToUse: "csc")]
 	[SetupLinkerLinkSymbols ("true")]
 	[SetupLinkerAction ("copy", "LibraryWithPortablePdbSymbols")]
 
 	[KeptSymbols ("LibraryWithPortablePdbSymbols.dll")]
-	public class ReferenceWithPortablePdbCopyActionAndSymbolLinkingEnabled {
+	public class ReferenceWithPortablePdbCopyActionAndSymbolLinkingEnabled
+	{
 		static void Main ()
 		{
 			LibraryWithPortablePdbSymbols.SomeMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbDeleteAction.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbDeleteAction.cs
index f9382472f..0a278cdcc 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbDeleteAction.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbDeleteAction.cs
@@ -2,13 +2,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileBefore ("LibraryWithPortablePdbSymbols.dll", new[] { "Dependencies/LibraryWithPortablePdbSymbols.cs" }, additionalArguments: "/debug:portable", compilerToUse: "csc")]
 	[SetupLinkerLinkSymbols ("false")]
 
 	[RemovedAssembly ("LibraryWithPortablePdbSymbols.dll")]
 	[RemovedSymbols ("LibraryWithPortablePdbSymbols.dll")]
-	public class ReferenceWithPortablePdbDeleteAction {
+	public class ReferenceWithPortablePdbDeleteAction
+	{
 		static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbDeleteActionAndSymbolLinkingEnabled.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbDeleteActionAndSymbolLinkingEnabled.cs
index 3ec76815f..b6fd73fde 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbDeleteActionAndSymbolLinkingEnabled.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferenceWithPortablePdbDeleteActionAndSymbolLinkingEnabled.cs
@@ -2,13 +2,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[SetupCompileBefore ("LibraryWithPortablePdbSymbols.dll", new[] { "Dependencies/LibraryWithPortablePdbSymbols.cs" }, additionalArguments: "/debug:portable", compilerToUse: "csc")]
 	[SetupLinkerLinkSymbols ("true")]
 
 	[RemovedAssembly ("LibraryWithPortablePdbSymbols.dll")]
 	[RemovedSymbols ("LibraryWithPortablePdbSymbols.dll")]
-	public class ReferenceWithPortablePdbDeleteActionAndSymbolLinkingEnabled {
+	public class ReferenceWithPortablePdbDeleteActionAndSymbolLinkingEnabled
+	{
 		static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferencesWithMixedSymbolTypes.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferencesWithMixedSymbolTypes.cs
index d468407bd..8b16c99b9 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferencesWithMixedSymbolTypes.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferencesWithMixedSymbolTypes.cs
@@ -3,7 +3,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 	[Reference ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll.mdb")]
 
@@ -11,8 +12,8 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 	[ReferenceDependency ("Dependencies/LibraryWithPdb/LibraryWithPdb.pdb")]
 
 	[SetupCompileBefore ("LibraryWithCompilerDefaultSymbols.dll", new[] { "Dependencies/LibraryWithCompilerDefaultSymbols.cs" }, additionalArguments: "/debug:full")]
-	[SetupCompileBefore("LibraryWithPortablePdbSymbols.dll", new[] { "Dependencies/LibraryWithPortablePdbSymbols.cs" }, additionalArguments: "/debug:portable", compilerToUse: "csc")]
-	[SetupCompileBefore("LibraryWithEmbeddedPdbSymbols.dll", new[] { "Dependencies/LibraryWithEmbeddedPdbSymbols.cs" }, additionalArguments: "/debug:embedded", compilerToUse: "csc")]
+	[SetupCompileBefore ("LibraryWithPortablePdbSymbols.dll", new[] { "Dependencies/LibraryWithPortablePdbSymbols.cs" }, additionalArguments: "/debug:portable", compilerToUse: "csc")]
+	[SetupCompileBefore ("LibraryWithEmbeddedPdbSymbols.dll", new[] { "Dependencies/LibraryWithEmbeddedPdbSymbols.cs" }, additionalArguments: "/debug:embedded", compilerToUse: "csc")]
 
 	[SetupCompileArgument ("/debug:full")]
 	[SetupLinkerLinkSymbols ("false")]
@@ -34,13 +35,14 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 	[KeptMemberInAssembly ("LibraryWithCompilerDefaultSymbols.dll", typeof (LibraryWithCompilerDefaultSymbols), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithCompilerDefaultSymbols.dll", typeof (LibraryWithCompilerDefaultSymbols), "NotUsed()")]
 
-	[KeptMemberInAssembly ("LibraryWithEmbeddedPdbSymbols.dll", typeof(LibraryWithEmbeddedPdbSymbols), "SomeMethod()")]
-	[RemovedMemberInAssembly ("LibraryWithEmbeddedPdbSymbols.dll", typeof(LibraryWithEmbeddedPdbSymbols), "NotUsed()")]
+	[KeptMemberInAssembly ("LibraryWithEmbeddedPdbSymbols.dll", typeof (LibraryWithEmbeddedPdbSymbols), "SomeMethod()")]
+	[RemovedMemberInAssembly ("LibraryWithEmbeddedPdbSymbols.dll", typeof (LibraryWithEmbeddedPdbSymbols), "NotUsed()")]
 
 	[KeptMemberInAssembly ("LibraryWithPortablePdbSymbols.dll", typeof (LibraryWithPortablePdbSymbols), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithPortablePdbSymbols.dll", typeof (LibraryWithPortablePdbSymbols), "NotUsed()")]
-	public class ReferencesWithMixedSymbolTypes {
-		static void Main()
+	public class ReferencesWithMixedSymbolTypes
+	{
+		static void Main ()
 		{
 			// Use some stuff so that we can verify that the linker output correct results
 			SomeMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/Symbols/ReferencesWithMixedSymbolTypesAndSymbolLinkingEnabled.cs b/test/Mono.Linker.Tests.Cases/Symbols/ReferencesWithMixedSymbolTypesAndSymbolLinkingEnabled.cs
index f6deaf36e..09e39401a 100644
--- a/test/Mono.Linker.Tests.Cases/Symbols/ReferencesWithMixedSymbolTypesAndSymbolLinkingEnabled.cs
+++ b/test/Mono.Linker.Tests.Cases/Symbols/ReferencesWithMixedSymbolTypesAndSymbolLinkingEnabled.cs
@@ -3,7 +3,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.Symbols.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.Symbols {
+namespace Mono.Linker.Tests.Cases.Symbols
+{
 #if !NETCOREAPP
 	[Reference ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll")]
 	[ReferenceDependency ("Dependencies/LibraryWithMdb/LibraryWithMdb.dll.mdb")]
@@ -49,7 +50,8 @@ namespace Mono.Linker.Tests.Cases.Symbols {
 
 	[KeptMemberInAssembly ("LibraryWithPortablePdbSymbols.dll", typeof (LibraryWithPortablePdbSymbols), "SomeMethod()")]
 	[RemovedMemberInAssembly ("LibraryWithPortablePdbSymbols.dll", typeof (LibraryWithPortablePdbSymbols), "NotUsed()")]
-	public class ReferencesWithMixedSymbolTypesAndSymbolLinkingEnabled {
+	public class ReferencesWithMixedSymbolTypesAndSymbolLinkingEnabled
+	{
 		static void Main ()
 		{
 			// Use some stuff so that we can verify that the linker output correct results
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/CanCheckInitializersByIndex.cs b/test/Mono.Linker.Tests.Cases/TestFramework/CanCheckInitializersByIndex.cs
index 6f7747398..acf7ec886 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/CanCheckInitializersByIndex.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/CanCheckInitializersByIndex.cs
@@ -1,7 +1,9 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.TestFramework {
-	public class CanCheckInitializersByIndex {
+namespace Mono.Linker.Tests.Cases.TestFramework
+{
+	public class CanCheckInitializersByIndex
+	{
 		public static void Main ()
 		{
 			Method1 ();
@@ -14,20 +16,20 @@ namespace Mono.Linker.Tests.Cases.TestFramework {
 		[KeptInitializerData (2)]
 		static void Method1 ()
 		{
-			Helper (new [] {1, 2, 3});
-			Helper (new [] {1, 2, 3, 4});
-			Helper (new [] {3, 4, 5});
+			Helper (new[] { 1, 2, 3 });
+			Helper (new[] { 1, 2, 3, 4 });
+			Helper (new[] { 3, 4, 5 });
 		}
 
 		[Kept]
 		[KeptInitializerData (0)]
 		static void Method2 ()
 		{
-			Helper(new [] {10, 11, 12});
+			Helper (new[] { 10, 11, 12 });
 		}
 
 		[Kept]
-		static void Helper<T> (T [] arr)
+		static void Helper<T> (T[] arr)
 		{
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileILAssembly.cs b/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileILAssembly.cs
index 73388f592..a00328925 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileILAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileILAssembly.cs
@@ -2,9 +2,10 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.TestFramework {
+namespace Mono.Linker.Tests.Cases.TestFramework
+{
 	[Define ("IL_ASSEMBLY_AVAILABLE")]
-	[SetupCompileBefore ("ILAssembly.dll", new [] { "Dependencies/ILAssemblySample.il" })]
+	[SetupCompileBefore ("ILAssembly.dll", new[] { "Dependencies/ILAssemblySample.il" })]
 	[KeptMemberInAssembly ("ILAssembly.dll", "Mono.Linker.Tests.Cases.TestFramework.Dependencies.ILAssemblySample", "GiveMeAValue()")]
 	public class CanCompileILAssembly
 	{
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileReferencesUsingTypes.cs b/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileReferencesUsingTypes.cs
index 0bcddb212..f20876f4c 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileReferencesUsingTypes.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileReferencesUsingTypes.cs
@@ -1,9 +1,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.TestFramework.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.TestFramework {
-	[SetupCompileBefore ("library1.dll", new [] { typeof (CanCompileReferencesUsingTypes_LibSource1), typeof (CanCompileReferencesUsingTypes_LibSource2.Nested1.Nested2) })]
-	public class CanCompileReferencesUsingTypes {
+namespace Mono.Linker.Tests.Cases.TestFramework
+{
+	[SetupCompileBefore ("library1.dll", new[] { typeof (CanCompileReferencesUsingTypes_LibSource1), typeof (CanCompileReferencesUsingTypes_LibSource2.Nested1.Nested2) })]
+	public class CanCompileReferencesUsingTypes
+	{
 		public static void Main ()
 		{
 			// Only the compile before assembly types are used because we wouldn't have access to the after types
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileReferencesWithResources.cs b/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileReferencesWithResources.cs
index c55e96a98..b6bfba94a 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileReferencesWithResources.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileReferencesWithResources.cs
@@ -2,19 +2,21 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.TestFramework.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.TestFramework {
+namespace Mono.Linker.Tests.Cases.TestFramework
+{
 	[SetupCompileBefore ("library.dll",
-		new [] { "Dependencies/CanCompileReferencesWithResources_Lib1.cs" },
-		resources: new [] { "Dependencies/CanCompileReferencesWithResources_Lib1.txt" })]
-	
+		new[] { "Dependencies/CanCompileReferencesWithResources_Lib1.cs" },
+		resources: new[] { "Dependencies/CanCompileReferencesWithResources_Lib1.txt" })]
+
 	// Compile the same assembly again with another resource to get coverage on SetupCompileAfter
 	[SetupCompileAfter ("library.dll",
-		new [] { "Dependencies/CanCompileReferencesWithResources_Lib1.cs" },
-		resources: new [] { "Dependencies/CanCompileReferencesWithResources_Lib1.txt", "Dependencies/CanCompileReferencesWithResources_Lib1.log" })]
-	
+		new[] { "Dependencies/CanCompileReferencesWithResources_Lib1.cs" },
+		resources: new[] { "Dependencies/CanCompileReferencesWithResources_Lib1.txt", "Dependencies/CanCompileReferencesWithResources_Lib1.log" })]
+
 	[KeptResourceInAssembly ("library.dll", "CanCompileReferencesWithResources_Lib1.txt")]
 	[KeptResourceInAssembly ("library.dll", "CanCompileReferencesWithResources_Lib1.log")]
-	public class CanCompileReferencesWithResources {
+	public class CanCompileReferencesWithResources
+	{
 		public static void Main ()
 		{
 			// Use something so that reference isn't removed at compile time
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileReferencesWithResourcesWithCsc.cs b/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileReferencesWithResourcesWithCsc.cs
index 75e85d8b7..62431c05b 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileReferencesWithResourcesWithCsc.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileReferencesWithResourcesWithCsc.cs
@@ -2,21 +2,23 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.TestFramework.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.TestFramework {
+namespace Mono.Linker.Tests.Cases.TestFramework
+{
 	[SetupCompileBefore ("library.dll",
-		new [] { "Dependencies/CanCompileReferencesWithResources_Lib1.cs" },
-		resources: new [] { "Dependencies/CanCompileReferencesWithResources_Lib1.txt" },
+		new[] { "Dependencies/CanCompileReferencesWithResources_Lib1.cs" },
+		resources: new[] { "Dependencies/CanCompileReferencesWithResources_Lib1.txt" },
 		compilerToUse: "csc")]
-	
+
 	// Compile the same assembly again with another resource to get coverage on SetupCompileAfter
 	[SetupCompileAfter ("library.dll",
-		new [] { "Dependencies/CanCompileReferencesWithResources_Lib1.cs" },
-		resources: new [] { "Dependencies/CanCompileReferencesWithResources_Lib1.txt", "Dependencies/CanCompileReferencesWithResources_Lib1.log" },
+		new[] { "Dependencies/CanCompileReferencesWithResources_Lib1.cs" },
+		resources: new[] { "Dependencies/CanCompileReferencesWithResources_Lib1.txt", "Dependencies/CanCompileReferencesWithResources_Lib1.log" },
 		compilerToUse: "csc")]
-	
+
 	[KeptResourceInAssembly ("library.dll", "CanCompileReferencesWithResources_Lib1.txt")]
 	[KeptResourceInAssembly ("library.dll", "CanCompileReferencesWithResources_Lib1.log")]
-	public class CanCompileReferencesWithResourcesWithCsc {
+	public class CanCompileReferencesWithResourcesWithCsc
+	{
 		public static void Main ()
 		{
 			// Use something so that reference isn't removed at compile time
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileReferencesWithResourcesWithMcs.cs b/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileReferencesWithResourcesWithMcs.cs
index 1190c7604..4b6a828d0 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileReferencesWithResourcesWithMcs.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileReferencesWithResourcesWithMcs.cs
@@ -2,24 +2,26 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.TestFramework.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.TestFramework {
+namespace Mono.Linker.Tests.Cases.TestFramework
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("Don't try to compile with mcs on .NET Core")]
 #endif
 	[SetupCompileBefore ("library.dll",
-		new [] { "Dependencies/CanCompileReferencesWithResources_Lib1.cs" },
-		resources: new [] { "Dependencies/CanCompileReferencesWithResources_Lib1.txt" },
+		new[] { "Dependencies/CanCompileReferencesWithResources_Lib1.cs" },
+		resources: new[] { "Dependencies/CanCompileReferencesWithResources_Lib1.txt" },
 		compilerToUse: "mcs")]
-	
+
 	// Compile the same assembly again with another resource to get coverage on SetupCompileAfter
 	[SetupCompileAfter ("library.dll",
-		new [] { "Dependencies/CanCompileReferencesWithResources_Lib1.cs" },
-		resources: new [] { "Dependencies/CanCompileReferencesWithResources_Lib1.txt", "Dependencies/CanCompileReferencesWithResources_Lib1.log" },
+		new[] { "Dependencies/CanCompileReferencesWithResources_Lib1.cs" },
+		resources: new[] { "Dependencies/CanCompileReferencesWithResources_Lib1.txt", "Dependencies/CanCompileReferencesWithResources_Lib1.log" },
 		compilerToUse: "mcs")]
-	
+
 	[KeptResourceInAssembly ("library.dll", "CanCompileReferencesWithResources_Lib1.txt")]
 	[KeptResourceInAssembly ("library.dll", "CanCompileReferencesWithResources_Lib1.log")]
-	public class CanCompileReferencesWithResourcesWithMcs {
+	public class CanCompileReferencesWithResourcesWithMcs
+	{
 		public static void Main ()
 		{
 			// Use something so that reference isn't removed at compile time
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileTestCaseWithCsc.cs b/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileTestCaseWithCsc.cs
index a2d94d87b..823e114a9 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileTestCaseWithCsc.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileTestCaseWithCsc.cs
@@ -3,7 +3,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.TestFramework.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.TestFramework {
+namespace Mono.Linker.Tests.Cases.TestFramework
+{
 	[SetupCSharpCompilerToUse ("csc")]
 
 	// Use all of the compiler setup attributes so that we can verify they all work
@@ -13,11 +14,12 @@ namespace Mono.Linker.Tests.Cases.TestFramework {
 	[Define ("VERIFY_DEFINE_WORKS")]
 	[Reference ("System.dll")]
 
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/CanCompileTestCaseWithCsc_Lib.cs" }, compilerToUse: "csc")]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/CanCompileTestCaseWithCsc_Lib.cs" }, compilerToUse: "csc")]
 
 	[KeptResource ("CanCompileTestCaseWithCsc.txt")]
 	[KeptMemberInAssembly ("library.dll", typeof (CanCompileTestCaseWithCsc_Lib), "Used()")]
-	class CanCompileTestCaseWithCsc {
+	class CanCompileTestCaseWithCsc
+	{
 		static void Main ()
 		{
 #if VERIFY_DEFINE_WORKS
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileTestCaseWithDebugPdbs.cs b/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileTestCaseWithDebugPdbs.cs
index 557ca5466..b07ae4db2 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileTestCaseWithDebugPdbs.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileTestCaseWithDebugPdbs.cs
@@ -2,9 +2,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.TestFramework {
+namespace Mono.Linker.Tests.Cases.TestFramework
+{
 	[SetupCompileArgument ("/debug:pdbonly")]
-	class CanCompileTestCaseWithDebugPdbs {
+	class CanCompileTestCaseWithDebugPdbs
+	{
 		static void Main ()
 		{
 			new Foo ().Method ();
@@ -12,7 +14,8 @@ namespace Mono.Linker.Tests.Cases.TestFramework {
 
 		[Kept]
 		[KeptMember (".ctor()")]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			public void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileTestCaseWithMcs.cs b/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileTestCaseWithMcs.cs
index cad804398..b7986d035 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileTestCaseWithMcs.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/CanCompileTestCaseWithMcs.cs
@@ -3,7 +3,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.TestFramework.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.TestFramework {
+namespace Mono.Linker.Tests.Cases.TestFramework
+{
 #if NETCOREAPP
 	[IgnoreTestCase ("Don't try to compile with mcs on .NET Core.")]
 #endif
@@ -20,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.TestFramework {
 
 	[KeptResource ("CanCompileTestCaseWithMcs.txt")]
 	[KeptMemberInAssembly ("library.dll", typeof (CanCompileTestCaseWithMcs_Lib), "Used()")]
-	class CanCompileTestCaseWithMcs {
+	class CanCompileTestCaseWithMcs
+	{
 		static void Main ()
 		{
 #if VERIFY_DEFINE_WORKS
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/CanSandboxDependenciesUsingType.cs b/test/Mono.Linker.Tests.Cases/TestFramework/CanSandboxDependenciesUsingType.cs
index baa322be1..8c9c96b55 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/CanSandboxDependenciesUsingType.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/CanSandboxDependenciesUsingType.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.TestFramework.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.TestFramework {
+namespace Mono.Linker.Tests.Cases.TestFramework
+{
 	[SandboxDependency (typeof (CanSandboxDependenciesUsingType_Source1))]
 	[SandboxDependency (typeof (CanSandboxDependenciesUsingType_Source2.Nested1.Nested2), "NameChanged.cs")]
-	public class CanSandboxDependenciesUsingType {
+	public class CanSandboxDependenciesUsingType
+	{
 		public static void Main ()
 		{
 			CanSandboxDependenciesUsingType_Source1.Method ();
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/CanVerifyInterfacesOnTypesInAssembly.cs b/test/Mono.Linker.Tests.Cases/TestFramework/CanVerifyInterfacesOnTypesInAssembly.cs
index 964d5e779..33410aaa7 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/CanVerifyInterfacesOnTypesInAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/CanVerifyInterfacesOnTypesInAssembly.cs
@@ -2,11 +2,13 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.TestFramework.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.TestFramework {
-	[SetupCompileBefore ("library.dll", new [] {"Dependencies/CanVerifyInterfacesOnTypesInAssembly_Lib.cs"})]
+namespace Mono.Linker.Tests.Cases.TestFramework
+{
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/CanVerifyInterfacesOnTypesInAssembly_Lib.cs" })]
 	[KeptInterfaceOnTypeInAssembly ("library", typeof (CanVerifyInterfacesOnTypesInAssembly_Lib.A), "library", typeof (CanVerifyInterfacesOnTypesInAssembly_Lib.IFoo))]
 	[RemovedInterfaceOnTypeInAssembly ("library", typeof (CanVerifyInterfacesOnTypesInAssembly_Lib.A), "library", typeof (CanVerifyInterfacesOnTypesInAssembly_Lib.IBar))]
-	public class CanVerifyInterfacesOnTypesInAssembly {
+	public class CanVerifyInterfacesOnTypesInAssembly
+	{
 		public static void Main ()
 		{
 			CanVerifyInterfacesOnTypesInAssembly_Lib.IFoo a = new CanVerifyInterfacesOnTypesInAssembly_Lib.A ();
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileReferencesUsingTypes_LibSource1.cs b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileReferencesUsingTypes_LibSource1.cs
index 01e15ec32..3375f7ec7 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileReferencesUsingTypes_LibSource1.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileReferencesUsingTypes_LibSource1.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies {
-	public class CanCompileReferencesUsingTypes_LibSource1 {
+namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies
+{
+	public class CanCompileReferencesUsingTypes_LibSource1
+	{
 		public static void MethodFromParentType ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileReferencesUsingTypes_LibSource2.cs b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileReferencesUsingTypes_LibSource2.cs
index b9c983b77..6c339f8d2 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileReferencesUsingTypes_LibSource2.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileReferencesUsingTypes_LibSource2.cs
@@ -1,7 +1,11 @@
-namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies {
-	public class CanCompileReferencesUsingTypes_LibSource2 {
-		public class Nested1 {
-			public class Nested2 {
+namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies
+{
+	public class CanCompileReferencesUsingTypes_LibSource2
+	{
+		public class Nested1
+		{
+			public class Nested2
+			{
 				public static void MethodFromNestedNested ()
 				{
 				}
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileReferencesWithResources_Lib1.cs b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileReferencesWithResources_Lib1.cs
index 358cd3c42..e4e1aaa0b 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileReferencesWithResources_Lib1.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileReferencesWithResources_Lib1.cs
@@ -1,5 +1,7 @@
-namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies {
-	public class CanCompileReferencesWithResources_Lib1 {
+namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies
+{
+	public class CanCompileReferencesWithResources_Lib1
+	{
 		public static void Used ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileTestCaseWithCsc_Lib.cs b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileTestCaseWithCsc_Lib.cs
index 120b2d367..8cd7344ad 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileTestCaseWithCsc_Lib.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileTestCaseWithCsc_Lib.cs
@@ -1,7 +1,9 @@
 using System;
 
-namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies {
-	public class CanCompileTestCaseWithCsc_Lib {
+namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies
+{
+	public class CanCompileTestCaseWithCsc_Lib
+	{
 		public static void Used ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileTestCaseWithMcs_Lib.cs b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileTestCaseWithMcs_Lib.cs
index 09b05174c..7c2cdf753 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileTestCaseWithMcs_Lib.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanCompileTestCaseWithMcs_Lib.cs
@@ -1,7 +1,9 @@
 using System;
 
-namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies {
-	public class CanCompileTestCaseWithMcs_Lib {
+namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies
+{
+	public class CanCompileTestCaseWithMcs_Lib
+	{
 		public static void Used ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanSandboxDependenciesUsingType_Source1.cs b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanSandboxDependenciesUsingType_Source1.cs
index ada073096..78c705522 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanSandboxDependenciesUsingType_Source1.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanSandboxDependenciesUsingType_Source1.cs
@@ -1,8 +1,10 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies {
+namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies
+{
 	[Kept]
-	public class CanSandboxDependenciesUsingType_Source1 {
+	public class CanSandboxDependenciesUsingType_Source1
+	{
 		[Kept]
 		public static void Method ()
 		{
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanSandboxDependenciesUsingType_Source2.cs b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanSandboxDependenciesUsingType_Source2.cs
index 2a730074f..d5ed716e0 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanSandboxDependenciesUsingType_Source2.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanSandboxDependenciesUsingType_Source2.cs
@@ -1,12 +1,16 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
-namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies {
+namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies
+{
 	[Kept]
-	public class CanSandboxDependenciesUsingType_Source2 {
+	public class CanSandboxDependenciesUsingType_Source2
+	{
 		[Kept]
-		public class Nested1 {
+		public class Nested1
+		{
 			[Kept]
-			public class Nested2 {
+			public class Nested2
+			{
 				[Kept]
 				public static void Method ()
 				{
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanVerifyInterfacesOnTypesInAssembly_Lib.cs b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanVerifyInterfacesOnTypesInAssembly_Lib.cs
index 06aa2f050..c035df10b 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanVerifyInterfacesOnTypesInAssembly_Lib.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/CanVerifyInterfacesOnTypesInAssembly_Lib.cs
@@ -1,13 +1,18 @@
-namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies {
-	public class CanVerifyInterfacesOnTypesInAssembly_Lib {
-		public interface IFoo {
+namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies
+{
+	public class CanVerifyInterfacesOnTypesInAssembly_Lib
+	{
+		public interface IFoo
+		{
 			void Foo ();
 		}
-		public interface IBar {
+		public interface IBar
+		{
 			void Bar ();
 		}
 
-		public class A : IFoo, IBar {
+		public class A : IFoo, IBar
+		{
 			public void Foo ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/VerifyAttributesInAssemblyWorks_Base.cs b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/VerifyAttributesInAssemblyWorks_Base.cs
index 92eb9ef8a..eca6b41b8 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/VerifyAttributesInAssemblyWorks_Base.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/VerifyAttributesInAssemblyWorks_Base.cs
@@ -1,11 +1,15 @@
 using System;
 
-namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies {
-	public class VerifyAttributesInAssemblyWorks_Base {
-		public class ForAssertingKeptAttribute : Attribute {
+namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies
+{
+	public class VerifyAttributesInAssemblyWorks_Base
+	{
+		public class ForAssertingKeptAttribute : Attribute
+		{
 		}
-		
-		public class ForAssertingRemoveAttribute : Attribute {
+
+		public class ForAssertingRemoveAttribute : Attribute
+		{
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/VerifyAttributesInAssemblyWorks_Lib.cs b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/VerifyAttributesInAssemblyWorks_Lib.cs
index 57dd0c380..1cf5bfe70 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/VerifyAttributesInAssemblyWorks_Lib.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/Dependencies/VerifyAttributesInAssemblyWorks_Lib.cs
@@ -4,10 +4,13 @@ using Mono.Linker.Tests.Cases.TestFramework.Dependencies;
 [assembly: VerifyAttributesInAssemblyWorks_Base.ForAssertingKept]
 [assembly: VerifyAttributesInAssemblyWorks_Base.ForAssertingRemove]
 
-namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies {
-	public class VerifyAttributesInAssemblyWorks_Lib {
+namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies
+{
+	public class VerifyAttributesInAssemblyWorks_Lib
+	{
 		[VerifyAttributesInAssemblyWorks_Base.ForAssertingKept]
-		public static class TypeWithKeptAttribute {
+		public static class TypeWithKeptAttribute
+		{
 			[VerifyAttributesInAssemblyWorks_Base.ForAssertingKept]
 			public static int Field;
 
@@ -15,13 +18,14 @@ namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies {
 			public static void Method ()
 			{
 			}
-			
+
 			[VerifyAttributesInAssemblyWorks_Base.ForAssertingKept]
 			public static int Property { get; set; }
 		}
 
 		[VerifyAttributesInAssemblyWorks_Base.ForAssertingRemove]
-		public class TypeWithRemovedAttribute {
+		public class TypeWithRemovedAttribute
+		{
 			[VerifyAttributesInAssemblyWorks_Base.ForAssertingRemove]
 			public static int Field;
 
@@ -29,7 +33,7 @@ namespace Mono.Linker.Tests.Cases.TestFramework.Dependencies {
 			public static void Method ()
 			{
 			}
-			
+
 			[VerifyAttributesInAssemblyWorks_Base.ForAssertingRemove]
 			public static int Property { get; set; }
 		}
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/VerifyAttributesInAssemblyWorks.cs b/test/Mono.Linker.Tests.Cases/TestFramework/VerifyAttributesInAssemblyWorks.cs
index ae450e2a5..2dfd16094 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/VerifyAttributesInAssemblyWorks.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/VerifyAttributesInAssemblyWorks.cs
@@ -2,34 +2,36 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.TestFramework.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.TestFramework {
+namespace Mono.Linker.Tests.Cases.TestFramework
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
 	// Put the attribute types in a different assembly than where we will assert since that is a more complex use case
-	[SetupCompileBefore ("base.dll", new [] { "Dependencies/VerifyAttributesInAssemblyWorks_Base.cs" })]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/VerifyAttributesInAssemblyWorks_Lib.cs" }, new [] { "base.dll" })]
-	
+	[SetupCompileBefore ("base.dll", new[] { "Dependencies/VerifyAttributesInAssemblyWorks_Base.cs" })]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/VerifyAttributesInAssemblyWorks_Lib.cs" }, new[] { "base.dll" })]
+
 	[KeptAttributeInAssembly ("library.dll", typeof (VerifyAttributesInAssemblyWorks_Base.ForAssertingKeptAttribute))]
 	[KeptAttributeInAssembly ("library.dll", typeof (VerifyAttributesInAssemblyWorks_Base.ForAssertingKeptAttribute), typeof (VerifyAttributesInAssemblyWorks_Lib.TypeWithKeptAttribute))]
 	[KeptAttributeInAssembly ("library.dll", typeof (VerifyAttributesInAssemblyWorks_Base.ForAssertingKeptAttribute), typeof (VerifyAttributesInAssemblyWorks_Lib.TypeWithKeptAttribute), "Field")]
 	[KeptAttributeInAssembly ("library.dll", typeof (VerifyAttributesInAssemblyWorks_Base.ForAssertingKeptAttribute), typeof (VerifyAttributesInAssemblyWorks_Lib.TypeWithKeptAttribute), "Property")]
 	[KeptAttributeInAssembly ("library.dll", typeof (VerifyAttributesInAssemblyWorks_Base.ForAssertingKeptAttribute), typeof (VerifyAttributesInAssemblyWorks_Lib.TypeWithKeptAttribute), "Method()")]
-	
+
 	[RemovedAttributeInAssembly ("library.dll", typeof (VerifyAttributesInAssemblyWorks_Base.ForAssertingRemoveAttribute))]
 	[RemovedAttributeInAssembly ("library.dll", typeof (VerifyAttributesInAssemblyWorks_Base.ForAssertingRemoveAttribute), typeof (VerifyAttributesInAssemblyWorks_Lib.TypeWithRemovedAttribute))]
 	[RemovedAttributeInAssembly ("library.dll", typeof (VerifyAttributesInAssemblyWorks_Base.ForAssertingRemoveAttribute), typeof (VerifyAttributesInAssemblyWorks_Lib.TypeWithRemovedAttribute), "Field")]
 	[RemovedAttributeInAssembly ("library.dll", typeof (VerifyAttributesInAssemblyWorks_Base.ForAssertingRemoveAttribute), typeof (VerifyAttributesInAssemblyWorks_Lib.TypeWithRemovedAttribute), "Property")]
 	[RemovedAttributeInAssembly ("library.dll", typeof (VerifyAttributesInAssemblyWorks_Base.ForAssertingRemoveAttribute), typeof (VerifyAttributesInAssemblyWorks_Lib.TypeWithRemovedAttribute), "Method()")]
-	public class VerifyAttributesInAssemblyWorks {
+	public class VerifyAttributesInAssemblyWorks
+	{
 		public static void Main ()
 		{
 			// Use the attribute type we want to keep
 			var tmp = typeof (VerifyAttributesInAssemblyWorks_Base.ForAssertingKeptAttribute).ToString ();
-			
+
 			// Now use the members of both types
 			VerifyAttributesInAssemblyWorks_Lib.TypeWithKeptAttribute.Field = 1;
 			VerifyAttributesInAssemblyWorks_Lib.TypeWithKeptAttribute.Property = 1;
 			VerifyAttributesInAssemblyWorks_Lib.TypeWithKeptAttribute.Method ();
-			
+
 			VerifyAttributesInAssemblyWorks_Lib.TypeWithRemovedAttribute.Field = 1;
 			VerifyAttributesInAssemblyWorks_Lib.TypeWithRemovedAttribute.Property = 1;
 			VerifyAttributesInAssemblyWorks_Lib.TypeWithRemovedAttribute.Method ();
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/VerifyAttributesInAssemblyWorksWithStrings.cs b/test/Mono.Linker.Tests.Cases/TestFramework/VerifyAttributesInAssemblyWorksWithStrings.cs
index bf1e0f18f..7836c0ac2 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/VerifyAttributesInAssemblyWorksWithStrings.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/VerifyAttributesInAssemblyWorksWithStrings.cs
@@ -2,11 +2,12 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.TestFramework.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.TestFramework {
+namespace Mono.Linker.Tests.Cases.TestFramework
+{
 	[SetupLinkerArgument ("--used-attrs-only", "true")]
 	// Put the attribute types in a different assembly than where we will assert since that is a more complex use case
-	[SetupCompileBefore ("base.dll", new [] { "Dependencies/VerifyAttributesInAssemblyWorks_Base.cs"} )]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/VerifyAttributesInAssemblyWorks_Lib.cs"}, new [] { "base.dll" })]
+	[SetupCompileBefore ("base.dll", new[] { "Dependencies/VerifyAttributesInAssemblyWorks_Base.cs" })]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/VerifyAttributesInAssemblyWorks_Lib.cs" }, new[] { "base.dll" })]
 
 	[KeptAttributeInAssembly ("library.dll", "Mono.Linker.Tests.Cases.TestFramework.Dependencies.VerifyAttributesInAssemblyWorks_Base/ForAssertingKeptAttribute")]
 	[KeptAttributeInAssembly ("library.dll", "Mono.Linker.Tests.Cases.TestFramework.Dependencies.VerifyAttributesInAssemblyWorks_Base/ForAssertingKeptAttribute", "Mono.Linker.Tests.Cases.TestFramework.Dependencies.VerifyAttributesInAssemblyWorks_Lib/TypeWithKeptAttribute")]
@@ -19,17 +20,18 @@ namespace Mono.Linker.Tests.Cases.TestFramework {
 	[RemovedAttributeInAssembly ("library.dll", "Mono.Linker.Tests.Cases.TestFramework.Dependencies.VerifyAttributesInAssemblyWorks_Base/ForAssertingRemoveAttribute", "Mono.Linker.Tests.Cases.TestFramework.Dependencies.VerifyAttributesInAssemblyWorks_Lib/TypeWithRemovedAttribute", "Field")]
 	[RemovedAttributeInAssembly ("library.dll", "Mono.Linker.Tests.Cases.TestFramework.Dependencies.VerifyAttributesInAssemblyWorks_Base/ForAssertingRemoveAttribute", "Mono.Linker.Tests.Cases.TestFramework.Dependencies.VerifyAttributesInAssemblyWorks_Lib/TypeWithRemovedAttribute", "Property")]
 	[RemovedAttributeInAssembly ("library.dll", "Mono.Linker.Tests.Cases.TestFramework.Dependencies.VerifyAttributesInAssemblyWorks_Base/ForAssertingRemoveAttribute", "Mono.Linker.Tests.Cases.TestFramework.Dependencies.VerifyAttributesInAssemblyWorks_Lib/TypeWithRemovedAttribute", "Method()")]
-	public class VerifyAttributesInAssemblyWorksWithStrings {
+	public class VerifyAttributesInAssemblyWorksWithStrings
+	{
 		public static void Main ()
 		{
 			// Use the attribute type we want to keep
 			var tmp = typeof (VerifyAttributesInAssemblyWorks_Base.ForAssertingKeptAttribute).ToString ();
-			
+
 			// Now use the members of both types
 			VerifyAttributesInAssemblyWorks_Lib.TypeWithKeptAttribute.Field = 1;
 			VerifyAttributesInAssemblyWorks_Lib.TypeWithKeptAttribute.Property = 1;
 			VerifyAttributesInAssemblyWorks_Lib.TypeWithKeptAttribute.Method ();
-			
+
 			VerifyAttributesInAssemblyWorks_Lib.TypeWithRemovedAttribute.Field = 1;
 			VerifyAttributesInAssemblyWorks_Lib.TypeWithRemovedAttribute.Property = 1;
 			VerifyAttributesInAssemblyWorks_Lib.TypeWithRemovedAttribute.Method ();
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/VerifyDefineAttributeBehavior.cs b/test/Mono.Linker.Tests.Cases/TestFramework/VerifyDefineAttributeBehavior.cs
index abe143042..e265807ee 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/VerifyDefineAttributeBehavior.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/VerifyDefineAttributeBehavior.cs
@@ -2,13 +2,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.TestFramework {
+namespace Mono.Linker.Tests.Cases.TestFramework
+{
 
 	/// <summary>
 	/// The purpose of this test is to verify that the testing framework's define attribute is working correctly
 	/// </summary>
-	[Define("SOME_DEFINE")]
-	public class VerifyDefineAttributeBehavior {
+	[Define ("SOME_DEFINE")]
+	public class VerifyDefineAttributeBehavior
+	{
 		static void Main ()
 		{
 #if SOME_DEFINE
@@ -16,7 +18,7 @@ namespace Mono.Linker.Tests.Cases.TestFramework {
 #endif
 		}
 
-		
+
 		[Kept]
 		static void MethodThatIsUsedIfDefineIsWorkingProperly ()
 		{
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/VerifyExpectModifiedAttributesWork.cs b/test/Mono.Linker.Tests.Cases/TestFramework/VerifyExpectModifiedAttributesWork.cs
index 787c5179e..8ac41d040 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/VerifyExpectModifiedAttributesWork.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/VerifyExpectModifiedAttributesWork.cs
@@ -3,7 +3,8 @@ using System.Diagnostics.Tracing;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.TestFramework {
+namespace Mono.Linker.Tests.Cases.TestFramework
+{
 	/// <summary>
 	/// This test is here to give some coverage to the attribute to ensure it doesn't break.  We need to leverage the ETW feature since it is the only
 	/// one that modifies bodies currently
@@ -16,30 +17,34 @@ namespace Mono.Linker.Tests.Cases.TestFramework {
 	[SetupLinkerCoreAction ("skip")]
 	// Used to avoid different compilers generating different IL which can mess up the instruction asserts
 	[SetupCompileArgument ("/optimize+")]
-	public class VerifyExpectModifiedAttributesWork {
+	public class VerifyExpectModifiedAttributesWork
+	{
 		public static void Main ()
 		{
 			var b = VerifyExpectModifiedAttributesWork_RemovedEventSource.Log.IsEnabled ();
 			if (b)
 				VerifyExpectModifiedAttributesWork_RemovedEventSource.Log.SomeMethod ();
 		}
-		
-		public class ClassForLocal {
+
+		public class ClassForLocal
+		{
 		}
 
 		public static void CallsToForceALocal (int arg1, int arg2, int arg3)
 		{
 		}
 	}
-	
+
 	[Kept]
 	[KeptBaseType (typeof (EventSource))]
 	[KeptMember (".ctor()")]
 	[KeptMember (".cctor()")]
 	[EventSource (Name = "MyCompany")]
-	class VerifyExpectModifiedAttributesWork_RemovedEventSource : EventSource {
-		public class Keywords {
-			public const EventKeywords Page = (EventKeywords)1;
+	class VerifyExpectModifiedAttributesWork_RemovedEventSource : EventSource
+	{
+		public class Keywords
+		{
+			public const EventKeywords Page = (EventKeywords) 1;
 
 			public int Unused;
 		}
@@ -59,7 +64,7 @@ namespace Mono.Linker.Tests.Cases.TestFramework {
 				VerifyExpectModifiedAttributesWork.CallsToForceALocal (1, 3, 4);
 				VerifyExpectModifiedAttributesWork.CallsToForceALocal (1, 4, 4);
 				var hashcode = tmp.GetHashCode ();
-				VerifyExpectModifiedAttributesWork.CallsToForceALocal(1, hashcode, 3);
+				VerifyExpectModifiedAttributesWork.CallsToForceALocal (1, hashcode, 3);
 			} catch {
 				try {
 					Removed ();
@@ -68,7 +73,7 @@ namespace Mono.Linker.Tests.Cases.TestFramework {
 					VerifyExpectModifiedAttributesWork.CallsToForceALocal (1, 3, 4);
 					VerifyExpectModifiedAttributesWork.CallsToForceALocal (1, 4, 4);
 					var hashcode = tmp.GetHashCode ();
-					VerifyExpectModifiedAttributesWork.CallsToForceALocal(1, hashcode, 3);
+					VerifyExpectModifiedAttributesWork.CallsToForceALocal (1, hashcode, 3);
 					throw;
 				}
 				throw;
diff --git a/test/Mono.Linker.Tests.Cases/TestFramework/VerifyResourceInAssemblyAttributesBehavior.cs b/test/Mono.Linker.Tests.Cases/TestFramework/VerifyResourceInAssemblyAttributesBehavior.cs
index c54be7565..e39b9f3f2 100644
--- a/test/Mono.Linker.Tests.Cases/TestFramework/VerifyResourceInAssemblyAttributesBehavior.cs
+++ b/test/Mono.Linker.Tests.Cases/TestFramework/VerifyResourceInAssemblyAttributesBehavior.cs
@@ -2,7 +2,8 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.TestFramework {
+namespace Mono.Linker.Tests.Cases.TestFramework
+{
 	[SetupCompileResource ("Dependencies/VerifyResourceInAssemblyAttributesBehavior.txt")]
 	[KeptResource ("VerifyResourceInAssemblyAttributesBehavior.txt")]
 	// These are technically redundant, but the goal of this test is to verify the attributes are working which we can do
@@ -10,7 +11,8 @@ namespace Mono.Linker.Tests.Cases.TestFramework {
 	// supporting assemblies
 	[KeptResourceInAssembly ("test.exe", "VerifyResourceInAssemblyAttributesBehavior.txt")]
 	[RemovedResourceInAssembly ("test.exe", "NeverExistedResource.txt")]
-	public class VerifyResourceInAssemblyAttributesBehavior {
+	public class VerifyResourceInAssemblyAttributesBehavior
+	{
 		public static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Tracing/DependencyRecorder/BasicDependencies.cs b/test/Mono.Linker.Tests.Cases/Tracing/DependencyRecorder/BasicDependencies.cs
index 484253644..b1507515b 100644
--- a/test/Mono.Linker.Tests.Cases/Tracing/DependencyRecorder/BasicDependencies.cs
+++ b/test/Mono.Linker.Tests.Cases/Tracing/DependencyRecorder/BasicDependencies.cs
@@ -3,12 +3,12 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 
 namespace Mono.Linker.Tests.Cases.Tracing.DependencyRecorder
 {
-	[DependencyRecorded("System.Void Mono.Linker.Tests.Cases.Tracing.DependencyRecorder.BasicDependencies::Main()", "Mono.Linker.Tests.Cases.Tracing.DependencyRecorder.UsedType")]
+	[DependencyRecorded ("System.Void Mono.Linker.Tests.Cases.Tracing.DependencyRecorder.BasicDependencies::Main()", "Mono.Linker.Tests.Cases.Tracing.DependencyRecorder.UsedType")]
 	[DependencyRecorded ("System.Void Mono.Linker.Tests.Cases.Tracing.DependencyRecorder.BasicDependencies::Main()", "System.Void Mono.Linker.Tests.Cases.Tracing.DependencyRecorder.UsedType::.ctor()")]
 	[DependencyRecorded ("System.Void Mono.Linker.Tests.Cases.Tracing.DependencyRecorder.BasicDependencies::Main()", "System.Void Mono.Linker.Tests.Cases.Tracing.DependencyRecorder.UsedType::UsedMethod()")]
 	public class BasicDependencies
 	{
-		public static void Main()
+		public static void Main ()
 		{
 			UsedType ut = new UsedType ();
 			ut.UsedMethod ();
@@ -19,12 +19,12 @@ namespace Mono.Linker.Tests.Cases.Tracing.DependencyRecorder
 	class UsedType
 	{
 		[Kept]
-		public UsedType()
+		public UsedType ()
 		{
 		}
 
 		[Kept]
-		public void UsedMethod()
+		public void UsedMethod ()
 		{
 		}
 	}
diff --git a/test/Mono.Linker.Tests.Cases/Tracing/Individual/CanDumpDependenciesToUncompressedXml.cs b/test/Mono.Linker.Tests.Cases/Tracing/Individual/CanDumpDependenciesToUncompressedXml.cs
index 5e4d82e8e..c9a33a301 100644
--- a/test/Mono.Linker.Tests.Cases/Tracing/Individual/CanDumpDependenciesToUncompressedXml.cs
+++ b/test/Mono.Linker.Tests.Cases/Tracing/Individual/CanDumpDependenciesToUncompressedXml.cs
@@ -1,11 +1,13 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Tracing.Individual {
+namespace Mono.Linker.Tests.Cases.Tracing.Individual
+{
 
 	[SetupLinkerArgument ("--dump-dependencies")]
 	[SetupLinkerArgument ("--dependencies-file", "linker-dependencies.xml")]
-	public class CanDumpDependenciesToUncompressedXml {
+	public class CanDumpDependenciesToUncompressedXml
+	{
 		public static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Tracing/Individual/CanEnableDependenciesDump.cs b/test/Mono.Linker.Tests.Cases/Tracing/Individual/CanEnableDependenciesDump.cs
index 810023860..2e312a67b 100644
--- a/test/Mono.Linker.Tests.Cases/Tracing/Individual/CanEnableDependenciesDump.cs
+++ b/test/Mono.Linker.Tests.Cases/Tracing/Individual/CanEnableDependenciesDump.cs
@@ -1,10 +1,12 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Tracing.Individual {
+namespace Mono.Linker.Tests.Cases.Tracing.Individual
+{
 
 	[SetupLinkerArgument ("--dump-dependencies")]
-	public class CanEnableDependenciesDump {
+	public class CanEnableDependenciesDump
+	{
 		public static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/Tracing/Individual/CanEnableReducedTracing.cs b/test/Mono.Linker.Tests.Cases/Tracing/Individual/CanEnableReducedTracing.cs
index 3a7fcadae..dd0160976 100644
--- a/test/Mono.Linker.Tests.Cases/Tracing/Individual/CanEnableReducedTracing.cs
+++ b/test/Mono.Linker.Tests.Cases/Tracing/Individual/CanEnableReducedTracing.cs
@@ -1,7 +1,8 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.Tracing.Individual {
+namespace Mono.Linker.Tests.Cases.Tracing.Individual
+{
 
 	[SetupLinkerArgument ("--dump-dependencies")]
 	[SetupLinkerArgument ("--reduced-tracing", "true")]
@@ -10,7 +11,8 @@ namespace Mono.Linker.Tests.Cases.Tracing.Individual {
 
 	// Need to define a custom name so that the linker outputs in uncompressed format, which is more useful for making assertions
 	[SetupLinkerArgument ("--dependencies-file", "linker-dependencies.xml")]
-	public class CanEnableReducedTracing {
+	public class CanEnableReducedTracing
+	{
 		public static void Main ()
 		{
 		}
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/AttributeArgumentForwarded.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/AttributeArgumentForwarded.cs
index 1e795e333..72c261520 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/AttributeArgumentForwarded.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/AttributeArgumentForwarded.cs
@@ -24,7 +24,7 @@ namespace Mono.Linker.Tests.Cases.TypeForwarding
 	[KeptMemberInAssembly ("Implementation.dll", typeof (ImplementationLibrary))]
 	class AttributeArgumentForwarded
 	{
-		static void Main()
+		static void Main ()
 		{
 			Test_1 ();
 			Test_1b ();
@@ -50,14 +50,14 @@ namespace Mono.Linker.Tests.Cases.TypeForwarding
 
 		[Kept]
 		[KeptAttributeAttribute (typeof (TestTypeAttribute))]
-		[TestType (typeof (ImplementationLibrary [,] []))]
+		[TestType (typeof (ImplementationLibrary[,][]))]
 		public static void Test_1c ()
 		{
 		}
 
 		[Kept]
 		[KeptAttributeAttribute (typeof (TestTypeAttribute))]
-		[TestType (TestProperty = new object [] { typeof (ImplementationLibrary) })]
+		[TestType (TestProperty = new object[] { typeof (ImplementationLibrary) })]
 		public static void Test_2 ()
 		{
 		}
@@ -79,7 +79,8 @@ namespace Mono.Linker.Tests.Cases.TypeForwarding
 	}
 
 	[KeptBaseType (typeof (Attribute))]
-	public class TestTypeAttribute : Attribute {
+	public class TestTypeAttribute : Attribute
+	{
 		[Kept]
 		public TestTypeAttribute ()
 		{
@@ -99,6 +100,7 @@ namespace Mono.Linker.Tests.Cases.TypeForwarding
 	}
 
 	[Kept]
-	public class SomeGenericType<T> {
+	public class SomeGenericType<T>
+	{
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/AttributeArgumentForwardedWithCopyAction.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/AttributeArgumentForwardedWithCopyAction.cs
index 6d211a151..9855ae444 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/AttributeArgumentForwardedWithCopyAction.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/AttributeArgumentForwardedWithCopyAction.cs
@@ -27,7 +27,7 @@ namespace Mono.Linker.Tests.Cases.TypeForwarding
 	[KeptMemberInAssembly ("Implementation.dll", typeof (ImplementationLibrary))]
 	static class AttributeArgumentForwardedWithCopyAction
 	{
-		static void Main()
+		static void Main ()
 		{
 			Test_1 ();
 		}
@@ -48,14 +48,14 @@ namespace Mono.Linker.Tests.Cases.TypeForwarding
 
 		[Kept]
 		[KeptAttributeAttribute (typeof (TestType2Attribute))]
-		[TestType2 (typeof (ImplementationLibrary [,] []))]
+		[TestType2 (typeof (ImplementationLibrary[,][]))]
 		public static void Test_1c ()
 		{
 		}
 
 		[Kept]
 		[KeptAttributeAttribute (typeof (TestType2Attribute))]
-		[TestType2 (TestProperty = new object [] { typeof (ImplementationLibrary) })]
+		[TestType2 (TestProperty = new object[] { typeof (ImplementationLibrary) })]
 		public static void Test_2 ()
 		{
 		}
@@ -77,7 +77,8 @@ namespace Mono.Linker.Tests.Cases.TypeForwarding
 	}
 
 	[KeptBaseType (typeof (Attribute))]
-	public class TestType2Attribute : Attribute {
+	public class TestType2Attribute : Attribute
+	{
 		[Kept]
 		public TestType2Attribute ()
 		{
@@ -97,6 +98,7 @@ namespace Mono.Linker.Tests.Cases.TypeForwarding
 	}
 
 	[Kept]
-	static class SomeGenericType2<T> {
+	static class SomeGenericType2<T>
+	{
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/AnotherLibrary.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/AnotherLibrary.cs
index fde1f82f9..c7e0b9756 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/AnotherLibrary.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/AnotherLibrary.cs
@@ -2,8 +2,10 @@ using System;
 using System.Reflection;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.TypeForwarding.Dependencies {
-	public class AnotherLibrary<T> {
+namespace Mono.Linker.Tests.Cases.TypeForwarding.Dependencies
+{
+	public class AnotherLibrary<T>
+	{
 		public string Prop { get; set; }
 	}
 }
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/ForwarderLibrary_3.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/ForwarderLibrary_3.cs
index 8b4ae26e0..d7aea07d7 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/ForwarderLibrary_3.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/ForwarderLibrary_3.cs
@@ -6,6 +6,6 @@ using System;
 namespace Mono.Linker.Tests.Cases.TypeForwarding.Dependencies
 {
 	public class RealClassInForwarder3
-	{	
+	{
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/ImplementationLibrary.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/ImplementationLibrary.cs
index 137414032..98fab0dba 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/ImplementationLibrary.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/ImplementationLibrary.cs
@@ -4,8 +4,10 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
 //[assembly: AssemblyVersion ("2.0")]
 
-namespace Mono.Linker.Tests.Cases.TypeForwarding.Dependencies {
-	public class ImplementationLibrary {
+namespace Mono.Linker.Tests.Cases.TypeForwarding.Dependencies
+{
+	public class ImplementationLibrary
+	{
 		public string GetSomeValue ()
 		{
 			return "Hello";
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/ImplementationLibrary_3.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/ImplementationLibrary_3.cs
index 30c3b61d9..29223748b 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/ImplementationLibrary_3.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/ImplementationLibrary_3.cs
@@ -1,7 +1,8 @@
 using System;
 using System.Reflection;
 
-namespace Mono.Linker.Tests.Cases.TypeForwarding.Dependencies {
+namespace Mono.Linker.Tests.Cases.TypeForwarding.Dependencies
+{
 	public class ImplementationLibrary3A
 	{
 	}
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/LibraryUsingForwarder.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/LibraryUsingForwarder.cs
index 97c728e7d..c88dd625e 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/LibraryUsingForwarder.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/LibraryUsingForwarder.cs
@@ -1,9 +1,11 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.TypeForwarding.Dependencies {
+namespace Mono.Linker.Tests.Cases.TypeForwarding.Dependencies
+{
 	[NotATestCase]
-	public class LibraryUsingForwarder {
+	public class LibraryUsingForwarder
+	{
 		public string GetValueFromOtherAssembly ()
 		{
 			return new ImplementationLibrary ().GetSomeValue ();
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/ReferenceImplementationLibrary.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/ReferenceImplementationLibrary.cs
index 00bb1e30c..ff4def7c9 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/ReferenceImplementationLibrary.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/Dependencies/ReferenceImplementationLibrary.cs
@@ -1,9 +1,11 @@
 using System;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.TypeForwarding.Dependencies {
+namespace Mono.Linker.Tests.Cases.TypeForwarding.Dependencies
+{
 	[NotATestCase]
-	public class ReferenceImplementationLibrary {
+	public class ReferenceImplementationLibrary
+	{
 	}
 
 #if INCLUDE_REFERENCE_IMPL
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/MissingTargetReference.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/MissingTargetReference.cs
index a0731064f..3d53f356c 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/MissingTargetReference.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/MissingTargetReference.cs
@@ -2,10 +2,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.TypeForwarding {
+namespace Mono.Linker.Tests.Cases.TypeForwarding
+{
 	[SkipUnresolved (true)]
 	[Define ("IL_ASSEMBLY_AVAILABLE")]
-	[SetupCompileBefore ("TypeForwarderMissingReference.dll", new [] { "Dependencies/TypeForwarderMissingReference.il" })]
+	[SetupCompileBefore ("TypeForwarderMissingReference.dll", new[] { "Dependencies/TypeForwarderMissingReference.il" })]
 	[SetupLinkerAction ("link", "TypeForwarderMissingReference.dll")]
 
 	[KeptMemberInAssembly ("TypeForwarderMissingReference.dll", "DummyClass", ".ctor()")]
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/TypeForwarderOnlyAssembliesKept.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/TypeForwarderOnlyAssembliesKept.cs
index e8a41a259..407cdab90 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/TypeForwarderOnlyAssembliesKept.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/TypeForwarderOnlyAssembliesKept.cs
@@ -3,7 +3,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.TypeForwarding.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.TypeForwarding {
+namespace Mono.Linker.Tests.Cases.TypeForwarding
+{
 	[KeepTypeForwarderOnlyAssemblies ("true")]
 	[SetupCompileBefore ("Forwarder.dll", new[] { "Dependencies/ReferenceImplementationLibrary.cs" }, defines: new[] { "INCLUDE_REFERENCE_IMPL" })]
 	// Add another assembly in that uses the forwarder just to make things a little more complex
@@ -16,7 +17,8 @@ namespace Mono.Linker.Tests.Cases.TypeForwarding {
 	[KeptAssembly ("Forwarder.dll")]
 	[KeptMemberInAssembly ("Library.dll", typeof (LibraryUsingForwarder), "GetValueFromOtherAssembly()")]
 	[KeptMemberInAssembly ("Implementation.dll", typeof (ImplementationLibrary), "GetSomeValue()")]
-	public class TypeForwarderOnlyAssembliesKept {
+	public class TypeForwarderOnlyAssembliesKept
+	{
 		public static void Main ()
 		{
 			Console.WriteLine (new ImplementationLibrary ().GetSomeValue ());
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/TypeForwarderOnlyAssemblyCanBePreservedViaLinkXml.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/TypeForwarderOnlyAssemblyCanBePreservedViaLinkXml.cs
index 95a0ad138..02a1a7cad 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/TypeForwarderOnlyAssemblyCanBePreservedViaLinkXml.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/TypeForwarderOnlyAssemblyCanBePreservedViaLinkXml.cs
@@ -3,7 +3,8 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.TypeForwarding.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.TypeForwarding {
+namespace Mono.Linker.Tests.Cases.TypeForwarding
+{
 	[KeepTypeForwarderOnlyAssemblies ("false")]
 	[SetupCompileBefore ("Forwarder.dll", new[] { "Dependencies/ReferenceImplementationLibrary.cs" }, defines: new[] { "INCLUDE_REFERENCE_IMPL" })]
 	// Add another assembly in that uses the forwarder just to make things a little more complex
@@ -16,10 +17,11 @@ namespace Mono.Linker.Tests.Cases.TypeForwarding {
 	[KeptAssembly ("Forwarder.dll")]
 	[KeptMemberInAssembly ("Implementation.dll", typeof (ImplementationLibrary), "GetSomeValue()")]
 	[KeptMemberInAssembly ("Library.dll", typeof (LibraryUsingForwarder), "GetValueFromOtherAssembly()")]
-	
-	[KeptTypeInAssembly("Forwarder.dll", typeof (ImplementationLibrary))]
-	public class TypeForwarderOnlyAssemblyCanBePreservedViaLinkXml {
-		static void Main()
+
+	[KeptTypeInAssembly ("Forwarder.dll", typeof (ImplementationLibrary))]
+	public class TypeForwarderOnlyAssemblyCanBePreservedViaLinkXml
+	{
+		static void Main ()
 		{
 			Console.WriteLine (new ImplementationLibrary ().GetSomeValue ());
 			Console.WriteLine (new LibraryUsingForwarder ().GetValueFromOtherAssembly ());
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/UnusedForwarderWithAssemblyCopyUsed.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/UnusedForwarderWithAssemblyCopyUsed.cs
index 1f8a11011..74630d2b0 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/UnusedForwarderWithAssemblyCopyUsed.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/UnusedForwarderWithAssemblyCopyUsed.cs
@@ -17,7 +17,7 @@ namespace Mono.Linker.Tests.Cases.TypeForwarding
 	[SetupCompileAfter ("Forwarder.dll", new[] { "Dependencies/ForwarderLibrary.cs" }, references: new[] { "Implementation.dll" })]
 
 	[RemovedAssembly ("Forwarder.dll")]
-	[RemovedAssembly("Implementation.dll")]
+	[RemovedAssembly ("Implementation.dll")]
 	class UnusedForwarderWithAssemblyCopyUsed
 	{
 		static void Main ()
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedAndUnusedForwarderWithAssemblyCopy.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedAndUnusedForwarderWithAssemblyCopy.cs
index fe957f90a..90e5b6391 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedAndUnusedForwarderWithAssemblyCopy.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedAndUnusedForwarderWithAssemblyCopy.cs
@@ -26,7 +26,7 @@ namespace Mono.Linker.Tests.Cases.TypeForwarding
 	[RemovedAssemblyReference ("Forwarder.dll", "Unused")]
 	class UsedAndUnusedForwarderWithAssemblyCopy
 	{
-		static void Main()
+		static void Main ()
 		{
 			new ImplementationLibrary ().GetSomeValue ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedForwarderIsRemovedWhenLink.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedForwarderIsRemovedWhenLink.cs
index 2366cf96b..deef0e497 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedForwarderIsRemovedWhenLink.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedForwarderIsRemovedWhenLink.cs
@@ -22,7 +22,7 @@ namespace Mono.Linker.Tests.Cases.TypeForwarding
 	[KeptMemberInAssembly ("Library.dll", typeof (LibraryUsingForwarder), "GetValueFromOtherAssembly()")]
 	class UsedForwarderIsRemovedWhenLink
 	{
-		static void Main()
+		static void Main ()
 		{
 			Console.WriteLine (new ImplementationLibrary ().GetSomeValue ());
 			Console.WriteLine (new LibraryUsingForwarder ().GetValueFromOtherAssembly ());
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedForwarderWithAssemblyCopy.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedForwarderWithAssemblyCopy.cs
index 1b1c6d56c..a0be84bb7 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedForwarderWithAssemblyCopy.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedForwarderWithAssemblyCopy.cs
@@ -21,7 +21,7 @@ namespace Mono.Linker.Tests.Cases.TypeForwarding
 	[KeptMemberInAssembly ("Forwarder.dll", typeof (ImplementationLibrary))]
 	class UsedForwarderWithAssemblyCopy
 	{
-		static void Main()
+		static void Main ()
 		{
 			new ImplementationLibrary ().GetSomeValue ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedForwarderWithAssemblyCopyUsed.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedForwarderWithAssemblyCopyUsed.cs
index f27148a88..01e8c7d9d 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedForwarderWithAssemblyCopyUsed.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedForwarderWithAssemblyCopyUsed.cs
@@ -20,7 +20,7 @@ namespace Mono.Linker.Tests.Cases.TypeForwarding
 	[KeptMemberInAssembly ("Implementation.dll", typeof (ImplementationLibrary), "GetSomeValue()")]
 	class UsedForwarderWithAssemblyCopyUsed
 	{
-		static void Main()
+		static void Main ()
 		{
 			new ImplementationLibrary ().GetSomeValue ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedForwarderWithAssemblyCopyUsedAndFacadesKept.cs b/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedForwarderWithAssemblyCopyUsedAndFacadesKept.cs
index 988d42712..7ccc53062 100644
--- a/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedForwarderWithAssemblyCopyUsedAndFacadesKept.cs
+++ b/test/Mono.Linker.Tests.Cases/TypeForwarding/UsedForwarderWithAssemblyCopyUsedAndFacadesKept.cs
@@ -21,7 +21,7 @@ namespace Mono.Linker.Tests.Cases.TypeForwarding
 	[KeptMemberInAssembly ("Implementation.dll", typeof (ImplementationLibrary), "GetSomeValue()")]
 	class UsedForwarderWithAssemblyCopyUsedAndFacadesKept
 	{
-		static void Main()
+		static void Main ()
 		{
 			new ImplementationLibrary ().GetSomeValue ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBlock/BodiesWithSubstitutions.cs b/test/Mono.Linker.Tests.Cases/UnreachableBlock/BodiesWithSubstitutions.cs
index 668d5142e..6b347bb1d 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBlock/BodiesWithSubstitutions.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBlock/BodiesWithSubstitutions.cs
@@ -17,7 +17,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 
 		static int field;
 
-		public static void Main()
+		public static void Main ()
 		{
 			TestProperty_int_1 ();
 			TestField_int_1 ();
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBlock/DeadVariables.cs b/test/Mono.Linker.Tests.Cases/UnreachableBlock/DeadVariables.cs
index f0f96f0f6..80a3908f9 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBlock/DeadVariables.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBlock/DeadVariables.cs
@@ -18,7 +18,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 
 		[Kept]
 		[ExpectBodyModified]
-		[ExpectedLocalsSequence (new string [0])]
+		[ExpectedLocalsSequence (new string[0])]
 		static void Test_1 ()
 		{
 			if (!AlwaysTrue) {
@@ -29,7 +29,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 
 		[Kept]
 		[ExpectBodyModified]
-		[ExpectedLocalsSequence (new string [] { "System.Object", "System.Int32" })]
+		[ExpectedLocalsSequence (new string[] { "System.Object", "System.Int32" })]
 		static int Test_2 (int arg)
 		{
 			if (!AlwaysTrue) {
@@ -47,7 +47,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 
 		[Kept]
 		[ExpectBodyModified]
-		[ExpectedLocalsSequence (new string [] { "System.Int32", "System.DateTime", "System.DateTimeOffset", "System.DateTimeOffset" })]
+		[ExpectedLocalsSequence (new string[] { "System.Int32", "System.DateTime", "System.DateTimeOffset", "System.DateTimeOffset" })]
 		static int Test_3 ()
 		{
 			var b = 3;
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBlock/MultiStageRemoval.cs b/test/Mono.Linker.Tests.Cases/UnreachableBlock/MultiStageRemoval.cs
index 7f9d02fad..95a435eea 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBlock/MultiStageRemoval.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBlock/MultiStageRemoval.cs
@@ -8,7 +8,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 	[SetupLinkerArgument ("--enable-opt", "ipconstprop")]
 	public class MultiStageRemoval
 	{
-		public static void Main()
+		public static void Main ()
 		{
 			TestMethod_1 ();
 			TestMethod_2 ();
@@ -53,7 +53,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 				return -1;
 
 			return 0;
-		}        
+		}
 
 		[Kept]
 		static int Prop {
@@ -69,14 +69,14 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 			get {
 				return true;
 			}
-		}        
-        
+		}
+
 		static void NeverReached_1 ()
-		{			
+		{
 		}
 
 		static void NeverReached_2 ()
-		{			
-		}        
+		{
+		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBlock/ReplacedReturns.cs b/test/Mono.Linker.Tests.Cases/UnreachableBlock/ReplacedReturns.cs
index 9af58122f..0758e32c7 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBlock/ReplacedReturns.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBlock/ReplacedReturns.cs
@@ -32,7 +32,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"pop",
 			"call",
@@ -50,7 +50,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"pop",
 			"call",
@@ -68,7 +68,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"pop",
 			"ldsfld",
@@ -87,7 +87,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"pop",
 			"ldsfld",
@@ -108,7 +108,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"pop",
 			"ldsfld",
@@ -132,7 +132,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"pop",
 			"call",
@@ -161,7 +161,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"pop",
 			"call",
@@ -192,7 +192,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"ldc.i4.0",
 			"stloc.0",
 			"call",
@@ -231,7 +231,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		[Kept]
 		[ExpectedExceptionHandlerSequence (new string[0])]
 		[ExpectedLocalsSequence (new string[0])]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"pop",
 			"call",
@@ -250,7 +250,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"pop",
 			"call",
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBlock/SimpleConditionalProperty.cs b/test/Mono.Linker.Tests.Cases/UnreachableBlock/SimpleConditionalProperty.cs
index a2708177f..5309bd332 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBlock/SimpleConditionalProperty.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBlock/SimpleConditionalProperty.cs
@@ -9,7 +9,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 	[SetupLinkerArgument ("--enable-opt", "ipconstprop")]
 	public class SimpleConditionalProperty
 	{
-		public static void Main()
+		public static void Main ()
 		{
 			TestProperty_int_1 ();
 			TestProperty_int_2 ();
@@ -23,7 +23,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"ldc.i4.3",
 			"beq.s",
@@ -36,7 +36,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"ldc.i4.3",
 			"call",
 			"beq.s",
@@ -52,7 +52,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"ldc.i4.5",
 			"ble.s",
@@ -69,7 +69,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"pop",
 			"ldloca.s",
@@ -86,7 +86,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"brfalse.s",
 			"ret"
@@ -101,7 +101,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"brfalse.s",
 			"ret"
@@ -114,7 +114,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"call",
 			"beq.s",
@@ -128,7 +128,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"br.s",
 			"call",
 			"pop",
@@ -142,7 +142,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"brfalse.s",
 			"ret"
@@ -187,13 +187,14 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		static void NeverReached_1 ()
-		{			
+		{
 		}
 
 		[Kept]
 		[KeptMember ("value__")]
 		[KeptBaseType (typeof (Enum))]
-		enum TestEnum {
+		enum TestEnum
+		{
 			[Kept]
 			A = 0,
 			[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBlock/SizeOfInConditions.cs b/test/Mono.Linker.Tests.Cases/UnreachableBlock/SizeOfInConditions.cs
index e5d97a702..fffd2c268 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBlock/SizeOfInConditions.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBlock/SizeOfInConditions.cs
@@ -2,7 +2,8 @@ using System;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBlock {
+namespace Mono.Linker.Tests.Cases.UnreachableBlock
+{
 #if ILLINK
 	[SetupLinkerSubstitutionFile ("SizeOfInConditions.netcore.xml")]
 #else
@@ -10,7 +11,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock {
 #endif
 	[SetupCompileArgument ("/unsafe")]
 	[SetupLinkerArgument ("--enable-opt", "ipconstprop")]
-	public unsafe class SizeOfInConditions {
+	public unsafe class SizeOfInConditions
+	{
 		public static void Main ()
 		{
 			TestIntPtr ();
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBlock/TryCatchBlocks.cs b/test/Mono.Linker.Tests.Cases/UnreachableBlock/TryCatchBlocks.cs
index e0a8132bd..dca8e0cfa 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBlock/TryCatchBlocks.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBlock/TryCatchBlocks.cs
@@ -14,7 +14,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"ldc.i4.6",
 			"beq.s",
@@ -26,13 +26,13 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		static int TestSimpleTryUnreachable ()
 		{
 			if (Prop != 6) {
-                try {
+				try {
 					Unreached_1 ();
 					return 1;
-                } catch {
-                    return 2;
-                }
-            }
+				} catch {
+					return 2;
+				}
+			}
 
 			return 3;
 		}
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBlock/TryFinallyBlocks.cs b/test/Mono.Linker.Tests.Cases/UnreachableBlock/TryFinallyBlocks.cs
index 07a17b804..e39a2f936 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBlock/TryFinallyBlocks.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBlock/TryFinallyBlocks.cs
@@ -14,7 +14,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBlock
 		}
 
 		[Kept]
-		[ExpectedInstructionSequence (new [] {
+		[ExpectedInstructionSequence (new[] {
 			"call",
 			"ldc.i4.3",
 			"beq.s",
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBlock/UninitializedLocals.cs b/test/Mono.Linker.Tests.Cases/UnreachableBlock/UninitializedLocals.cs
index 31283486a..dafdd100d 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBlock/UninitializedLocals.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBlock/UninitializedLocals.cs
@@ -4,12 +4,12 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata;
 namespace Mono.Linker.Tests.Cases.UnreachableBlock
 {
 	[Define ("IL_ASSEMBLY_AVAILABLE")]
-	[SetupCompileBefore ("library.dll", new [] { "Dependencies/LocalsWithoutStore.il" })]
+	[SetupCompileBefore ("library.dll", new[] { "Dependencies/LocalsWithoutStore.il" })]
 	[SetupLinkerArgument ("--enable-opt", "ipconstprop")]
 	[SkipPeVerify]
 	public class UninitializedLocals
 	{
-		public static void Main()
+		public static void Main ()
 		{
 #if IL_ASSEMBLY_AVAILABLE
 			Mono.Linker.Tests.Cases.UnreachableBlock.Dependencies.ClassA.Method_1 ();
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/BodyWithManyVariables.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/BodyWithManyVariables.cs
index 57fc9311f..d3b732189 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/BodyWithManyVariables.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/BodyWithManyVariables.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class BodyWithManyVariables {
-		public static void Main()
+	public class BodyWithManyVariables
+	{
+		public static void Main ()
 		{
 			UsedToMarkMethod (null);
 		}
@@ -16,7 +18,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[ExpectBodyModified]
 			[ExpectLocalsModified]
@@ -37,37 +40,43 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 			}
 		}
 
-		class Bar1 {
+		class Bar1
+		{
 			public void Method ()
 			{
 			}
 		}
 
-		class Bar2 {
+		class Bar2
+		{
 			public void Method ()
 			{
 			}
 		}
-		
-		class Bar3 {
+
+		class Bar3
+		{
 			public void Method ()
 			{
 			}
 		}
 
-		class Bar4 {
+		class Bar4
+		{
 			public void Method ()
 			{
 			}
 		}
-		
-		class Bar5 {
+
+		class Bar5
+		{
 			public void Method ()
 			{
 			}
 		}
 
-		class Bar6 {
+		class Bar6
+		{
 			public void Method ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/BodyWithManyVariablesWithSymbols.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/BodyWithManyVariablesWithSymbols.cs
index 4861e9675..70f576379 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/BodyWithManyVariablesWithSymbols.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/BodyWithManyVariablesWithSymbols.cs
@@ -1,13 +1,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupCompileArgument ("/debug:full")]
 	[SetupLinkerLinkSymbols ("true")]
 	[KeptSymbols ("test.exe")]
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class BodyWithManyVariablesWithSymbols {
-		public static void Main()
+	public class BodyWithManyVariablesWithSymbols
+	{
+		public static void Main ()
 		{
 			UsedToMarkMethod (null);
 		}
@@ -19,58 +21,65 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[ExpectBodyModified]
 			[ExpectLocalsModified]
 			public void Method ()
 			{
-				var b1 = new Bar1();
-				var b2 = new Bar2();
-				var b3 = new Bar3();
-				var b4 = new Bar4();
-				var b5 = new Bar5();
-				var b6 = new Bar6();
-				b1.Method();
-				b2.Method();
-				b3.Method();
-				b4.Method();
-				b5.Method();
-				b6.Method();
+				var b1 = new Bar1 ();
+				var b2 = new Bar2 ();
+				var b3 = new Bar3 ();
+				var b4 = new Bar4 ();
+				var b5 = new Bar5 ();
+				var b6 = new Bar6 ();
+				b1.Method ();
+				b2.Method ();
+				b3.Method ();
+				b4.Method ();
+				b5.Method ();
+				b6.Method ();
 			}
 		}
 
-		class Bar1 {
+		class Bar1
+		{
 			public void Method ()
 			{
 			}
 		}
 
-		class Bar2 {
+		class Bar2
+		{
 			public void Method ()
 			{
 			}
 		}
 
-		class Bar3 {
+		class Bar3
+		{
 			public void Method ()
 			{
 			}
 		}
 
-		class Bar4 {
+		class Bar4
+		{
 			public void Method ()
 			{
 			}
 		}
-		
-		class Bar5 {
+
+		class Bar5
+		{
 			public void Method ()
 			{
 			}
 		}
 
-		class Bar6 {
+		class Bar6
+		{
 			public void Method ()
 			{
 			}
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/CanDisableLazyBodyMarking.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/CanDisableLazyBodyMarking.cs
index 4f72c7798..4c79dbbe1 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/CanDisableLazyBodyMarking.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/CanDisableLazyBodyMarking.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--disable-opt", "unreachablebodies")]
-	public class CanDisableLazyBodyMarking {
-		public static void Main()
+	public class CanDisableLazyBodyMarking
+	{
+		public static void Main ()
 		{
 			UsedToMarkMethod (null);
 		}
@@ -16,7 +18,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			public void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/Dependencies/OtherAssembly.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/Dependencies/OtherAssembly.cs
index 8e7abcd65..82819c391 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/Dependencies/OtherAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/Dependencies/OtherAssembly.cs
@@ -1,10 +1,13 @@
-namespace Mono.Linker.Tests.Cases.UnreachableBody.Dependencies {
-	public class OtherAssembly {
+namespace Mono.Linker.Tests.Cases.UnreachableBody.Dependencies
+{
+	public class OtherAssembly
+	{
 		public static void UnusedSanityCheck ()
 		{
 		}
 
-		public class Foo {
+		public class Foo
+		{
 			public void Method ()
 			{
 				UsedByMethod ();
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/DoesNotApplyToCopiedAssembly.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/DoesNotApplyToCopiedAssembly.cs
index daed76fd1..4b6d1f3e1 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/DoesNotApplyToCopiedAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/DoesNotApplyToCopiedAssembly.cs
@@ -2,15 +2,17 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.UnreachableBody.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerAction ("copy", "other2")]
-	[SetupCompileBefore ("other2.dll", new [] {typeof (OtherAssembly)})]
+	[SetupCompileBefore ("other2.dll", new[] { typeof (OtherAssembly) })]
 	[KeptMemberInAssembly ("other2.dll", typeof (OtherAssembly.Foo), "Method()")]
 	[KeptMemberInAssembly ("other2.dll", typeof (OtherAssembly.Foo), "UsedByMethod()")]
 	[KeptMemberInAssembly ("other2.dll", typeof (OtherAssembly), "UnusedSanityCheck()")]
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class DoesNotApplyToCopiedAssembly {
-		public static void Main()
+	public class DoesNotApplyToCopiedAssembly
+	{
+		public static void Main ()
 		{
 			UsedToMarkMethod (null);
 		}
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/DoesNotApplyToCopiedAssembly2.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/DoesNotApplyToCopiedAssembly2.cs
index 4b04bd953..29353e642 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/DoesNotApplyToCopiedAssembly2.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/DoesNotApplyToCopiedAssembly2.cs
@@ -1,15 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[Define ("OTHER_INCLUDED")]
 	[SetupLinkerAction ("copy", "other")]
-	[SetupCompileBefore ("other.dll", new [] { "Dependencies/OtherAssemblyNoInstanceCtor.il" })]
+	[SetupCompileBefore ("other.dll", new[] { "Dependencies/OtherAssemblyNoInstanceCtor.il" })]
 	[KeptMemberInAssembly ("other.dll", "Mono.Linker.Tests.Cases.UnreachableBody.Dependencies.OtherAssemblyNoInstanceCtor/Foo", "Method()")]
 	[KeptMemberInAssembly ("other.dll", "Mono.Linker.Tests.Cases.UnreachableBody.Dependencies.OtherAssemblyNoInstanceCtor/Foo", "UsedByMethod()")]
 	[KeptMemberInAssembly ("other.dll", "Mono.Linker.Tests.Cases.UnreachableBody.Dependencies.OtherAssemblyNoInstanceCtor", "UnusedSanityCheck()")]
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class DoesNotApplyToCopiedAssembly2 {
+	public class DoesNotApplyToCopiedAssembly2
+	{
 		public static void Main ()
 		{
 #if OTHER_INCLUDED
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/DoesNotApplyToSavedAssembly.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/DoesNotApplyToSavedAssembly.cs
index 10cf7d529..525e8b130 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/DoesNotApplyToSavedAssembly.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/DoesNotApplyToSavedAssembly.cs
@@ -2,15 +2,17 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.UnreachableBody.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerAction ("save", "other2")]
-	[SetupCompileBefore ("other2.dll", new [] {typeof (OtherAssembly)})]
+	[SetupCompileBefore ("other2.dll", new[] { typeof (OtherAssembly) })]
 	[KeptMemberInAssembly ("other2.dll", typeof (OtherAssembly.Foo), "Method()")]
 	[KeptMemberInAssembly ("other2.dll", typeof (OtherAssembly.Foo), "UsedByMethod()")]
 	[KeptMemberInAssembly ("other2.dll", typeof (OtherAssembly), "UnusedSanityCheck()")]
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class DoesNotApplyToSavedAssembly {
-		public static void Main()
+	public class DoesNotApplyToSavedAssembly
+	{
+		public static void Main ()
 		{
 			UsedToMarkMethod (null);
 		}
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/DoesNotApplyToSavedAssembly2.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/DoesNotApplyToSavedAssembly2.cs
index 5ffde19bc..67a94430d 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/DoesNotApplyToSavedAssembly2.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/DoesNotApplyToSavedAssembly2.cs
@@ -1,15 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[Define ("OTHER_INCLUDED")]
 	[SetupLinkerAction ("save", "other")]
-	[SetupCompileBefore ("other.dll", new [] { "Dependencies/OtherAssemblyNoInstanceCtor.il" })]
+	[SetupCompileBefore ("other.dll", new[] { "Dependencies/OtherAssemblyNoInstanceCtor.il" })]
 	[KeptMemberInAssembly ("other.dll", "Mono.Linker.Tests.Cases.UnreachableBody.Dependencies.OtherAssemblyNoInstanceCtor/Foo", "Method()")]
 	[KeptMemberInAssembly ("other.dll", "Mono.Linker.Tests.Cases.UnreachableBody.Dependencies.OtherAssemblyNoInstanceCtor/Foo", "UsedByMethod()")]
 	[KeptMemberInAssembly ("other.dll", "Mono.Linker.Tests.Cases.UnreachableBody.Dependencies.OtherAssemblyNoInstanceCtor", "UnusedSanityCheck()")]
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class DoesNotApplyToSavedAssembly2 {
+	public class DoesNotApplyToSavedAssembly2
+	{
 		public static void Main ()
 		{
 #if OTHER_INCLUDED
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/ExplicitInstructionCheck.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/ExplicitInstructionCheck.cs
index 36f25980d..222700ddd 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/ExplicitInstructionCheck.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/ExplicitInstructionCheck.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class ExplicitInstructionCheck {
-		public static void Main()
+	public class ExplicitInstructionCheck
+	{
+		public static void Main ()
 		{
 			UsedToMarkMethod (null);
 		}
@@ -16,9 +18,10 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		class Foo {
+		class Foo
+		{
 			[Kept]
-			[ExpectedInstructionSequence(new []
+			[ExpectedInstructionSequence (new[]
 			{
 				"ldstr",
 				"newobj",
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/InterfaceMethod.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/InterfaceMethod.cs
index 22e2b55c2..abe14867f 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/InterfaceMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/InterfaceMethod.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody  {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class InterfaceMethod {
-		public static void Main()
+	public class InterfaceMethod
+	{
+		public static void Main ()
 		{
 			UsedToMarkMethod (null);
 		}
@@ -17,14 +19,16 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody  {
 		}
 
 		[Kept]
-		interface IFoo {
+		interface IFoo
+		{
 			[Kept]
 			void Method ();
 		}
 
 		[Kept]
 		[KeptInterface (typeof (IFoo))]
-		class Foo : IFoo {
+		class Foo : IFoo
+		{
 			[Kept]
 			[ExpectBodyModified]
 			public void Method ()
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/LinkedOtherIncludedLibrary.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/LinkedOtherIncludedLibrary.cs
index e0dcd48e0..63c8a9e06 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/LinkedOtherIncludedLibrary.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/LinkedOtherIncludedLibrary.cs
@@ -2,15 +2,17 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 using Mono.Linker.Tests.Cases.UnreachableBody.Dependencies;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("-r", "other2")]
-	[SetupCompileBefore ("other2.dll", new [] {typeof (OtherAssembly)})]
+	[SetupCompileBefore ("other2.dll", new[] { typeof (OtherAssembly) })]
 	[KeptMemberInAssembly ("other2.dll", typeof (OtherAssembly.Foo), "Method()")]
 	[KeptMemberInAssembly ("other2.dll", typeof (OtherAssembly.Foo), "UsedByMethod()")]
 	[KeptMemberInAssembly ("other2.dll", typeof (OtherAssembly), "UnusedSanityCheck()")]
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class LinkedOtherIncludedLibrary {
-		public static void Main()
+	public class LinkedOtherIncludedLibrary
+	{
+		public static void Main ()
 		{
 			UsedToMarkMethod (null);
 		}
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/LinkedOtherIncludedLibraryNoInstanceCtor.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/LinkedOtherIncludedLibraryNoInstanceCtor.cs
index 29f06e96e..9405f540b 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/LinkedOtherIncludedLibraryNoInstanceCtor.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/LinkedOtherIncludedLibraryNoInstanceCtor.cs
@@ -1,15 +1,17 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody  {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[Define ("OTHER_INCLUDED")]
 	[SetupLinkerArgument ("-r", "other")]
-	[SetupCompileBefore ("other.dll", new [] { "Dependencies/OtherAssemblyNoInstanceCtor.il" })]
+	[SetupCompileBefore ("other.dll", new[] { "Dependencies/OtherAssemblyNoInstanceCtor.il" })]
 	[KeptMemberInAssembly ("other.dll", "Mono.Linker.Tests.Cases.UnreachableBody.Dependencies.OtherAssemblyNoInstanceCtor/Foo", "Method()")]
 	[RemovedMemberInAssembly ("other.dll", "Mono.Linker.Tests.Cases.UnreachableBody.Dependencies.OtherAssemblyNoInstanceCtor/Foo", "UsedByMethod()")]
 	[KeptMemberInAssembly ("other.dll", "Mono.Linker.Tests.Cases.UnreachableBody.Dependencies.OtherAssemblyNoInstanceCtor", "UnusedSanityCheck()")]
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class LinkedOtherIncludedLibraryNoInstanceCtor {
+	public class LinkedOtherIncludedLibraryNoInstanceCtor
+	{
 		public static void Main ()
 		{
 #if OTHER_INCLUDED
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/MixOfMethods.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/MixOfMethods.cs
index 9f62b7f5b..990ab2261 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/MixOfMethods.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/MixOfMethods.cs
@@ -1,9 +1,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class MixOfMethods {
+	public class MixOfMethods
+	{
 		public static void Main ()
 		{
 			UseInstanceMethods (null);
@@ -18,18 +20,19 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 			f.Method1 ();
 			f.Method2 ();
 			f.Method3 ();
-			
+
 			f.BaseMethod1 ();
 			f.BaseMethod2 ();
 			f.BaseMethod3 ();
-			
+
 			f.Base2Method1 ();
 			f.Base2Method2 ();
 			f.Base2Method3 ();
 		}
-		
+
 		[Kept]
-		class Base {
+		class Base
+		{
 			[Kept]
 			[ExpectBodyModified]
 			public void BaseMethod1 ()
@@ -54,11 +57,11 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 			void UsedByInstance ()
 			{
 			}
-			
+
 			[Kept]
 			public static void BasePublicStatic ()
 			{
-				UsedByStatic();
+				UsedByStatic ();
 			}
 
 			[Kept]
@@ -69,7 +72,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 
 		[Kept]
 		[KeptBaseType (typeof (Base))]
-		class Base2 : Base {
+		class Base2 : Base
+		{
 			[Kept]
 			[ExpectBodyModified]
 			public void Base2Method1 ()
@@ -94,11 +98,11 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 			void UsedByInstance ()
 			{
 			}
-			
+
 			[Kept]
 			public static void Base2PublicStatic ()
 			{
-				UsedByStatic();
+				UsedByStatic ();
 			}
 
 			[Kept]
@@ -109,7 +113,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 
 		[Kept]
 		[KeptBaseType (typeof (Base2))]
-		class Foo : Base2 {
+		class Foo : Base2
+		{
 			[Kept]
 			[ExpectBodyModified]
 			public void Method1 ()
@@ -138,7 +143,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 			[Kept]
 			public static void PublicStatic ()
 			{
-				UsedByStatic();
+				UsedByStatic ();
 			}
 
 			[Kept]
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingEmpty.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingEmpty.cs
index 609506c13..b2b931a1e 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingEmpty.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingEmpty.cs
@@ -1,13 +1,15 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	/// <summary>
 	/// Stubbing an empty method would result in more instructions.  It's more size efficient to just leave it alone
 	/// </summary>
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class NotWorthConvertingEmpty {
-		public static void Main()
+	public class NotWorthConvertingEmpty
+	{
+		public static void Main ()
 		{
 			UsedToMarkMethod (null);
 		}
@@ -19,7 +21,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			public void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnDouble.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnDouble.cs
index 3ae5da068..c40fd355d 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnDouble.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnDouble.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupCompileArgument ("/optimize+")]
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class NotWorthConvertingReturnDouble {
+	public class NotWorthConvertingReturnDouble
+	{
 		public static void Main ()
 		{
 			UsedToMarkMethod (null);
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnFalse.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnFalse.cs
index 78f295976..c32933e53 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnFalse.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnFalse.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupCompileArgument ("/optimize+")]
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class NotWorthConvertingReturnFalse {
+	public class NotWorthConvertingReturnFalse
+	{
 		public static void Main ()
 		{
 			UsedToMarkMethod (null);
@@ -17,7 +19,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			public bool Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnFloat.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnFloat.cs
index a8204535a..de7209d4e 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnFloat.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnFloat.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupCompileArgument ("/optimize+")]
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class NotWorthConvertingReturnFloat {
+	public class NotWorthConvertingReturnFloat
+	{
 		public static void Main ()
 		{
 			UsedToMarkMethod (null);
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnInt.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnInt.cs
index c33d126c1..2133024b0 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnInt.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnInt.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupCompileArgument ("/optimize+")]
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class NotWorthConvertingReturnInt {
+	public class NotWorthConvertingReturnInt
+	{
 		public static void Main ()
 		{
 			UsedToMarkMethod (null);
@@ -26,61 +28,62 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			public int Method ()
 			{
 				return 0;
 			}
-			
+
 			[Kept]
 			public int Method1 ()
 			{
 				return 1;
 			}
-			
+
 			[Kept]
 			public int Method2 ()
 			{
 				return 2;
 			}
-			
+
 			[Kept]
 			public int Method3 ()
 			{
 				return 3;
 			}
-			
+
 			[Kept]
 			public int Method4 ()
 			{
 				return 4;
 			}
-			
+
 			[Kept]
 			public int Method5 ()
 			{
 				return 5;
 			}
-			
+
 			[Kept]
 			public int Method6 ()
 			{
 				return 6;
 			}
-			
+
 			[Kept]
 			public int Method7 ()
 			{
 				return 7;
 			}
-			
+
 			[Kept]
 			public int Method8 ()
 			{
 				return 8;
 			}
-			
+
 			[Kept]
 			public int Method9 ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnLong.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnLong.cs
index daad06c9f..5cd97fbbb 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnLong.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnLong.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupCompileArgument ("/optimize+")]
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class NotWorthConvertingReturnLong {
+	public class NotWorthConvertingReturnLong
+	{
 		public static void Main ()
 		{
 			UsedToMarkMethod (null);
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnNull.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnNull.cs
index d2c66f479..468b3490f 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnNull.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnNull.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupCompileArgument ("/optimize+")]
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class NotWorthConvertingReturnNull {
+	public class NotWorthConvertingReturnNull
+	{
 		public static void Main ()
 		{
 			UsedToMarkMethod (null);
@@ -17,7 +19,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			public object Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnTrue.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnTrue.cs
index 0883c9fdf..713ced928 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnTrue.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/NotWorthConvertingReturnTrue.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupCompileArgument ("/optimize+")]
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class NotWorthConvertingReturnTrue {
+	public class NotWorthConvertingReturnTrue
+	{
 		public static void Main ()
 		{
 			UsedToMarkMethod (null);
@@ -17,7 +19,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			public bool Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAVirtual.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAVirtual.cs
index 814a09353..69bc5c801 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAVirtual.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAVirtual.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class OverrideOfAVirtual {
-		public static void Main()
+	public class OverrideOfAVirtual
+	{
+		public static void Main ()
 		{
 			UsedToMarkMethod (null);
 		}
@@ -16,14 +18,15 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		class Base {
+		class Base
+		{
 			[Kept]
 			[ExpectBodyModified]
 			public virtual void Method ()
 			{
-				UsedByMethod();
+				UsedByMethod ();
 			}
-			
+
 			void UsedByMethod ()
 			{
 			}
@@ -31,7 +34,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 
 		[Kept]
 		[KeptBaseType (typeof (Base))]
-		class Foo : Base {
+		class Foo : Base
+		{
 			// A callvirt to Base.Method() appears in the IL so this override can be removed entirely
 			public override void Method ()
 			{
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractAndInterfaceMethodCalledFromLocal.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractAndInterfaceMethodCalledFromLocal.cs
index f5c7f942b..ff4b7c785 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractAndInterfaceMethodCalledFromLocal.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractAndInterfaceMethodCalledFromLocal.cs
@@ -1,9 +1,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class OverrideOfAbstractAndInterfaceMethodCalledFromLocal {
+	public class OverrideOfAbstractAndInterfaceMethodCalledFromLocal
+	{
 		public static void Main ()
 		{
 			Foo b = HelperToMarkFooAndRequireBase ();
@@ -18,7 +20,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		abstract class Base {
+		abstract class Base
+		{
 			[Kept] // FIXME : Technically this can be removed
 			public abstract void Method ();
 		}
@@ -26,7 +29,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		[Kept]
 		[KeptBaseType (typeof (Base))]
 		[KeptInterface (typeof (IBar))]
-		class Foo : Base, IBar {
+		class Foo : Base, IBar
+		{
 			[Kept]
 			[ExpectBodyModified]
 			public override void Method ()
@@ -40,7 +44,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		interface IBar {
+		interface IBar
+		{
 			[Kept]
 			void Method ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractAndInterfaceMethodCalledFromLocal2.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractAndInterfaceMethodCalledFromLocal2.cs
index be97dff57..57cb508c3 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractAndInterfaceMethodCalledFromLocal2.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractAndInterfaceMethodCalledFromLocal2.cs
@@ -1,9 +1,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class OverrideOfAbstractAndInterfaceMethodCalledFromLocal2 {
+	public class OverrideOfAbstractAndInterfaceMethodCalledFromLocal2
+	{
 		public static void Main ()
 		{
 			Foo f = HelperToMarkFooAndRequireBase ();
@@ -25,7 +27,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		abstract class Base {
+		abstract class Base
+		{
 			[Kept] // FIXME : Technically this can be removed
 			public abstract void Method ();
 		}
@@ -33,7 +36,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		[Kept]
 		[KeptBaseType (typeof (Base))]
 		[KeptInterface (typeof (IBar))]
-		class Foo : Base, IBar {
+		class Foo : Base, IBar
+		{
 			[Kept]
 			[ExpectBodyModified]
 			public override void Method ()
@@ -47,9 +51,10 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		interface IBar {
+		interface IBar
+		{
 			[Kept]
-			void Method();
+			void Method ();
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractAndInterfaceMethodCalledFromLocal3.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractAndInterfaceMethodCalledFromLocal3.cs
index aa5dcd903..665d6d342 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractAndInterfaceMethodCalledFromLocal3.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractAndInterfaceMethodCalledFromLocal3.cs
@@ -1,9 +1,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class OverrideOfAbstractAndInterfaceMethodCalledFromLocal3 {
+	public class OverrideOfAbstractAndInterfaceMethodCalledFromLocal3
+	{
 		public static void Main ()
 		{
 			Foo b = null;
@@ -12,7 +14,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		abstract class Base {
+		abstract class Base
+		{
 			[Kept] // FIXME : Technically this can be removed
 			public abstract void Method ();
 		}
@@ -20,7 +23,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		[Kept]
 		[KeptBaseType (typeof (Base))]
 		[KeptInterface (typeof (IBar))]
-		class Foo : Base, IBar {
+		class Foo : Base, IBar
+		{
 			[Kept]
 			[ExpectBodyModified]
 			public override void Method ()
@@ -34,7 +38,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		interface IBar {
+		interface IBar
+		{
 			[Kept]
 			void Method ();
 		}
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved2.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved2.cs
index 18337629a..0f6ed0d7d 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved2.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved2.cs
@@ -1,9 +1,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved2 {
+	public class OverrideOfAbstractAndInterfaceMethodWhenInterfaceRemoved2
+	{
 		public static void Main ()
 		{
 			Foo f = HelperToMarkFooAndRequireBase ();
@@ -23,22 +25,24 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		{
 			return null;
 		}
-		
+
 		[Kept]
-		static void HelperToMarkIBar()
+		static void HelperToMarkIBar ()
 		{
-			GetAnIBar().Method();
+			GetAnIBar ().Method ();
 		}
 
 		[Kept]
-		abstract class Base {
+		abstract class Base
+		{
 			[Kept]
 			public abstract void Method ();
 		}
 
 		[Kept]
 		[KeptBaseType (typeof (Base))]
-		class Foo : Base, IBar {
+		class Foo : Base, IBar
+		{
 			[Kept]
 			[ExpectBodyModified]
 			public override void Method ()
@@ -52,9 +56,10 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		interface IBar {
+		interface IBar
+		{
 			[Kept]
-			void Method();
+			void Method ();
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractIsStubbed.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractIsStubbed.cs
index 83cd63392..f8ba8548b 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractIsStubbed.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractIsStubbed.cs
@@ -1,9 +1,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class OverrideOfAbstractIsStubbed {
+	public class OverrideOfAbstractIsStubbed
+	{
 		public static void Main ()
 		{
 			Base b = HelperToMarkFooAndRequireBase ();
@@ -25,7 +27,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 
 		[Kept]
 		[KeptBaseType (typeof (Base))]
-		class Foo : Base {
+		class Foo : Base
+		{
 			[Kept]
 			[ExpectBodyModified]
 			public override void Method ()
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractIsStubbedWithUnusedInterface.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractIsStubbedWithUnusedInterface.cs
index 56e73a881..4c50d9d08 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractIsStubbedWithUnusedInterface.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/OverrideOfAbstractIsStubbedWithUnusedInterface.cs
@@ -1,9 +1,11 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class OverrideOfAbstractIsStubbedWithUnusedInterface {
+	public class OverrideOfAbstractIsStubbedWithUnusedInterface
+	{
 		public static void Main ()
 		{
 			Base b = HelperToMarkFooAndRequireBase ();
@@ -25,7 +27,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 
 		[Kept]
 		[KeptBaseType (typeof (Base))]
-		class Foo : Base, IBar {
+		class Foo : Base, IBar
+		{
 			[Kept]
 			[ExpectBodyModified]
 			public override void Method ()
@@ -40,7 +43,7 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 
 		interface IBar
 		{
-			void Method();
+			void Method ();
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/SimpleGetter.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/SimpleGetter.cs
index 7950d5524..7cf0078e4 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/SimpleGetter.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/SimpleGetter.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class SimpleGetter {
-		public static void Main()
+	public class SimpleGetter
+	{
+		public static void Main ()
 		{
 			UsedToMarkMethod (null);
 		}
@@ -16,7 +18,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			public string Property { [Kept] [ExpectBodyModified] get; set; }
 		}
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/SimpleMethod.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/SimpleMethod.cs
index 00f8baec3..fd29e7f07 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/SimpleMethod.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/SimpleMethod.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class SimpleMethod {
-		public static void Main()
+	public class SimpleMethod
+	{
+		public static void Main ()
 		{
 			UsedToMarkMethod (null);
 		}
@@ -16,7 +18,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[ExpectBodyModified]
 			public void Method ()
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/SimpleSetter.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/SimpleSetter.cs
index 0a5d63c4f..971477418 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/SimpleSetter.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/SimpleSetter.cs
@@ -1,10 +1,12 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class SimpleSetter {
-		public static void Main()
+	public class SimpleSetter
+	{
+		public static void Main ()
 		{
 			UsedToMarkMethod (null);
 		}
@@ -16,7 +18,8 @@ namespace Mono.Linker.Tests.Cases.UnreachableBody {
 		}
 
 		[Kept]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			public string Property { get; [Kept] [ExpectBodyModified] set; }
 		}
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/WorksWithLinkXml.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/WorksWithLinkXml.cs
index 54750a377..99e667a52 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/WorksWithLinkXml.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/WorksWithLinkXml.cs
@@ -1,15 +1,18 @@
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	public class WorksWithLinkXml {
-		public static void Main()
+	public class WorksWithLinkXml
+	{
+		public static void Main ()
 		{
 		}
 
 		[Kept]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[ExpectBodyModified]
 			public void InstanceMethod ()
diff --git a/test/Mono.Linker.Tests.Cases/UnreachableBody/WorksWithPreserveDependency.cs b/test/Mono.Linker.Tests.Cases/UnreachableBody/WorksWithPreserveDependency.cs
index ea2ffef58..5f4cad1d2 100644
--- a/test/Mono.Linker.Tests.Cases/UnreachableBody/WorksWithPreserveDependency.cs
+++ b/test/Mono.Linker.Tests.Cases/UnreachableBody/WorksWithPreserveDependency.cs
@@ -2,17 +2,20 @@ using System.Runtime.CompilerServices;
 using Mono.Linker.Tests.Cases.Expectations.Assertions;
 using Mono.Linker.Tests.Cases.Expectations.Metadata;
 
-namespace Mono.Linker.Tests.Cases.UnreachableBody {
+namespace Mono.Linker.Tests.Cases.UnreachableBody
+{
 	[SetupLinkerArgument ("--enable-opt", "unreachablebodies")]
-	[SetupCompileBefore ("FakeSystemAssembly.dll", new [] { "../PreserveDependencies/Dependencies/PreserveDependencyAttribute.cs" })]
-	public class WorksWithPreserveDependency {
-		public static void Main()
+	[SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "../PreserveDependencies/Dependencies/PreserveDependencyAttribute.cs" })]
+	public class WorksWithPreserveDependency
+	{
+		public static void Main ()
 		{
 			Foo.StaticMethod ();
 		}
 
 		[Kept]
-		class Foo {
+		class Foo
+		{
 			[Kept]
 			[PreserveDependency ("InstanceMethod()")]
 			public static void StaticMethod ()