Get Non-windows platforms working

src/NServiceBus.Core.Tests/StructConventionsTests.ApproveStructsWhichDontFollowStructGuidelines.approved.txt

@@ -13,4 +13,5 @@ In all other cases, you should define your types as classes.
 NServiceBus.LogicalAddress violates the following rules:
    - The following fields are reference types, which are potentially mutable:
       - Field <EndpointInstance>k__BackingField of type NServiceBus.Routing.EndpointInstance is a reference type.
+   - The size cannot be determined because there are fields that are reference types.
 

src/NServiceBus.Core.Tests/StructConventionsTests.cs

@@ -30,34 +30,46 @@ public void ApproveStructsWhichDontFollowStructGuidelines()
 ");
 
             var assembly = typeof(Endpoint).Assembly;
+
             foreach (var type in assembly.GetTypes().OrderBy(t => t.FullName))
             {
-                if (!type.IsValueType || type.IsEnum || type.IsSpecialName|| type.Namespace == null || !type.Namespace.StartsWith("NServiceBus") || type.FullName.Contains("__")) continue;
+                if (!type.IsValueType || type.IsEnum || type.IsSpecialName || type.Namespace == null || !type.Namespace.StartsWith("NServiceBus") || type.FullName.Contains("__"))
+                {
+                    continue;
+                }
 
                 var violatedRules = new List<string> { $"{type.FullName} violates the following rules:" };
 
-                InspectSizeOfStruct(type, violatedRules);
-                InspectWhetherStructViolatesMutabilityRules(type, violatedRules);
+                InspectWhetherStructContainsPublicFields(type, violatedRules);
+                InspectWhetherStructContainsWritableProperties(type, violatedRules);
+                var containsRefereneceTypes = InspectWhetherStructContainsReferenceTypes(type, violatedRules);
+
+                if (containsRefereneceTypes)
+                {
+                    violatedRules.Add("   - The size cannot be determined because there are fields that are reference types.");
+                }
+                else
+                {
+                    InspectSizeOfStruct(type, violatedRules);
+                }
+
+                if (violatedRules.Count <= 1)
+                {
+                    continue;
+                }
 
-                if (violatedRules.Count <= 1) continue;
                 foreach (var violatedRule in violatedRules)
                 {
                     approvalBuilder.AppendLine(violatedRule);
                 }
+
                 approvalBuilder.AppendLine();
             }
 
             Approvals.Verify(approvalBuilder.ToString());
         }
 
-        static void InspectWhetherStructViolatesMutabilityRules(Type type, List<string> violatedRules)
-        {
-            InspectWhetherStructContainsReferenceTypes(type, violatedRules);
-            InspectWhetherStructContainsPublicFields(type, violatedRules);
-            InspectWhetherStructContainsWritableProperties(type, violatedRules);
-        }
-
-        static void InspectWhetherStructContainsReferenceTypes(Type type, List<string> violatedRules)
+        static bool InspectWhetherStructContainsReferenceTypes(Type type, List<string> violatedRules)
         {
             var mutabilityRules = new List<string> { "   - The following fields are reference types, which are potentially mutable:" };
 
@@ -76,11 +88,17 @@ static void InspectWhetherStructContainsReferenceTypes(Type type, List<string> v
                 }
             }
 
-            if(mutabilityRules.Count > 1)
+            if (mutabilityRules.Count > 1)
+            {
                 violatedRules.AddRange(mutabilityRules);
+
+                return true;
+            }
+
+            return false;
         }
 
-        static void InspectWhetherStructContainsPublicFields(Type type, List<string> violatedRules)
+        static bool InspectWhetherStructContainsPublicFields(Type type, List<string> violatedRules)
         {
             var mutabilityRules = new List<string> { "   - The following fields are public, so the type is not immutable:" };
 
@@ -95,10 +113,16 @@ static void InspectWhetherStructContainsPublicFields(Type type, List<string> vio
             }
 
             if (mutabilityRules.Count > 1)
+            {
                 violatedRules.AddRange(mutabilityRules);
+
+                return true;
+            }
+
+            return false;
         }
 
-        static void InspectWhetherStructContainsWritableProperties(Type type, List<string> violatedRules)
+        static bool InspectWhetherStructContainsWritableProperties(Type type, List<string> violatedRules)
         {
             var mutabilityRules = new List<string> { "   - The following properties can be written to, so the type is not immutable:" };
 
@@ -113,17 +137,24 @@ static void InspectWhetherStructContainsWritableProperties(Type type, List<strin
             }
 
             if (mutabilityRules.Count > 1)
+            {
                 violatedRules.AddRange(mutabilityRules);
+
+                return true;
+            }
+
+            return false;
         }
 
         static void InspectSizeOfStruct(Type type, List<string> violatedRules)
         {
             try
             {
-                var sizeOf = Marshal.SizeOf(type);
-                if (IsLargerThanSixteenBytes(sizeOf))
+                var size = Marshal.SizeOf(type);
+
+                if (IsLargerThanSixteenBytes(size))
                 {
-                    violatedRules.Add($"   - The size is {sizeOf} bytes, which exceeds the recommended maximum of 16 bytes.");
+                    violatedRules.Add($"   - The size is {size} bytes, which exceeds the recommended maximum of 16 bytes.");
                 }
             }
             catch (Exception)
@@ -132,9 +163,6 @@ static void InspectSizeOfStruct(Type type, List<string> violatedRules)
             }
         }
 
-        static bool IsLargerThanSixteenBytes(int sizeOf)
-        {
-            return sizeOf > 16;
-        }
+        static bool IsLargerThanSixteenBytes(int size) => size > 16;
     }
 }