Skip to content

Fix Critical Round-Trip Conversion Issues #2

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
kamil-kaszuba wants to merge 1 commit into
base: main
Choose a base branch
from
Open

Fix Critical Round-Trip Conversion Issues #2

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 5 additions & 1 deletion Minerals.StringCases.Tests/Minerals.StringCases.Tests.csproj
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,7 +16,11 @@

<ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.0" />
<PackageReference Include="MSTest" Version="3.8.3" />
<PackageReference Include="xunit" Version="2.9.2" />
<PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
<PrivateAssets>all</PrivateAssets>
</PackageReference>
<PackageReference Include="FluentAssertions" Version="8.2.0" />
</ItemGroup>

Expand Down
189 changes: 92 additions & 97 deletions Minerals.StringCases.Tests/StringExtensionsTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,9 +1,8 @@
using Microsoft.VisualStudio.TestTools.UnitTesting;
using FluentAssertions;
using Xunit;

namespace Minerals.StringCases.Tests
{
[TestClass]
public class StringExtensionsTests
{
private const string PascalCase1 = "ExampleVariableName321TestA";
Expand All @@ -16,54 +15,6 @@ public class StringExtensionsTests
private const string TitleCase1 = "Example Variable Name 321 Test A";
private const string SampleText1 = " _ example Variable - - Name 321 TestA";

[TestMethod]
public void PascalCase_FromSampleText1()
{
Minerals.StringCases.StringExtensions.ToPascalCase(SampleText1).Should().Be(PascalCase1);
}

[TestMethod]
public void CamelCase_FromSampleText1()
{
Minerals.StringCases.StringExtensions.ToCamelCase(SampleText1).Should().Be(CamelCase1);
}

[TestMethod]
public void UnderscoreCamelCase_FromSampleText1()
{
Minerals.StringCases.StringExtensions.ToUnderscoreCamelCase(SampleText1).Should().Be(UnderscoreCamelCase1);
}

[TestMethod]
public void KebabCase_FromSampleText1()
{
Minerals.StringCases.StringExtensions.ToKebabCase(SampleText1).Should().Be(KebabCase1);
}

[TestMethod]
public void SnakeCase_FromSampleText1()
{
Minerals.StringCases.StringExtensions.ToSnakeCase(SampleText1).Should().Be(SnakeCase1);
}

[TestMethod]
public void MacroCase_FromSampleText1()
{
Minerals.StringCases.StringExtensions.ToMacroCase(SampleText1).Should().Be(MacroCase1);
}

[TestMethod]
public void TrainCase_FromSampleText1()
{
Minerals.StringCases.StringExtensions.ToTrainCase(SampleText1).Should().Be(TrainCase1);
}

[TestMethod]
public void TitleCase_FromSampleText1()
{
Minerals.StringCases.StringExtensions.ToTitleCase(SampleText1).Should().Be(TitleCase1);
}

private const string PascalCase2 = "ExampleVariableNameAbCd321";
private const string CamelCase2 = "exampleVariableNameAbCd321";
private const string UnderscoreCamelCase2 = "_exampleVariableNameAbCd321";
Expand All @@ -74,52 +25,96 @@ public void TitleCase_FromSampleText1()
private const string TitleCase2 = "Example Variable Name Ab Cd 321";
private const string SampleText2 = " _ example VARIABLE - - Name AbCd 321";

[TestMethod]
public void PascalCase_FromSampleText2()
{
Minerals.StringCases.StringExtensions.ToPascalCase(SampleText2).Should().Be(PascalCase2);
}

[TestMethod]
public void CamelCase_FromSampleText2()
{
Minerals.StringCases.StringExtensions.ToCamelCase(SampleText2).Should().Be(CamelCase2);
}

[TestMethod]
public void UnderscoreCamelCase_FromSampleText2()
{
Minerals.StringCases.StringExtensions.ToUnderscoreCamelCase(SampleText2).Should().Be(UnderscoreCamelCase2);
}

[TestMethod]
public void KebabCase_FromSampleText2()
{
Minerals.StringCases.StringExtensions.ToKebabCase(SampleText2).Should().Be(KebabCase2);
}

[TestMethod]
public void SnakeCase_FromSampleText2()
{
Minerals.StringCases.StringExtensions.ToSnakeCase(SampleText2).Should().Be(SnakeCase2);
}

[TestMethod]
public void MacroCase_FromSampleText2()
{
Minerals.StringCases.StringExtensions.ToMacroCase(SampleText2).Should().Be(MacroCase2);
}

[TestMethod]
public void TrainCase_FromSampleText2()
{
Minerals.StringCases.StringExtensions.ToTrainCase(SampleText2).Should().Be(TrainCase2);
}

[TestMethod]
public void TitleCase_FromSampleText2()
{
Minerals.StringCases.StringExtensions.ToTitleCase(SampleText2).Should().Be(TitleCase2);
}
[Theory]
[InlineData("ToPascalCase", SampleText1, PascalCase1)]
[InlineData("ToPascalCase", SampleText2, PascalCase2)]
[InlineData("ToCamelCase", SampleText1, CamelCase1)]
[InlineData("ToCamelCase", SampleText2, CamelCase2)]
[InlineData("ToUnderscoreCamelCase", SampleText1, UnderscoreCamelCase1)]
[InlineData("ToUnderscoreCamelCase", SampleText2, UnderscoreCamelCase2)]
[InlineData("ToKebabCase", SampleText1, KebabCase1)]
[InlineData("ToKebabCase", SampleText2, KebabCase2)]
[InlineData("ToSnakeCase", SampleText1, SnakeCase1)]
[InlineData("ToSnakeCase", SampleText2, SnakeCase2)]
[InlineData("ToMacroCase", SampleText1, MacroCase1)]
[InlineData("ToMacroCase", SampleText2, MacroCase2)]
[InlineData("ToTrainCase", SampleText1, TrainCase1)]
[InlineData("ToTrainCase", SampleText2, TrainCase2)]
[InlineData("ToTitleCase", SampleText1, TitleCase1)]
[InlineData("ToTitleCase", SampleText2, TitleCase2)]
public void ConversionMethods_ShouldConvertCorrectly(string methodName, string input, string expected)
{
string result = ApplyConversionMethod(input, methodName);

result.Should().Be(expected);
}

[Theory]
[InlineData("PascalCase", PascalCase1, "ToKebabCase", "ToPascalCase")]
[InlineData("PascalCase", PascalCase1, "ToSnakeCase", "ToPascalCase")]
[InlineData("PascalCase", PascalCase1, "ToMacroCase", "ToPascalCase")]
[InlineData("PascalCase", PascalCase1, "ToTrainCase", "ToPascalCase")]
[InlineData("CamelCase", CamelCase1, "ToKebabCase", "ToCamelCase")]
[InlineData("CamelCase", CamelCase1, "ToSnakeCase", "ToCamelCase")]
[InlineData("CamelCase", CamelCase1, "ToMacroCase", "ToCamelCase")]
[InlineData("KebabCase", KebabCase1, "ToPascalCase", "ToKebabCase")]
[InlineData("KebabCase", KebabCase1, "ToCamelCase", "ToKebabCase")]
[InlineData("KebabCase", KebabCase1, "ToSnakeCase", "ToKebabCase")]
[InlineData("KebabCase", KebabCase1, "ToMacroCase", "ToKebabCase")]
[InlineData("KebabCase", KebabCase1, "ToTrainCase", "ToKebabCase")]
[InlineData("SnakeCase", SnakeCase1, "ToPascalCase", "ToSnakeCase")]
[InlineData("SnakeCase", SnakeCase1, "ToCamelCase", "ToSnakeCase")]
[InlineData("SnakeCase", SnakeCase1, "ToKebabCase", "ToSnakeCase")]
[InlineData("SnakeCase", SnakeCase1, "ToMacroCase", "ToSnakeCase")]
[InlineData("SnakeCase", SnakeCase1, "ToTrainCase", "ToSnakeCase")]
[InlineData("MacroCase", MacroCase1, "ToPascalCase", "ToMacroCase")]
[InlineData("MacroCase", MacroCase1, "ToCamelCase", "ToMacroCase")]
[InlineData("MacroCase", MacroCase1, "ToKebabCase", "ToMacroCase")]
[InlineData("MacroCase", MacroCase1, "ToSnakeCase", "ToMacroCase")]
[InlineData("MacroCase", MacroCase1, "ToTrainCase", "ToMacroCase")]
[InlineData("TrainCase", TrainCase1, "ToPascalCase", "ToTrainCase")]
[InlineData("TrainCase", TrainCase1, "ToKebabCase", "ToTrainCase")]
[InlineData("TrainCase", TrainCase1, "ToSnakeCase", "ToTrainCase")]
[InlineData("TrainCase", TrainCase1, "ToMacroCase", "ToTrainCase")]
public void RoundTripConversions_ShouldPreserveOriginal(string caseType, string input, string firstMethod, string secondMethod)
{
string intermediate = ApplyConversionMethod(input, firstMethod);
string result = ApplyConversionMethod(intermediate, secondMethod);

result.Should().Be(input, $"{caseType} -> {firstMethod} -> {secondMethod} should preserve the original value");
}

[Fact]
public void RoundTrip_EdgeCase_PascalToTitleToPascal()
{
// This might not work due to space conversion
string result = PascalCase1.ToTitleCase().ToPascalCase();
// We expect this to still be a valid PascalCase string, but might not match exactly
result.Should().NotBeNullOrEmpty();
char.IsUpper(result[0]).Should().BeTrue("PascalCase should start with uppercase");
}

[Fact]
public void RoundTrip_EdgeCase_CamelToTitleToCamel()
{
// This might not work due to space conversion
string result = CamelCase1.ToTitleCase().ToCamelCase();
// We expect this to still be a valid camelCase string
result.Should().NotBeNullOrEmpty();
char.IsLower(result[0]).Should().BeTrue("camelCase should start with lowercase");
}

private static string ApplyConversionMethod(string input, string methodName) => methodName switch
{
"ToPascalCase" => input.ToPascalCase(),
"ToCamelCase" => input.ToCamelCase(),
"ToUnderscoreCamelCase" => input.ToUnderscoreCamelCase(),
"ToKebabCase" => input.ToKebabCase(),
"ToSnakeCase" => input.ToSnakeCase(),
"ToMacroCase" => input.ToMacroCase(),
"ToTrainCase" => input.ToTrainCase(),
"ToTitleCase" => input.ToTitleCase(),
_ => throw new ArgumentException($"Unknown method: {methodName}")
};
}
}
Loading