ConvertStringAndIntToEnum: retarget net10.0, rename DayOfWeek to WeekDay, generic Enum overloads

csharp-basic-topics/ConvertStringAndIntToEnum/ConvertStringAndIntToEnumTests/ConvertStringAndIntToEnumTests.cs

@@ -1,85 +1,123 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System;
 
-namespace ConvertStringAndIntToEnumTests
+namespace ConvertStringAndIntToEnumTests;
+
+[TestClass]
+public class ConvertStringAndIntToEnumTests
 {
-    [TestClass]
-    public class ConvertStringAndIntToEnumTests
+    [TestMethod]
+    public void GivenValidEnumAsString_WhenConvertingToEnum_ThenCorrectlyConverted()
     {
-        [TestMethod]
-        public void GivenValidEnumAsString_WhenConvertingToEnum_ThenCorrectlyConverted()
-        {
-            var inputString = "Sunday";
-
-            DayOfWeek dayOfWeek = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), inputString);
-
-            Assert.AreEqual(DayOfWeek.Sunday, dayOfWeek);
-        }
+        var inputString = "Sunday";
+        var mixedCaseInputString = "SaTurDaY";
 
-        [TestMethod]
-        public void GivenInvalidEnumAsString_WhenConvertingToEnum_ThenFails()
-        {
-            var inputString = "Today";
-
-            var isEnumParsed = Enum.TryParse(inputString, true, out DayOfWeek dayOfWeek);
-
-            Assert.IsFalse(isEnumParsed);
-        }
+        var weekDay = Enum.Parse<WeekDay>(inputString);
+        var caseInsensitiveWeekDay = Enum.Parse<WeekDay>(mixedCaseInputString, true);
 
-        [TestMethod]
-        public void GivenValidEnumAsStringInteger_WhenConvertingToEnum_ThenCorrectlyConverted()
-        {
-            var inputString = "0";
-
-            var isEnumParsed = Enum.TryParse(inputString, true, out DayOfWeek dayOfWeek);
-
-            Assert.IsTrue(isEnumParsed);
-            Assert.AreEqual(DayOfWeek.Monday, dayOfWeek);
-        }
+        Assert.AreEqual(WeekDay.Sunday, weekDay);
+        Assert.AreEqual(WeekDay.Saturday, caseInsensitiveWeekDay);
+    }
 
