Merge pull request #57 from andy840119/refactor-text-index-test

Refactor the TextIndexTest.cs

LrcParser.Tests/Helper/TestCaseTextIndexHelper.cs

@@ -0,0 +1,24 @@
+// Copyright (c) karaoke.dev <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Text.RegularExpressions;
+using LrcParser.Extension;
+using LrcParser.Model;
+
+namespace LrcParser.Tests.Helper;
+
+public static class TestCaseTextIndexHelper
+{
+    public static TextIndex ParseTextIndex(string str)
+    {
+        var regex = new Regex("(?<index>[-0-9]+),(?<state>start|end)");
+        var result = regex.Match(str);
+        if (!result.Success)
+            throw new RegexMatchTimeoutException(nameof(str));
+
+        int index = result.GetGroupValue<int>("index");
+        var state = result.GetGroupValue<string>("state") == "start" ? IndexState.Start : IndexState.End;
+
+        return new TextIndex(index, state);
+    }
+}

LrcParser.Tests/Model/TextIndexTest.cs

@@ -1,74 +1,66 @@
 // Copyright (c) karaoke.dev <[email protected]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
-using LrcParser.Model;
+using LrcParser.Tests.Helper;
 using NUnit.Framework;
 
 namespace LrcParser.Tests.Model;
 
 [TestFixture]
 public class TextIndexTest
 {
-    [TestCase(1, 1)]
-    [TestCase(1.5, 1.5)]
-    [TestCase(-1.5, -1.5)]
-    public void TestOperatorEqual(double tone1, double tone2)
+    [TestCase("1,start")]
+    [TestCase("1,end")]
+    [TestCase("-1,start")]
+    public void TestOperatorEqual(string textIndex1)
     {
-        Assert.AreEqual(numberToTextIndex(tone1), numberToTextIndex(tone2));
+        Assert.AreEqual(TestCaseTextIndexHelper.ParseTextIndex(textIndex1), TestCaseTextIndexHelper.ParseTextIndex(textIndex1));
     }
 
-    [TestCase(-1, 1)]
-    [TestCase(1, -1)]
-    [TestCase(1.5, -1.5)]
-    [TestCase(1.5, 1)]
-    [TestCase(-1.5, -1)]
-    [TestCase(-1.5, -2)]
-    public void TestOperatorNotEqual(double tone1, double tone2)
+    [TestCase("-1,start", "1,start")]
+    [TestCase("1,start", "-1,start")]
+    [TestCase("1,end", "-1,end")]
+    [TestCase("1,end", "1,start")]
+    [TestCase("-2,end", "-1,start")]
+    [TestCase("-2,end", "-2,start")]
+    public void TestOperatorNotEqual(string textIndex1, string textIndex2)
     {
-        Assert.AreNotEqual(numberToTextIndex(tone1), numberToTextIndex(tone2));
+        Assert.AreNotEqual(TestCaseTextIndexHelper.ParseTextIndex(textIndex1), TestCaseTextIndexHelper.ParseTextIndex(textIndex2));
     }
 
-    [TestCase(1, 0, true)]
-    [TestCase(1, 0.5, true)]
-    [TestCase(1, 1, false)]
-    [TestCase(1, 1.5, false)]
-    public void TestOperatorGreater(double tone1, double tone2, bool match)
+    [TestCase("1,start", "0,start", true)]
+    [TestCase("1,start", "0,end", true)]
+    [TestCase("1,start", "1,start", false)]
+    [TestCase("1,start", "1,end", false)]
+    public void TestOperatorGreater(string textIndex1, string textIndex2, bool match)
     {
-        Assert.AreEqual(numberToTextIndex(tone1) > numberToTextIndex(tone2), match);
+        Assert.AreEqual(TestCaseTextIndexHelper.ParseTextIndex(textIndex1) > TestCaseTextIndexHelper.ParseTextIndex(textIndex2), match);
     }
 
-    [TestCase(1, 0, true)]
-    [TestCase(1, 0.5, true)]
-    [TestCase(1, 1, true)]
-    [TestCase(1, 1.5, false)]
-    public void TestOperatorGreaterOrEqual(double tone1, double tone2, bool match)
+    [TestCase("1,start", "0,start", true)]
+    [TestCase("1,start", "0,end", true)]
+    [TestCase("1,start", "1,start", true)]
+    [TestCase("1,start", "1,end", false)]
+    public void TestOperatorGreaterOrEqual(string textIndex1, string textIndex2, bool match)
     {
-        Assert.AreEqual(numberToTextIndex(tone1) >= numberToTextIndex(tone2), match);
+        Assert.AreEqual(TestCaseTextIndexHelper.ParseTextIndex(textIndex1) >= TestCaseTextIndexHelper.ParseTextIndex(textIndex2), match);
     }
 
-    [TestCase(-1, 0, true)]
-    [TestCase(-1, -0.5, true)]
-    [TestCase(-1, -1, false)]
-    [TestCase(-1, -1.5, false)]
-    public void TestOperatorLess(double tone1, double tone2, bool match)
+    [TestCase("-1,start", "0,start", true)]
+    [TestCase("-1,start", "-1,end", true)]
+    [TestCase("-1,start", "-1,start", false)]
+    [TestCase("-1,start", "-2,end", false)]
+    public void TestOperatorLess(string textIndex1, string textIndex2, bool match)
     {
-        Assert.AreEqual(numberToTextIndex(tone1) < numberToTextIndex(tone2), match);
+        Assert.AreEqual(TestCaseTextIndexHelper.ParseTextIndex(textIndex1) < TestCaseTextIndexHelper.ParseTextIndex(textIndex2), match);
     }
 
-    [TestCase(-1, 0, true)]
-    [TestCase(-1, -0.5, true)]
-    [TestCase(-1, -1, true)]
-    [TestCase(-1, -1.5, false)]
-    public void TestOperatorLessOrEqual(double tone1, double tone2, bool match)
+    [TestCase("-1,start", "0,start", true)]
+    [TestCase("-1,start", "-1,end", true)]
+    [TestCase("-1,start", "-1,start", true)]
+    [TestCase("-1,start", "-2,end", false)]
+    public void TestOperatorLessOrEqual(string textIndex1, string textIndex2, bool match)
     {
-        Assert.AreEqual(numberToTextIndex(tone1) <= numberToTextIndex(tone2), match);
-    }
-
-    private static TextIndex numberToTextIndex(double tone)
-    {
-        var half = Math.Abs(tone) % 1 == 0.5;
-        var scale = tone < 0 ? (int)tone - (half ? 1 : 0) : (int)tone;
-        return new TextIndex(scale, half ? IndexState.End : IndexState.Start);
+        Assert.AreEqual(TestCaseTextIndexHelper.ParseTextIndex(textIndex1) <= TestCaseTextIndexHelper.ParseTextIndex(textIndex2), match);
     }
 }

