Changed each test to have arrange/act/assert

CLVMDotNet/tests/CLVM/CLVMObject/InstantiationTests.cs

@@ -13,8 +13,13 @@ public class InstantiationTests
     [InlineData(0x03, 0x03)]
     public void Constructor_with_tuple_sets_pair(dynamic? left, dynamic? right)
     {
+        // Arrange
         Tuple<dynamic?, dynamic?> tuple = new Tuple<dynamic?, dynamic?>(left, right);
+
+        // Act
         var clvmobject = new x.CLVMObject(tuple);
+
+        // Assert
         Assert.NotNull(clvmobject.Pair);
         Assert.Null(clvmobject.Atom);
     }
@@ -25,39 +30,52 @@ public void Constructor_with_tuple_sets_pair(dynamic? left, dynamic? right)
     [InlineData(0x03)]
     public void Constructor_with_atom_sets_atom(dynamic atom)
     {
+        // Arrange
+
+        // Act
         var clvmobject = new x.CLVMObject(atom);
+
+        // Assert
         Assert.NotNull(clvmobject.Atom);
         Assert.Null(clvmobject.Pair);
     }
 
     [Fact]
     public void Constructor_with_sexp_sets_atom()
     {
+        // Arrange
         var sexp = x.SExp.To(0x03);
+
+        // Act
         var clvmobject = new x.CLVMObject(sexp);
+
+        // Assert
         Assert.NotNull(clvmobject.Atom);
         Assert.Null(clvmobject.Pair);
     }
 
     [Fact]
     public void Constructor_with_invalid_tuple_shape()
     {
+        // Arrange
+
+        // Act
         var errorLength3 =
             Assert.Throws<ArgumentException>(() =>
                 new x.CLVMObject((1, 2, 3))
             );
-        Assert.Contains("tuples must be of size 2", errorLength3.Message);
-
         var errorLength4 =
             Assert.Throws<ArgumentException>(() =>
                 new x.CLVMObject((1, 2, 3, 4))
             );
-        Assert.Contains("tuples must be of size 2", errorLength4.Message);
-
         var errorLength5 =
             Assert.Throws<ArgumentException>(() =>
                 new x.CLVMObject((1, 2, 3, 4, 5))
             );
+
+        // Assert
+        Assert.Contains("tuples must be of size 2", errorLength3.Message);
+        Assert.Contains("tuples must be of size 2", errorLength4.Message);
         Assert.Contains("tuples must be of size 2", errorLength5.Message);
     }
 }

CLVMDotNet/tests/CLVM/Casts/IntFromBytes.cs

@@ -26,8 +26,13 @@ public class IntFromBytes
         [InlineData("20482048204820482048", new byte[] { 0x01, 0x1C, 0x3E, 0xDA, 0x52, 0xE0, 0xC0, 0x88, 0x00 })]
         public void IntFromBytes_returns_expectedint(string expectedNumberStr, byte[] from_bytes)
         {
+            // Arrange
             BigInteger expectedNumber = BigInteger.Parse(expectedNumberStr);
+
+            // Act
             var returnedBytes = x.Casts.IntFromBytes(from_bytes);
+
+            // Assert
             Assert.Equal(expectedNumber, returnedBytes);
         }
     }

CLVMDotNet/tests/CLVM/Casts/IntToBytes.cs

@@ -41,8 +41,13 @@ public class IntToBytes
         // })]
         public void IntToBytes_returns_expectedbytes(string numberStr, byte[] expectedBytes)
         {
+            // Arrange
             BigInteger number = BigInteger.Parse(numberStr);
+
+            // Act
             var returnedBytes = x.Casts.IntToBytes(number);
+
+            // Assert
             Assert.Equal(expectedBytes, returnedBytes);
         }
     }

CLVMDotNet/tests/CLVM/Casts/LimbsForInt.cs

@@ -21,8 +21,13 @@ public class LimbsForInt
         [InlineData("20482048204820482048", 9)]
         public void LimbsForInt_returns_expectedlength(string numStr, int expectedNumberOfBytes)
         {
+            // Arrange
             BigInteger num = BigInteger.Parse(numStr);
+
+            // Act
             var numberOfBytes = x.Casts.LimbsForInt(num);
+
+            // Assert
             Assert.Equal(expectedNumberOfBytes, numberOfBytes);
         }
     }

CLVMDotNet/tests/CLVM/HelperFunctions/MSBMask.cs

@@ -22,7 +22,13 @@ public class MSBMask
         [InlineData(0x80, 0xFF)]
         public void TestMsbMask(byte expectedbyte, byte MSB)
         {
-            Assert.Equal(expectedbyte, x.HelperFunctions.MSBMask(MSB));
+            // Arrange
+
+            // Act
+            var result = x.HelperFunctions.MSBMask(MSB);
+
+            // Assert
+            Assert.Equal(expectedbyte, result);
         }
     }
 }