Added some more UString methods. Updated to 0.8.3.

Author: FoolRunning

UnicodeHelper.Tests/UStringExtensionsTests.cs

@@ -0,0 +1,51 @@
+namespace UnicodeHelper
+{
+    [TestClass]
+    public class UStringExtensionsTests
+    {
+        #region GetDotNetString tests
+        private static IEnumerable<object[]> GetDotNetStringIndexExceptionTestData =>
+        [
+            ["", -1, typeof(ArgumentOutOfRangeException)],
+            ["", 1, typeof(ArgumentOutOfRangeException)],
+            ["This", 5, typeof(ArgumentOutOfRangeException)],
+            ["This is 😮", 10, typeof(ArgumentOutOfRangeException)],
+            ["😁🤔😮", 4, typeof(ArgumentOutOfRangeException)]
+        ];
+
+        [TestMethod]
+        [DynamicData(nameof(GetDotNetStringIndexExceptionTestData))]
+        public void GetDotNetStringIndex_InvalidParameters(string testString, int index, 
+            Type expectedExceptionType)
+        {
+            UString us = new(testString);
+            Assert.That.ThrowsException(expectedExceptionType, () => us.GetDotNetStringIndex(index));
+        }
+
+        public static IEnumerable<object?[]> GetDotNetStringIndexTestData =>
+        [
+            ["", 0, 0],
+            ["This is a string!", 0, 0],
+            ["This is a string!", 12, 12],
+            ["This is a string!", 17, 17],
+            ["العربية", 3, 3],
+            ["العربية", 7, 7],
+            ["😁🤔😮", 0, 0],
+            ["😁🤔😮", 1, 2],
+            ["😁🤔😮", 2, 4],
+            ["😁🤔😮", 3, 6],
+            ["This is 😮", 0, 0],
+            ["This is 😮", 8, 8],
+            ["This is 😮", 9, 10],
+        ];
+
+        [TestMethod]
+        [DynamicData(nameof(GetDotNetStringIndexTestData))]
+        public void GetDotNetStringIndex(string testString, int index, int expectedIndex)
+        {
+            UString us = new UString(testString);
+            Assert.AreEqual(expectedIndex, us.GetDotNetStringIndex(index));
+        }
+        #endregion
+    }
+}

UnicodeHelper.Tests/UStringTests.cs

@@ -354,6 +354,66 @@ public void LastIndexOf_UCodepoint(string testString, UCodepoint codePoint,
         }
         #endregion
 