LrcParser.Tests/Utils/TextIndexUtilsTest.cs

@@ -35,8 +35,8 @@ public void TestToGapIndex(int index, IndexState state, int expected)
 
     [TestCase(IndexState.Start, 1, -1, 1)]
     [TestCase(IndexState.End, 1, -1, -1)]
-    [TestCase(IndexState.Start, "1", "-1", "1")]
-    [TestCase(IndexState.End, "1", "-1", "-1")]
+    [TestCase(IndexState.Start, "start", "end", "start")]
+    [TestCase(IndexState.End, "start", "end", "end")]
     public void TestGetValueByState(IndexState state, object startValue, object endValue, object expected)
     {
         var textIndex = new TextIndex(0, state);

LrcParser/Utils/TextIndexUtils.cs

@@ -26,6 +26,17 @@ internal static int ToCharIndex(TextIndex index)
     internal static int ToGapIndex(TextIndex index)
         => GetValueByState(index, index.Index, index.Index + 1);
 
+    /// <summary>
+    /// Get the value by state.
+    /// If the state is start, then return start value.
+    /// If the state is end, then return end value.
+    /// </summary>
+    /// <param name="index"></param>
+    /// <param name="startValue"></param>
+    /// <param name="endValue"></param>
+    /// <typeparam name="T"></typeparam>
+    /// <returns></returns>
+    /// <exception cref="ArgumentOutOfRangeException"></exception>
     internal static T GetValueByState<T>(TextIndex index, T startValue, T endValue) =>
         index.State switch
         {