diff --git a/BallanceTasEditor/BallanceTasEditor/Backend/FpsConverter.cs b/BallanceTasEditor/BallanceTasEditor/Backend/FpsConverter.cs
index c2cd032..9effe7d 100644
--- a/BallanceTasEditor/BallanceTasEditor/Backend/FpsConverter.cs
+++ b/BallanceTasEditor/BallanceTasEditor/Backend/FpsConverter.cs
@@ -48,9 +48,9 @@ namespace BallanceTasEditor.Backend {
         /// Convert float point delta time to integer FPS
         /// </summary>
         /// <param name="delta">Delta time in float point</param>
-        /// <returns>FPS in floor integer</returns>
-        public static uint ToFloorFps(float delta) {
-            return (uint)Math.Floor(ToFps(delta));
+        /// <returns>FPS in round integer</returns>
+        public static uint ToRoundFps(float delta) {
+            return Convert.ToUInt32(ToFps(delta));
         }
 
         /// <summary>
diff --git a/BallanceTasEditor/BallanceTasEditor/Backend/TasOperation.cs b/BallanceTasEditor/BallanceTasEditor/Backend/TasOperation.cs
index dc046d7..e5b76db 100644
--- a/BallanceTasEditor/BallanceTasEditor/Backend/TasOperation.cs
+++ b/BallanceTasEditor/BallanceTasEditor/Backend/TasOperation.cs
@@ -110,7 +110,7 @@ namespace BallanceTasEditor.Backend {
             // Do backup and set values at the same time
             var backups = new RawTasFrame[m_EndIndex - m_StartIndex + 1];
             // Pre-build key list for fast fetching.
-            var keys = Enumerable.Range(m_StartKey.ToIndex(), m_EndKey.ToIndex() - m_StartKey.ToIndex()).Select((i) => TasKey.FromIndex(i)).ToArray();
+            var keys = Enumerable.Range(m_StartKey.ToIndex(), m_EndKey.ToIndex() - m_StartKey.ToIndex() + 1).Select((i) => TasKey.FromIndex(i)).ToArray();
             for (int index = m_StartIndex; index <= m_EndIndex; index++) {
                 // Fetch frame
                 var frame = seq.Visit(index);
@@ -292,20 +292,26 @@ namespace BallanceTasEditor.Backend {
         }
     }
 
+    public enum AddFrameOperationKind {
+        Before, After
+    }
+
     public class AddFrameOperation : ITasRevocableOperation {
-        public AddFrameOperation(int index, uint fps, int count) {
+        public AddFrameOperation(AddFrameOperationKind kind, int index, uint fps, int count) {
             // Check argument
             if (!FpsConverter.IsValidFps(fps)) {
                 throw new ArgumentOutOfRangeException(nameof(fps));
             }
             ArgumentOutOfRangeException.ThrowIfNegative(count);
             // Assign argument
+            m_Kind = kind;
             m_Index = index;
             m_Fps = fps;
             m_Count = count;
             m_IsExecuted = false;
         }
 
+        private AddFrameOperationKind m_Kind;
         private int m_Index;
         private uint m_Fps;
         private int m_Count;
@@ -320,16 +326,32 @@ namespace BallanceTasEditor.Backend {
                 throw OperationUtils.ExecutionEnvironment;
             }
 
-            // Check argument.
-            ArgumentOutOfRangeException.ThrowIfGreaterThan(m_Index, seq.GetCount());
+            // Check arguments
+            // If we add before some frame, the valid index can be [0, count],
+            // however, if we add after some frame, the valid index is [0, count),
+            switch (m_Kind) {
+                case AddFrameOperationKind.Before:
+                    ArgumentOutOfRangeException.ThrowIfGreaterThan(m_Index, seq.GetCount());
+                    break;
+                case AddFrameOperationKind.After:
+                    ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(m_Index, seq.GetCount());
+                    break;
+                default:
+                    throw new UnreachableException("Unknown AddFrameOperationKind");
+            }
 
             // Skip if count is zero.
             if (m_Count != 0) {
                 // Prepare data builder.
                 var iter = Enumerable.Range(0, m_Count).Select((_) => TasFrame.FromFps(m_Fps));
                 var exactSizedIter = new ExactSizeEnumerableAdapter<TasFrame>(iter, m_Count);
-                // Execute inserting.
-                seq.Insert(m_Index, exactSizedIter);
+                // Compute the insert index
+                var index = m_Kind switch {
+                    AddFrameOperationKind.Before => m_Index,
+                    AddFrameOperationKind.After => m_Index + 1,
+                    _ => throw new UnreachableException("Unknown AddFrameOperationKind"),
+                };
+                seq.Insert(index, exactSizedIter);
             }
 
             // Set status
@@ -344,8 +366,16 @@ namespace BallanceTasEditor.Backend {
             // Arguments were checked so we directly resotre them.
             // If we inserted count is not zero, remove inserted frames, otherwise do nothing.
             if (m_Count != 0) {
-                seq.Remove(m_Index, m_Index + m_Count - 1);
+                // Compute the index for removing
+                var index = m_Kind switch {
+                    AddFrameOperationKind.Before => m_Index,
+                    AddFrameOperationKind.After => m_Index + 1,
+                    _ => throw new UnreachableException("Unknown AddFrameOperationKind"),
+                };
+                // Execute removing.
+                seq.Remove(index, index + m_Count - 1);
             }
+
             // Modify execution status
             m_IsExecuted = false;
         }
diff --git a/BallanceTasEditor/BallanceTasEditorTests/AssertExtension.cs b/BallanceTasEditor/BallanceTasEditorTests/AssertExtension.cs
index ca2e247..34c2755 100644
--- a/BallanceTasEditor/BallanceTasEditorTests/AssertExtension.cs
+++ b/BallanceTasEditor/BallanceTasEditorTests/AssertExtension.cs
@@ -1,4 +1,4 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -6,8 +6,8 @@ using System.Text;
 using System.Threading.Tasks;
 
 namespace BallanceTasEditorTests {
-    public static class AssertExtension {
-        public static T ThrowsDerivedException<T>(Action action) where T : Exception {
+    internal static class AssertExtension {
+        internal static T ThrowsDerivedException<T>(Action action) where T : Exception {
             try {
                 action();
             } catch (T ex) {
diff --git a/BallanceTasEditor/BallanceTasEditorTests/Backend/TasOperationTests.cs b/BallanceTasEditor/BallanceTasEditorTests/Backend/TasOperationTests.cs
index 89db9ee..0713f9c 100644
--- a/BallanceTasEditor/BallanceTasEditorTests/Backend/TasOperationTests.cs
+++ b/BallanceTasEditor/BallanceTasEditorTests/Backend/TasOperationTests.cs
@@ -10,12 +10,123 @@ namespace BallanceTasEditorTests.Backend {
     [TestClass]
     public class TasOperationTests {
 
-        private static IEnumerable<object[]> TasSequenceInstanceProvider {
+        #region Utilities
+
+        private static IEnumerable<object[]> TestDataCombiner<T>(IEnumerable<ITasSequence> seqs, IEnumerable<T> payloads) where T : notnull {
+            // YYC MARK:
+            // We must iterate payload as outside "for" and iterate sequence as inner "for",
+            // because if we flip this order, each payload will share the same reference to sequence,
+            // which cause test error.
+            foreach (T payload in payloads) {
+                foreach (ITasSequence seq in seqs) {
+                    yield return new object[] { seq, payload };
+                }
+            }
+        }
+
+        private static void AssertRevocableOperation(ITasSequence sequence, ITasRevocableOperation op, string source, string expected) {
+            // Prepare environment
+            sequence.Clear();
+            GenerateSequence(sequence, source);
+
+            // Test execute
+            op.Execute(sequence);
+            Assert.AreEqual(expected, SummarizeSequence(sequence));
+
+            // Test revoke
+            op.Revoke(sequence);
+            Assert.AreEqual(source, SummarizeSequence(sequence));
+
+            // Test re-execute and re-revoke again
+            op.Execute(sequence);
+            Assert.AreEqual(expected, SummarizeSequence(sequence));
+            op.Revoke(sequence);
+            Assert.AreEqual(source, SummarizeSequence(sequence));
+        }
+
+        private static void AssertOperation(ITasSequence sequence, ITasOperation op, string source, string expected) {
+            // Prepare environment
+            sequence.Clear();
+            GenerateSequence(sequence, source);
+
+            // Test execute
+            op.Execute(sequence);
+            Assert.AreEqual(expected, SummarizeSequence(sequence));
+        }
+
+        private static void GenerateSequence(ITasSequence sequence, string pattern) {
+            var strFrame = pattern.Split(';');
+            var frameIter = strFrame.Select((s) => {
+                // Extract FPS and Keys
+                var framePair = s.Split(',');
+                var fps = uint.Parse(framePair[0]);
+                var keyFlags = uint.Parse(framePair[1]);
+                // Build raw frame and convert it to frame.
+                var rawFrame = new RawTasFrame() { TimeDelta = FpsConverter.ToDelta(fps), KeyFlags = keyFlags };
+                return TasFrame.FromRaw(rawFrame);
+            });
+            var frameExactSizeIter = new ExactSizeEnumerableAdapter<TasFrame>(frameIter, strFrame.Length);
+            sequence.Insert(0, frameExactSizeIter);
+        }
+
+        private static string SummarizeSequence(ITasSequence sequence) {
+            return string.Join(
+                ";",
+                sequence.Select((f) => {
+                    var rawFrame = f.ToRaw();
+                    return $"{FpsConverter.ToRoundFps(rawFrame.TimeDelta)},{rawFrame.KeyFlags}";
+                })
+            );
+        }
+
+        #endregion
+
+        #region Cell Keys Operation
+
+        public record CellKeysOperationTestPayload {
+            public required string Source { get; init; }
+            public required string Expected { get; init; }
+
+            public required CellKeysOperationKind Kind { get; init; }
+            public required int StartIndex { get; init; }
+            public required int EndIndex { get; init; }
+            public required TasKey StartKey { get; init; }
+            public required TasKey EndKey { get; init; }
+        }
+
+        private static IEnumerable<CellKeysOperationTestPayload> GetCellKeysOperationTestPayload() {
+            yield return new CellKeysOperationTestPayload {
+                Source = "1,1;1,2;1,3;1,4;1,5",
+                Expected = "1,15;1,15;1,15;1,4;1,5",
+                Kind = CellKeysOperationKind.Set,
+                StartIndex = 0,
+                EndIndex = 2,
+                StartKey = TasKey.KEY_UP,
+                EndKey = TasKey.KEY_RIGHT
+            };
+            yield return new CellKeysOperationTestPayload {
+                Source = "1,1;1,2;1,3;1,4;1,5",
+                Expected = "1,0;1,0;1,0;1,4;1,5",
+                Kind = CellKeysOperationKind.Unset,
+                StartIndex = 0,
+                EndIndex = 2,
+                StartKey = TasKey.KEY_UP,
+                EndKey = TasKey.KEY_RIGHT
+            };
+            yield return new CellKeysOperationTestPayload {
+                Source = "1,1;1,2;1,3;1,4;1,5",
+                Expected = "1,14;1,13;1,12;1,4;1,5",
+                Kind = CellKeysOperationKind.Flip,
+                StartIndex = 0,
+                EndIndex = 2,
+                StartKey = TasKey.KEY_UP,
+                EndKey = TasKey.KEY_RIGHT
+            };
+        }
+
+        private static IEnumerable<object[]> CellKeysOperationTestDataProvider {
             get {
-                yield return new object[] { new ListTasSequence() };
-                yield return new object[] { new LegacyTasSequence() };
-                // TODO: Add GapBufferTasSequence once we finish it.
-                //yield return new object[] { new GapBufferTasSequence() };
+                return TestDataCombiner(TasSequenceUtils.EnumerateTasSequenceImplementation(), GetCellKeysOperationTestPayload());
             }
         }
 
@@ -23,64 +134,280 @@ namespace BallanceTasEditorTests.Backend {
         /// CellKeysOperation测试。
         /// </summary>
         [DataTestMethod]
-        [DynamicData(nameof(TasSequenceInstanceProvider))]
-        public void CellKeysOperationTest(ITasSequence sequence, CellKeysOperationKind kind, int startIndex, int endIndex, TasKey startKey, TasKey endKey) {
-            throw new NotImplementedException();
+        [DynamicData(nameof(CellKeysOperationTestDataProvider))]
+        public void CellKeysOperationTest(ITasSequence sequence, CellKeysOperationTestPayload payload) {
+            var op = CellKeysOperation.FromCellRange(payload.Kind, payload.StartIndex, payload.EndIndex, payload.StartKey, payload.EndKey);
+            AssertRevocableOperation(sequence, op, payload.Source, payload.Expected);
+        }
+
+        #endregion
+
+        #region Frame Fps Operation
+
+        public record FrameFpsOperationTestPayload {
+            public required string Source { get; init; }
+            public required string Expected { get; init; }
+
+            public required int StartIndex { get; init; }
+            public required int EndIndex { get; init; }
+            public required uint Fps { get; init; }
+        }
+
+        private static IEnumerable<FrameFpsOperationTestPayload> GetFrameFpsOperationTestPayload() {
+            yield return new FrameFpsOperationTestPayload {
+                Source = "1,1;1,2;1,3;1,4;1,5",
+                Expected = "2,1;2,2;2,3;2,4;1,5",
+                StartIndex = 0,
+                EndIndex = 3,
+                Fps = 2
+            };
+            yield return new FrameFpsOperationTestPayload {
+                Source = "1,1;1,2;1,3;1,4;1,5",
+                Expected = "1,1;4,2;4,3;4,4;4,5",
+                StartIndex = 1,
+                EndIndex = 4,
+                Fps = 4
+            };
+        }
+
+        private static IEnumerable<object[]> FrameFpsOperationTestDataProvider {
+            get {
+                return TestDataCombiner(TasSequenceUtils.EnumerateTasSequenceImplementation(), GetFrameFpsOperationTestPayload());
+            }
         }
 
         /// <summary>
         /// FrameFpsOperation测试。
         /// </summary>
         [DataTestMethod]
-        [DynamicData(nameof(TasSequenceInstanceProvider))]
-        public void FrameFpsOperationTest(ITasSequence sequence) {
-            throw new NotImplementedException();
+        [DynamicData(nameof(FrameFpsOperationTestDataProvider))]
+        public void FrameFpsOperationTest(ITasSequence sequence, FrameFpsOperationTestPayload payload) {
+            var op = FrameFpsOperation.FromFrameRange(payload.StartIndex, payload.EndIndex, payload.Fps);
+            AssertRevocableOperation(sequence, op, payload.Source, payload.Expected);
+        }
+
+        #endregion
+
+        #region Remove Frame Operation
+
+        public record RemoveFrameOperationTestPayload {
+            public required string Source { get; init; }
+            public required string Expected { get; init; }
+
+            public required int StartIndex { get; init; }
+            public required int EndIndex { get; init; }
+        }
+
+        private static IEnumerable<RemoveFrameOperationTestPayload> GetRemoveFrameOperationTestPayload() {
+            yield return new RemoveFrameOperationTestPayload {
+                Source = "1,1;1,2;1,3;1,4;1,5",
+                Expected = "1,3;1,4;1,5",
+                StartIndex = 0,
+                EndIndex = 1
+            };
+            yield return new RemoveFrameOperationTestPayload {
+                Source = "1,1;1,2;1,3;1,4;1,5",
+                Expected = "",
+                StartIndex = 0,
+                EndIndex = 4
+            };
+            yield return new RemoveFrameOperationTestPayload {
+                Source = "1,1;1,2;1,3;1,4;1,5",
+                Expected = "1,1;1,2;1,3",
+                StartIndex = 3,
+                EndIndex = 4
+            };
+            yield return new RemoveFrameOperationTestPayload {
+                Source = "1,1;1,2;1,3;1,4;1,5",
+                Expected = "1,2;1,3;1,4;1,5",
+                StartIndex = 0,
+                EndIndex = 0
+            };
+            yield return new RemoveFrameOperationTestPayload {
+                Source = "1,1;1,2;1,3;1,4;1,5",
+                Expected = "1,1;1,2;1,3;1,4",
+                StartIndex = 4,
+                EndIndex = 4
+            };
+        }
+
+        private static IEnumerable<object[]> RemoveFrameOperationTestDataProvider {
+            get {
+                return TestDataCombiner(TasSequenceUtils.EnumerateTasSequenceImplementation(), GetRemoveFrameOperationTestPayload());
+            }
         }
 
         /// <summary>
         /// RemoveFrameOperation测试。
         /// </summary>
         [DataTestMethod]
-        [DynamicData(nameof(TasSequenceInstanceProvider))]
-        public void RemoveFrameOperationTest(ITasSequence sequence) {
-            throw new NotImplementedException();
+        [DynamicData(nameof(RemoveFrameOperationTestDataProvider))]
+        public void RemoveFrameOperationTest(ITasSequence sequence, RemoveFrameOperationTestPayload payload) {
+            var op = new RemoveFrameOperation(payload.StartIndex, payload.EndIndex);
+            AssertRevocableOperation(sequence, op, payload.Source, payload.Expected);
+        }
+
+        #endregion
+
+        #region Add Frame Operation
+
+        public record AddFrameOperationTestPayload {
+            public required string Source { get; init; }
+            public required string Expected { get; init; }
+
+            public required AddFrameOperationKind Kind { get; init; }
+            public required int Index { get; init; }
+            public required uint Fps { get; init; }
+            public required int Count { get; init; }
+        }
+
+        private static IEnumerable<AddFrameOperationTestPayload> GetAddFrameOperationTestPayload() {
+            yield return new AddFrameOperationTestPayload {
+                Source = "1,1;1,2;1,3;1,4;1,5",
+                Expected = "1,1;1,2;240,0;240,0;240,0;1,3;1,4;1,5",
+                Kind = AddFrameOperationKind.Before,
+                Index = 2,
+                Fps = 240,
+                Count = 3
+            };
+            yield return new AddFrameOperationTestPayload {
+                Source = "1,1;1,2;1,3;1,4;1,5",
+                Expected = "1,1;1,2;1,3;240,0;240,0;240,0;1,4;1,5",
+                Kind = AddFrameOperationKind.After,
+                Index = 2,
+                Fps = 240,
+                Count = 3
+            };
+            yield return new AddFrameOperationTestPayload {
+                Source = "1,1;1,2;1,3;1,4;1,5",
+                Expected = "240,0;240,0;240,0;1,1;1,2;1,3;1,4;1,5",
+                Kind = AddFrameOperationKind.Before,
+                Index = 0,
+                Fps = 240,
+                Count = 3
+            };
+            yield return new AddFrameOperationTestPayload {
+                Source = "1,1;1,2;1,3;1,4;1,5",
+                Expected = "1,1;1,2;1,3;1,4;1,5;240,0;240,0;240,0",
+                Kind = AddFrameOperationKind.After,
+                Index = 4,
+                Fps = 240,
+                Count = 3
+            };
+        }
+
+        private static IEnumerable<object[]> AddFrameOperationTestDataProvider {
+            get {
+                return TestDataCombiner(TasSequenceUtils.EnumerateTasSequenceImplementation(), GetAddFrameOperationTestPayload());
+            }
         }
 
         /// <summary>
         /// AddFrameOperation测试。
         /// </summary>
         [DataTestMethod]
-        [DynamicData(nameof(TasSequenceInstanceProvider))]
-        public void AddFrameOperationTest(ITasSequence sequence) {
-            throw new NotImplementedException();
+        [DynamicData(nameof(AddFrameOperationTestDataProvider))]
+        public void AddFrameOperationTest(ITasSequence sequence, AddFrameOperationTestPayload payload) {
+            var op = new AddFrameOperation(payload.Kind, payload.Index, payload.Fps, payload.Count);
+            AssertRevocableOperation(sequence, op, payload.Source, payload.Expected);
+        }
+
+        #endregion
+
+        #region Insert Frame Operation
+
+        public record InsertFrameOperationTestPayload {
+            public required string Source { get; init; }
+            public required string Inserted { get; init; }
+            public required string Expected { get; init; }
+
+            public required InsertFrameOperationKind Kind { get; init; }
+            public required int Index { get; init; }
+            public required uint Fps { get; init; }
+            public required int Count { get; init; }
+        }
+
+        private static IEnumerable<InsertFrameOperationTestPayload> GetInsertFrameOperationTestPayload() {
+            yield break;
+        }
+
+        private static IEnumerable<object[]> InsertFrameOperationTestDataProvider {
+            get {
+                return TestDataCombiner(TasSequenceUtils.EnumerateTasSequenceImplementation(), GetInsertFrameOperationTestPayload());
+            }
         }
 
         /// <summary>
         /// InsertFrameOperation测试。
         /// </summary>
         [DataTestMethod]
-        [DynamicData(nameof(TasSequenceInstanceProvider))]
-        public void InsertFrameOperationTest(ITasSequence sequence) {
-            throw new NotImplementedException();
+        [DynamicData(nameof(InsertFrameOperationTestDataProvider))]
+        public void InsertFrameOperationTest(ITasSequence sequence, InsertFrameOperationTestPayload payload) {
+            //var op = new InsertFrameOperation(payload.Kind, payload.Index, payload.Fps, payload.Count);
+            //AssertRevocableOperation(sequence, op, payload.Source, payload.Expected);
+        }
+
+        #endregion
+
+        #region Clear Keys Operation
+
+        public record ClearKeysOperationTestPayload {
+            public required string Source { get; init; }
+            public required string Expected { get; init; }
+        }
+
+        private static IEnumerable<ClearKeysOperationTestPayload> GetClearKeysOperationTestPayload() {
+            yield break;
+        }
+
+        private static IEnumerable<object[]> ClearKeysOperationTestDataProvider {
+            get {
+                return TestDataCombiner(TasSequenceUtils.EnumerateTasSequenceImplementation(), GetClearKeysOperationTestPayload());
+            }
         }
 
         /// <summary>
         /// ClearKeysOperation测试。
         /// </summary>
         [DataTestMethod]
-        [DynamicData(nameof(TasSequenceInstanceProvider))]
-        public void ClearKeysOperationTest(ITasSequence sequence) {
-            throw new NotImplementedException();
+        [DynamicData(nameof(ClearKeysOperationTestDataProvider))]
+        public void ClearKeysOperationTest(ITasSequence sequence, ClearKeysOperationTestPayload payload) {
+            var op = new ClearKeysOperation();
+            AssertOperation(sequence, op, payload.Source, payload.Expected);
+        }
+
+        #endregion
+
+        #region Uniform Fps Operation
+
+        public record UniformFpsOperationTestPayload {
+            public required string Source { get; init; }
+            public required string Expected { get; init; }
+
+            public required uint Fps { get; init; }
+        }
+
+        private static IEnumerable<UniformFpsOperationTestPayload> GetUniformFpsOperationTestPayload() {
+            yield break;
+        }
+
+        private static IEnumerable<object[]> UniformFpsOperationTestDataProvider {
+            get {
+                return TestDataCombiner(TasSequenceUtils.EnumerateTasSequenceImplementation(), GetUniformFpsOperationTestPayload());
+            }
         }
 
         /// <summary>
         /// UniformFpsOperation测试。
         /// </summary>
         [DataTestMethod]
-        [DynamicData(nameof(TasSequenceInstanceProvider))]
-        public void UniformFpsOperationTest(ITasSequence sequence) {
-            throw new NotImplementedException();
+        [DynamicData(nameof(UniformFpsOperationTestDataProvider))]
+        public void UniformFpsOperationTest(ITasSequence sequence, UniformFpsOperationTestPayload payload) {
+            var op = new UniformFpsOperation(payload.Fps);
+            AssertOperation(sequence, op, payload.Source, payload.Expected);
         }
 
+        #endregion
+
     }
 }
diff --git a/BallanceTasEditor/BallanceTasEditorTests/Backend/TasSequenceTests.cs b/BallanceTasEditor/BallanceTasEditorTests/Backend/TasSequenceTests.cs
index 36ab806..5c8b93f 100644
--- a/BallanceTasEditor/BallanceTasEditorTests/Backend/TasSequenceTests.cs
+++ b/BallanceTasEditor/BallanceTasEditorTests/Backend/TasSequenceTests.cs
@@ -28,12 +28,9 @@ namespace BallanceTasEditorTests.Backend {
             return new ExactSizeEnumerableAdapter<TasFrame>(BLANK, BLANK.Length);
         }
 
-        private static IEnumerable<object[]> TasSequenceInstanceProvider {
+        private static IEnumerable<object[]> CommonTestDataProvider {
             get {
-                yield return new object[] { new ListTasSequence() };
-                yield return new object[] { new LegacyTasSequence() };
-                // TODO: Add GapBufferTasSequence once we finish it.
-                //yield return new object[] { new GapBufferTasSequence() };
+                return TasSequenceUtils.EnumerateTasSequenceImplementation().Select((seq) => new object[] { seq });
             }
         }
 
@@ -41,7 +38,7 @@ namespace BallanceTasEditorTests.Backend {
         /// Visit函数独立测试。
         /// </summary>
         [DataTestMethod]
-        [DynamicData(nameof(TasSequenceInstanceProvider))]
+        [DynamicData(nameof(CommonTestDataProvider))]
         public void VisitTest(ITasSequence sequence) {
             // 空时访问
             AssertExtension.ThrowsDerivedException<IndexOutOfRangeException>(() => sequence.Visit(-1));
@@ -62,7 +59,7 @@ namespace BallanceTasEditorTests.Backend {
         /// Insert函数独立测试。
         /// </summary>
         [DataTestMethod]
-        [DynamicData(nameof(TasSequenceInstanceProvider))]
+        [DynamicData(nameof(CommonTestDataProvider))]
         public void InsertTest(ITasSequence sequence) {
             // 需要在不同的存储器上，分别检测在空的时候插入，
             // 和在非空时的头，中，尾分别插入的结果。
@@ -101,7 +98,7 @@ namespace BallanceTasEditorTests.Backend {
         /// Remove函数独立测试。
         /// </summary>
         [DataTestMethod]
-        [DynamicData(nameof(TasSequenceInstanceProvider))]
+        [DynamicData(nameof(CommonTestDataProvider))]
         public void RemoveTest(ITasSequence sequence) {
             // 插入项目后尝试在头中尾分别删除
             var indices = new int[] { 0, PROBE.Length / 2, PROBE.Length - 1 };
@@ -128,7 +125,7 @@ namespace BallanceTasEditorTests.Backend {
         /// Clear函数独立测试。
         /// </summary>
         [DataTestMethod]
-        [DynamicData(nameof(TasSequenceInstanceProvider))]
+        [DynamicData(nameof(CommonTestDataProvider))]
         public void ClearTest(ITasSequence sequence) {
             // 设置数据后清空
             sequence.Insert(0, GetExactSizeProbe());
@@ -142,7 +139,7 @@ namespace BallanceTasEditorTests.Backend {
         /// IsEmpty函数独立测试。
         /// </summary>
         [DataTestMethod]
-        [DynamicData(nameof(TasSequenceInstanceProvider))]
+        [DynamicData(nameof(CommonTestDataProvider))]
         public void IsEmptyTest(ITasSequence sequence) {
             // 检查是否为空
             Assert.IsTrue(sequence.IsEmpty());
@@ -156,7 +153,7 @@ namespace BallanceTasEditorTests.Backend {
         /// GetCount函数独立测试。
         /// </summary>
         [DataTestMethod]
-        [DynamicData(nameof(TasSequenceInstanceProvider))]
+        [DynamicData(nameof(CommonTestDataProvider))]
         public void GetCountTest(ITasSequence sequence) {
             // 检查长度为0
             Assert.AreEqual(sequence.GetCount(), 0);
@@ -171,7 +168,7 @@ namespace BallanceTasEditorTests.Backend {
         /// </summary>
         /// <param name="sequence"></param>
         [DataTestMethod]
-        [DynamicData(nameof(TasSequenceInstanceProvider))]
+        [DynamicData(nameof(CommonTestDataProvider))]
         public void HybridTest(ITasSequence sequence) {
             // 检查空和大小
             Assert.IsTrue(sequence.IsEmpty());
diff --git a/BallanceTasEditor/BallanceTasEditorTests/TasSequenceUtils.cs b/BallanceTasEditor/BallanceTasEditorTests/TasSequenceUtils.cs
new file mode 100644
index 0000000..a24d4dc
--- /dev/null
+++ b/BallanceTasEditor/BallanceTasEditorTests/TasSequenceUtils.cs
@@ -0,0 +1,22 @@
+using BallanceTasEditor.Backend;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BallanceTasEditorTests {
+
+    internal static class TasSequenceUtils {
+
+        internal static IEnumerable<ITasSequence> EnumerateTasSequenceImplementation() {
+            yield return new ListTasSequence();
+            yield return new LegacyTasSequence();
+            // TODO: Add GapBufferTasSequence once we finish it.
+            //yield return new GapBufferTasSequence();
+        }
+
+    }
+
+}