+        #region StartsWith_UCodepoint tests        
+        private static IEnumerable<object[]> UCodepointStartsWithTestData =>
+        [
+            ["", (UCodepoint)'A', true, false],
+            ["", (UCodepoint)'A', false, false],
+            ["This test!", (UCodepoint)'h', false, false],
+            ["This test!", (UCodepoint)'T', false, true],
+            ["This test!", (UCodepoint)'T', true, true],
+            ["This test!", (UCodepoint)'t', false, false],
+            ["This test!", (UCodepoint)'t', true, true],
+            ["العربية", (UCodepoint)'ا', false, true],
+            ["\U00010570\U00010597", UCodepoint.ReadFromStr("\U00010570", 0), false, true], // VITHKUQI letters
+            ["\U00010570\U00010597", UCodepoint.ReadFromStr("\U00010570", 0), true, true], // VITHKUQI letters
+            ["\U00010570\U00010597", UCodepoint.ReadFromStr("\U00010597", 0), false, false], // VITHKUQI letters
+            ["\U00010570\U00010597", UCodepoint.ReadFromStr("\U00010597", 0), true, true], // VITHKUQI letters
+        ];
+
+        [TestMethod]
+        [DynamicData(nameof(UCodepointStartsWithTestData))]
+        public void StartsWith_UCodepoint(string testString, UCodepoint codePoint, bool ignoreCase, bool expectedResult)
+        {
+            UString us = new(testString);
+            Assert.AreEqual(expectedResult, us.StartsWith(codePoint, ignoreCase));
+
+            // Test making sure that a substring results in the correct result
+            us = CreateTestSubstring(testString);
+            Assert.AreEqual(expectedResult, us.StartsWith(codePoint, ignoreCase));
+        }
+        #endregion
+
+        #region EndsWith_UCodepoint tests
+        private static IEnumerable<object[]> UCodepointEndsWithTestData =>
+        [
+            ["", (UCodepoint)'A', true, false],
+            ["", (UCodepoint)'A', false, false],
+            ["This test", (UCodepoint)'s', false, false],
+            ["This test", (UCodepoint)'t', false, true],
+            ["This test", (UCodepoint)'t', true, true],
+            ["This test", (UCodepoint)'T', false, false],
+            ["This test", (UCodepoint)'T', true, true],
+            ["العربية", (UCodepoint)'ة', false, true],
+            ["\U00010570\U00010597", UCodepoint.ReadFromStr("\U00010597", 0), false, true], // VITHKUQI letters
+            ["\U00010570\U00010597", UCodepoint.ReadFromStr("\U00010597", 0), true, true], // VITHKUQI letters
+            ["\U00010570\U00010597", UCodepoint.ReadFromStr("\U00010570", 0), false, false], // VITHKUQI letters
+            ["\U00010570\U00010597", UCodepoint.ReadFromStr("\U00010570", 0), true, true], // VITHKUQI letters
+        ];
+
+        [TestMethod]
+        [DynamicData(nameof(UCodepointEndsWithTestData))]
+        public void EndsWith_UCodepoint(string testString, UCodepoint codePoint, bool ignoreCase, bool expectedResult)
+        {
+            UString us = new(testString);
+            Assert.AreEqual(expectedResult, us.EndsWith(codePoint, ignoreCase));
+
+            // Test making sure that a substring results in the correct result
+            us = CreateTestSubstring(testString);
+            Assert.AreEqual(expectedResult, us.EndsWith(codePoint, ignoreCase));
+        }
+        #endregion
+
         #region IsNullOrEmpty tests
         private static IEnumerable<object?[]> IsNullOrEmptyTestData =>
         [

UnicodeHelper/UString.cs

@@ -531,10 +531,20 @@ public int LastIndexOf(UString value, int startIndex, int count)
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Determines whether the beginning of this Unicode string matches the specified value.
+        /// </summary>
         public bool StartsWith(UCodepoint value, bool ignoreCase = false)
         {
-            // TODO: Write tests for this method
-            throw new NotImplementedException();
+            if (Length == 0)
+                return false;
+            
+            UCodepoint start = _codepoints[_startIndex];
+            if (start == value)
+                return true;
+
+            return ignoreCase &&
+                   (UCodepoint.ToLower(start) == value || UCodepoint.ToUpper(start) == value);
         }
 
         public bool StartsWith(UString value, bool ignoreCase = false)
@@ -543,10 +553,20 @@ public bool StartsWith(UString value, bool ignoreCase = false)
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Determines whether the end of this Unicode string matches the specified value.
+        /// </summary>
         public bool EndsWith(UCodepoint value, bool ignoreCase = false)
         {
-            // TODO: Write tests for this method
-            throw new NotImplementedException();
+            if (Length == 0)
+                return false;
+            
+            UCodepoint end = _codepoints[_startIndex + Length - 1];
+            if (end == value)
+                return true;
+
+            return ignoreCase &&
+                   (UCodepoint.ToLower(end) == value || UCodepoint.ToUpper(end) == value);
         }
 
         public bool EndsWith(UString value, bool ignoreCase = false)

UnicodeHelper/UStringExtensions.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace UnicodeHelper
+{
+    /// <summary>
+    /// Provides extension methods for the <see cref="UString"/> class, enabling additional functionality
+    /// such as converting indices and lengths between Unicode strings and .Net strings.
+    /// </summary>
+    public static class UStringExtensions
+    {
+        /// <summary>
+        /// Used to convert an index in this UString to an index in the equivalent .Net string
+        /// </summary>
+        public static int GetDotNetStringIndex(this UString ustr, int index)
+        {
+            if (index < 0)
+                throw new ArgumentOutOfRangeException(nameof(index), "Index cannot be negative.");
+            if (index > ustr.Length)
+                throw new ArgumentOutOfRangeException(nameof(index), "Index cannot be greater than the length.");
+            
+            if (index == 0)
+                return 0;
+            
+            if (index == ustr.Length)
+                return ustr.CharLength;
+
+            int dotNetStringIndex = 0;
+            for (int i = 0; i < index; i++)
+                dotNetStringIndex += ustr[i] <= 0xffff ? 1 : 2;
+
+            return dotNetStringIndex;
+        }
+    }
+}

UnicodeHelper/UnicodeHelper.csproj

@@ -7,7 +7,7 @@
     <RunAnalyzersDuringLiveAnalysis>False</RunAnalyzersDuringLiveAnalysis>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>Unicode Helper</Title>
-    <Version>0.8.2</Version>
+    <Version>0.8.3</Version>
     <Authors>FoolRunning</Authors>
     <Description>.Net library to get information about Unicode codepoints and to better handle the upper planes (1-16) of Unicode.</Description>
     <Copyright>© 2025 Tim Steenwyk</Copyright>