-        [TestMethod]
-        public void GivenValidEnumAsInteger_WhenConvertingToEnum_ThenCorrectlyConverted()
-        {
-            var inputInt = 2;
-
-            var isEnumParsed = Enum.IsDefined(typeof(DayOfWeek), inputInt);
-
-            Assert.IsTrue(isEnumParsed);
-            DayOfWeek dayOfWeek = (DayOfWeek)inputInt;
-            Assert.AreEqual(DayOfWeek.Wednesday, dayOfWeek);
-        }
+    [TestMethod]
+    public void GivenInvalidEnumAsString_WhenConvertingToEnum_ThenFails()
+    {
+        var inputString = "Today";
 
-        [TestMethod]
-        public void GivenInvalidEnumAsInteger_WhenConvertingToEnum_ThenFails()
-        {
-            var inputInt = 9;
-
-            var isEnumParsed = Enum.IsDefined(typeof(DayOfWeek), inputInt);
-
-            Assert.IsFalse(isEnumParsed);
-        }
+        var isEnumParsed = Enum.TryParse(inputString, true, out WeekDay weekDay);
+
+        Assert.IsFalse(isEnumParsed);
+    }
+
+    [TestMethod]
+    public void GivenValidEnumAsStringInteger_WhenConvertingToEnum_ThenCorrectlyConverted()
+    {
+        var inputString = "0";
+
+        var isEnumParsed = Enum.TryParse(inputString, true, out WeekDay weekDay);
+
+        Assert.IsTrue(isEnumParsed);
+        Assert.AreEqual(WeekDay.Monday, weekDay);
+    }
+
+    [TestMethod]
+    public void GivenNumericStringThatIsNotAMember_WhenConvertingToEnum_ThenParsesIntoAnUndefinedValue()
+    {
+        var inputString = "42";
+
+        var isEnumParsed = Enum.TryParse<WeekDay>(inputString, out var weekDay);
+
+        Assert.IsTrue(isEnumParsed);
+        Assert.IsFalse(Enum.IsDefined(weekDay));
+        Assert.AreEqual("42", weekDay.ToString());
+    }
+
+    [TestMethod]
+    public void GivenValidEnumAsInteger_WhenConvertingToEnum_ThenCorrectlyConverted()
+    {
+        var inputInt = 2;
+
+        var isEnumParsed = Enum.IsDefined((WeekDay)inputInt);
+
+        Assert.IsTrue(isEnumParsed);
+        WeekDay weekDay = (WeekDay)inputInt;
+        Assert.AreEqual(WeekDay.Wednesday, weekDay);
+    }
+
+    [TestMethod]
+    public void GivenInvalidEnumAsInteger_WhenConvertingToEnum_ThenFails()
+    {
+        var inputInt = 9;
+
+        var isEnumParsed = Enum.IsDefined((WeekDay)inputInt);
+
+        Assert.IsFalse(isEnumParsed);
+    }
+
+    [TestMethod]
+    public void GivenValidFlagsEnumAsInteger_WhenConvertingToEnum_ThenCorrectlyConverted()
+    {
+        var inputInt = 3;
+        var parsedEnum = (UserType)inputInt;
+
+        var isEnumParsed = Enum.IsDefined(parsedEnum) || parsedEnum.ToString().Contains(",");
+
+        Assert.IsTrue(isEnumParsed);
+        Assert.AreEqual(UserType.Customer | UserType.Driver, parsedEnum);
+    }
+
+    [TestMethod]
+    public void GivenInvalidFlagsEnumAsInteger_WhenConvertingToEnum_ThenFails()
+    {
+        var inputInt = 8;
+        var parsedEnum = (UserType)inputInt;
+
+        var isEnumParsed = Enum.IsDefined(parsedEnum) || parsedEnum.ToString().Contains(",");
 
-        [TestMethod]
-        public void GivenValidFlagsEnumAsInteger_WhenConvertingToEnum_ThenCorrectlyConverted()
+        Assert.IsFalse(isEnumParsed);
+    }
+
+    [TestMethod]
+    public void GivenFlagsEnumValues_WhenCheckingAgainstTheDeclaredFlagsMask_ThenOnlyDeclaredCombinationsAreValid()
+    {
+        var allFlags = (UserType)0;
+
+        foreach (var flag in Enum.GetValues<UserType>())
         {
-            var inputInt = 3;
-            var parsedEnum = (UserType)inputInt;
-
-            var isEnumParsed = Enum.IsDefined(typeof(UserType), inputInt) || parsedEnum.ToString().Contains(",");
-
-            Assert.IsTrue(isEnumParsed);
-            Assert.AreEqual(UserType.Customer| UserType.Driver, parsedEnum);
+            allFlags |= flag;
         }
 
-        [TestMethod]
-        public void GivenInvalidFlagsEnumAsInteger_WhenConvertingToEnum_ThenFails()
+        Assert.AreEqual((UserType)7, allFlags);
+
+        for (var inputInt = 0; inputInt <= 7; inputInt++)
         {
-            var inputInt = 8;
             var parsedEnum = (UserType)inputInt;
-
-            var isEnumParsed = Enum.IsDefined(typeof(UserType), inputInt) || parsedEnum.ToString().Contains(",");
-
-            Assert.IsFalse(isEnumParsed);
+
+            Assert.IsTrue((parsedEnum & ~allFlags) == 0, $"{inputInt} should be a valid combination");
         }
+
+        var invalidEnum = (UserType)8;
+
+        Assert.IsFalse((invalidEnum & ~allFlags) == 0);
     }
-}
+}

csharp-basic-topics/ConvertStringAndIntToEnum/ConvertStringAndIntToEnumTests/ConvertStringAndIntToEnumTests.csproj

@@ -1,17 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <Nullable>enable</Nullable>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
-    <PackageReference Include="MSTest.TestAdapter" Version="2.2.7" />
-    <PackageReference Include="MSTest.TestFramework" Version="2.2.7" />
-    <PackageReference Include="coverlet.collector" Version="3.1.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.9.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="4.3.3" />
+    <PackageReference Include="MSTest.TestFramework" Version="4.3.3" />
+    <PackageReference Include="coverlet.collector" Version="10.0.1" />
   </ItemGroup>
 
 </Project>

csharp-basic-topics/ConvertStringAndIntToEnum/ConvertStringAndIntToEnumTests/UserType.cs

@@ -1,13 +1,12 @@
-using System;
+using System;
 
-namespace ConvertStringAndIntToEnumTests
+namespace ConvertStringAndIntToEnumTests;
+
+[Flags]
+public enum UserType
 {
-    [Flags]
-    public enum UserType
-    {
-        None = 0,
-        Customer = 1,
-        Driver = 2,
-        Admin = 4,
-    }
+    None = 0,
+    Customer = 1,
+    Driver = 2,
+    Admin = 4,
 }

csharp-basic-topics/ConvertStringAndIntToEnum/ConvertStringAndIntToEnumTests/WeekDay.cs

@@ -0,0 +1,12 @@
+namespace ConvertStringAndIntToEnumTests;
+
+public enum WeekDay
+{
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+    Sunday
+}