From 21d0c53dcd5a9949df69b551954115e0ef0fedc8 Mon Sep 17 00:00:00 2001 From: Takaaki Suzuki Date: Thu, 26 Dec 2024 22:21:57 +0900 Subject: [PATCH 1/2] Pass ignoreCase argument explicitly --- .../Cases/Generators/BasicTests.cs | 736 +++++++++--------- .../Cases/Generators/BasicTests.tt | 92 +-- .../Cases/Generators/EmptyTests.cs | 44 +- .../Cases/Generators/SameValueTests.cs | 184 ++--- .../Cases/Generators/SameValueTests.tt | 92 +-- .../Cases/Reflections/BasicTests.cs | 736 +++++++++--------- .../Cases/Reflections/BasicTests.tt | 92 +-- .../Cases/Reflections/ContinuousTests.cs | 736 +++++++++--------- .../Cases/Reflections/ContinuousTests.tt | 92 +-- .../Cases/Reflections/DiscontinuousTests.cs | 736 +++++++++--------- .../Cases/Reflections/DiscontinuousTests.tt | 92 +-- .../Cases/Reflections/EmptyTests.cs | 44 +- .../Cases/Reflections/SameValueTests.cs | 184 ++--- .../Cases/Reflections/SameValueTests.tt | 92 +-- 14 files changed, 2064 insertions(+), 1888 deletions(-) diff --git a/src/insights/FastEnum.UnitTests/Cases/Generators/BasicTests.cs b/src/insights/FastEnum.UnitTests/Cases/Generators/BasicTests.cs index 7ce8013..5302c6b 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Generators/BasicTests.cs +++ b/src/insights/FastEnum.UnitTests/Cases/Generators/BasicTests.cs @@ -61,6 +61,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue), valueString: ((sbyte)SByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -69,24 +70,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((SByteEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((SByteEnum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue), valueString: ((sbyte)SByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -95,24 +97,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((SByteEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((SByteEnum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue), valueString: ((sbyte)SByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -121,26 +124,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((SByteEnum)123); } @@ -148,6 +151,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue), valueString: ((sbyte)SByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -156,29 +160,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((SByteEnum)123); } @@ -243,6 +247,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue), valueString: ((byte)ByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -250,24 +255,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((ByteEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ByteEnum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue), valueString: ((byte)ByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -275,24 +281,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((ByteEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ByteEnum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue), valueString: ((byte)ByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -300,26 +307,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ByteEnum)123); } @@ -327,6 +334,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue), valueString: ((byte)ByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -334,29 +342,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ByteEnum)123); } @@ -423,6 +431,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue), valueString: ((short)Int16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -431,24 +440,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((Int16Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((Int16Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue), valueString: ((short)Int16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -457,24 +467,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((Int16Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((Int16Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue), valueString: ((short)Int16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -483,26 +494,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((Int16Enum)123); } @@ -510,6 +521,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue), valueString: ((short)Int16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -518,29 +530,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((Int16Enum)123); } @@ -605,6 +617,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue), valueString: ((ushort)UInt16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -612,24 +625,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((UInt16Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((UInt16Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue), valueString: ((ushort)UInt16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -637,24 +651,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((UInt16Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((UInt16Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue), valueString: ((ushort)UInt16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -662,26 +677,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((UInt16Enum)123); } @@ -689,6 +704,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue), valueString: ((ushort)UInt16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -696,29 +712,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((UInt16Enum)123); } @@ -785,6 +801,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue), valueString: ((int)Int32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -793,24 +810,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((Int32Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((Int32Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue), valueString: ((int)Int32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -819,24 +837,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((Int32Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((Int32Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue), valueString: ((int)Int32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -845,26 +864,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((Int32Enum)123); } @@ -872,6 +891,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue), valueString: ((int)Int32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -880,29 +900,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((Int32Enum)123); } @@ -967,6 +987,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue), valueString: ((uint)UInt32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -974,24 +995,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((UInt32Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((UInt32Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue), valueString: ((uint)UInt32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -999,24 +1021,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((UInt32Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((UInt32Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue), valueString: ((uint)UInt32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1024,26 +1047,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((UInt32Enum)123); } @@ -1051,6 +1074,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue), valueString: ((uint)UInt32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1058,29 +1082,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((UInt32Enum)123); } @@ -1147,6 +1171,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue), valueString: ((long)Int64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1155,24 +1180,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((Int64Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((Int64Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue), valueString: ((long)Int64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1181,24 +1207,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((Int64Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((Int64Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue), valueString: ((long)Int64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1207,26 +1234,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((Int64Enum)123); } @@ -1234,6 +1261,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue), valueString: ((long)Int64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1242,29 +1270,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((Int64Enum)123); } @@ -1329,6 +1357,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue), valueString: ((ulong)UInt64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1336,24 +1365,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((UInt64Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((UInt64Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue), valueString: ((ulong)UInt64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1361,24 +1391,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((UInt64Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((UInt64Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue), valueString: ((ulong)UInt64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1386,26 +1417,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((UInt64Enum)123); } @@ -1413,6 +1444,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue), valueString: ((ulong)UInt64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1420,29 +1452,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((UInt64Enum)123); } diff --git a/src/insights/FastEnum.UnitTests/Cases/Generators/BasicTests.tt b/src/insights/FastEnum.UnitTests/Cases/Generators/BasicTests.tt index c63fc03..bd7d667 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Generators/BasicTests.tt +++ b/src/insights/FastEnum.UnitTests/Cases/Generators/BasicTests.tt @@ -84,6 +84,7 @@ public sealed class Basic<#= x.AliasType #>Tests [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -94,24 +95,25 @@ public sealed class Basic<#= x.AliasType #>Tests }; foreach (var x in parameters) { - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("ABCDE")).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("123").Should().Be((<#= x.EnumType #>)123); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("123", ignoreCase).Should().Be((<#= x.EnumType #>)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -122,24 +124,25 @@ public sealed class Basic<#= x.AliasType #>Tests }; foreach (var x in parameters) { - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("ABCDE", true)).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("123", true).Should().Be((<#= x.EnumType #>)123); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("123", ignoreCase).Should().Be((<#= x.EnumType #>)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -150,26 +153,26 @@ public sealed class Basic<#= x.AliasType #>Tests }; foreach (var x in parameters) { - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(" ", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("123", out var r).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((<#= x.EnumType #>)123); } @@ -177,6 +180,7 @@ public sealed class Basic<#= x.AliasType #>Tests [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -187,29 +191,29 @@ public sealed class Basic<#= x.AliasType #>Tests }; foreach (var x in parameters) { - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((<#= x.EnumType #>)123); } diff --git a/src/insights/FastEnum.UnitTests/Cases/Generators/EmptyTests.cs b/src/insights/FastEnum.UnitTests/Cases/Generators/EmptyTests.cs index eeb6b8e..6bba453 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Generators/EmptyTests.cs +++ b/src/insights/FastEnum.UnitTests/Cases/Generators/EmptyTests.cs @@ -27,33 +27,36 @@ public void IsDefined() [TestMethod] public void Parse() { - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((TEnum)123); + const bool ignoreCase = false; + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((TEnum)123); } [TestMethod] public void ParseIgnoreCase() { - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123").Should().Be((TEnum)123); + const bool ignoreCase = true; + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((TEnum)123); } [TestMethod] public void TryParse() { - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + const bool ignoreCase = false; + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((TEnum)123); } @@ -61,11 +64,12 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + const bool ignoreCase = true; + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((TEnum)123); } diff --git a/src/insights/FastEnum.UnitTests/Cases/Generators/SameValueTests.cs b/src/insights/FastEnum.UnitTests/Cases/Generators/SameValueTests.cs index d0cc382..15d9592 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Generators/SameValueTests.cs +++ b/src/insights/FastEnum.UnitTests/Cases/Generators/SameValueTests.cs @@ -51,6 +51,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A), valueString: ((byte)SameValueContinuousEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -60,24 +61,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((SameValueContinuousEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((SameValueContinuousEnum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A), valueString: ((byte)SameValueContinuousEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -87,24 +89,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((SameValueContinuousEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((SameValueContinuousEnum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A), valueString: ((byte)SameValueContinuousEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -114,26 +117,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((SameValueContinuousEnum)123); } @@ -141,6 +144,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A), valueString: ((byte)SameValueContinuousEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -150,29 +154,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((SameValueContinuousEnum)123); } @@ -230,6 +234,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A), valueString: ((byte)SameValueDiscontinuousEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -239,24 +244,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((SameValueDiscontinuousEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((SameValueDiscontinuousEnum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A), valueString: ((byte)SameValueDiscontinuousEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -266,24 +272,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((SameValueDiscontinuousEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((SameValueDiscontinuousEnum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A), valueString: ((byte)SameValueDiscontinuousEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -293,26 +300,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((SameValueDiscontinuousEnum)123); } @@ -320,6 +327,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A), valueString: ((byte)SameValueDiscontinuousEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -329,29 +337,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((SameValueDiscontinuousEnum)123); } diff --git a/src/insights/FastEnum.UnitTests/Cases/Generators/SameValueTests.tt b/src/insights/FastEnum.UnitTests/Cases/Generators/SameValueTests.tt index 2580cd2..d577f09 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Generators/SameValueTests.tt +++ b/src/insights/FastEnum.UnitTests/Cases/Generators/SameValueTests.tt @@ -64,6 +64,7 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), @@ -73,24 +74,25 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" }; foreach (var x in parameters) { - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("ABCDE")).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("123").Should().Be((<#= x.EnumType #>)123); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("123", ignoreCase).Should().Be((<#= x.EnumType #>)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), @@ -100,24 +102,25 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" }; foreach (var x in parameters) { - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("ABCDE", true)).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("123", true).Should().Be((<#= x.EnumType #>)123); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("123", ignoreCase).Should().Be((<#= x.EnumType #>)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), @@ -127,26 +130,26 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" }; foreach (var x in parameters) { - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(" ", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("123", out var r).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((<#= x.EnumType #>)123); } @@ -154,6 +157,7 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), @@ -163,29 +167,29 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" }; foreach (var x in parameters) { - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((<#= x.EnumType #>)123); } diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/BasicTests.cs b/src/insights/FastEnum.UnitTests/Cases/Reflections/BasicTests.cs index d358180..015f9a8 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/BasicTests.cs +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/BasicTests.cs @@ -194,6 +194,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue), valueString: ((sbyte)SByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -202,24 +203,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((SByteEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((SByteEnum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue), valueString: ((sbyte)SByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -228,24 +230,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((SByteEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((SByteEnum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue), valueString: ((sbyte)SByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -254,26 +257,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((SByteEnum)123); } @@ -281,6 +284,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue), valueString: ((sbyte)SByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -289,29 +293,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((SByteEnum)123); } @@ -550,6 +554,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue), valueString: ((byte)ByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -557,24 +562,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((ByteEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ByteEnum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue), valueString: ((byte)ByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -582,24 +588,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((ByteEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ByteEnum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue), valueString: ((byte)ByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -607,26 +614,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ByteEnum)123); } @@ -634,6 +641,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue), valueString: ((byte)ByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -641,29 +649,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ByteEnum)123); } @@ -904,6 +912,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue), valueString: ((short)Int16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -912,24 +921,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((Int16Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((Int16Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue), valueString: ((short)Int16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -938,24 +948,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((Int16Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((Int16Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue), valueString: ((short)Int16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -964,26 +975,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((Int16Enum)123); } @@ -991,6 +1002,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue), valueString: ((short)Int16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -999,29 +1011,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((Int16Enum)123); } @@ -1260,6 +1272,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue), valueString: ((ushort)UInt16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1267,24 +1280,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((UInt16Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((UInt16Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue), valueString: ((ushort)UInt16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1292,24 +1306,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((UInt16Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((UInt16Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue), valueString: ((ushort)UInt16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1317,26 +1332,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((UInt16Enum)123); } @@ -1344,6 +1359,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue), valueString: ((ushort)UInt16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1351,29 +1367,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((UInt16Enum)123); } @@ -1614,6 +1630,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue), valueString: ((int)Int32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1622,24 +1639,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((Int32Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((Int32Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue), valueString: ((int)Int32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1648,24 +1666,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((Int32Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((Int32Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue), valueString: ((int)Int32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1674,26 +1693,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((Int32Enum)123); } @@ -1701,6 +1720,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue), valueString: ((int)Int32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1709,29 +1729,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((Int32Enum)123); } @@ -1970,6 +1990,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue), valueString: ((uint)UInt32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -1977,24 +1998,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((UInt32Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((UInt32Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue), valueString: ((uint)UInt32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -2002,24 +2024,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((UInt32Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((UInt32Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue), valueString: ((uint)UInt32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -2027,26 +2050,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((UInt32Enum)123); } @@ -2054,6 +2077,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue), valueString: ((uint)UInt32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -2061,29 +2085,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((UInt32Enum)123); } @@ -2324,6 +2348,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue), valueString: ((long)Int64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -2332,24 +2357,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((Int64Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((Int64Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue), valueString: ((long)Int64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -2358,24 +2384,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((Int64Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((Int64Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue), valueString: ((long)Int64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -2384,26 +2411,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((Int64Enum)123); } @@ -2411,6 +2438,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue), valueString: ((long)Int64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -2419,29 +2447,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((Int64Enum)123); } @@ -2680,6 +2708,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue), valueString: ((ulong)UInt64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -2687,24 +2716,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((UInt64Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((UInt64Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue), valueString: ((ulong)UInt64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -2712,24 +2742,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((UInt64Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((UInt64Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue), valueString: ((ulong)UInt64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -2737,26 +2768,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((UInt64Enum)123); } @@ -2764,6 +2795,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue), valueString: ((ulong)UInt64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -2771,29 +2803,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((UInt64Enum)123); } diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/BasicTests.tt b/src/insights/FastEnum.UnitTests/Cases/Reflections/BasicTests.tt index d50a16f..f5e6459 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/BasicTests.tt +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/BasicTests.tt @@ -219,6 +219,7 @@ public sealed class Basic<#= x.AliasType #>Tests [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -229,24 +230,25 @@ public sealed class Basic<#= x.AliasType #>Tests }; foreach (var x in parameters) { - FastEnum.Parse<<#= x.EnumType #>>(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("ABCDE")).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>>("123").Should().Be((<#= x.EnumType #>)123); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>>("123", ignoreCase).Should().Be((<#= x.EnumType #>)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -257,24 +259,25 @@ public sealed class Basic<#= x.AliasType #>Tests }; foreach (var x in parameters) { - FastEnum.Parse<<#= x.EnumType #>>(x.name, true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString, true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("ABCDE", true)).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>>("123", true).Should().Be((<#= x.EnumType #>)123); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>>("123", ignoreCase).Should().Be((<#= x.EnumType #>)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -285,26 +288,26 @@ public sealed class Basic<#= x.AliasType #>Tests }; foreach (var x in parameters) { - FastEnum.TryParse<<#= x.EnumType #>>(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse<<#= x.EnumType #>>((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>(" ", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("123", out var r).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((<#= x.EnumType #>)123); } @@ -312,6 +315,7 @@ public sealed class Basic<#= x.AliasType #>Tests [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MinValue).ToString(CultureInfo.InvariantCulture)), @@ -322,29 +326,29 @@ public sealed class Basic<#= x.AliasType #>Tests }; foreach (var x in parameters) { - FastEnum.TryParse<<#= x.EnumType #>>(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse<<#= x.EnumType #>>((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((<#= x.EnumType #>)123); } diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/ContinuousTests.cs b/src/insights/FastEnum.UnitTests/Cases/Reflections/ContinuousTests.cs index 53b1272..7567118 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/ContinuousTests.cs +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/ContinuousTests.cs @@ -198,6 +198,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: ContinuousSByteEnum.A, name: nameof(ContinuousSByteEnum.A), valueString: ((sbyte)ContinuousSByteEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -206,24 +207,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((ContinuousSByteEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ContinuousSByteEnum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ContinuousSByteEnum.A, name: nameof(ContinuousSByteEnum.A), valueString: ((sbyte)ContinuousSByteEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -232,24 +234,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((ContinuousSByteEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ContinuousSByteEnum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: ContinuousSByteEnum.A, name: nameof(ContinuousSByteEnum.A), valueString: ((sbyte)ContinuousSByteEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -258,26 +261,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ContinuousSByteEnum)123); } @@ -285,6 +288,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ContinuousSByteEnum.A, name: nameof(ContinuousSByteEnum.A), valueString: ((sbyte)ContinuousSByteEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -293,29 +297,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ContinuousSByteEnum)123); } @@ -561,6 +565,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: ContinuousByteEnum.A, name: nameof(ContinuousByteEnum.A), valueString: ((byte)ContinuousByteEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -569,24 +574,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((ContinuousByteEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ContinuousByteEnum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ContinuousByteEnum.A, name: nameof(ContinuousByteEnum.A), valueString: ((byte)ContinuousByteEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -595,24 +601,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((ContinuousByteEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ContinuousByteEnum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: ContinuousByteEnum.A, name: nameof(ContinuousByteEnum.A), valueString: ((byte)ContinuousByteEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -621,26 +628,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ContinuousByteEnum)123); } @@ -648,6 +655,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ContinuousByteEnum.A, name: nameof(ContinuousByteEnum.A), valueString: ((byte)ContinuousByteEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -656,29 +664,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ContinuousByteEnum)123); } @@ -924,6 +932,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: ContinuousInt16Enum.A, name: nameof(ContinuousInt16Enum.A), valueString: ((short)ContinuousInt16Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -932,24 +941,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((ContinuousInt16Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ContinuousInt16Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ContinuousInt16Enum.A, name: nameof(ContinuousInt16Enum.A), valueString: ((short)ContinuousInt16Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -958,24 +968,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((ContinuousInt16Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ContinuousInt16Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: ContinuousInt16Enum.A, name: nameof(ContinuousInt16Enum.A), valueString: ((short)ContinuousInt16Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -984,26 +995,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ContinuousInt16Enum)123); } @@ -1011,6 +1022,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ContinuousInt16Enum.A, name: nameof(ContinuousInt16Enum.A), valueString: ((short)ContinuousInt16Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1019,29 +1031,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ContinuousInt16Enum)123); } @@ -1287,6 +1299,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: ContinuousUInt16Enum.A, name: nameof(ContinuousUInt16Enum.A), valueString: ((ushort)ContinuousUInt16Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1295,24 +1308,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((ContinuousUInt16Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ContinuousUInt16Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ContinuousUInt16Enum.A, name: nameof(ContinuousUInt16Enum.A), valueString: ((ushort)ContinuousUInt16Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1321,24 +1335,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((ContinuousUInt16Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ContinuousUInt16Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: ContinuousUInt16Enum.A, name: nameof(ContinuousUInt16Enum.A), valueString: ((ushort)ContinuousUInt16Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1347,26 +1362,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ContinuousUInt16Enum)123); } @@ -1374,6 +1389,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ContinuousUInt16Enum.A, name: nameof(ContinuousUInt16Enum.A), valueString: ((ushort)ContinuousUInt16Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1382,29 +1398,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ContinuousUInt16Enum)123); } @@ -1650,6 +1666,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: ContinuousInt32Enum.A, name: nameof(ContinuousInt32Enum.A), valueString: ((int)ContinuousInt32Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1658,24 +1675,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((ContinuousInt32Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ContinuousInt32Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ContinuousInt32Enum.A, name: nameof(ContinuousInt32Enum.A), valueString: ((int)ContinuousInt32Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1684,24 +1702,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((ContinuousInt32Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ContinuousInt32Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: ContinuousInt32Enum.A, name: nameof(ContinuousInt32Enum.A), valueString: ((int)ContinuousInt32Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1710,26 +1729,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ContinuousInt32Enum)123); } @@ -1737,6 +1756,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ContinuousInt32Enum.A, name: nameof(ContinuousInt32Enum.A), valueString: ((int)ContinuousInt32Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1745,29 +1765,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ContinuousInt32Enum)123); } @@ -2013,6 +2033,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: ContinuousUInt32Enum.A, name: nameof(ContinuousUInt32Enum.A), valueString: ((uint)ContinuousUInt32Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2021,24 +2042,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((ContinuousUInt32Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ContinuousUInt32Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ContinuousUInt32Enum.A, name: nameof(ContinuousUInt32Enum.A), valueString: ((uint)ContinuousUInt32Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2047,24 +2069,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((ContinuousUInt32Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ContinuousUInt32Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: ContinuousUInt32Enum.A, name: nameof(ContinuousUInt32Enum.A), valueString: ((uint)ContinuousUInt32Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2073,26 +2096,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ContinuousUInt32Enum)123); } @@ -2100,6 +2123,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ContinuousUInt32Enum.A, name: nameof(ContinuousUInt32Enum.A), valueString: ((uint)ContinuousUInt32Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2108,29 +2132,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ContinuousUInt32Enum)123); } @@ -2376,6 +2400,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: ContinuousInt64Enum.A, name: nameof(ContinuousInt64Enum.A), valueString: ((long)ContinuousInt64Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2384,24 +2409,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((ContinuousInt64Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ContinuousInt64Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ContinuousInt64Enum.A, name: nameof(ContinuousInt64Enum.A), valueString: ((long)ContinuousInt64Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2410,24 +2436,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((ContinuousInt64Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ContinuousInt64Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: ContinuousInt64Enum.A, name: nameof(ContinuousInt64Enum.A), valueString: ((long)ContinuousInt64Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2436,26 +2463,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ContinuousInt64Enum)123); } @@ -2463,6 +2490,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ContinuousInt64Enum.A, name: nameof(ContinuousInt64Enum.A), valueString: ((long)ContinuousInt64Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2471,29 +2499,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ContinuousInt64Enum)123); } @@ -2739,6 +2767,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: ContinuousUInt64Enum.A, name: nameof(ContinuousUInt64Enum.A), valueString: ((ulong)ContinuousUInt64Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2747,24 +2776,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((ContinuousUInt64Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ContinuousUInt64Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ContinuousUInt64Enum.A, name: nameof(ContinuousUInt64Enum.A), valueString: ((ulong)ContinuousUInt64Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2773,24 +2803,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((ContinuousUInt64Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((ContinuousUInt64Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: ContinuousUInt64Enum.A, name: nameof(ContinuousUInt64Enum.A), valueString: ((ulong)ContinuousUInt64Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2799,26 +2830,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ContinuousUInt64Enum)123); } @@ -2826,6 +2857,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: ContinuousUInt64Enum.A, name: nameof(ContinuousUInt64Enum.A), valueString: ((ulong)ContinuousUInt64Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2834,29 +2866,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((ContinuousUInt64Enum)123); } diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/ContinuousTests.tt b/src/insights/FastEnum.UnitTests/Cases/Reflections/ContinuousTests.tt index a75a506..72476d5 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/ContinuousTests.tt +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/ContinuousTests.tt @@ -217,6 +217,7 @@ public sealed class Continuous<#= x.AliasType #>Tests [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), @@ -225,24 +226,25 @@ public sealed class Continuous<#= x.AliasType #>Tests }; foreach (var x in parameters) { - FastEnum.Parse<<#= x.EnumType #>>(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("ABCDE")).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>>("123").Should().Be((<#= x.EnumType #>)123); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>>("123", ignoreCase).Should().Be((<#= x.EnumType #>)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), @@ -251,24 +253,25 @@ public sealed class Continuous<#= x.AliasType #>Tests }; foreach (var x in parameters) { - FastEnum.Parse<<#= x.EnumType #>>(x.name, true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString, true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("ABCDE", true)).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>>("123", true).Should().Be((<#= x.EnumType #>)123); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>>("123", ignoreCase).Should().Be((<#= x.EnumType #>)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), @@ -277,26 +280,26 @@ public sealed class Continuous<#= x.AliasType #>Tests }; foreach (var x in parameters) { - FastEnum.TryParse<<#= x.EnumType #>>(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse<<#= x.EnumType #>>((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>(" ", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("123", out var r).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((<#= x.EnumType #>)123); } @@ -304,6 +307,7 @@ public sealed class Continuous<#= x.AliasType #>Tests [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), @@ -312,29 +316,29 @@ public sealed class Continuous<#= x.AliasType #>Tests }; foreach (var x in parameters) { - FastEnum.TryParse<<#= x.EnumType #>>(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse<<#= x.EnumType #>>((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((<#= x.EnumType #>)123); } diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/DiscontinuousTests.cs b/src/insights/FastEnum.UnitTests/Cases/Reflections/DiscontinuousTests.cs index 0135c36..4443a88 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/DiscontinuousTests.cs +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/DiscontinuousTests.cs @@ -194,6 +194,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: DiscontinuousSByteEnum.A, name: nameof(DiscontinuousSByteEnum.A), valueString: ((sbyte)DiscontinuousSByteEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -202,24 +203,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((DiscontinuousSByteEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((DiscontinuousSByteEnum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: DiscontinuousSByteEnum.A, name: nameof(DiscontinuousSByteEnum.A), valueString: ((sbyte)DiscontinuousSByteEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -228,24 +230,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((DiscontinuousSByteEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((DiscontinuousSByteEnum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: DiscontinuousSByteEnum.A, name: nameof(DiscontinuousSByteEnum.A), valueString: ((sbyte)DiscontinuousSByteEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -254,26 +257,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((DiscontinuousSByteEnum)123); } @@ -281,6 +284,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: DiscontinuousSByteEnum.A, name: nameof(DiscontinuousSByteEnum.A), valueString: ((sbyte)DiscontinuousSByteEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -289,29 +293,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((DiscontinuousSByteEnum)123); } @@ -553,6 +557,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: DiscontinuousByteEnum.A, name: nameof(DiscontinuousByteEnum.A), valueString: ((byte)DiscontinuousByteEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -561,24 +566,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((DiscontinuousByteEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((DiscontinuousByteEnum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: DiscontinuousByteEnum.A, name: nameof(DiscontinuousByteEnum.A), valueString: ((byte)DiscontinuousByteEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -587,24 +593,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((DiscontinuousByteEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((DiscontinuousByteEnum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: DiscontinuousByteEnum.A, name: nameof(DiscontinuousByteEnum.A), valueString: ((byte)DiscontinuousByteEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -613,26 +620,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((DiscontinuousByteEnum)123); } @@ -640,6 +647,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: DiscontinuousByteEnum.A, name: nameof(DiscontinuousByteEnum.A), valueString: ((byte)DiscontinuousByteEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -648,29 +656,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((DiscontinuousByteEnum)123); } @@ -912,6 +920,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: DiscontinuousInt16Enum.A, name: nameof(DiscontinuousInt16Enum.A), valueString: ((short)DiscontinuousInt16Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -920,24 +929,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((DiscontinuousInt16Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((DiscontinuousInt16Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: DiscontinuousInt16Enum.A, name: nameof(DiscontinuousInt16Enum.A), valueString: ((short)DiscontinuousInt16Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -946,24 +956,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((DiscontinuousInt16Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((DiscontinuousInt16Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: DiscontinuousInt16Enum.A, name: nameof(DiscontinuousInt16Enum.A), valueString: ((short)DiscontinuousInt16Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -972,26 +983,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((DiscontinuousInt16Enum)123); } @@ -999,6 +1010,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: DiscontinuousInt16Enum.A, name: nameof(DiscontinuousInt16Enum.A), valueString: ((short)DiscontinuousInt16Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1007,29 +1019,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((DiscontinuousInt16Enum)123); } @@ -1271,6 +1283,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: DiscontinuousUInt16Enum.A, name: nameof(DiscontinuousUInt16Enum.A), valueString: ((ushort)DiscontinuousUInt16Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1279,24 +1292,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((DiscontinuousUInt16Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((DiscontinuousUInt16Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: DiscontinuousUInt16Enum.A, name: nameof(DiscontinuousUInt16Enum.A), valueString: ((ushort)DiscontinuousUInt16Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1305,24 +1319,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((DiscontinuousUInt16Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((DiscontinuousUInt16Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: DiscontinuousUInt16Enum.A, name: nameof(DiscontinuousUInt16Enum.A), valueString: ((ushort)DiscontinuousUInt16Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1331,26 +1346,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((DiscontinuousUInt16Enum)123); } @@ -1358,6 +1373,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: DiscontinuousUInt16Enum.A, name: nameof(DiscontinuousUInt16Enum.A), valueString: ((ushort)DiscontinuousUInt16Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1366,29 +1382,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((DiscontinuousUInt16Enum)123); } @@ -1630,6 +1646,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: DiscontinuousInt32Enum.A, name: nameof(DiscontinuousInt32Enum.A), valueString: ((int)DiscontinuousInt32Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1638,24 +1655,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((DiscontinuousInt32Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((DiscontinuousInt32Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: DiscontinuousInt32Enum.A, name: nameof(DiscontinuousInt32Enum.A), valueString: ((int)DiscontinuousInt32Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1664,24 +1682,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((DiscontinuousInt32Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((DiscontinuousInt32Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: DiscontinuousInt32Enum.A, name: nameof(DiscontinuousInt32Enum.A), valueString: ((int)DiscontinuousInt32Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1690,26 +1709,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((DiscontinuousInt32Enum)123); } @@ -1717,6 +1736,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: DiscontinuousInt32Enum.A, name: nameof(DiscontinuousInt32Enum.A), valueString: ((int)DiscontinuousInt32Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1725,29 +1745,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((DiscontinuousInt32Enum)123); } @@ -1989,6 +2009,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: DiscontinuousUInt32Enum.A, name: nameof(DiscontinuousUInt32Enum.A), valueString: ((uint)DiscontinuousUInt32Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -1997,24 +2018,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((DiscontinuousUInt32Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((DiscontinuousUInt32Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: DiscontinuousUInt32Enum.A, name: nameof(DiscontinuousUInt32Enum.A), valueString: ((uint)DiscontinuousUInt32Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2023,24 +2045,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((DiscontinuousUInt32Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((DiscontinuousUInt32Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: DiscontinuousUInt32Enum.A, name: nameof(DiscontinuousUInt32Enum.A), valueString: ((uint)DiscontinuousUInt32Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2049,26 +2072,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((DiscontinuousUInt32Enum)123); } @@ -2076,6 +2099,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: DiscontinuousUInt32Enum.A, name: nameof(DiscontinuousUInt32Enum.A), valueString: ((uint)DiscontinuousUInt32Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2084,29 +2108,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((DiscontinuousUInt32Enum)123); } @@ -2348,6 +2372,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: DiscontinuousInt64Enum.A, name: nameof(DiscontinuousInt64Enum.A), valueString: ((long)DiscontinuousInt64Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2356,24 +2381,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((DiscontinuousInt64Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((DiscontinuousInt64Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: DiscontinuousInt64Enum.A, name: nameof(DiscontinuousInt64Enum.A), valueString: ((long)DiscontinuousInt64Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2382,24 +2408,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((DiscontinuousInt64Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((DiscontinuousInt64Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: DiscontinuousInt64Enum.A, name: nameof(DiscontinuousInt64Enum.A), valueString: ((long)DiscontinuousInt64Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2408,26 +2435,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((DiscontinuousInt64Enum)123); } @@ -2435,6 +2462,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: DiscontinuousInt64Enum.A, name: nameof(DiscontinuousInt64Enum.A), valueString: ((long)DiscontinuousInt64Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2443,29 +2471,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((DiscontinuousInt64Enum)123); } @@ -2707,6 +2735,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: DiscontinuousUInt64Enum.A, name: nameof(DiscontinuousUInt64Enum.A), valueString: ((ulong)DiscontinuousUInt64Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2715,24 +2744,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((DiscontinuousUInt64Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((DiscontinuousUInt64Enum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: DiscontinuousUInt64Enum.A, name: nameof(DiscontinuousUInt64Enum.A), valueString: ((ulong)DiscontinuousUInt64Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2741,24 +2771,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((DiscontinuousUInt64Enum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((DiscontinuousUInt64Enum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: DiscontinuousUInt64Enum.A, name: nameof(DiscontinuousUInt64Enum.A), valueString: ((ulong)DiscontinuousUInt64Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2767,26 +2798,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((DiscontinuousUInt64Enum)123); } @@ -2794,6 +2825,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: DiscontinuousUInt64Enum.A, name: nameof(DiscontinuousUInt64Enum.A), valueString: ((ulong)DiscontinuousUInt64Enum.A).ToString(CultureInfo.InvariantCulture)), @@ -2802,29 +2834,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((DiscontinuousUInt64Enum)123); } diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/DiscontinuousTests.tt b/src/insights/FastEnum.UnitTests/Cases/Reflections/DiscontinuousTests.tt index 1ff882e..7a3967c 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/DiscontinuousTests.tt +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/DiscontinuousTests.tt @@ -213,6 +213,7 @@ public sealed class Discontinuous<#= x.AliasType #>Tests [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), @@ -221,24 +222,25 @@ public sealed class Discontinuous<#= x.AliasType #>Tests }; foreach (var x in parameters) { - FastEnum.Parse<<#= x.EnumType #>>(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("ABCDE")).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>>("123").Should().Be((<#= x.EnumType #>)123); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>>("123", ignoreCase).Should().Be((<#= x.EnumType #>)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), @@ -247,24 +249,25 @@ public sealed class Discontinuous<#= x.AliasType #>Tests }; foreach (var x in parameters) { - FastEnum.Parse<<#= x.EnumType #>>(x.name, true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString, true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("ABCDE", true)).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>>("123", true).Should().Be((<#= x.EnumType #>)123); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>>("123", ignoreCase).Should().Be((<#= x.EnumType #>)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), @@ -273,26 +276,26 @@ public sealed class Discontinuous<#= x.AliasType #>Tests }; foreach (var x in parameters) { - FastEnum.TryParse<<#= x.EnumType #>>(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse<<#= x.EnumType #>>((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>(" ", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("123", out var r).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((<#= x.EnumType #>)123); } @@ -300,6 +303,7 @@ public sealed class Discontinuous<#= x.AliasType #>Tests [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), @@ -308,29 +312,29 @@ public sealed class Discontinuous<#= x.AliasType #>Tests }; foreach (var x in parameters) { - FastEnum.TryParse<<#= x.EnumType #>>(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse<<#= x.EnumType #>>((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((<#= x.EnumType #>)123); } diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/EmptyTests.cs b/src/insights/FastEnum.UnitTests/Cases/Reflections/EmptyTests.cs index 0fa2e6f..2ce247c 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/EmptyTests.cs +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/EmptyTests.cs @@ -66,33 +66,36 @@ public void IsDefined() [TestMethod] public void Parse() { - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((TEnum)123); + const bool ignoreCase = false; + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((TEnum)123); } [TestMethod] public void ParseIgnoreCase() { - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123").Should().Be((TEnum)123); + const bool ignoreCase = true; + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((TEnum)123); } [TestMethod] public void TryParse() { - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + const bool ignoreCase = false; + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((TEnum)123); } @@ -100,11 +103,12 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + const bool ignoreCase = true; + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((TEnum)123); } diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/SameValueTests.cs b/src/insights/FastEnum.UnitTests/Cases/Reflections/SameValueTests.cs index d8097ef..b2d71f5 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/SameValueTests.cs +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/SameValueTests.cs @@ -97,6 +97,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A), valueString: ((byte)SameValueContinuousEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -106,24 +107,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((SameValueContinuousEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((SameValueContinuousEnum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A), valueString: ((byte)SameValueContinuousEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -133,24 +135,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((SameValueContinuousEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((SameValueContinuousEnum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A), valueString: ((byte)SameValueContinuousEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -160,26 +163,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((SameValueContinuousEnum)123); } @@ -187,6 +190,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A), valueString: ((byte)SameValueContinuousEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -196,29 +200,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((SameValueContinuousEnum)123); } @@ -391,6 +395,7 @@ public void IsDefined() [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A), valueString: ((byte)SameValueDiscontinuousEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -400,24 +405,25 @@ public void Parse() }; foreach (var x in parameters) { - FastEnum.Parse(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE")).Should().Throw(); - FastEnum.Parse("123").Should().Be((SameValueDiscontinuousEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((SameValueDiscontinuousEnum)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A), valueString: ((byte)SameValueDiscontinuousEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -427,24 +433,25 @@ public void ParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.Parse(x.name, true).Should().Be(x.value); - FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString, true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", true)).Should().Throw(); - FastEnum.Parse("123", true).Should().Be((SameValueDiscontinuousEnum)123); + FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse("123", ignoreCase).Should().Be((SameValueDiscontinuousEnum)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A), valueString: ((byte)SameValueDiscontinuousEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -454,26 +461,26 @@ public void TryParse() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse("", out var _).Should().BeFalse(); - FastEnum.TryParse(" ", out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse("123", out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((SameValueDiscontinuousEnum)123); } @@ -481,6 +488,7 @@ public void TryParse() [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A), valueString: ((byte)SameValueDiscontinuousEnum.A).ToString(CultureInfo.InvariantCulture)), @@ -490,29 +498,29 @@ public void TryParseIgnoreCase() }; foreach (var x in parameters) { - FastEnum.TryParse(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse("", true, out var _).Should().BeFalse(); - FastEnum.TryParse(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((SameValueDiscontinuousEnum)123); } diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/SameValueTests.tt b/src/insights/FastEnum.UnitTests/Cases/Reflections/SameValueTests.tt index 2254c7f..e7bb740 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/SameValueTests.tt +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/SameValueTests.tt @@ -110,6 +110,7 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" [TestMethod] public void Parse() { + const bool ignoreCase = false; var parameters = new[] { (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), @@ -119,24 +120,25 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" }; foreach (var x in parameters) { - FastEnum.Parse<<#= x.EnumType #>>(x.name).Should().Be(x.value); - FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture))).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture)).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture)).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.name, ignoreCase).Should().Be(x.value); + FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>(" ")).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("ABCDE")).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>>("123").Should().Be((<#= x.EnumType #>)123); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>>("123", ignoreCase).Should().Be((<#= x.EnumType #>)123); } [TestMethod] public void ParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), @@ -146,24 +148,25 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" }; foreach (var x in parameters) { - FastEnum.Parse<<#= x.EnumType #>>(x.name, true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString, true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), true).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), true).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.name, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>(" ", true)).Should().Throw(); - FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("ABCDE", true)).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>>("123", true).Should().Be((<#= x.EnumType #>)123); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>(" ", ignoreCase)).Should().Throw(); + FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("ABCDE", ignoreCase)).Should().Throw(); + FastEnum.Parse<<#= x.EnumType #>>("123", ignoreCase).Should().Be((<#= x.EnumType #>)123); } [TestMethod] public void TryParse() { + const bool ignoreCase = false; var parameters = new[] { (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), @@ -173,26 +176,26 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" }; foreach (var x in parameters) { - FastEnum.TryParse<<#= x.EnumType #>>(x.name, out var r1).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), out var _).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } - FastEnum.TryParse<<#= x.EnumType #>>((string?)null, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>(" ", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("ABCDE", out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("123", out var r).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((<#= x.EnumType #>)123); } @@ -200,6 +203,7 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" [TestMethod] public void TryParseIgnoreCase() { + const bool ignoreCase = true; var parameters = new[] { (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), @@ -209,29 +213,29 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" }; foreach (var x in parameters) { - FastEnum.TryParse<<#= x.EnumType #>>(x.name, true, out var r1).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), true, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), true, out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, true, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), true, out var r5).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), true, out var r6).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } - FastEnum.TryParse<<#= x.EnumType #>>((string?)null, true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>(" ", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("ABCDE", true, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>("123", true, out var r).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>(" ", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("ABCDE", ignoreCase, out var _).Should().BeFalse(); + FastEnum.TryParse<<#= x.EnumType #>>("123", ignoreCase, out var r).Should().BeTrue(); r.Should().Be((<#= x.EnumType #>)123); } From 3cfd19ec793eacef09e86dd9760b60a9473cbdc7 Mon Sep 17 00:00:00 2001 From: Takaaki Suzuki Date: Thu, 26 Dec 2024 22:38:48 +0900 Subject: [PATCH 2/2] Unify the generation process of valueString. --- .../Cases/Generators/BasicTests.cs | 400 +++++++++------- .../Cases/Generators/BasicTests.tt | 54 ++- .../Cases/Generators/SameValueTests.cs | 124 ++--- .../Cases/Generators/SameValueTests.tt | 62 +-- .../Cases/Reflections/BasicTests.cs | 400 +++++++++------- .../Cases/Reflections/BasicTests.tt | 54 ++- .../Cases/Reflections/ContinuousTests.cs | 432 ++++++++++-------- .../Cases/Reflections/ContinuousTests.tt | 54 ++- .../Cases/Reflections/DiscontinuousTests.cs | 432 ++++++++++-------- .../Cases/Reflections/DiscontinuousTests.tt | 54 ++- .../Cases/Reflections/SameValueTests.cs | 124 ++--- .../Cases/Reflections/SameValueTests.tt | 62 +-- 12 files changed, 1252 insertions(+), 1000 deletions(-) diff --git a/src/insights/FastEnum.UnitTests/Cases/Generators/BasicTests.cs b/src/insights/FastEnum.UnitTests/Cases/Generators/BasicTests.cs index 5302c6b..f52cf9f 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Generators/BasicTests.cs +++ b/src/insights/FastEnum.UnitTests/Cases/Generators/BasicTests.cs @@ -64,18 +64,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue), valueString: ((sbyte)SByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: SByteEnum.Zero, name: nameof(SByteEnum.Zero), valueString: ((sbyte)SByteEnum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: SByteEnum.MaxValue, name: nameof(SByteEnum.MaxValue), valueString: ((sbyte)SByteEnum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue)), + (value: SByteEnum.Zero, name: nameof(SByteEnum.Zero)), + (value: SByteEnum.MaxValue, name: nameof(SByteEnum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((sbyte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -91,18 +92,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue), valueString: ((sbyte)SByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: SByteEnum.Zero, name: nameof(SByteEnum.Zero), valueString: ((sbyte)SByteEnum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: SByteEnum.MaxValue, name: nameof(SByteEnum.MaxValue), valueString: ((sbyte)SByteEnum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue)), + (value: SByteEnum.Zero, name: nameof(SByteEnum.Zero)), + (value: SByteEnum.MaxValue, name: nameof(SByteEnum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((sbyte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -118,25 +120,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue), valueString: ((sbyte)SByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: SByteEnum.Zero, name: nameof(SByteEnum.Zero), valueString: ((sbyte)SByteEnum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: SByteEnum.MaxValue, name: nameof(SByteEnum.MaxValue), valueString: ((sbyte)SByteEnum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue)), + (value: SByteEnum.Zero, name: nameof(SByteEnum.Zero)), + (value: SByteEnum.MaxValue, name: nameof(SByteEnum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((sbyte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -154,12 +158,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue), valueString: ((sbyte)SByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: SByteEnum.Zero, name: nameof(SByteEnum.Zero), valueString: ((sbyte)SByteEnum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: SByteEnum.MaxValue, name: nameof(SByteEnum.MaxValue), valueString: ((sbyte)SByteEnum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue)), + (value: SByteEnum.Zero, name: nameof(SByteEnum.Zero)), + (value: SByteEnum.MaxValue, name: nameof(SByteEnum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((sbyte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -169,13 +175,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -250,17 +256,18 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue), valueString: ((byte)ByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: ByteEnum.MaxValue, name: nameof(ByteEnum.MaxValue), valueString: ((byte)ByteEnum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue)), + (value: ByteEnum.MaxValue, name: nameof(ByteEnum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -276,17 +283,18 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue), valueString: ((byte)ByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: ByteEnum.MaxValue, name: nameof(ByteEnum.MaxValue), valueString: ((byte)ByteEnum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue)), + (value: ByteEnum.MaxValue, name: nameof(ByteEnum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -302,24 +310,26 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue), valueString: ((byte)ByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: ByteEnum.MaxValue, name: nameof(ByteEnum.MaxValue), valueString: ((byte)ByteEnum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue)), + (value: ByteEnum.MaxValue, name: nameof(ByteEnum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -337,11 +347,13 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue), valueString: ((byte)ByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: ByteEnum.MaxValue, name: nameof(ByteEnum.MaxValue), valueString: ((byte)ByteEnum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue)), + (value: ByteEnum.MaxValue, name: nameof(ByteEnum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -351,13 +363,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -434,18 +446,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue), valueString: ((short)Int16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int16Enum.Zero, name: nameof(Int16Enum.Zero), valueString: ((short)Int16Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int16Enum.MaxValue, name: nameof(Int16Enum.MaxValue), valueString: ((short)Int16Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue)), + (value: Int16Enum.Zero, name: nameof(Int16Enum.Zero)), + (value: Int16Enum.MaxValue, name: nameof(Int16Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((short)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -461,18 +474,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue), valueString: ((short)Int16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int16Enum.Zero, name: nameof(Int16Enum.Zero), valueString: ((short)Int16Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int16Enum.MaxValue, name: nameof(Int16Enum.MaxValue), valueString: ((short)Int16Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue)), + (value: Int16Enum.Zero, name: nameof(Int16Enum.Zero)), + (value: Int16Enum.MaxValue, name: nameof(Int16Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((short)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -488,25 +502,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue), valueString: ((short)Int16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int16Enum.Zero, name: nameof(Int16Enum.Zero), valueString: ((short)Int16Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int16Enum.MaxValue, name: nameof(Int16Enum.MaxValue), valueString: ((short)Int16Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue)), + (value: Int16Enum.Zero, name: nameof(Int16Enum.Zero)), + (value: Int16Enum.MaxValue, name: nameof(Int16Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((short)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -524,12 +540,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue), valueString: ((short)Int16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int16Enum.Zero, name: nameof(Int16Enum.Zero), valueString: ((short)Int16Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int16Enum.MaxValue, name: nameof(Int16Enum.MaxValue), valueString: ((short)Int16Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue)), + (value: Int16Enum.Zero, name: nameof(Int16Enum.Zero)), + (value: Int16Enum.MaxValue, name: nameof(Int16Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((short)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -539,13 +557,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -620,17 +638,18 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue), valueString: ((ushort)UInt16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt16Enum.MaxValue, name: nameof(UInt16Enum.MaxValue), valueString: ((ushort)UInt16Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue)), + (value: UInt16Enum.MaxValue, name: nameof(UInt16Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((ushort)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -646,17 +665,18 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue), valueString: ((ushort)UInt16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt16Enum.MaxValue, name: nameof(UInt16Enum.MaxValue), valueString: ((ushort)UInt16Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue)), + (value: UInt16Enum.MaxValue, name: nameof(UInt16Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((ushort)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -672,24 +692,26 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue), valueString: ((ushort)UInt16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt16Enum.MaxValue, name: nameof(UInt16Enum.MaxValue), valueString: ((ushort)UInt16Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue)), + (value: UInt16Enum.MaxValue, name: nameof(UInt16Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((ushort)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -707,11 +729,13 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue), valueString: ((ushort)UInt16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt16Enum.MaxValue, name: nameof(UInt16Enum.MaxValue), valueString: ((ushort)UInt16Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue)), + (value: UInt16Enum.MaxValue, name: nameof(UInt16Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((ushort)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -721,13 +745,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -804,18 +828,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue), valueString: ((int)Int32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int32Enum.Zero, name: nameof(Int32Enum.Zero), valueString: ((int)Int32Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int32Enum.MaxValue, name: nameof(Int32Enum.MaxValue), valueString: ((int)Int32Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue)), + (value: Int32Enum.Zero, name: nameof(Int32Enum.Zero)), + (value: Int32Enum.MaxValue, name: nameof(Int32Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((int)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -831,18 +856,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue), valueString: ((int)Int32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int32Enum.Zero, name: nameof(Int32Enum.Zero), valueString: ((int)Int32Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int32Enum.MaxValue, name: nameof(Int32Enum.MaxValue), valueString: ((int)Int32Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue)), + (value: Int32Enum.Zero, name: nameof(Int32Enum.Zero)), + (value: Int32Enum.MaxValue, name: nameof(Int32Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((int)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -858,25 +884,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue), valueString: ((int)Int32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int32Enum.Zero, name: nameof(Int32Enum.Zero), valueString: ((int)Int32Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int32Enum.MaxValue, name: nameof(Int32Enum.MaxValue), valueString: ((int)Int32Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue)), + (value: Int32Enum.Zero, name: nameof(Int32Enum.Zero)), + (value: Int32Enum.MaxValue, name: nameof(Int32Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((int)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -894,12 +922,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue), valueString: ((int)Int32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int32Enum.Zero, name: nameof(Int32Enum.Zero), valueString: ((int)Int32Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int32Enum.MaxValue, name: nameof(Int32Enum.MaxValue), valueString: ((int)Int32Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue)), + (value: Int32Enum.Zero, name: nameof(Int32Enum.Zero)), + (value: Int32Enum.MaxValue, name: nameof(Int32Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((int)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -909,13 +939,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -990,17 +1020,18 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue), valueString: ((uint)UInt32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt32Enum.MaxValue, name: nameof(UInt32Enum.MaxValue), valueString: ((uint)UInt32Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue)), + (value: UInt32Enum.MaxValue, name: nameof(UInt32Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((uint)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1016,17 +1047,18 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue), valueString: ((uint)UInt32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt32Enum.MaxValue, name: nameof(UInt32Enum.MaxValue), valueString: ((uint)UInt32Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue)), + (value: UInt32Enum.MaxValue, name: nameof(UInt32Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((uint)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1042,24 +1074,26 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue), valueString: ((uint)UInt32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt32Enum.MaxValue, name: nameof(UInt32Enum.MaxValue), valueString: ((uint)UInt32Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue)), + (value: UInt32Enum.MaxValue, name: nameof(UInt32Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((uint)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1077,11 +1111,13 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue), valueString: ((uint)UInt32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt32Enum.MaxValue, name: nameof(UInt32Enum.MaxValue), valueString: ((uint)UInt32Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue)), + (value: UInt32Enum.MaxValue, name: nameof(UInt32Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((uint)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -1091,13 +1127,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1174,18 +1210,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue), valueString: ((long)Int64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int64Enum.Zero, name: nameof(Int64Enum.Zero), valueString: ((long)Int64Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int64Enum.MaxValue, name: nameof(Int64Enum.MaxValue), valueString: ((long)Int64Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue)), + (value: Int64Enum.Zero, name: nameof(Int64Enum.Zero)), + (value: Int64Enum.MaxValue, name: nameof(Int64Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((long)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1201,18 +1238,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue), valueString: ((long)Int64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int64Enum.Zero, name: nameof(Int64Enum.Zero), valueString: ((long)Int64Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int64Enum.MaxValue, name: nameof(Int64Enum.MaxValue), valueString: ((long)Int64Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue)), + (value: Int64Enum.Zero, name: nameof(Int64Enum.Zero)), + (value: Int64Enum.MaxValue, name: nameof(Int64Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((long)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1228,25 +1266,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue), valueString: ((long)Int64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int64Enum.Zero, name: nameof(Int64Enum.Zero), valueString: ((long)Int64Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int64Enum.MaxValue, name: nameof(Int64Enum.MaxValue), valueString: ((long)Int64Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue)), + (value: Int64Enum.Zero, name: nameof(Int64Enum.Zero)), + (value: Int64Enum.MaxValue, name: nameof(Int64Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((long)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1264,12 +1304,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue), valueString: ((long)Int64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int64Enum.Zero, name: nameof(Int64Enum.Zero), valueString: ((long)Int64Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int64Enum.MaxValue, name: nameof(Int64Enum.MaxValue), valueString: ((long)Int64Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue)), + (value: Int64Enum.Zero, name: nameof(Int64Enum.Zero)), + (value: Int64Enum.MaxValue, name: nameof(Int64Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((long)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -1279,13 +1321,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1360,17 +1402,18 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue), valueString: ((ulong)UInt64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt64Enum.MaxValue, name: nameof(UInt64Enum.MaxValue), valueString: ((ulong)UInt64Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue)), + (value: UInt64Enum.MaxValue, name: nameof(UInt64Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((ulong)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1386,17 +1429,18 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue), valueString: ((ulong)UInt64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt64Enum.MaxValue, name: nameof(UInt64Enum.MaxValue), valueString: ((ulong)UInt64Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue)), + (value: UInt64Enum.MaxValue, name: nameof(UInt64Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((ulong)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1412,24 +1456,26 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue), valueString: ((ulong)UInt64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt64Enum.MaxValue, name: nameof(UInt64Enum.MaxValue), valueString: ((ulong)UInt64Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue)), + (value: UInt64Enum.MaxValue, name: nameof(UInt64Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((ulong)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1447,11 +1493,13 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue), valueString: ((ulong)UInt64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt64Enum.MaxValue, name: nameof(UInt64Enum.MaxValue), valueString: ((ulong)UInt64Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue)), + (value: UInt64Enum.MaxValue, name: nameof(UInt64Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((ulong)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -1461,13 +1509,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); diff --git a/src/insights/FastEnum.UnitTests/Cases/Generators/BasicTests.tt b/src/insights/FastEnum.UnitTests/Cases/Generators/BasicTests.tt index bd7d667..b690bbd 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Generators/BasicTests.tt +++ b/src/insights/FastEnum.UnitTests/Cases/Generators/BasicTests.tt @@ -87,20 +87,21 @@ public sealed class Basic<#= x.AliasType #>Tests const bool ignoreCase = false; var parameters = new[] { - (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MinValue).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue)), <# if (x.IsSignedType) { #> - (value: <#= x.EnumType #>.Zero, name: nameof(<#= x.EnumType #>.Zero), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.Zero).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.Zero, name: nameof(<#= x.EnumType #>.Zero)), <# } #> - (value: <#= x.EnumType #>.MaxValue, name: nameof(<#= x.EnumType #>.MaxValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.MaxValue, name: nameof(<#= x.EnumType #>.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("", ignoreCase)).Should().Throw(); @@ -116,20 +117,21 @@ public sealed class Basic<#= x.AliasType #>Tests const bool ignoreCase = true; var parameters = new[] { - (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MinValue).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue)), <# if (x.IsSignedType) { #> - (value: <#= x.EnumType #>.Zero, name: nameof(<#= x.EnumType #>.Zero), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.Zero).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.Zero, name: nameof(<#= x.EnumType #>.Zero)), <# } #> - (value: <#= x.EnumType #>.MaxValue, name: nameof(<#= x.EnumType #>.MaxValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.MaxValue, name: nameof(<#= x.EnumType #>.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("", ignoreCase)).Should().Throw(); @@ -145,27 +147,29 @@ public sealed class Basic<#= x.AliasType #>Tests const bool ignoreCase = false; var parameters = new[] { - (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MinValue).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue)), <# if (x.IsSignedType) { #> - (value: <#= x.EnumType #>.Zero, name: nameof(<#= x.EnumType #>.Zero), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.Zero).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.Zero, name: nameof(<#= x.EnumType #>.Zero)), <# } #> - (value: <#= x.EnumType #>.MaxValue, name: nameof(<#= x.EnumType #>.MaxValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.MaxValue, name: nameof(<#= x.EnumType #>.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -183,14 +187,16 @@ public sealed class Basic<#= x.AliasType #>Tests const bool ignoreCase = true; var parameters = new[] { - (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MinValue).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue)), <# if (x.IsSignedType) { #> - (value: <#= x.EnumType #>.Zero, name: nameof(<#= x.EnumType #>.Zero), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.Zero).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.Zero, name: nameof(<#= x.EnumType #>.Zero)), <# } #> - (value: <#= x.EnumType #>.MaxValue, name: nameof(<#= x.EnumType #>.MaxValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.MaxValue, name: nameof(<#= x.EnumType #>.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -200,13 +206,13 @@ public sealed class Basic<#= x.AliasType #>Tests FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); diff --git a/src/insights/FastEnum.UnitTests/Cases/Generators/SameValueTests.cs b/src/insights/FastEnum.UnitTests/Cases/Generators/SameValueTests.cs index 15d9592..5172a35 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Generators/SameValueTests.cs +++ b/src/insights/FastEnum.UnitTests/Cases/Generators/SameValueTests.cs @@ -54,19 +54,20 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A), valueString: ((byte)SameValueContinuousEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.B, name: nameof(SameValueContinuousEnum.B), valueString: ((byte)SameValueContinuousEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.C, name: nameof(SameValueContinuousEnum.C), valueString: ((byte)SameValueContinuousEnum.C).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.D, name: nameof(SameValueContinuousEnum.D), valueString: ((byte)SameValueContinuousEnum.D).ToString(CultureInfo.InvariantCulture)), + (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A)), + (value: SameValueContinuousEnum.B, name: nameof(SameValueContinuousEnum.B)), + (value: SameValueContinuousEnum.C, name: nameof(SameValueContinuousEnum.C)), + (value: SameValueContinuousEnum.D, name: nameof(SameValueContinuousEnum.D)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -82,19 +83,20 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A), valueString: ((byte)SameValueContinuousEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.B, name: nameof(SameValueContinuousEnum.B), valueString: ((byte)SameValueContinuousEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.C, name: nameof(SameValueContinuousEnum.C), valueString: ((byte)SameValueContinuousEnum.C).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.D, name: nameof(SameValueContinuousEnum.D), valueString: ((byte)SameValueContinuousEnum.D).ToString(CultureInfo.InvariantCulture)), + (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A)), + (value: SameValueContinuousEnum.B, name: nameof(SameValueContinuousEnum.B)), + (value: SameValueContinuousEnum.C, name: nameof(SameValueContinuousEnum.C)), + (value: SameValueContinuousEnum.D, name: nameof(SameValueContinuousEnum.D)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -110,26 +112,28 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A), valueString: ((byte)SameValueContinuousEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.B, name: nameof(SameValueContinuousEnum.B), valueString: ((byte)SameValueContinuousEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.C, name: nameof(SameValueContinuousEnum.C), valueString: ((byte)SameValueContinuousEnum.C).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.D, name: nameof(SameValueContinuousEnum.D), valueString: ((byte)SameValueContinuousEnum.D).ToString(CultureInfo.InvariantCulture)), + (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A)), + (value: SameValueContinuousEnum.B, name: nameof(SameValueContinuousEnum.B)), + (value: SameValueContinuousEnum.C, name: nameof(SameValueContinuousEnum.C)), + (value: SameValueContinuousEnum.D, name: nameof(SameValueContinuousEnum.D)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -147,13 +151,15 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A), valueString: ((byte)SameValueContinuousEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.B, name: nameof(SameValueContinuousEnum.B), valueString: ((byte)SameValueContinuousEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.C, name: nameof(SameValueContinuousEnum.C), valueString: ((byte)SameValueContinuousEnum.C).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.D, name: nameof(SameValueContinuousEnum.D), valueString: ((byte)SameValueContinuousEnum.D).ToString(CultureInfo.InvariantCulture)), + (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A)), + (value: SameValueContinuousEnum.B, name: nameof(SameValueContinuousEnum.B)), + (value: SameValueContinuousEnum.C, name: nameof(SameValueContinuousEnum.C)), + (value: SameValueContinuousEnum.D, name: nameof(SameValueContinuousEnum.D)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -163,13 +169,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -237,19 +243,20 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A), valueString: ((byte)SameValueDiscontinuousEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.B, name: nameof(SameValueDiscontinuousEnum.B), valueString: ((byte)SameValueDiscontinuousEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.C, name: nameof(SameValueDiscontinuousEnum.C), valueString: ((byte)SameValueDiscontinuousEnum.C).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.D, name: nameof(SameValueDiscontinuousEnum.D), valueString: ((byte)SameValueDiscontinuousEnum.D).ToString(CultureInfo.InvariantCulture)), + (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A)), + (value: SameValueDiscontinuousEnum.B, name: nameof(SameValueDiscontinuousEnum.B)), + (value: SameValueDiscontinuousEnum.C, name: nameof(SameValueDiscontinuousEnum.C)), + (value: SameValueDiscontinuousEnum.D, name: nameof(SameValueDiscontinuousEnum.D)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -265,19 +272,20 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A), valueString: ((byte)SameValueDiscontinuousEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.B, name: nameof(SameValueDiscontinuousEnum.B), valueString: ((byte)SameValueDiscontinuousEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.C, name: nameof(SameValueDiscontinuousEnum.C), valueString: ((byte)SameValueDiscontinuousEnum.C).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.D, name: nameof(SameValueDiscontinuousEnum.D), valueString: ((byte)SameValueDiscontinuousEnum.D).ToString(CultureInfo.InvariantCulture)), + (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A)), + (value: SameValueDiscontinuousEnum.B, name: nameof(SameValueDiscontinuousEnum.B)), + (value: SameValueDiscontinuousEnum.C, name: nameof(SameValueDiscontinuousEnum.C)), + (value: SameValueDiscontinuousEnum.D, name: nameof(SameValueDiscontinuousEnum.D)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -293,26 +301,28 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A), valueString: ((byte)SameValueDiscontinuousEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.B, name: nameof(SameValueDiscontinuousEnum.B), valueString: ((byte)SameValueDiscontinuousEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.C, name: nameof(SameValueDiscontinuousEnum.C), valueString: ((byte)SameValueDiscontinuousEnum.C).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.D, name: nameof(SameValueDiscontinuousEnum.D), valueString: ((byte)SameValueDiscontinuousEnum.D).ToString(CultureInfo.InvariantCulture)), + (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A)), + (value: SameValueDiscontinuousEnum.B, name: nameof(SameValueDiscontinuousEnum.B)), + (value: SameValueDiscontinuousEnum.C, name: nameof(SameValueDiscontinuousEnum.C)), + (value: SameValueDiscontinuousEnum.D, name: nameof(SameValueDiscontinuousEnum.D)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -330,13 +340,15 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A), valueString: ((byte)SameValueDiscontinuousEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.B, name: nameof(SameValueDiscontinuousEnum.B), valueString: ((byte)SameValueDiscontinuousEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.C, name: nameof(SameValueDiscontinuousEnum.C), valueString: ((byte)SameValueDiscontinuousEnum.C).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.D, name: nameof(SameValueDiscontinuousEnum.D), valueString: ((byte)SameValueDiscontinuousEnum.D).ToString(CultureInfo.InvariantCulture)), + (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A)), + (value: SameValueDiscontinuousEnum.B, name: nameof(SameValueDiscontinuousEnum.B)), + (value: SameValueDiscontinuousEnum.C, name: nameof(SameValueDiscontinuousEnum.C)), + (value: SameValueDiscontinuousEnum.D, name: nameof(SameValueDiscontinuousEnum.D)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -346,13 +358,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); diff --git a/src/insights/FastEnum.UnitTests/Cases/Generators/SameValueTests.tt b/src/insights/FastEnum.UnitTests/Cases/Generators/SameValueTests.tt index d577f09..a02c70b 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Generators/SameValueTests.tt +++ b/src/insights/FastEnum.UnitTests/Cases/Generators/SameValueTests.tt @@ -67,19 +67,20 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" const bool ignoreCase = false; var parameters = new[] { - (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.B).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.C).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.D, name: nameof(<#= x.EnumType #>.D), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.D).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A)), + (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B)), + (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C)), + (value: <#= x.EnumType #>.D, name: nameof(<#= x.EnumType #>.D)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("", ignoreCase)).Should().Throw(); @@ -95,19 +96,20 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" const bool ignoreCase = true; var parameters = new[] { - (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.B).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.C).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.D, name: nameof(<#= x.EnumType #>.D), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.D).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A)), + (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B)), + (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C)), + (value: <#= x.EnumType #>.D, name: nameof(<#= x.EnumType #>.D)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>, <#= x.BoosterType #>>("", ignoreCase)).Should().Throw(); @@ -123,26 +125,28 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" const bool ignoreCase = false; var parameters = new[] { - (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.B).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.C).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.D, name: nameof(<#= x.EnumType #>.D), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.D).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A)), + (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B)), + (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C)), + (value: <#= x.EnumType #>.D, name: nameof(<#= x.EnumType #>.D)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -160,13 +164,15 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" const bool ignoreCase = true; var parameters = new[] { - (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.B).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.C).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.D, name: nameof(<#= x.EnumType #>.D), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.D).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A)), + (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B)), + (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C)), + (value: <#= x.EnumType #>.D, name: nameof(<#= x.EnumType #>.D)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -176,13 +182,13 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse<<#= x.EnumType #>, <#= x.BoosterType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/BasicTests.cs b/src/insights/FastEnum.UnitTests/Cases/Reflections/BasicTests.cs index 015f9a8..738fecb 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/BasicTests.cs +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/BasicTests.cs @@ -197,18 +197,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue), valueString: ((sbyte)SByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: SByteEnum.Zero, name: nameof(SByteEnum.Zero), valueString: ((sbyte)SByteEnum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: SByteEnum.MaxValue, name: nameof(SByteEnum.MaxValue), valueString: ((sbyte)SByteEnum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue)), + (value: SByteEnum.Zero, name: nameof(SByteEnum.Zero)), + (value: SByteEnum.MaxValue, name: nameof(SByteEnum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((sbyte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -224,18 +225,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue), valueString: ((sbyte)SByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: SByteEnum.Zero, name: nameof(SByteEnum.Zero), valueString: ((sbyte)SByteEnum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: SByteEnum.MaxValue, name: nameof(SByteEnum.MaxValue), valueString: ((sbyte)SByteEnum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue)), + (value: SByteEnum.Zero, name: nameof(SByteEnum.Zero)), + (value: SByteEnum.MaxValue, name: nameof(SByteEnum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((sbyte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -251,25 +253,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue), valueString: ((sbyte)SByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: SByteEnum.Zero, name: nameof(SByteEnum.Zero), valueString: ((sbyte)SByteEnum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: SByteEnum.MaxValue, name: nameof(SByteEnum.MaxValue), valueString: ((sbyte)SByteEnum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue)), + (value: SByteEnum.Zero, name: nameof(SByteEnum.Zero)), + (value: SByteEnum.MaxValue, name: nameof(SByteEnum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((sbyte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -287,12 +291,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue), valueString: ((sbyte)SByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: SByteEnum.Zero, name: nameof(SByteEnum.Zero), valueString: ((sbyte)SByteEnum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: SByteEnum.MaxValue, name: nameof(SByteEnum.MaxValue), valueString: ((sbyte)SByteEnum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: SByteEnum.MinValue, name: nameof(SByteEnum.MinValue)), + (value: SByteEnum.Zero, name: nameof(SByteEnum.Zero)), + (value: SByteEnum.MaxValue, name: nameof(SByteEnum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((sbyte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -302,13 +308,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -557,17 +563,18 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue), valueString: ((byte)ByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: ByteEnum.MaxValue, name: nameof(ByteEnum.MaxValue), valueString: ((byte)ByteEnum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue)), + (value: ByteEnum.MaxValue, name: nameof(ByteEnum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -583,17 +590,18 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue), valueString: ((byte)ByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: ByteEnum.MaxValue, name: nameof(ByteEnum.MaxValue), valueString: ((byte)ByteEnum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue)), + (value: ByteEnum.MaxValue, name: nameof(ByteEnum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -609,24 +617,26 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue), valueString: ((byte)ByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: ByteEnum.MaxValue, name: nameof(ByteEnum.MaxValue), valueString: ((byte)ByteEnum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue)), + (value: ByteEnum.MaxValue, name: nameof(ByteEnum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -644,11 +654,13 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue), valueString: ((byte)ByteEnum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: ByteEnum.MaxValue, name: nameof(ByteEnum.MaxValue), valueString: ((byte)ByteEnum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: ByteEnum.MinValue, name: nameof(ByteEnum.MinValue)), + (value: ByteEnum.MaxValue, name: nameof(ByteEnum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -658,13 +670,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -915,18 +927,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue), valueString: ((short)Int16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int16Enum.Zero, name: nameof(Int16Enum.Zero), valueString: ((short)Int16Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int16Enum.MaxValue, name: nameof(Int16Enum.MaxValue), valueString: ((short)Int16Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue)), + (value: Int16Enum.Zero, name: nameof(Int16Enum.Zero)), + (value: Int16Enum.MaxValue, name: nameof(Int16Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((short)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -942,18 +955,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue), valueString: ((short)Int16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int16Enum.Zero, name: nameof(Int16Enum.Zero), valueString: ((short)Int16Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int16Enum.MaxValue, name: nameof(Int16Enum.MaxValue), valueString: ((short)Int16Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue)), + (value: Int16Enum.Zero, name: nameof(Int16Enum.Zero)), + (value: Int16Enum.MaxValue, name: nameof(Int16Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((short)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -969,25 +983,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue), valueString: ((short)Int16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int16Enum.Zero, name: nameof(Int16Enum.Zero), valueString: ((short)Int16Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int16Enum.MaxValue, name: nameof(Int16Enum.MaxValue), valueString: ((short)Int16Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue)), + (value: Int16Enum.Zero, name: nameof(Int16Enum.Zero)), + (value: Int16Enum.MaxValue, name: nameof(Int16Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((short)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1005,12 +1021,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue), valueString: ((short)Int16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int16Enum.Zero, name: nameof(Int16Enum.Zero), valueString: ((short)Int16Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int16Enum.MaxValue, name: nameof(Int16Enum.MaxValue), valueString: ((short)Int16Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int16Enum.MinValue, name: nameof(Int16Enum.MinValue)), + (value: Int16Enum.Zero, name: nameof(Int16Enum.Zero)), + (value: Int16Enum.MaxValue, name: nameof(Int16Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((short)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -1020,13 +1038,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1275,17 +1293,18 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue), valueString: ((ushort)UInt16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt16Enum.MaxValue, name: nameof(UInt16Enum.MaxValue), valueString: ((ushort)UInt16Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue)), + (value: UInt16Enum.MaxValue, name: nameof(UInt16Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((ushort)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1301,17 +1320,18 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue), valueString: ((ushort)UInt16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt16Enum.MaxValue, name: nameof(UInt16Enum.MaxValue), valueString: ((ushort)UInt16Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue)), + (value: UInt16Enum.MaxValue, name: nameof(UInt16Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((ushort)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1327,24 +1347,26 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue), valueString: ((ushort)UInt16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt16Enum.MaxValue, name: nameof(UInt16Enum.MaxValue), valueString: ((ushort)UInt16Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue)), + (value: UInt16Enum.MaxValue, name: nameof(UInt16Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((ushort)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1362,11 +1384,13 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue), valueString: ((ushort)UInt16Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt16Enum.MaxValue, name: nameof(UInt16Enum.MaxValue), valueString: ((ushort)UInt16Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt16Enum.MinValue, name: nameof(UInt16Enum.MinValue)), + (value: UInt16Enum.MaxValue, name: nameof(UInt16Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((ushort)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -1376,13 +1400,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1633,18 +1657,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue), valueString: ((int)Int32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int32Enum.Zero, name: nameof(Int32Enum.Zero), valueString: ((int)Int32Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int32Enum.MaxValue, name: nameof(Int32Enum.MaxValue), valueString: ((int)Int32Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue)), + (value: Int32Enum.Zero, name: nameof(Int32Enum.Zero)), + (value: Int32Enum.MaxValue, name: nameof(Int32Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((int)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1660,18 +1685,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue), valueString: ((int)Int32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int32Enum.Zero, name: nameof(Int32Enum.Zero), valueString: ((int)Int32Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int32Enum.MaxValue, name: nameof(Int32Enum.MaxValue), valueString: ((int)Int32Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue)), + (value: Int32Enum.Zero, name: nameof(Int32Enum.Zero)), + (value: Int32Enum.MaxValue, name: nameof(Int32Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((int)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1687,25 +1713,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue), valueString: ((int)Int32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int32Enum.Zero, name: nameof(Int32Enum.Zero), valueString: ((int)Int32Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int32Enum.MaxValue, name: nameof(Int32Enum.MaxValue), valueString: ((int)Int32Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue)), + (value: Int32Enum.Zero, name: nameof(Int32Enum.Zero)), + (value: Int32Enum.MaxValue, name: nameof(Int32Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((int)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1723,12 +1751,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue), valueString: ((int)Int32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int32Enum.Zero, name: nameof(Int32Enum.Zero), valueString: ((int)Int32Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int32Enum.MaxValue, name: nameof(Int32Enum.MaxValue), valueString: ((int)Int32Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int32Enum.MinValue, name: nameof(Int32Enum.MinValue)), + (value: Int32Enum.Zero, name: nameof(Int32Enum.Zero)), + (value: Int32Enum.MaxValue, name: nameof(Int32Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((int)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -1738,13 +1768,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1993,17 +2023,18 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue), valueString: ((uint)UInt32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt32Enum.MaxValue, name: nameof(UInt32Enum.MaxValue), valueString: ((uint)UInt32Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue)), + (value: UInt32Enum.MaxValue, name: nameof(UInt32Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((uint)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2019,17 +2050,18 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue), valueString: ((uint)UInt32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt32Enum.MaxValue, name: nameof(UInt32Enum.MaxValue), valueString: ((uint)UInt32Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue)), + (value: UInt32Enum.MaxValue, name: nameof(UInt32Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((uint)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2045,24 +2077,26 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue), valueString: ((uint)UInt32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt32Enum.MaxValue, name: nameof(UInt32Enum.MaxValue), valueString: ((uint)UInt32Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue)), + (value: UInt32Enum.MaxValue, name: nameof(UInt32Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((uint)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2080,11 +2114,13 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue), valueString: ((uint)UInt32Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt32Enum.MaxValue, name: nameof(UInt32Enum.MaxValue), valueString: ((uint)UInt32Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt32Enum.MinValue, name: nameof(UInt32Enum.MinValue)), + (value: UInt32Enum.MaxValue, name: nameof(UInt32Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((uint)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -2094,13 +2130,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2351,18 +2387,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue), valueString: ((long)Int64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int64Enum.Zero, name: nameof(Int64Enum.Zero), valueString: ((long)Int64Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int64Enum.MaxValue, name: nameof(Int64Enum.MaxValue), valueString: ((long)Int64Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue)), + (value: Int64Enum.Zero, name: nameof(Int64Enum.Zero)), + (value: Int64Enum.MaxValue, name: nameof(Int64Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((long)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2378,18 +2415,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue), valueString: ((long)Int64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int64Enum.Zero, name: nameof(Int64Enum.Zero), valueString: ((long)Int64Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int64Enum.MaxValue, name: nameof(Int64Enum.MaxValue), valueString: ((long)Int64Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue)), + (value: Int64Enum.Zero, name: nameof(Int64Enum.Zero)), + (value: Int64Enum.MaxValue, name: nameof(Int64Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((long)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2405,25 +2443,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue), valueString: ((long)Int64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int64Enum.Zero, name: nameof(Int64Enum.Zero), valueString: ((long)Int64Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int64Enum.MaxValue, name: nameof(Int64Enum.MaxValue), valueString: ((long)Int64Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue)), + (value: Int64Enum.Zero, name: nameof(Int64Enum.Zero)), + (value: Int64Enum.MaxValue, name: nameof(Int64Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((long)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2441,12 +2481,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue), valueString: ((long)Int64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: Int64Enum.Zero, name: nameof(Int64Enum.Zero), valueString: ((long)Int64Enum.Zero).ToString(CultureInfo.InvariantCulture)), - (value: Int64Enum.MaxValue, name: nameof(Int64Enum.MaxValue), valueString: ((long)Int64Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: Int64Enum.MinValue, name: nameof(Int64Enum.MinValue)), + (value: Int64Enum.Zero, name: nameof(Int64Enum.Zero)), + (value: Int64Enum.MaxValue, name: nameof(Int64Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((long)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -2456,13 +2498,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2711,17 +2753,18 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue), valueString: ((ulong)UInt64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt64Enum.MaxValue, name: nameof(UInt64Enum.MaxValue), valueString: ((ulong)UInt64Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue)), + (value: UInt64Enum.MaxValue, name: nameof(UInt64Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((ulong)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2737,17 +2780,18 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue), valueString: ((ulong)UInt64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt64Enum.MaxValue, name: nameof(UInt64Enum.MaxValue), valueString: ((ulong)UInt64Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue)), + (value: UInt64Enum.MaxValue, name: nameof(UInt64Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((ulong)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2763,24 +2807,26 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue), valueString: ((ulong)UInt64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt64Enum.MaxValue, name: nameof(UInt64Enum.MaxValue), valueString: ((ulong)UInt64Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue)), + (value: UInt64Enum.MaxValue, name: nameof(UInt64Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((ulong)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2798,11 +2844,13 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue), valueString: ((ulong)UInt64Enum.MinValue).ToString(CultureInfo.InvariantCulture)), - (value: UInt64Enum.MaxValue, name: nameof(UInt64Enum.MaxValue), valueString: ((ulong)UInt64Enum.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: UInt64Enum.MinValue, name: nameof(UInt64Enum.MinValue)), + (value: UInt64Enum.MaxValue, name: nameof(UInt64Enum.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((ulong)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -2812,13 +2860,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/BasicTests.tt b/src/insights/FastEnum.UnitTests/Cases/Reflections/BasicTests.tt index f5e6459..217ad12 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/BasicTests.tt +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/BasicTests.tt @@ -222,20 +222,21 @@ public sealed class Basic<#= x.AliasType #>Tests const bool ignoreCase = false; var parameters = new[] { - (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MinValue).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue)), <# if (x.IsSignedType) { #> - (value: <#= x.EnumType #>.Zero, name: nameof(<#= x.EnumType #>.Zero), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.Zero).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.Zero, name: nameof(<#= x.EnumType #>.Zero)), <# } #> - (value: <#= x.EnumType #>.MaxValue, name: nameof(<#= x.EnumType #>.MaxValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.MaxValue, name: nameof(<#= x.EnumType #>.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse<<#= x.EnumType #>>(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", ignoreCase)).Should().Throw(); @@ -251,20 +252,21 @@ public sealed class Basic<#= x.AliasType #>Tests const bool ignoreCase = true; var parameters = new[] { - (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MinValue).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue)), <# if (x.IsSignedType) { #> - (value: <#= x.EnumType #>.Zero, name: nameof(<#= x.EnumType #>.Zero), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.Zero).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.Zero, name: nameof(<#= x.EnumType #>.Zero)), <# } #> - (value: <#= x.EnumType #>.MaxValue, name: nameof(<#= x.EnumType #>.MaxValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.MaxValue, name: nameof(<#= x.EnumType #>.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse<<#= x.EnumType #>>(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", ignoreCase)).Should().Throw(); @@ -280,27 +282,29 @@ public sealed class Basic<#= x.AliasType #>Tests const bool ignoreCase = false; var parameters = new[] { - (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MinValue).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue)), <# if (x.IsSignedType) { #> - (value: <#= x.EnumType #>.Zero, name: nameof(<#= x.EnumType #>.Zero), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.Zero).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.Zero, name: nameof(<#= x.EnumType #>.Zero)), <# } #> - (value: <#= x.EnumType #>.MaxValue, name: nameof(<#= x.EnumType #>.MaxValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.MaxValue, name: nameof(<#= x.EnumType #>.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse<<#= x.EnumType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse<<#= x.EnumType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -318,14 +322,16 @@ public sealed class Basic<#= x.AliasType #>Tests const bool ignoreCase = true; var parameters = new[] { - (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MinValue).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.MinValue, name: nameof(<#= x.EnumType #>.MinValue)), <# if (x.IsSignedType) { #> - (value: <#= x.EnumType #>.Zero, name: nameof(<#= x.EnumType #>.Zero), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.Zero).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.Zero, name: nameof(<#= x.EnumType #>.Zero)), <# } #> - (value: <#= x.EnumType #>.MaxValue, name: nameof(<#= x.EnumType #>.MaxValue), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.MaxValue).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.MaxValue, name: nameof(<#= x.EnumType #>.MaxValue)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse<<#= x.EnumType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -335,13 +341,13 @@ public sealed class Basic<#= x.AliasType #>Tests FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse<<#= x.EnumType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/ContinuousTests.cs b/src/insights/FastEnum.UnitTests/Cases/Reflections/ContinuousTests.cs index 7567118..930d965 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/ContinuousTests.cs +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/ContinuousTests.cs @@ -201,18 +201,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: ContinuousSByteEnum.A, name: nameof(ContinuousSByteEnum.A), valueString: ((sbyte)ContinuousSByteEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousSByteEnum.B, name: nameof(ContinuousSByteEnum.B), valueString: ((sbyte)ContinuousSByteEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousSByteEnum.C, name: nameof(ContinuousSByteEnum.C), valueString: ((sbyte)ContinuousSByteEnum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousSByteEnum.A, name: nameof(ContinuousSByteEnum.A)), + (value: ContinuousSByteEnum.B, name: nameof(ContinuousSByteEnum.B)), + (value: ContinuousSByteEnum.C, name: nameof(ContinuousSByteEnum.C)), }; foreach (var x in parameters) { + var valueString = ((sbyte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -228,18 +229,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ContinuousSByteEnum.A, name: nameof(ContinuousSByteEnum.A), valueString: ((sbyte)ContinuousSByteEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousSByteEnum.B, name: nameof(ContinuousSByteEnum.B), valueString: ((sbyte)ContinuousSByteEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousSByteEnum.C, name: nameof(ContinuousSByteEnum.C), valueString: ((sbyte)ContinuousSByteEnum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousSByteEnum.A, name: nameof(ContinuousSByteEnum.A)), + (value: ContinuousSByteEnum.B, name: nameof(ContinuousSByteEnum.B)), + (value: ContinuousSByteEnum.C, name: nameof(ContinuousSByteEnum.C)), }; foreach (var x in parameters) { + var valueString = ((sbyte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -255,25 +257,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: ContinuousSByteEnum.A, name: nameof(ContinuousSByteEnum.A), valueString: ((sbyte)ContinuousSByteEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousSByteEnum.B, name: nameof(ContinuousSByteEnum.B), valueString: ((sbyte)ContinuousSByteEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousSByteEnum.C, name: nameof(ContinuousSByteEnum.C), valueString: ((sbyte)ContinuousSByteEnum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousSByteEnum.A, name: nameof(ContinuousSByteEnum.A)), + (value: ContinuousSByteEnum.B, name: nameof(ContinuousSByteEnum.B)), + (value: ContinuousSByteEnum.C, name: nameof(ContinuousSByteEnum.C)), }; foreach (var x in parameters) { + var valueString = ((sbyte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -291,12 +295,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ContinuousSByteEnum.A, name: nameof(ContinuousSByteEnum.A), valueString: ((sbyte)ContinuousSByteEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousSByteEnum.B, name: nameof(ContinuousSByteEnum.B), valueString: ((sbyte)ContinuousSByteEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousSByteEnum.C, name: nameof(ContinuousSByteEnum.C), valueString: ((sbyte)ContinuousSByteEnum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousSByteEnum.A, name: nameof(ContinuousSByteEnum.A)), + (value: ContinuousSByteEnum.B, name: nameof(ContinuousSByteEnum.B)), + (value: ContinuousSByteEnum.C, name: nameof(ContinuousSByteEnum.C)), }; foreach (var x in parameters) { + var valueString = ((sbyte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -306,13 +312,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -568,18 +574,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: ContinuousByteEnum.A, name: nameof(ContinuousByteEnum.A), valueString: ((byte)ContinuousByteEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousByteEnum.B, name: nameof(ContinuousByteEnum.B), valueString: ((byte)ContinuousByteEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousByteEnum.C, name: nameof(ContinuousByteEnum.C), valueString: ((byte)ContinuousByteEnum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousByteEnum.A, name: nameof(ContinuousByteEnum.A)), + (value: ContinuousByteEnum.B, name: nameof(ContinuousByteEnum.B)), + (value: ContinuousByteEnum.C, name: nameof(ContinuousByteEnum.C)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -595,18 +602,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ContinuousByteEnum.A, name: nameof(ContinuousByteEnum.A), valueString: ((byte)ContinuousByteEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousByteEnum.B, name: nameof(ContinuousByteEnum.B), valueString: ((byte)ContinuousByteEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousByteEnum.C, name: nameof(ContinuousByteEnum.C), valueString: ((byte)ContinuousByteEnum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousByteEnum.A, name: nameof(ContinuousByteEnum.A)), + (value: ContinuousByteEnum.B, name: nameof(ContinuousByteEnum.B)), + (value: ContinuousByteEnum.C, name: nameof(ContinuousByteEnum.C)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -622,25 +630,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: ContinuousByteEnum.A, name: nameof(ContinuousByteEnum.A), valueString: ((byte)ContinuousByteEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousByteEnum.B, name: nameof(ContinuousByteEnum.B), valueString: ((byte)ContinuousByteEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousByteEnum.C, name: nameof(ContinuousByteEnum.C), valueString: ((byte)ContinuousByteEnum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousByteEnum.A, name: nameof(ContinuousByteEnum.A)), + (value: ContinuousByteEnum.B, name: nameof(ContinuousByteEnum.B)), + (value: ContinuousByteEnum.C, name: nameof(ContinuousByteEnum.C)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -658,12 +668,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ContinuousByteEnum.A, name: nameof(ContinuousByteEnum.A), valueString: ((byte)ContinuousByteEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousByteEnum.B, name: nameof(ContinuousByteEnum.B), valueString: ((byte)ContinuousByteEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousByteEnum.C, name: nameof(ContinuousByteEnum.C), valueString: ((byte)ContinuousByteEnum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousByteEnum.A, name: nameof(ContinuousByteEnum.A)), + (value: ContinuousByteEnum.B, name: nameof(ContinuousByteEnum.B)), + (value: ContinuousByteEnum.C, name: nameof(ContinuousByteEnum.C)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -673,13 +685,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -935,18 +947,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: ContinuousInt16Enum.A, name: nameof(ContinuousInt16Enum.A), valueString: ((short)ContinuousInt16Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt16Enum.B, name: nameof(ContinuousInt16Enum.B), valueString: ((short)ContinuousInt16Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt16Enum.C, name: nameof(ContinuousInt16Enum.C), valueString: ((short)ContinuousInt16Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousInt16Enum.A, name: nameof(ContinuousInt16Enum.A)), + (value: ContinuousInt16Enum.B, name: nameof(ContinuousInt16Enum.B)), + (value: ContinuousInt16Enum.C, name: nameof(ContinuousInt16Enum.C)), }; foreach (var x in parameters) { + var valueString = ((short)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -962,18 +975,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ContinuousInt16Enum.A, name: nameof(ContinuousInt16Enum.A), valueString: ((short)ContinuousInt16Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt16Enum.B, name: nameof(ContinuousInt16Enum.B), valueString: ((short)ContinuousInt16Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt16Enum.C, name: nameof(ContinuousInt16Enum.C), valueString: ((short)ContinuousInt16Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousInt16Enum.A, name: nameof(ContinuousInt16Enum.A)), + (value: ContinuousInt16Enum.B, name: nameof(ContinuousInt16Enum.B)), + (value: ContinuousInt16Enum.C, name: nameof(ContinuousInt16Enum.C)), }; foreach (var x in parameters) { + var valueString = ((short)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -989,25 +1003,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: ContinuousInt16Enum.A, name: nameof(ContinuousInt16Enum.A), valueString: ((short)ContinuousInt16Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt16Enum.B, name: nameof(ContinuousInt16Enum.B), valueString: ((short)ContinuousInt16Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt16Enum.C, name: nameof(ContinuousInt16Enum.C), valueString: ((short)ContinuousInt16Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousInt16Enum.A, name: nameof(ContinuousInt16Enum.A)), + (value: ContinuousInt16Enum.B, name: nameof(ContinuousInt16Enum.B)), + (value: ContinuousInt16Enum.C, name: nameof(ContinuousInt16Enum.C)), }; foreach (var x in parameters) { + var valueString = ((short)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1025,12 +1041,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ContinuousInt16Enum.A, name: nameof(ContinuousInt16Enum.A), valueString: ((short)ContinuousInt16Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt16Enum.B, name: nameof(ContinuousInt16Enum.B), valueString: ((short)ContinuousInt16Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt16Enum.C, name: nameof(ContinuousInt16Enum.C), valueString: ((short)ContinuousInt16Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousInt16Enum.A, name: nameof(ContinuousInt16Enum.A)), + (value: ContinuousInt16Enum.B, name: nameof(ContinuousInt16Enum.B)), + (value: ContinuousInt16Enum.C, name: nameof(ContinuousInt16Enum.C)), }; foreach (var x in parameters) { + var valueString = ((short)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -1040,13 +1058,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1302,18 +1320,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: ContinuousUInt16Enum.A, name: nameof(ContinuousUInt16Enum.A), valueString: ((ushort)ContinuousUInt16Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt16Enum.B, name: nameof(ContinuousUInt16Enum.B), valueString: ((ushort)ContinuousUInt16Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt16Enum.C, name: nameof(ContinuousUInt16Enum.C), valueString: ((ushort)ContinuousUInt16Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousUInt16Enum.A, name: nameof(ContinuousUInt16Enum.A)), + (value: ContinuousUInt16Enum.B, name: nameof(ContinuousUInt16Enum.B)), + (value: ContinuousUInt16Enum.C, name: nameof(ContinuousUInt16Enum.C)), }; foreach (var x in parameters) { + var valueString = ((ushort)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1329,18 +1348,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ContinuousUInt16Enum.A, name: nameof(ContinuousUInt16Enum.A), valueString: ((ushort)ContinuousUInt16Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt16Enum.B, name: nameof(ContinuousUInt16Enum.B), valueString: ((ushort)ContinuousUInt16Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt16Enum.C, name: nameof(ContinuousUInt16Enum.C), valueString: ((ushort)ContinuousUInt16Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousUInt16Enum.A, name: nameof(ContinuousUInt16Enum.A)), + (value: ContinuousUInt16Enum.B, name: nameof(ContinuousUInt16Enum.B)), + (value: ContinuousUInt16Enum.C, name: nameof(ContinuousUInt16Enum.C)), }; foreach (var x in parameters) { + var valueString = ((ushort)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1356,25 +1376,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: ContinuousUInt16Enum.A, name: nameof(ContinuousUInt16Enum.A), valueString: ((ushort)ContinuousUInt16Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt16Enum.B, name: nameof(ContinuousUInt16Enum.B), valueString: ((ushort)ContinuousUInt16Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt16Enum.C, name: nameof(ContinuousUInt16Enum.C), valueString: ((ushort)ContinuousUInt16Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousUInt16Enum.A, name: nameof(ContinuousUInt16Enum.A)), + (value: ContinuousUInt16Enum.B, name: nameof(ContinuousUInt16Enum.B)), + (value: ContinuousUInt16Enum.C, name: nameof(ContinuousUInt16Enum.C)), }; foreach (var x in parameters) { + var valueString = ((ushort)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1392,12 +1414,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ContinuousUInt16Enum.A, name: nameof(ContinuousUInt16Enum.A), valueString: ((ushort)ContinuousUInt16Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt16Enum.B, name: nameof(ContinuousUInt16Enum.B), valueString: ((ushort)ContinuousUInt16Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt16Enum.C, name: nameof(ContinuousUInt16Enum.C), valueString: ((ushort)ContinuousUInt16Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousUInt16Enum.A, name: nameof(ContinuousUInt16Enum.A)), + (value: ContinuousUInt16Enum.B, name: nameof(ContinuousUInt16Enum.B)), + (value: ContinuousUInt16Enum.C, name: nameof(ContinuousUInt16Enum.C)), }; foreach (var x in parameters) { + var valueString = ((ushort)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -1407,13 +1431,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1669,18 +1693,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: ContinuousInt32Enum.A, name: nameof(ContinuousInt32Enum.A), valueString: ((int)ContinuousInt32Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt32Enum.B, name: nameof(ContinuousInt32Enum.B), valueString: ((int)ContinuousInt32Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt32Enum.C, name: nameof(ContinuousInt32Enum.C), valueString: ((int)ContinuousInt32Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousInt32Enum.A, name: nameof(ContinuousInt32Enum.A)), + (value: ContinuousInt32Enum.B, name: nameof(ContinuousInt32Enum.B)), + (value: ContinuousInt32Enum.C, name: nameof(ContinuousInt32Enum.C)), }; foreach (var x in parameters) { + var valueString = ((int)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1696,18 +1721,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ContinuousInt32Enum.A, name: nameof(ContinuousInt32Enum.A), valueString: ((int)ContinuousInt32Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt32Enum.B, name: nameof(ContinuousInt32Enum.B), valueString: ((int)ContinuousInt32Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt32Enum.C, name: nameof(ContinuousInt32Enum.C), valueString: ((int)ContinuousInt32Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousInt32Enum.A, name: nameof(ContinuousInt32Enum.A)), + (value: ContinuousInt32Enum.B, name: nameof(ContinuousInt32Enum.B)), + (value: ContinuousInt32Enum.C, name: nameof(ContinuousInt32Enum.C)), }; foreach (var x in parameters) { + var valueString = ((int)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1723,25 +1749,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: ContinuousInt32Enum.A, name: nameof(ContinuousInt32Enum.A), valueString: ((int)ContinuousInt32Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt32Enum.B, name: nameof(ContinuousInt32Enum.B), valueString: ((int)ContinuousInt32Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt32Enum.C, name: nameof(ContinuousInt32Enum.C), valueString: ((int)ContinuousInt32Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousInt32Enum.A, name: nameof(ContinuousInt32Enum.A)), + (value: ContinuousInt32Enum.B, name: nameof(ContinuousInt32Enum.B)), + (value: ContinuousInt32Enum.C, name: nameof(ContinuousInt32Enum.C)), }; foreach (var x in parameters) { + var valueString = ((int)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1759,12 +1787,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ContinuousInt32Enum.A, name: nameof(ContinuousInt32Enum.A), valueString: ((int)ContinuousInt32Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt32Enum.B, name: nameof(ContinuousInt32Enum.B), valueString: ((int)ContinuousInt32Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt32Enum.C, name: nameof(ContinuousInt32Enum.C), valueString: ((int)ContinuousInt32Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousInt32Enum.A, name: nameof(ContinuousInt32Enum.A)), + (value: ContinuousInt32Enum.B, name: nameof(ContinuousInt32Enum.B)), + (value: ContinuousInt32Enum.C, name: nameof(ContinuousInt32Enum.C)), }; foreach (var x in parameters) { + var valueString = ((int)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -1774,13 +1804,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2036,18 +2066,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: ContinuousUInt32Enum.A, name: nameof(ContinuousUInt32Enum.A), valueString: ((uint)ContinuousUInt32Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt32Enum.B, name: nameof(ContinuousUInt32Enum.B), valueString: ((uint)ContinuousUInt32Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt32Enum.C, name: nameof(ContinuousUInt32Enum.C), valueString: ((uint)ContinuousUInt32Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousUInt32Enum.A, name: nameof(ContinuousUInt32Enum.A)), + (value: ContinuousUInt32Enum.B, name: nameof(ContinuousUInt32Enum.B)), + (value: ContinuousUInt32Enum.C, name: nameof(ContinuousUInt32Enum.C)), }; foreach (var x in parameters) { + var valueString = ((uint)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2063,18 +2094,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ContinuousUInt32Enum.A, name: nameof(ContinuousUInt32Enum.A), valueString: ((uint)ContinuousUInt32Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt32Enum.B, name: nameof(ContinuousUInt32Enum.B), valueString: ((uint)ContinuousUInt32Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt32Enum.C, name: nameof(ContinuousUInt32Enum.C), valueString: ((uint)ContinuousUInt32Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousUInt32Enum.A, name: nameof(ContinuousUInt32Enum.A)), + (value: ContinuousUInt32Enum.B, name: nameof(ContinuousUInt32Enum.B)), + (value: ContinuousUInt32Enum.C, name: nameof(ContinuousUInt32Enum.C)), }; foreach (var x in parameters) { + var valueString = ((uint)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2090,25 +2122,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: ContinuousUInt32Enum.A, name: nameof(ContinuousUInt32Enum.A), valueString: ((uint)ContinuousUInt32Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt32Enum.B, name: nameof(ContinuousUInt32Enum.B), valueString: ((uint)ContinuousUInt32Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt32Enum.C, name: nameof(ContinuousUInt32Enum.C), valueString: ((uint)ContinuousUInt32Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousUInt32Enum.A, name: nameof(ContinuousUInt32Enum.A)), + (value: ContinuousUInt32Enum.B, name: nameof(ContinuousUInt32Enum.B)), + (value: ContinuousUInt32Enum.C, name: nameof(ContinuousUInt32Enum.C)), }; foreach (var x in parameters) { + var valueString = ((uint)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2126,12 +2160,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ContinuousUInt32Enum.A, name: nameof(ContinuousUInt32Enum.A), valueString: ((uint)ContinuousUInt32Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt32Enum.B, name: nameof(ContinuousUInt32Enum.B), valueString: ((uint)ContinuousUInt32Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt32Enum.C, name: nameof(ContinuousUInt32Enum.C), valueString: ((uint)ContinuousUInt32Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousUInt32Enum.A, name: nameof(ContinuousUInt32Enum.A)), + (value: ContinuousUInt32Enum.B, name: nameof(ContinuousUInt32Enum.B)), + (value: ContinuousUInt32Enum.C, name: nameof(ContinuousUInt32Enum.C)), }; foreach (var x in parameters) { + var valueString = ((uint)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -2141,13 +2177,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2403,18 +2439,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: ContinuousInt64Enum.A, name: nameof(ContinuousInt64Enum.A), valueString: ((long)ContinuousInt64Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt64Enum.B, name: nameof(ContinuousInt64Enum.B), valueString: ((long)ContinuousInt64Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt64Enum.C, name: nameof(ContinuousInt64Enum.C), valueString: ((long)ContinuousInt64Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousInt64Enum.A, name: nameof(ContinuousInt64Enum.A)), + (value: ContinuousInt64Enum.B, name: nameof(ContinuousInt64Enum.B)), + (value: ContinuousInt64Enum.C, name: nameof(ContinuousInt64Enum.C)), }; foreach (var x in parameters) { + var valueString = ((long)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2430,18 +2467,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ContinuousInt64Enum.A, name: nameof(ContinuousInt64Enum.A), valueString: ((long)ContinuousInt64Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt64Enum.B, name: nameof(ContinuousInt64Enum.B), valueString: ((long)ContinuousInt64Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt64Enum.C, name: nameof(ContinuousInt64Enum.C), valueString: ((long)ContinuousInt64Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousInt64Enum.A, name: nameof(ContinuousInt64Enum.A)), + (value: ContinuousInt64Enum.B, name: nameof(ContinuousInt64Enum.B)), + (value: ContinuousInt64Enum.C, name: nameof(ContinuousInt64Enum.C)), }; foreach (var x in parameters) { + var valueString = ((long)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2457,25 +2495,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: ContinuousInt64Enum.A, name: nameof(ContinuousInt64Enum.A), valueString: ((long)ContinuousInt64Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt64Enum.B, name: nameof(ContinuousInt64Enum.B), valueString: ((long)ContinuousInt64Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt64Enum.C, name: nameof(ContinuousInt64Enum.C), valueString: ((long)ContinuousInt64Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousInt64Enum.A, name: nameof(ContinuousInt64Enum.A)), + (value: ContinuousInt64Enum.B, name: nameof(ContinuousInt64Enum.B)), + (value: ContinuousInt64Enum.C, name: nameof(ContinuousInt64Enum.C)), }; foreach (var x in parameters) { + var valueString = ((long)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2493,12 +2533,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ContinuousInt64Enum.A, name: nameof(ContinuousInt64Enum.A), valueString: ((long)ContinuousInt64Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt64Enum.B, name: nameof(ContinuousInt64Enum.B), valueString: ((long)ContinuousInt64Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousInt64Enum.C, name: nameof(ContinuousInt64Enum.C), valueString: ((long)ContinuousInt64Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousInt64Enum.A, name: nameof(ContinuousInt64Enum.A)), + (value: ContinuousInt64Enum.B, name: nameof(ContinuousInt64Enum.B)), + (value: ContinuousInt64Enum.C, name: nameof(ContinuousInt64Enum.C)), }; foreach (var x in parameters) { + var valueString = ((long)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -2508,13 +2550,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2770,18 +2812,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: ContinuousUInt64Enum.A, name: nameof(ContinuousUInt64Enum.A), valueString: ((ulong)ContinuousUInt64Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt64Enum.B, name: nameof(ContinuousUInt64Enum.B), valueString: ((ulong)ContinuousUInt64Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt64Enum.C, name: nameof(ContinuousUInt64Enum.C), valueString: ((ulong)ContinuousUInt64Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousUInt64Enum.A, name: nameof(ContinuousUInt64Enum.A)), + (value: ContinuousUInt64Enum.B, name: nameof(ContinuousUInt64Enum.B)), + (value: ContinuousUInt64Enum.C, name: nameof(ContinuousUInt64Enum.C)), }; foreach (var x in parameters) { + var valueString = ((ulong)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2797,18 +2840,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ContinuousUInt64Enum.A, name: nameof(ContinuousUInt64Enum.A), valueString: ((ulong)ContinuousUInt64Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt64Enum.B, name: nameof(ContinuousUInt64Enum.B), valueString: ((ulong)ContinuousUInt64Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt64Enum.C, name: nameof(ContinuousUInt64Enum.C), valueString: ((ulong)ContinuousUInt64Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousUInt64Enum.A, name: nameof(ContinuousUInt64Enum.A)), + (value: ContinuousUInt64Enum.B, name: nameof(ContinuousUInt64Enum.B)), + (value: ContinuousUInt64Enum.C, name: nameof(ContinuousUInt64Enum.C)), }; foreach (var x in parameters) { + var valueString = ((ulong)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2824,25 +2868,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: ContinuousUInt64Enum.A, name: nameof(ContinuousUInt64Enum.A), valueString: ((ulong)ContinuousUInt64Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt64Enum.B, name: nameof(ContinuousUInt64Enum.B), valueString: ((ulong)ContinuousUInt64Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt64Enum.C, name: nameof(ContinuousUInt64Enum.C), valueString: ((ulong)ContinuousUInt64Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousUInt64Enum.A, name: nameof(ContinuousUInt64Enum.A)), + (value: ContinuousUInt64Enum.B, name: nameof(ContinuousUInt64Enum.B)), + (value: ContinuousUInt64Enum.C, name: nameof(ContinuousUInt64Enum.C)), }; foreach (var x in parameters) { + var valueString = ((ulong)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2860,12 +2906,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: ContinuousUInt64Enum.A, name: nameof(ContinuousUInt64Enum.A), valueString: ((ulong)ContinuousUInt64Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt64Enum.B, name: nameof(ContinuousUInt64Enum.B), valueString: ((ulong)ContinuousUInt64Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: ContinuousUInt64Enum.C, name: nameof(ContinuousUInt64Enum.C), valueString: ((ulong)ContinuousUInt64Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: ContinuousUInt64Enum.A, name: nameof(ContinuousUInt64Enum.A)), + (value: ContinuousUInt64Enum.B, name: nameof(ContinuousUInt64Enum.B)), + (value: ContinuousUInt64Enum.C, name: nameof(ContinuousUInt64Enum.C)), }; foreach (var x in parameters) { + var valueString = ((ulong)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -2875,13 +2923,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/ContinuousTests.tt b/src/insights/FastEnum.UnitTests/Cases/Reflections/ContinuousTests.tt index 72476d5..8bb04a7 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/ContinuousTests.tt +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/ContinuousTests.tt @@ -220,18 +220,19 @@ public sealed class Continuous<#= x.AliasType #>Tests const bool ignoreCase = false; var parameters = new[] { - (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.B).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.C).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A)), + (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B)), + (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse<<#= x.EnumType #>>(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", ignoreCase)).Should().Throw(); @@ -247,18 +248,19 @@ public sealed class Continuous<#= x.AliasType #>Tests const bool ignoreCase = true; var parameters = new[] { - (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.B).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.C).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A)), + (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B)), + (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse<<#= x.EnumType #>>(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", ignoreCase)).Should().Throw(); @@ -274,25 +276,27 @@ public sealed class Continuous<#= x.AliasType #>Tests const bool ignoreCase = false; var parameters = new[] { - (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.B).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.C).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A)), + (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B)), + (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse<<#= x.EnumType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse<<#= x.EnumType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -310,12 +314,14 @@ public sealed class Continuous<#= x.AliasType #>Tests const bool ignoreCase = true; var parameters = new[] { - (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.B).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.C).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A)), + (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B)), + (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse<<#= x.EnumType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -325,13 +331,13 @@ public sealed class Continuous<#= x.AliasType #>Tests FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse<<#= x.EnumType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/DiscontinuousTests.cs b/src/insights/FastEnum.UnitTests/Cases/Reflections/DiscontinuousTests.cs index 4443a88..d1e6006 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/DiscontinuousTests.cs +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/DiscontinuousTests.cs @@ -197,18 +197,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: DiscontinuousSByteEnum.A, name: nameof(DiscontinuousSByteEnum.A), valueString: ((sbyte)DiscontinuousSByteEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousSByteEnum.B, name: nameof(DiscontinuousSByteEnum.B), valueString: ((sbyte)DiscontinuousSByteEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousSByteEnum.C, name: nameof(DiscontinuousSByteEnum.C), valueString: ((sbyte)DiscontinuousSByteEnum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousSByteEnum.A, name: nameof(DiscontinuousSByteEnum.A)), + (value: DiscontinuousSByteEnum.B, name: nameof(DiscontinuousSByteEnum.B)), + (value: DiscontinuousSByteEnum.C, name: nameof(DiscontinuousSByteEnum.C)), }; foreach (var x in parameters) { + var valueString = ((sbyte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -224,18 +225,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: DiscontinuousSByteEnum.A, name: nameof(DiscontinuousSByteEnum.A), valueString: ((sbyte)DiscontinuousSByteEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousSByteEnum.B, name: nameof(DiscontinuousSByteEnum.B), valueString: ((sbyte)DiscontinuousSByteEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousSByteEnum.C, name: nameof(DiscontinuousSByteEnum.C), valueString: ((sbyte)DiscontinuousSByteEnum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousSByteEnum.A, name: nameof(DiscontinuousSByteEnum.A)), + (value: DiscontinuousSByteEnum.B, name: nameof(DiscontinuousSByteEnum.B)), + (value: DiscontinuousSByteEnum.C, name: nameof(DiscontinuousSByteEnum.C)), }; foreach (var x in parameters) { + var valueString = ((sbyte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -251,25 +253,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: DiscontinuousSByteEnum.A, name: nameof(DiscontinuousSByteEnum.A), valueString: ((sbyte)DiscontinuousSByteEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousSByteEnum.B, name: nameof(DiscontinuousSByteEnum.B), valueString: ((sbyte)DiscontinuousSByteEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousSByteEnum.C, name: nameof(DiscontinuousSByteEnum.C), valueString: ((sbyte)DiscontinuousSByteEnum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousSByteEnum.A, name: nameof(DiscontinuousSByteEnum.A)), + (value: DiscontinuousSByteEnum.B, name: nameof(DiscontinuousSByteEnum.B)), + (value: DiscontinuousSByteEnum.C, name: nameof(DiscontinuousSByteEnum.C)), }; foreach (var x in parameters) { + var valueString = ((sbyte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -287,12 +291,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: DiscontinuousSByteEnum.A, name: nameof(DiscontinuousSByteEnum.A), valueString: ((sbyte)DiscontinuousSByteEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousSByteEnum.B, name: nameof(DiscontinuousSByteEnum.B), valueString: ((sbyte)DiscontinuousSByteEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousSByteEnum.C, name: nameof(DiscontinuousSByteEnum.C), valueString: ((sbyte)DiscontinuousSByteEnum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousSByteEnum.A, name: nameof(DiscontinuousSByteEnum.A)), + (value: DiscontinuousSByteEnum.B, name: nameof(DiscontinuousSByteEnum.B)), + (value: DiscontinuousSByteEnum.C, name: nameof(DiscontinuousSByteEnum.C)), }; foreach (var x in parameters) { + var valueString = ((sbyte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -302,13 +308,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -560,18 +566,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: DiscontinuousByteEnum.A, name: nameof(DiscontinuousByteEnum.A), valueString: ((byte)DiscontinuousByteEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousByteEnum.B, name: nameof(DiscontinuousByteEnum.B), valueString: ((byte)DiscontinuousByteEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousByteEnum.C, name: nameof(DiscontinuousByteEnum.C), valueString: ((byte)DiscontinuousByteEnum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousByteEnum.A, name: nameof(DiscontinuousByteEnum.A)), + (value: DiscontinuousByteEnum.B, name: nameof(DiscontinuousByteEnum.B)), + (value: DiscontinuousByteEnum.C, name: nameof(DiscontinuousByteEnum.C)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -587,18 +594,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: DiscontinuousByteEnum.A, name: nameof(DiscontinuousByteEnum.A), valueString: ((byte)DiscontinuousByteEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousByteEnum.B, name: nameof(DiscontinuousByteEnum.B), valueString: ((byte)DiscontinuousByteEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousByteEnum.C, name: nameof(DiscontinuousByteEnum.C), valueString: ((byte)DiscontinuousByteEnum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousByteEnum.A, name: nameof(DiscontinuousByteEnum.A)), + (value: DiscontinuousByteEnum.B, name: nameof(DiscontinuousByteEnum.B)), + (value: DiscontinuousByteEnum.C, name: nameof(DiscontinuousByteEnum.C)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -614,25 +622,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: DiscontinuousByteEnum.A, name: nameof(DiscontinuousByteEnum.A), valueString: ((byte)DiscontinuousByteEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousByteEnum.B, name: nameof(DiscontinuousByteEnum.B), valueString: ((byte)DiscontinuousByteEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousByteEnum.C, name: nameof(DiscontinuousByteEnum.C), valueString: ((byte)DiscontinuousByteEnum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousByteEnum.A, name: nameof(DiscontinuousByteEnum.A)), + (value: DiscontinuousByteEnum.B, name: nameof(DiscontinuousByteEnum.B)), + (value: DiscontinuousByteEnum.C, name: nameof(DiscontinuousByteEnum.C)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -650,12 +660,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: DiscontinuousByteEnum.A, name: nameof(DiscontinuousByteEnum.A), valueString: ((byte)DiscontinuousByteEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousByteEnum.B, name: nameof(DiscontinuousByteEnum.B), valueString: ((byte)DiscontinuousByteEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousByteEnum.C, name: nameof(DiscontinuousByteEnum.C), valueString: ((byte)DiscontinuousByteEnum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousByteEnum.A, name: nameof(DiscontinuousByteEnum.A)), + (value: DiscontinuousByteEnum.B, name: nameof(DiscontinuousByteEnum.B)), + (value: DiscontinuousByteEnum.C, name: nameof(DiscontinuousByteEnum.C)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -665,13 +677,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -923,18 +935,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: DiscontinuousInt16Enum.A, name: nameof(DiscontinuousInt16Enum.A), valueString: ((short)DiscontinuousInt16Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt16Enum.B, name: nameof(DiscontinuousInt16Enum.B), valueString: ((short)DiscontinuousInt16Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt16Enum.C, name: nameof(DiscontinuousInt16Enum.C), valueString: ((short)DiscontinuousInt16Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousInt16Enum.A, name: nameof(DiscontinuousInt16Enum.A)), + (value: DiscontinuousInt16Enum.B, name: nameof(DiscontinuousInt16Enum.B)), + (value: DiscontinuousInt16Enum.C, name: nameof(DiscontinuousInt16Enum.C)), }; foreach (var x in parameters) { + var valueString = ((short)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -950,18 +963,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: DiscontinuousInt16Enum.A, name: nameof(DiscontinuousInt16Enum.A), valueString: ((short)DiscontinuousInt16Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt16Enum.B, name: nameof(DiscontinuousInt16Enum.B), valueString: ((short)DiscontinuousInt16Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt16Enum.C, name: nameof(DiscontinuousInt16Enum.C), valueString: ((short)DiscontinuousInt16Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousInt16Enum.A, name: nameof(DiscontinuousInt16Enum.A)), + (value: DiscontinuousInt16Enum.B, name: nameof(DiscontinuousInt16Enum.B)), + (value: DiscontinuousInt16Enum.C, name: nameof(DiscontinuousInt16Enum.C)), }; foreach (var x in parameters) { + var valueString = ((short)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -977,25 +991,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: DiscontinuousInt16Enum.A, name: nameof(DiscontinuousInt16Enum.A), valueString: ((short)DiscontinuousInt16Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt16Enum.B, name: nameof(DiscontinuousInt16Enum.B), valueString: ((short)DiscontinuousInt16Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt16Enum.C, name: nameof(DiscontinuousInt16Enum.C), valueString: ((short)DiscontinuousInt16Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousInt16Enum.A, name: nameof(DiscontinuousInt16Enum.A)), + (value: DiscontinuousInt16Enum.B, name: nameof(DiscontinuousInt16Enum.B)), + (value: DiscontinuousInt16Enum.C, name: nameof(DiscontinuousInt16Enum.C)), }; foreach (var x in parameters) { + var valueString = ((short)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1013,12 +1029,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: DiscontinuousInt16Enum.A, name: nameof(DiscontinuousInt16Enum.A), valueString: ((short)DiscontinuousInt16Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt16Enum.B, name: nameof(DiscontinuousInt16Enum.B), valueString: ((short)DiscontinuousInt16Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt16Enum.C, name: nameof(DiscontinuousInt16Enum.C), valueString: ((short)DiscontinuousInt16Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousInt16Enum.A, name: nameof(DiscontinuousInt16Enum.A)), + (value: DiscontinuousInt16Enum.B, name: nameof(DiscontinuousInt16Enum.B)), + (value: DiscontinuousInt16Enum.C, name: nameof(DiscontinuousInt16Enum.C)), }; foreach (var x in parameters) { + var valueString = ((short)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -1028,13 +1046,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1286,18 +1304,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: DiscontinuousUInt16Enum.A, name: nameof(DiscontinuousUInt16Enum.A), valueString: ((ushort)DiscontinuousUInt16Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt16Enum.B, name: nameof(DiscontinuousUInt16Enum.B), valueString: ((ushort)DiscontinuousUInt16Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt16Enum.C, name: nameof(DiscontinuousUInt16Enum.C), valueString: ((ushort)DiscontinuousUInt16Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousUInt16Enum.A, name: nameof(DiscontinuousUInt16Enum.A)), + (value: DiscontinuousUInt16Enum.B, name: nameof(DiscontinuousUInt16Enum.B)), + (value: DiscontinuousUInt16Enum.C, name: nameof(DiscontinuousUInt16Enum.C)), }; foreach (var x in parameters) { + var valueString = ((ushort)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1313,18 +1332,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: DiscontinuousUInt16Enum.A, name: nameof(DiscontinuousUInt16Enum.A), valueString: ((ushort)DiscontinuousUInt16Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt16Enum.B, name: nameof(DiscontinuousUInt16Enum.B), valueString: ((ushort)DiscontinuousUInt16Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt16Enum.C, name: nameof(DiscontinuousUInt16Enum.C), valueString: ((ushort)DiscontinuousUInt16Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousUInt16Enum.A, name: nameof(DiscontinuousUInt16Enum.A)), + (value: DiscontinuousUInt16Enum.B, name: nameof(DiscontinuousUInt16Enum.B)), + (value: DiscontinuousUInt16Enum.C, name: nameof(DiscontinuousUInt16Enum.C)), }; foreach (var x in parameters) { + var valueString = ((ushort)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1340,25 +1360,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: DiscontinuousUInt16Enum.A, name: nameof(DiscontinuousUInt16Enum.A), valueString: ((ushort)DiscontinuousUInt16Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt16Enum.B, name: nameof(DiscontinuousUInt16Enum.B), valueString: ((ushort)DiscontinuousUInt16Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt16Enum.C, name: nameof(DiscontinuousUInt16Enum.C), valueString: ((ushort)DiscontinuousUInt16Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousUInt16Enum.A, name: nameof(DiscontinuousUInt16Enum.A)), + (value: DiscontinuousUInt16Enum.B, name: nameof(DiscontinuousUInt16Enum.B)), + (value: DiscontinuousUInt16Enum.C, name: nameof(DiscontinuousUInt16Enum.C)), }; foreach (var x in parameters) { + var valueString = ((ushort)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1376,12 +1398,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: DiscontinuousUInt16Enum.A, name: nameof(DiscontinuousUInt16Enum.A), valueString: ((ushort)DiscontinuousUInt16Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt16Enum.B, name: nameof(DiscontinuousUInt16Enum.B), valueString: ((ushort)DiscontinuousUInt16Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt16Enum.C, name: nameof(DiscontinuousUInt16Enum.C), valueString: ((ushort)DiscontinuousUInt16Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousUInt16Enum.A, name: nameof(DiscontinuousUInt16Enum.A)), + (value: DiscontinuousUInt16Enum.B, name: nameof(DiscontinuousUInt16Enum.B)), + (value: DiscontinuousUInt16Enum.C, name: nameof(DiscontinuousUInt16Enum.C)), }; foreach (var x in parameters) { + var valueString = ((ushort)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -1391,13 +1415,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1649,18 +1673,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: DiscontinuousInt32Enum.A, name: nameof(DiscontinuousInt32Enum.A), valueString: ((int)DiscontinuousInt32Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt32Enum.B, name: nameof(DiscontinuousInt32Enum.B), valueString: ((int)DiscontinuousInt32Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt32Enum.C, name: nameof(DiscontinuousInt32Enum.C), valueString: ((int)DiscontinuousInt32Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousInt32Enum.A, name: nameof(DiscontinuousInt32Enum.A)), + (value: DiscontinuousInt32Enum.B, name: nameof(DiscontinuousInt32Enum.B)), + (value: DiscontinuousInt32Enum.C, name: nameof(DiscontinuousInt32Enum.C)), }; foreach (var x in parameters) { + var valueString = ((int)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1676,18 +1701,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: DiscontinuousInt32Enum.A, name: nameof(DiscontinuousInt32Enum.A), valueString: ((int)DiscontinuousInt32Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt32Enum.B, name: nameof(DiscontinuousInt32Enum.B), valueString: ((int)DiscontinuousInt32Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt32Enum.C, name: nameof(DiscontinuousInt32Enum.C), valueString: ((int)DiscontinuousInt32Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousInt32Enum.A, name: nameof(DiscontinuousInt32Enum.A)), + (value: DiscontinuousInt32Enum.B, name: nameof(DiscontinuousInt32Enum.B)), + (value: DiscontinuousInt32Enum.C, name: nameof(DiscontinuousInt32Enum.C)), }; foreach (var x in parameters) { + var valueString = ((int)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -1703,25 +1729,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: DiscontinuousInt32Enum.A, name: nameof(DiscontinuousInt32Enum.A), valueString: ((int)DiscontinuousInt32Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt32Enum.B, name: nameof(DiscontinuousInt32Enum.B), valueString: ((int)DiscontinuousInt32Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt32Enum.C, name: nameof(DiscontinuousInt32Enum.C), valueString: ((int)DiscontinuousInt32Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousInt32Enum.A, name: nameof(DiscontinuousInt32Enum.A)), + (value: DiscontinuousInt32Enum.B, name: nameof(DiscontinuousInt32Enum.B)), + (value: DiscontinuousInt32Enum.C, name: nameof(DiscontinuousInt32Enum.C)), }; foreach (var x in parameters) { + var valueString = ((int)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -1739,12 +1767,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: DiscontinuousInt32Enum.A, name: nameof(DiscontinuousInt32Enum.A), valueString: ((int)DiscontinuousInt32Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt32Enum.B, name: nameof(DiscontinuousInt32Enum.B), valueString: ((int)DiscontinuousInt32Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt32Enum.C, name: nameof(DiscontinuousInt32Enum.C), valueString: ((int)DiscontinuousInt32Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousInt32Enum.A, name: nameof(DiscontinuousInt32Enum.A)), + (value: DiscontinuousInt32Enum.B, name: nameof(DiscontinuousInt32Enum.B)), + (value: DiscontinuousInt32Enum.C, name: nameof(DiscontinuousInt32Enum.C)), }; foreach (var x in parameters) { + var valueString = ((int)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -1754,13 +1784,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2012,18 +2042,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: DiscontinuousUInt32Enum.A, name: nameof(DiscontinuousUInt32Enum.A), valueString: ((uint)DiscontinuousUInt32Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt32Enum.B, name: nameof(DiscontinuousUInt32Enum.B), valueString: ((uint)DiscontinuousUInt32Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt32Enum.C, name: nameof(DiscontinuousUInt32Enum.C), valueString: ((uint)DiscontinuousUInt32Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousUInt32Enum.A, name: nameof(DiscontinuousUInt32Enum.A)), + (value: DiscontinuousUInt32Enum.B, name: nameof(DiscontinuousUInt32Enum.B)), + (value: DiscontinuousUInt32Enum.C, name: nameof(DiscontinuousUInt32Enum.C)), }; foreach (var x in parameters) { + var valueString = ((uint)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2039,18 +2070,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: DiscontinuousUInt32Enum.A, name: nameof(DiscontinuousUInt32Enum.A), valueString: ((uint)DiscontinuousUInt32Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt32Enum.B, name: nameof(DiscontinuousUInt32Enum.B), valueString: ((uint)DiscontinuousUInt32Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt32Enum.C, name: nameof(DiscontinuousUInt32Enum.C), valueString: ((uint)DiscontinuousUInt32Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousUInt32Enum.A, name: nameof(DiscontinuousUInt32Enum.A)), + (value: DiscontinuousUInt32Enum.B, name: nameof(DiscontinuousUInt32Enum.B)), + (value: DiscontinuousUInt32Enum.C, name: nameof(DiscontinuousUInt32Enum.C)), }; foreach (var x in parameters) { + var valueString = ((uint)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2066,25 +2098,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: DiscontinuousUInt32Enum.A, name: nameof(DiscontinuousUInt32Enum.A), valueString: ((uint)DiscontinuousUInt32Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt32Enum.B, name: nameof(DiscontinuousUInt32Enum.B), valueString: ((uint)DiscontinuousUInt32Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt32Enum.C, name: nameof(DiscontinuousUInt32Enum.C), valueString: ((uint)DiscontinuousUInt32Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousUInt32Enum.A, name: nameof(DiscontinuousUInt32Enum.A)), + (value: DiscontinuousUInt32Enum.B, name: nameof(DiscontinuousUInt32Enum.B)), + (value: DiscontinuousUInt32Enum.C, name: nameof(DiscontinuousUInt32Enum.C)), }; foreach (var x in parameters) { + var valueString = ((uint)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2102,12 +2136,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: DiscontinuousUInt32Enum.A, name: nameof(DiscontinuousUInt32Enum.A), valueString: ((uint)DiscontinuousUInt32Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt32Enum.B, name: nameof(DiscontinuousUInt32Enum.B), valueString: ((uint)DiscontinuousUInt32Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt32Enum.C, name: nameof(DiscontinuousUInt32Enum.C), valueString: ((uint)DiscontinuousUInt32Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousUInt32Enum.A, name: nameof(DiscontinuousUInt32Enum.A)), + (value: DiscontinuousUInt32Enum.B, name: nameof(DiscontinuousUInt32Enum.B)), + (value: DiscontinuousUInt32Enum.C, name: nameof(DiscontinuousUInt32Enum.C)), }; foreach (var x in parameters) { + var valueString = ((uint)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -2117,13 +2153,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2375,18 +2411,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: DiscontinuousInt64Enum.A, name: nameof(DiscontinuousInt64Enum.A), valueString: ((long)DiscontinuousInt64Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt64Enum.B, name: nameof(DiscontinuousInt64Enum.B), valueString: ((long)DiscontinuousInt64Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt64Enum.C, name: nameof(DiscontinuousInt64Enum.C), valueString: ((long)DiscontinuousInt64Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousInt64Enum.A, name: nameof(DiscontinuousInt64Enum.A)), + (value: DiscontinuousInt64Enum.B, name: nameof(DiscontinuousInt64Enum.B)), + (value: DiscontinuousInt64Enum.C, name: nameof(DiscontinuousInt64Enum.C)), }; foreach (var x in parameters) { + var valueString = ((long)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2402,18 +2439,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: DiscontinuousInt64Enum.A, name: nameof(DiscontinuousInt64Enum.A), valueString: ((long)DiscontinuousInt64Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt64Enum.B, name: nameof(DiscontinuousInt64Enum.B), valueString: ((long)DiscontinuousInt64Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt64Enum.C, name: nameof(DiscontinuousInt64Enum.C), valueString: ((long)DiscontinuousInt64Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousInt64Enum.A, name: nameof(DiscontinuousInt64Enum.A)), + (value: DiscontinuousInt64Enum.B, name: nameof(DiscontinuousInt64Enum.B)), + (value: DiscontinuousInt64Enum.C, name: nameof(DiscontinuousInt64Enum.C)), }; foreach (var x in parameters) { + var valueString = ((long)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2429,25 +2467,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: DiscontinuousInt64Enum.A, name: nameof(DiscontinuousInt64Enum.A), valueString: ((long)DiscontinuousInt64Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt64Enum.B, name: nameof(DiscontinuousInt64Enum.B), valueString: ((long)DiscontinuousInt64Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt64Enum.C, name: nameof(DiscontinuousInt64Enum.C), valueString: ((long)DiscontinuousInt64Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousInt64Enum.A, name: nameof(DiscontinuousInt64Enum.A)), + (value: DiscontinuousInt64Enum.B, name: nameof(DiscontinuousInt64Enum.B)), + (value: DiscontinuousInt64Enum.C, name: nameof(DiscontinuousInt64Enum.C)), }; foreach (var x in parameters) { + var valueString = ((long)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2465,12 +2505,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: DiscontinuousInt64Enum.A, name: nameof(DiscontinuousInt64Enum.A), valueString: ((long)DiscontinuousInt64Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt64Enum.B, name: nameof(DiscontinuousInt64Enum.B), valueString: ((long)DiscontinuousInt64Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousInt64Enum.C, name: nameof(DiscontinuousInt64Enum.C), valueString: ((long)DiscontinuousInt64Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousInt64Enum.A, name: nameof(DiscontinuousInt64Enum.A)), + (value: DiscontinuousInt64Enum.B, name: nameof(DiscontinuousInt64Enum.B)), + (value: DiscontinuousInt64Enum.C, name: nameof(DiscontinuousInt64Enum.C)), }; foreach (var x in parameters) { + var valueString = ((long)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -2480,13 +2522,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2738,18 +2780,19 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: DiscontinuousUInt64Enum.A, name: nameof(DiscontinuousUInt64Enum.A), valueString: ((ulong)DiscontinuousUInt64Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt64Enum.B, name: nameof(DiscontinuousUInt64Enum.B), valueString: ((ulong)DiscontinuousUInt64Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt64Enum.C, name: nameof(DiscontinuousUInt64Enum.C), valueString: ((ulong)DiscontinuousUInt64Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousUInt64Enum.A, name: nameof(DiscontinuousUInt64Enum.A)), + (value: DiscontinuousUInt64Enum.B, name: nameof(DiscontinuousUInt64Enum.B)), + (value: DiscontinuousUInt64Enum.C, name: nameof(DiscontinuousUInt64Enum.C)), }; foreach (var x in parameters) { + var valueString = ((ulong)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2765,18 +2808,19 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: DiscontinuousUInt64Enum.A, name: nameof(DiscontinuousUInt64Enum.A), valueString: ((ulong)DiscontinuousUInt64Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt64Enum.B, name: nameof(DiscontinuousUInt64Enum.B), valueString: ((ulong)DiscontinuousUInt64Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt64Enum.C, name: nameof(DiscontinuousUInt64Enum.C), valueString: ((ulong)DiscontinuousUInt64Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousUInt64Enum.A, name: nameof(DiscontinuousUInt64Enum.A)), + (value: DiscontinuousUInt64Enum.B, name: nameof(DiscontinuousUInt64Enum.B)), + (value: DiscontinuousUInt64Enum.C, name: nameof(DiscontinuousUInt64Enum.C)), }; foreach (var x in parameters) { + var valueString = ((ulong)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -2792,25 +2836,27 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: DiscontinuousUInt64Enum.A, name: nameof(DiscontinuousUInt64Enum.A), valueString: ((ulong)DiscontinuousUInt64Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt64Enum.B, name: nameof(DiscontinuousUInt64Enum.B), valueString: ((ulong)DiscontinuousUInt64Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt64Enum.C, name: nameof(DiscontinuousUInt64Enum.C), valueString: ((ulong)DiscontinuousUInt64Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousUInt64Enum.A, name: nameof(DiscontinuousUInt64Enum.A)), + (value: DiscontinuousUInt64Enum.B, name: nameof(DiscontinuousUInt64Enum.B)), + (value: DiscontinuousUInt64Enum.C, name: nameof(DiscontinuousUInt64Enum.C)), }; foreach (var x in parameters) { + var valueString = ((ulong)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -2828,12 +2874,14 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: DiscontinuousUInt64Enum.A, name: nameof(DiscontinuousUInt64Enum.A), valueString: ((ulong)DiscontinuousUInt64Enum.A).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt64Enum.B, name: nameof(DiscontinuousUInt64Enum.B), valueString: ((ulong)DiscontinuousUInt64Enum.B).ToString(CultureInfo.InvariantCulture)), - (value: DiscontinuousUInt64Enum.C, name: nameof(DiscontinuousUInt64Enum.C), valueString: ((ulong)DiscontinuousUInt64Enum.C).ToString(CultureInfo.InvariantCulture)), + (value: DiscontinuousUInt64Enum.A, name: nameof(DiscontinuousUInt64Enum.A)), + (value: DiscontinuousUInt64Enum.B, name: nameof(DiscontinuousUInt64Enum.B)), + (value: DiscontinuousUInt64Enum.C, name: nameof(DiscontinuousUInt64Enum.C)), }; foreach (var x in parameters) { + var valueString = ((ulong)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -2843,13 +2891,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/DiscontinuousTests.tt b/src/insights/FastEnum.UnitTests/Cases/Reflections/DiscontinuousTests.tt index 7a3967c..9a0bf4b 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/DiscontinuousTests.tt +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/DiscontinuousTests.tt @@ -216,18 +216,19 @@ public sealed class Discontinuous<#= x.AliasType #>Tests const bool ignoreCase = false; var parameters = new[] { - (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.B).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.C).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A)), + (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B)), + (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse<<#= x.EnumType #>>(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", ignoreCase)).Should().Throw(); @@ -243,18 +244,19 @@ public sealed class Discontinuous<#= x.AliasType #>Tests const bool ignoreCase = true; var parameters = new[] { - (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.B).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.C).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A)), + (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B)), + (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse<<#= x.EnumType #>>(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", ignoreCase)).Should().Throw(); @@ -270,25 +272,27 @@ public sealed class Discontinuous<#= x.AliasType #>Tests const bool ignoreCase = false; var parameters = new[] { - (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.B).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.C).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A)), + (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B)), + (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse<<#= x.EnumType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse<<#= x.EnumType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -306,12 +310,14 @@ public sealed class Discontinuous<#= x.AliasType #>Tests const bool ignoreCase = true; var parameters = new[] { - (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.B).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.C).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A)), + (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B)), + (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse<<#= x.EnumType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -321,13 +327,13 @@ public sealed class Discontinuous<#= x.AliasType #>Tests FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse<<#= x.EnumType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/SameValueTests.cs b/src/insights/FastEnum.UnitTests/Cases/Reflections/SameValueTests.cs index b2d71f5..9e344b0 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/SameValueTests.cs +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/SameValueTests.cs @@ -100,19 +100,20 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A), valueString: ((byte)SameValueContinuousEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.B, name: nameof(SameValueContinuousEnum.B), valueString: ((byte)SameValueContinuousEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.C, name: nameof(SameValueContinuousEnum.C), valueString: ((byte)SameValueContinuousEnum.C).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.D, name: nameof(SameValueContinuousEnum.D), valueString: ((byte)SameValueContinuousEnum.D).ToString(CultureInfo.InvariantCulture)), + (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A)), + (value: SameValueContinuousEnum.B, name: nameof(SameValueContinuousEnum.B)), + (value: SameValueContinuousEnum.C, name: nameof(SameValueContinuousEnum.C)), + (value: SameValueContinuousEnum.D, name: nameof(SameValueContinuousEnum.D)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -128,19 +129,20 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A), valueString: ((byte)SameValueContinuousEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.B, name: nameof(SameValueContinuousEnum.B), valueString: ((byte)SameValueContinuousEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.C, name: nameof(SameValueContinuousEnum.C), valueString: ((byte)SameValueContinuousEnum.C).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.D, name: nameof(SameValueContinuousEnum.D), valueString: ((byte)SameValueContinuousEnum.D).ToString(CultureInfo.InvariantCulture)), + (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A)), + (value: SameValueContinuousEnum.B, name: nameof(SameValueContinuousEnum.B)), + (value: SameValueContinuousEnum.C, name: nameof(SameValueContinuousEnum.C)), + (value: SameValueContinuousEnum.D, name: nameof(SameValueContinuousEnum.D)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -156,26 +158,28 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A), valueString: ((byte)SameValueContinuousEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.B, name: nameof(SameValueContinuousEnum.B), valueString: ((byte)SameValueContinuousEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.C, name: nameof(SameValueContinuousEnum.C), valueString: ((byte)SameValueContinuousEnum.C).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.D, name: nameof(SameValueContinuousEnum.D), valueString: ((byte)SameValueContinuousEnum.D).ToString(CultureInfo.InvariantCulture)), + (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A)), + (value: SameValueContinuousEnum.B, name: nameof(SameValueContinuousEnum.B)), + (value: SameValueContinuousEnum.C, name: nameof(SameValueContinuousEnum.C)), + (value: SameValueContinuousEnum.D, name: nameof(SameValueContinuousEnum.D)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -193,13 +197,15 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A), valueString: ((byte)SameValueContinuousEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.B, name: nameof(SameValueContinuousEnum.B), valueString: ((byte)SameValueContinuousEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.C, name: nameof(SameValueContinuousEnum.C), valueString: ((byte)SameValueContinuousEnum.C).ToString(CultureInfo.InvariantCulture)), - (value: SameValueContinuousEnum.D, name: nameof(SameValueContinuousEnum.D), valueString: ((byte)SameValueContinuousEnum.D).ToString(CultureInfo.InvariantCulture)), + (value: SameValueContinuousEnum.A, name: nameof(SameValueContinuousEnum.A)), + (value: SameValueContinuousEnum.B, name: nameof(SameValueContinuousEnum.B)), + (value: SameValueContinuousEnum.C, name: nameof(SameValueContinuousEnum.C)), + (value: SameValueContinuousEnum.D, name: nameof(SameValueContinuousEnum.D)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -209,13 +215,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -398,19 +404,20 @@ public void Parse() const bool ignoreCase = false; var parameters = new[] { - (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A), valueString: ((byte)SameValueDiscontinuousEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.B, name: nameof(SameValueDiscontinuousEnum.B), valueString: ((byte)SameValueDiscontinuousEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.C, name: nameof(SameValueDiscontinuousEnum.C), valueString: ((byte)SameValueDiscontinuousEnum.C).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.D, name: nameof(SameValueDiscontinuousEnum.D), valueString: ((byte)SameValueDiscontinuousEnum.D).ToString(CultureInfo.InvariantCulture)), + (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A)), + (value: SameValueDiscontinuousEnum.B, name: nameof(SameValueDiscontinuousEnum.B)), + (value: SameValueDiscontinuousEnum.C, name: nameof(SameValueDiscontinuousEnum.C)), + (value: SameValueDiscontinuousEnum.D, name: nameof(SameValueDiscontinuousEnum.D)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -426,19 +433,20 @@ public void ParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A), valueString: ((byte)SameValueDiscontinuousEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.B, name: nameof(SameValueDiscontinuousEnum.B), valueString: ((byte)SameValueDiscontinuousEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.C, name: nameof(SameValueDiscontinuousEnum.C), valueString: ((byte)SameValueDiscontinuousEnum.C).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.D, name: nameof(SameValueDiscontinuousEnum.D), valueString: ((byte)SameValueDiscontinuousEnum.D).ToString(CultureInfo.InvariantCulture)), + (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A)), + (value: SameValueDiscontinuousEnum.B, name: nameof(SameValueDiscontinuousEnum.B)), + (value: SameValueDiscontinuousEnum.C, name: nameof(SameValueDiscontinuousEnum.C)), + (value: SameValueDiscontinuousEnum.D, name: nameof(SameValueDiscontinuousEnum.D)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse("", ignoreCase)).Should().Throw(); @@ -454,26 +462,28 @@ public void TryParse() const bool ignoreCase = false; var parameters = new[] { - (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A), valueString: ((byte)SameValueDiscontinuousEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.B, name: nameof(SameValueDiscontinuousEnum.B), valueString: ((byte)SameValueDiscontinuousEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.C, name: nameof(SameValueDiscontinuousEnum.C), valueString: ((byte)SameValueDiscontinuousEnum.C).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.D, name: nameof(SameValueDiscontinuousEnum.D), valueString: ((byte)SameValueDiscontinuousEnum.D).ToString(CultureInfo.InvariantCulture)), + (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A)), + (value: SameValueDiscontinuousEnum.B, name: nameof(SameValueDiscontinuousEnum.B)), + (value: SameValueDiscontinuousEnum.C, name: nameof(SameValueDiscontinuousEnum.C)), + (value: SameValueDiscontinuousEnum.D, name: nameof(SameValueDiscontinuousEnum.D)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -491,13 +501,15 @@ public void TryParseIgnoreCase() const bool ignoreCase = true; var parameters = new[] { - (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A), valueString: ((byte)SameValueDiscontinuousEnum.A).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.B, name: nameof(SameValueDiscontinuousEnum.B), valueString: ((byte)SameValueDiscontinuousEnum.B).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.C, name: nameof(SameValueDiscontinuousEnum.C), valueString: ((byte)SameValueDiscontinuousEnum.C).ToString(CultureInfo.InvariantCulture)), - (value: SameValueDiscontinuousEnum.D, name: nameof(SameValueDiscontinuousEnum.D), valueString: ((byte)SameValueDiscontinuousEnum.D).ToString(CultureInfo.InvariantCulture)), + (value: SameValueDiscontinuousEnum.A, name: nameof(SameValueDiscontinuousEnum.A)), + (value: SameValueDiscontinuousEnum.B, name: nameof(SameValueDiscontinuousEnum.B)), + (value: SameValueDiscontinuousEnum.C, name: nameof(SameValueDiscontinuousEnum.C)), + (value: SameValueDiscontinuousEnum.D, name: nameof(SameValueDiscontinuousEnum.D)), }; foreach (var x in parameters) { + var valueString = ((byte)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -507,13 +519,13 @@ public void TryParseIgnoreCase() FastEnum.TryParse(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse((string?)null, ignoreCase, out var _).Should().BeFalse(); diff --git a/src/insights/FastEnum.UnitTests/Cases/Reflections/SameValueTests.tt b/src/insights/FastEnum.UnitTests/Cases/Reflections/SameValueTests.tt index e7bb740..0681d66 100644 --- a/src/insights/FastEnum.UnitTests/Cases/Reflections/SameValueTests.tt +++ b/src/insights/FastEnum.UnitTests/Cases/Reflections/SameValueTests.tt @@ -113,19 +113,20 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" const bool ignoreCase = false; var parameters = new[] { - (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.B).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.C).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.D, name: nameof(<#= x.EnumType #>.D), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.D).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A)), + (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B)), + (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C)), + (value: <#= x.EnumType #>.D, name: nameof(<#= x.EnumType #>.D)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse<<#= x.EnumType #>>(x.name, ignoreCase).Should().Be(x.value); FluentActions.Invoking(() => FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase)).Should().Throw(); FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", ignoreCase)).Should().Throw(); @@ -141,19 +142,20 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" const bool ignoreCase = true; var parameters = new[] { - (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.B).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.C).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.D, name: nameof(<#= x.EnumType #>.D), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.D).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A)), + (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B)), + (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C)), + (value: <#= x.EnumType #>.D, name: nameof(<#= x.EnumType #>.D)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); FastEnum.Parse<<#= x.EnumType #>>(x.name, ignoreCase).Should().Be(x.value); FastEnum.Parse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); FastEnum.Parse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString, ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); - FastEnum.Parse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString, ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); + FastEnum.Parse<<#= x.EnumType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase).Should().Be(x.value); } FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>((string?)null, ignoreCase)).Should().Throw(); FluentActions.Invoking(static () => FastEnum.Parse<<#= x.EnumType #>>("", ignoreCase)).Should().Throw(); @@ -169,26 +171,28 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" const bool ignoreCase = false; var parameters = new[] { - (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.B).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.C).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.D, name: nameof(<#= x.EnumType #>.D), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.D).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A)), + (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B)), + (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C)), + (value: <#= x.EnumType #>.D, name: nameof(<#= x.EnumType #>.D)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse<<#= x.EnumType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeFalse(); FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var _).Should().BeTrue(); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, ignoreCase, out var r2).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString, ignoreCase, out var r2).Should().BeTrue(); r2.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); } FastEnum.TryParse<<#= x.EnumType #>>((string?)null, ignoreCase, out var _).Should().BeFalse(); @@ -206,13 +210,15 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" const bool ignoreCase = true; var parameters = new[] { - (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.A).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.B).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.C).ToString(CultureInfo.InvariantCulture)), - (value: <#= x.EnumType #>.D, name: nameof(<#= x.EnumType #>.D), valueString: ((<#= x.UnderlyingType #>)<#= x.EnumType #>.D).ToString(CultureInfo.InvariantCulture)), + (value: <#= x.EnumType #>.A, name: nameof(<#= x.EnumType #>.A)), + (value: <#= x.EnumType #>.B, name: nameof(<#= x.EnumType #>.B)), + (value: <#= x.EnumType #>.C, name: nameof(<#= x.EnumType #>.C)), + (value: <#= x.EnumType #>.D, name: nameof(<#= x.EnumType #>.D)), }; foreach (var x in parameters) { + var valueString = ((<#= x.UnderlyingType #>)x.value).ToString(CultureInfo.InvariantCulture); + FastEnum.TryParse<<#= x.EnumType #>>(x.name, ignoreCase, out var r1).Should().BeTrue(); r1.Should().Be(x.value); @@ -222,13 +228,13 @@ public sealed class SameValue<#= x.IsContinuous ? "Continuous" : "Discontinuous" FastEnum.TryParse<<#= x.EnumType #>>(x.name.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r3).Should().BeTrue(); r3.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString, ignoreCase, out var r4).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString, ignoreCase, out var r4).Should().BeTrue(); r4.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString.ToLower(CultureInfo.InvariantCulture), ignoreCase, out var r5).Should().BeTrue(); r5.Should().Be(x.value); - FastEnum.TryParse<<#= x.EnumType #>>(x.valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); + FastEnum.TryParse<<#= x.EnumType #>>(valueString.ToUpper(CultureInfo.InvariantCulture), ignoreCase, out var r6).Should().BeTrue(); r6.Should().Be(x.value); } FastEnum.TryParse<<#= x.EnumType #>>((string?)null, ignoreCase, out var _).Should().BeFalse();