Fill in another significant chunk of extension tests

MPF.Test/RedumpLib/ExtensionsTests.cs

@@ -6,6 +6,7 @@ using Xunit;
 
 namespace MPF.Test.RedumpLib
 {
+    // TODO: Add tests for string-to-enum conversion
     public class ExtensionsTests
     {
         #region Cross-Enumeration
@@ -51,7 +52,7 @@ namespace MPF.Test.RedumpLib
         /// </summary>
         /// <param name="redumpSystem">RedumpSystem value to check</param>
         [Theory]
-        [MemberData(nameof(GenerateRedumpSystemTestData))]
+        [MemberData(nameof(GenerateRedumpSystemMappingTestData))]
         public void MediaTypesTest(RedumpSystem? redumpSystem)
         {
             var actual = redumpSystem.MediaTypes();
@@ -64,7 +65,7 @@ namespace MPF.Test.RedumpLib
         /// <param name="mediaType">MediaType value to check</param>
         /// <param name="expectNull">True to expect a null mapping, false otherwise</param>
         [Theory]
-        [MemberData(nameof(GenerateMediaTypeTestData))]
+        [MemberData(nameof(GenerateMediaTypeMappingTestData))]
         public void ToDiscTypeTest(MediaType? mediaType, bool expectNull)
         {
             DiscType? actual = mediaType.ToDiscType();
@@ -77,7 +78,7 @@ namespace MPF.Test.RedumpLib
         /// <param name="discType">DiscType value to check</param>
         /// <param name="expectNull">True to expect a null mapping, false otherwise</param>
         [Theory]
-        [MemberData(nameof(GenerateDiscTypeTestData))]
+        [MemberData(nameof(GenerateDiscTypeMappingTestData))]
         public void ToMediaTypeTest(DiscType? discType, bool expectNull)
         {
             MediaType? actual = discType.ToMediaType();
@@ -88,7 +89,7 @@ namespace MPF.Test.RedumpLib
         /// Generate a test set of DiscType values
         /// </summary>
         /// <returns>MemberData-compatible list of DiscType values</returns>
-        public static List<object[]> GenerateDiscTypeTestData()
+        public static List<object[]> GenerateDiscTypeMappingTestData()
         {
             var testData = new List<object[]>() { new object[] { null, true } };
             foreach (DiscType? discType in Enum.GetValues(typeof(DiscType)))
@@ -106,7 +107,7 @@ namespace MPF.Test.RedumpLib
         /// Generate a test set of RedumpSystem values
         /// </summary>
         /// <returns>MemberData-compatible list of RedumpSystem values</returns>
-        public static List<object[]> GenerateRedumpSystemTestData()
+        public static List<object[]> GenerateRedumpSystemMappingTestData()
         {
             var testData = new List<object[]>() { new object[] { null } };
             foreach (RedumpSystem? redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
@@ -121,7 +122,7 @@ namespace MPF.Test.RedumpLib
         /// Generate a test set of mappable media types
         /// </summary>
         /// <returns>MemberData-compatible list of MediaTypes</returns>
-        public static List<object[]> GenerateMediaTypeTestData()
+        public static List<object[]> GenerateMediaTypeMappingTestData()
         {
             var testData = new List<object[]>() { new object[] { null, true } };
 
@@ -137,5 +138,274 @@ namespace MPF.Test.RedumpLib
         }
 
         #endregion
+
+        #region Disc Category
+
+        /// <summary>
+        /// Check that every DiscCategory has a long name provided
+        /// </summary>
+        /// <param name="discCategory">DiscCategory value to check</param>
+        [Theory]
+        [MemberData(nameof(GenerateDiscCategoryTestData))]
+        public void DiscCategoryLongNameTest(DiscCategory? discCategory, bool expectNull)
+        {
+            string actual = discCategory.LongName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Generate a test set of DiscCategory values
+        /// </summary>
+        /// <returns>MemberData-compatible list of DiscCategory values</returns>
+        public static List<object[]> GenerateDiscCategoryTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (DiscCategory? discCategory in Enum.GetValues(typeof(DiscCategory)))
+            {
+                testData.Add(new object[] { discCategory, false });
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region Disc Type
+
+        /// <summary>
+        /// Check that every DiscType has a long name provided
+        /// </summary>
+        /// <param name="discType">DiscType value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateDiscTypeTestData))]
+        public void DiscTypeLongNameTest(DiscType? discType, bool expectNull)
+        {
+            string actual = discType.LongName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Generate a test set of DiscType values
+        /// </summary>
+        /// <returns>MemberData-compatible list of DiscType values</returns>
+        public static List<object[]> GenerateDiscTypeTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (DiscType? discType in Enum.GetValues(typeof(DiscType)))
+            {
+                if (discType == DiscType.NONE)
+                    testData.Add(new object[] { discType, true });
+                else
+                    testData.Add(new object[] { discType, false });
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region Language
+
+        /// <summary>
+        /// Check that every Language has a long name provided
+        /// </summary>
+        /// <param name="language">Language value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateLanguageTestData))]
+        public void LanguageLongNameTest(Language? language, bool expectNull)
+        {
+            string actual = language.LongName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Check that every Language has a short name provided
+        /// </summary>
+        /// <param name="language">Language value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateLanguageTestData))]
+        public void LanguageShortNameTest(Language? language, bool expectNull)
+        {
+            string actual = language.ShortName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Generate a test set of Language values
+        /// </summary>
+        /// <returns>MemberData-compatible list of Language values</returns>
+        public static List<object[]> GenerateLanguageTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (Language? language in Enum.GetValues(typeof(Language)))
+            {
+                testData.Add(new object[] { language, false });
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region Language Selection
+
+        /// <summary>
+        /// Check that every LanguageSelection has a long name provided
+        /// </summary>
+        /// <param name="languageSelection">LanguageSelection value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateLanguageSelectionTestData))]
+        public void LanguageSelectionLongNameTest(LanguageSelection? languageSelection, bool expectNull)
+        {
+            string actual = languageSelection.LongName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Generate a test set of LanguageSelection values
+        /// </summary>
+        /// <returns>MemberData-compatible list of LanguageSelection values</returns>
+        public static List<object[]> GenerateLanguageSelectionTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (LanguageSelection? languageSelection in Enum.GetValues(typeof(LanguageSelection)))
+            {
+                testData.Add(new object[] { languageSelection, false });
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region Media Type
+
+        /// <summary>
+        /// Check that every MediaType has a long name provided
+        /// </summary>
+        /// <param name="mediaType">MediaType value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateMediaTypeTestData))]
+        public void MediaTypeLongNameTest(MediaType? mediaType, bool expectNull)
+        {
+            string actual = mediaType.LongName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Check that every MediaType has a short name provided
+        /// </summary>
+        /// <param name="mediaType">MediaType value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateMediaTypeTestData))]
+        public void MediaTypeShortNameTest(MediaType? mediaType, bool expectNull)
+        {
+            string actual = mediaType.ShortName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Generate a test set of MediaType values
+        /// </summary>
+        /// <returns>MemberData-compatible list of MediaType values</returns>
+        public static List<object[]> GenerateMediaTypeTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (MediaType? mediaType in Enum.GetValues(typeof(MediaType)))
+            {
+                testData.Add(new object[] { mediaType, false });
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region Region
+
+        /// <summary>
+        /// Check that every Region has a long name provided
+        /// </summary>
+        /// <param name="mediaType">Region value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateRegionTestData))]
+        public void RegionLongNameTest(Region? region, bool expectNull)
+        {
+            string actual = region.LongName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Check that every Region has a short name provided
+        /// </summary>
+        /// <param name="region">Region value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateRegionTestData))]
+        public void RegionShortNameTest(Region? region, bool expectNull)
+        {
+            string actual = region.ShortName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Generate a test set of Region values
+        /// </summary>
+        /// <returns>MemberData-compatible list of Region values</returns>
+        public static List<object[]> GenerateRegionTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (Region? region in Enum.GetValues(typeof(Region)))
+            {
+                testData.Add(new object[] { region, false });
+            }
+
+            return testData;
+        }
+
+        #endregion
     }
 }