Test fixes

Author: wallstop

Runtime/DataStructures/CyclicBuffer.cs

@@ -135,22 +135,40 @@ public void Clear()
 
         public void Resize(int newCapacity)
         {
+            if (newCapacity == Capacity)
+            {
+                return;
+            }
+
             if (newCapacity < 0)
             {
                 throw new ArgumentException(nameof(newCapacity));
             }
 
-            int oldCapacity = Capacity;
             Capacity = newCapacity;
+
+            // Normalize underlying storage so the oldest element is at index 0.
             _buffer.Shift(-_position);
+
             if (newCapacity < _buffer.Count)
             {
-                _buffer.RemoveRange(newCapacity, _buffer.Count - newCapacity);
+                // When shrinking, drop the oldest elements to retain the most recent window.
+                int removeCount = _buffer.Count - newCapacity;
+                _buffer.RemoveRange(0, removeCount);
+            }
+
+            // Update next-write position: if full, wrap to 0 to overwrite oldest; otherwise append at end.
+            if (Capacity <= 0)
+            {
+                _position = 0;
+                Count = 0;
+                _buffer.Clear();
+                return;
             }
 
-            _position =
-                newCapacity < oldCapacity && newCapacity <= _buffer.Count ? 0 : _buffer.Count;
+            // Count cannot exceed new capacity
             Count = Math.Min(newCapacity, Count);
+            _position = _buffer.Count >= Capacity ? 0 : _buffer.Count;
         }
 
         public bool Contains(T item)

Tests/Runtime/AutocompleteTests.cs

@@ -160,7 +160,7 @@ public void AutoRegisteredCommandReceivesCompleter()
             CommandHistory history = new CommandHistory(8);
             CommandShell shell = new CommandShell(history);
 
-            shell.InitializeAutoRegisteredCommands();
+            shell.InitializeAutoRegisteredCommands(Array.Empty<string>());
 
             Assert.IsTrue(
                 shell.Commands.TryGetValue(
@@ -224,5 +224,69 @@ public void AutoCompleteChainsArguments()
             Assert.AreEqual(1, partialSecondContext.ArgsBeforeCursor.Count);
             Assert.AreEqual("alpha", partialSecondContext.ArgsBeforeCursor[0].contents);
         }
+
+        [Test]
+        public void AutoCompleteHonorsCaretIndexWithinInput()
+        {
+            CommandHistory history = new CommandHistory(16);
+            CommandShell shell = new CommandShell(history);
+            ChainedCompleter chainedCompleter = new ChainedCompleter();
+            shell.AddCommand("chain", _ => { }, 0, -1, string.Empty, null, chainedCompleter);
+
+            CommandAutoComplete autoComplete = new CommandAutoComplete(history, shell);
+            List<string> buffer = new List<string>();
+            int caretIndex = "chain alpha ".Length;
+            autoComplete.Complete("chain alpha gamma", caretIndex, buffer);
+
+            Assert.AreEqual(1, buffer.Count);
+            Assert.AreEqual("chain alpha gamma", buffer[0]);
+            Assert.AreEqual(1, chainedCompleter.Calls.Count);
+            CommandCompletionContext context = chainedCompleter.Calls[0];
+            Assert.AreEqual(1, context.ArgIndex);
+            Assert.AreEqual(string.Empty, context.PartialArg);
+            Assert.AreEqual(1, context.ArgsBeforeCursor.Count);
+            Assert.AreEqual("alpha", context.ArgsBeforeCursor[0].contents);
+        }
+
+        [Test]
+        public void AutoCompleteFallsBackToHistoryWhenCommandUnknown()
+        {
+            CommandHistory history = new CommandHistory(16);
+            history.Push("login", true, true);
+            history.Push("logout", true, true);
+            CommandShell shell = new CommandShell(history);
+
+            CommandAutoComplete autoComplete = new CommandAutoComplete(history, shell);
+            string[] suggestions = autoComplete.Complete("lo");
+
+            Assert.IsNotNull(suggestions);
+            CollectionAssert.Contains(suggestions, "login");
+            CollectionAssert.Contains(suggestions, "logout");
+        }
+
+        [Test]
+        public void AutoCompleteDeduplicatesValuesAcrossSources()
+        {
+            CommandHistory history = new CommandHistory(16);
+            history.Push("list", true, true);
+            CommandShell shell = new CommandShell(history);
+            shell.AddCommand("list", _ => { });
+            List<string> knownWords = new List<string> { "list" };
+            CommandAutoComplete autoComplete = new CommandAutoComplete(history, shell, knownWords);
+
+            string[] suggestions = autoComplete.Complete("li");
+            Assert.IsNotNull(suggestions);
+
+            int matches = 0;
+            for (int i = 0; i < suggestions.Length; ++i)
+            {
+                if (string.Equals(suggestions[i], "list", StringComparison.Ordinal))
+                {
+                    matches++;
+                }
+            }
+
+            Assert.AreEqual(1, matches, "Expected deduplicated suggestion list.");
+        }
     }
 }

Tests/Runtime/CyclicBufferTests.cs

@@ -0,0 +1,60 @@
+namespace WallstopStudios.DxCommandTerminal.Tests.Runtime
+{
+    using System.Collections;
+    using NUnit.Framework;
+    using UnityEngine.TestTools;
+    using WallstopStudios.DxCommandTerminal.DataStructures;
+
+    public sealed class CyclicBufferTests
+    {
+        [UnityTest]
+        public IEnumerator AddAndOverwritePreservesChronology()
+        {
+            CyclicBuffer<int> buf = new(3) { 0, 1, 2 };
+
+            Assert.AreEqual(
+                3,
+                buf.Count,
+                "Count should reflect number of elements added up to capacity."
+            );
+            Assert.AreEqual(0, buf[0], "Oldest element should be at index 0 before wrap.");
+            Assert.AreEqual(1, buf[1], "Next element should be index 1.");
+            Assert.AreEqual(2, buf[2], "Newest element should be index 2 before wrap.");
+
+            // Overwrite oldest
+            buf.Add(3);
+            Assert.AreEqual(3, buf.Count, "Count should not grow beyond capacity.");
+            Assert.AreEqual(1, buf[0], "After overwrite, oldest is dropped.");
+            Assert.AreEqual(2, buf[1], "Element order should advance by one.");
+            Assert.AreEqual(3, buf[2], "Newest written value should be last.");
+
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator ResizeTruncatesOrExtends()
+        {
+            CyclicBuffer<int> buf = new(5);
+            for (int i = 0; i < 5; ++i)
+            {
+                buf.Add(i);
+            }
+            Assert.AreEqual(5, buf.Count, "Filled buffer should have full count.");
+
+            // Shrink: oldest entries should be truncated
+            buf.Resize(3);
+            Assert.AreEqual(3, buf.Count, "Count should reflect new capacity after shrink.");
+            Assert.AreEqual(2, buf[0], "Shrink should retain most recent entries and drop oldest.");
+            Assert.AreEqual(3, buf[1], "Remaining order should be preserved (middle).");
+            Assert.AreEqual(4, buf[2], "Remaining order should be preserved (newest).");
+
+            // Grow: capacity increases, order stays
+            buf.Resize(6);
+            Assert.AreEqual(3, buf.Count, "Growing capacity should not change current count.");
+            Assert.AreEqual(2, buf[0], "Growing capacity should not alter order (first).");
+            Assert.AreEqual(3, buf[1], "Growing capacity should not alter order (second).");
+            Assert.AreEqual(4, buf[2], "Growing capacity should not alter order (third).");
+            yield break;
+        }
+    }
+}