Fix: Some more tests and their correct implementation

Author: AnnaSasDev

src/CodeOfChaos.Extensions/StringCaseExtensions.cs

@@ -16,8 +16,7 @@ public static partial class StringCaseExtensions {
     // -----------------------------------------------------------------------------------------------------------------
     // Convert to PascalCase
     public static string ToPascalCase(this string input) {
-        if (string.IsNullOrEmpty(input))
-            return input;
+        if (input.IsNullOrWhiteSpace()) return input;
 
         string[] words = NonAlphanumericRegex.Split(input);
 
@@ -33,10 +32,8 @@ public static string ToPascalCase(this string input) {
 
     // Convert to camelCase
     public static string ToCamelCase(this string input) {
-        if (string.IsNullOrEmpty(input))
-            return input;
-
-
+        if (input.IsNullOrWhiteSpace()) return input;
+        
         string[] words = NonAlphanumericRegex.Split(input);
 
         for (int i = 0; i < words.Length; i++) {
@@ -56,10 +53,9 @@ public static string ToCamelCase(this string input) {
 
     // Convert to kebab-case
     public static string ToKebabCase(this string input) {
-        if (string.IsNullOrEmpty(input))
-            return input;
+        if (input.IsNullOrWhiteSpace()) return input;
 
-        string[] words = NonAlphanumericRegex.Split(input);
+        Span<string> words = NonAlphanumericRegex.Split(input);
         for (int i = 0; i < words.Length; i++) {
             words[i] = words[i].ToLower();
         }
@@ -69,8 +65,7 @@ public static string ToKebabCase(this string input) {
 
     // Convert to snake_case
     public static string ToSnakeCase(this string input) {
-        if (string.IsNullOrEmpty(input))
-            return input;
+        if (input.IsNullOrWhiteSpace()) return input;
 
         string[] words = NonAlphanumericRegex.Split(input);
         for (int i = 0; i < words.Length; i++) {
@@ -82,8 +77,7 @@ public static string ToSnakeCase(this string input) {
 
     // Convert to period.separated.case
     public static string ToPeriodSeparatedCase(this string input) {
-        if (string.IsNullOrEmpty(input))
-            return input;
+        if (input.IsNullOrWhiteSpace()) return input;
 
         string[] words = NonAlphanumericRegex.Split(input);
         for (int i = 0; i < words.Length; i++) {

tests/Tests.CodeOfChaos.Extensions/StringCaseExtensionTests.cs

@@ -12,6 +12,9 @@ public class StringCaseExtensionTests {
 
     // Tests for ToCamelCase
     [Test]
+    [Arguments("", "")]
+    [Arguments(null, null)]
+    [Arguments(" ", " ")]
     [Arguments("a", "a")]
     [Arguments("A", "a")]
     [Arguments("aA", "aA")]
@@ -30,18 +33,21 @@ public class StringCaseExtensionTests {
     [Arguments("kebab-case", "kebabCase")]
     [Arguments("kebab-case-with-numbers-123", "kebabCaseWithNumbers123")]
     [Arguments("kebab-case-with-numbers-123-and-more", "kebabCaseWithNumbers123AndMore")]
-    public async Task ToCamelCase_ShouldWork(string input, string expected) {
+    public async Task ToCamelCase_ShouldWork(string? input, string? expected) {
         // Arrange
 
         // Act
-        var result = input.ToCamelCase();
+        string? result = input?.ToCamelCase();
 
         // Assert
         await Assert.That(result).IsEqualTo(expected);
     }
 
     // Tests for ToPascalCase
     [Test]
+    [Arguments("", "")]
+    [Arguments(null, null)]
+    [Arguments(" ", " ")]
     [Arguments("a", "A")]
     [Arguments("A", "A")]
     [Arguments("aA", "AA")]
@@ -60,18 +66,21 @@ public async Task ToCamelCase_ShouldWork(string input, string expected) {
     [Arguments("kebab-case", "KebabCase")]
     [Arguments("kebab-case-with-numbers-123", "KebabCaseWithNumbers123")]
     [Arguments("kebab-case-with-numbers-123-and-more", "KebabCaseWithNumbers123AndMore")]
-    public async Task ToPascalCase_ShouldWork(string input, string expected) {
+    public async Task ToPascalCase_ShouldWork(string? input, string? expected) {
         // Arrange
 
         // Act
-        var result = input.ToPascalCase();
+        string? result = input?.ToPascalCase();
 
         // Assert
         await Assert.That(result).IsEqualTo(expected);
     }
 
     // Tests for ToKebabCase
     [Test]
+    [Arguments("", "")]
+    [Arguments(null, null)]
+    [Arguments(" ", " ")]
     [Arguments("a", "a")]
     [Arguments("A", "a")]
     [Arguments("aA", "a-a")]
@@ -90,18 +99,21 @@ public async Task ToPascalCase_ShouldWork(string input, string expected) {
     [Arguments("kebab-case", "kebab-case")]
     [Arguments("kebab-case-with-numbers-123", "kebab-case-with-numbers-123")]
     [Arguments("kebab-case-with-numbers-123-and-more", "kebab-case-with-numbers-123-and-more")]
-    public async Task ToKebabCase_ShouldWork(string input, string expected) {
+    public async Task ToKebabCase_ShouldWork(string? input, string? expected) {
         // Arrange
 
         // Act
-        var result = input.ToKebabCase();
+        string? result = input?.ToKebabCase();
 
         // Assert
         await Assert.That(result).IsEqualTo(expected);
     }
 
     // Tests for ToSnakeCase
     [Test]
+    [Arguments("", "")]
+    [Arguments(null, null)]
+    [Arguments(" ", " ")]
     [Arguments("a", "a")]
     [Arguments("A", "a")]
     [Arguments("aA", "a_a")]
@@ -120,18 +132,21 @@ public async Task ToKebabCase_ShouldWork(string input, string expected) {
     [Arguments("kebab-case", "kebab_case")]
     [Arguments("kebab-case-with-numbers-123", "kebab_case_with_numbers_123")]
     [Arguments("kebab-case-with-numbers-123-and-more", "kebab_case_with_numbers_123_and_more")]
-    public async Task ToSnakeCase_ShouldWork(string input, string expected) {
+    public async Task ToSnakeCase_ShouldWork(string? input, string? expected) {
         // Arrange
 
         // Act
-        var result = input.ToSnakeCase();
+        string? result = input?.ToSnakeCase();
 
         // Assert
         await Assert.That(result).IsEqualTo(expected);
     }
 
     // Tests for ToPeriodSeparatedCase
     [Test]
+    [Arguments("", "")]
+    [Arguments(null, null)]
+    [Arguments(" ", " ")]
     [Arguments("a", "a")]
     [Arguments("A", "a")]
     [Arguments("aA", "a.a")]
@@ -150,11 +165,11 @@ public async Task ToSnakeCase_ShouldWork(string input, string expected) {
     [Arguments("kebab-case", "kebab.case")]
     [Arguments("kebab-case-with-numbers-123", "kebab.case.with.numbers.123")]
     [Arguments("kebab-case-with-numbers-123-and-more", "kebab.case.with.numbers.123.and.more")]
-    public async Task ToPeriodSeparatedCase_ShouldWork(string input, string expected) {
+    public async Task ToPeriodSeparatedCase_ShouldWork(string? input, string? expected) {
         // Arrange
 
         // Act
-        var result = input.ToPeriodSeparatedCase();
+        string? result = input?.ToPeriodSeparatedCase();
 
         // Assert
         await Assert.That(result).IsEqualTo(expected);