test: refactoring (renaming)

Author: yv989c

tests/QueryableValues.SqlServer.Tests/Integration/SimpleTypeTests.cs

@@ -362,31 +362,31 @@ public async Task MustMatchSequenceOfGuid()
             Assert.Equal(expected, actual);
         }
 
-        enum MyByteEnum : byte
+        enum ByteEnum : byte
         {
             None,
             A,
             B,
             C
         }
 
-        enum MyInt16Enum : short
+        enum Int16Enum : short
         {
             None,
             A,
             B,
             C
         }
 
-        enum MyInt32Enum
+        enum Int32Enum
         {
             None,
             A,
             B,
             C
         }
 
-        enum MyInt64Enum : long
+        enum Int64Enum : long
         {
             None,
             A,
@@ -399,12 +399,12 @@ public async Task MustMatchSequenceOfEnumByte()
         {
             var expected = new[]
             {
-                MyByteEnum.None,
-                MyByteEnum.A,
-                MyByteEnum.A,
-                MyByteEnum.B,
-                MyByteEnum.C,
-                MyByteEnum.A
+                ByteEnum.None,
+                ByteEnum.A,
+                ByteEnum.A,
+                ByteEnum.B,
+                ByteEnum.C,
+                ByteEnum.A
             };
 
             var actual = await _db.AsQueryableValues(expected).ToListAsync();
@@ -417,12 +417,12 @@ public async Task MustMatchSequenceOfEnumInt16()
         {
             var expected = new[]
             {
-                MyInt16Enum.None,
-                MyInt16Enum.A,
-                MyInt16Enum.A,
-                MyInt16Enum.B,
-                MyInt16Enum.C,
-                MyInt16Enum.A
+                Int16Enum.None,
+                Int16Enum.A,
+                Int16Enum.A,
+                Int16Enum.B,
+                Int16Enum.C,
+                Int16Enum.A
             };
 
             var actual = await _db.AsQueryableValues(expected).ToListAsync();
@@ -435,12 +435,12 @@ public async Task MustMatchSequenceOfEnumInt32()
         {
             var expected = new[]
             {
-                MyInt32Enum.A,
-                MyInt32Enum.A,
-                MyInt32Enum.B,
-                MyInt32Enum.C,
-                MyInt32Enum.A,
-                MyInt32Enum.None
+                Int32Enum.A,
+                Int32Enum.A,
+                Int32Enum.B,
+                Int32Enum.C,
+                Int32Enum.A,
+                Int32Enum.None
             };
 
             var actual = await _db.AsQueryableValues(expected).ToListAsync();
@@ -453,12 +453,12 @@ public async Task MustMatchSequenceOfEnumInt64()
         {
             var expected = new[]
             {
-                MyInt64Enum.A,
-                MyInt64Enum.A,
-                MyInt64Enum.B,
-                MyInt64Enum.C,
-                MyInt64Enum.A,
-                MyInt64Enum.None
+                Int64Enum.A,
+                Int64Enum.A,
+                Int64Enum.B,
+                Int64Enum.C,
+                Int64Enum.A,
+                Int64Enum.None
             };
 
             var actual = await _db.AsQueryableValues(expected).ToListAsync();
@@ -834,10 +834,10 @@ public async Task MustBeEmptyEnum()
         {
             var testCounter = 0;
 
-            await AssertEmpty<MyByteEnum>();
-            await AssertEmpty<MyInt16Enum>();
-            await AssertEmpty<MyInt32Enum>();
-            await AssertEmpty<MyInt64Enum>();
+            await AssertEmpty<ByteEnum>();
+            await AssertEmpty<Int16Enum>();
+            await AssertEmpty<Int32Enum>();
+            await AssertEmpty<Int64Enum>();
 
             // Coverage check.
             var expectedTestCount = 4;
@@ -894,10 +894,10 @@ public async Task MustMatchCountEnum()
 
             var testCounter = 0;
 
-            await AssertCount(i => (MyByteEnum)(i % 4));
-            await AssertCount(i => (MyInt16Enum)(i % 4));
-            await AssertCount(i => (MyInt32Enum)(i % 4));
-            await AssertCount(i => (MyInt64Enum)(i % 4));
+            await AssertCount(i => (ByteEnum)(i % 4));
+            await AssertCount(i => (Int16Enum)(i % 4));
+            await AssertCount(i => (Int32Enum)(i % 4));
+            await AssertCount(i => (Int64Enum)(i % 4));
 
             // Coverage check.
             var expectedTestCount = 4;