Example #1
0
 public void EmptyBuffer()
 {
     var buffer = new ConsoleInputBuffer();
     buffer.Contents.Should().BeEmpty();
     buffer.CursorIndex.Should().Be(0);
     buffer.Length.Should().Be(0);
     buffer.CursorIsAtEnd.Should().BeTrue();
     buffer.ToString().Should().BeEmpty();
 }
Example #2
0
        public void InsertCharAtEnd()
        {
            var buffer = new ConsoleInputBuffer();

            buffer.Insert('x');

            buffer.Contents.Should().Be("x");
            buffer.CursorIndex.Should().Be(0);
            buffer.Length.Should().Be(1);
            buffer.CursorIsAtEnd.Should().BeFalse();
            buffer.ToString().Should().Be("x");
            buffer[0].Should().Be('x');
        }
Example #3
0
        public void InsertStringAtEnd()
        {
            const string s = "xyzzy";
            var buffer = new ConsoleInputBuffer();

            buffer.Insert(s);

            buffer.Contents.Should().Be(s);
            buffer.CursorIndex.Should().Be(0);
            buffer.Length.Should().Be(s.Length);
            buffer.CursorIsAtEnd.Should().BeFalse();
            buffer.ToString().Should().Be(s);
        }
Example #4
0
        public void InsertCharInMiddle()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");
            buffer.MoveCursor(SeekOrigin.Begin, 2);

            buffer.Insert('x');

            buffer.Contents.Should().Be("abxcd");
            buffer.CursorIndex.Should().Be(2);
            buffer.Length.Should().Be(5);
            buffer.CursorIsAtEnd.Should().BeFalse();
            buffer.ToString().Should().Be("abxcd");
        }
Example #5
0
        public void RemovingAtEnd()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");
            buffer.MoveCursor(SeekOrigin.End, 0);

            buffer.Remove().Should().BeFalse();
            buffer.Contents.Should().Be("abcd");
        }
Example #6
0
        public void Truncate()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");
            buffer.MoveCursor(SeekOrigin.Begin, 2);

            buffer.Truncate();

            buffer.Contents.Should().Be("ab");
            buffer.CursorIndex.Should().Be(2);
            buffer.Length.Should().Be(2);
            buffer.CursorIsAtEnd.Should().BeTrue();
            buffer.ToString().Should().Be("ab");
        }
Example #7
0
        public void ReplaceWithTooLongString()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");

            Action replacement = () => buffer.Replace("xyzzy");
            replacement.ShouldThrow<ArgumentOutOfRangeException>();
        }
Example #8
0
 public void ReplaceOneChar()
 {
     var buffer = new ConsoleInputBuffer();
     buffer.Insert("abcd");
     buffer.MoveCursor(SeekOrigin.Current, 1).Should().BeTrue();
     buffer.Replace('x');
     buffer.Contents.Should().Be("axcd");
 }
Example #9
0
        public void RemoveCharBeforeInMiddle()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");

            buffer.MoveCursor(SeekOrigin.End, -1);
            buffer.RemoveCharBeforeCursor().Should().BeTrue();

            buffer.Contents.Should().Be("abd");
            buffer.Length.Should().Be(3);
            buffer.CursorIndex.Should().Be(2);
        }
Example #10
0
        public void RemovePastEnd()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");

            buffer.Remove(5).Should().BeFalse();
            buffer.Contents.Should().Be("abcd");
        }
Example #11
0
        public void MovingCursorBogusly()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");

            Action movement = () => buffer.MoveCursor((SeekOrigin)0x10, 1);
            movement.ShouldThrow<ArgumentOutOfRangeException>();
        }
Example #12
0
        public void Indexing()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");
            buffer[0].Should().Be('a');
            buffer[3].Should().Be('d');

            Action action1 = () => { var x = buffer[-1]; };
            action1.ShouldThrow<IndexOutOfRangeException>();

            Action action2 = () => { var x = buffer[4]; };
            action2.ShouldThrow<IndexOutOfRangeException>();
        }
Example #13
0
        public void ReplaceEntireString()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");

            buffer.Replace("xyzw");
            buffer.Contents.Should().Be("xyzw");
        }
Example #14
0
        public void ReplacePartOfString()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");

            buffer.MoveCursor(SeekOrigin.Begin, 1);
            buffer.Replace("xy");
            buffer.Contents.Should().Be("axyd");
        }
Example #15
0
        public void ReplaceWithEmptyString()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");

            buffer.Replace(string.Empty);
            buffer.Contents.Should().Be("abcd");
        }
Example #16
0
        public void RemoveLastChar()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");
            buffer.MoveCursor(SeekOrigin.Begin, 3);

            buffer.Remove().Should().BeTrue();

            buffer.Contents.Should().Be("abc");
            buffer.CursorIndex.Should().Be(3);
            buffer.Length.Should().Be(3);
            buffer.CursorIsAtEnd.Should().BeTrue();
            buffer.ToString().Should().Be("abc");
        }
Example #17
0
        public void RemoveMultipleChars()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");
            buffer.MoveCursor(SeekOrigin.Begin, 1);

            buffer.Remove(2).Should().BeTrue();

            buffer.Contents.Should().Be("ad");
            buffer.CursorIndex.Should().Be(1);
            buffer.Length.Should().Be(2);
            buffer.CursorIsAtEnd.Should().BeFalse();
            buffer.ToString().Should().Be("ad");
        }
Example #18
0
        public void MovingCursorRelativeToEnd()
        {
            int delta;

            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");

            buffer.MoveCursor(SeekOrigin.End, 1, out delta).Should().BeFalse();
            buffer.CursorIndex.Should().Be(0);
            delta.Should().Be(0);

            buffer.MoveCursor(SeekOrigin.End, 0, out delta).Should().BeTrue();
            buffer.CursorIndex.Should().Be(4);
            delta.Should().Be(4);

            buffer.MoveCursor(SeekOrigin.End, -2, out delta).Should().BeTrue();
            buffer.CursorIndex.Should().Be(2);
            delta.Should().Be(-2);

            buffer.MoveCursor(SeekOrigin.End, 4, out delta).Should().BeFalse();
            buffer.CursorIndex.Should().Be(2);
            delta.Should().Be(0);

            buffer.MoveCursor(SeekOrigin.End, -10, out delta).Should().BeFalse();
            buffer.CursorIndex.Should().Be(2);
            delta.Should().Be(0);
        }
Example #19
0
        public void RemoveCharBeforeStart()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");

            buffer.RemoveCharBeforeCursor().Should().BeFalse();

            buffer.Contents.Should().Be("abcd");
        }
Example #20
0
        public void Reading()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");

            buffer.Read(0).Should().BeEmpty();
            buffer.Read(1).Should().ContainInOrder('a');
            buffer.Read(2).Should().ContainInOrder('a', 'b');
            buffer.Read(3).Should().ContainInOrder('a', 'b', 'c');
            buffer.Read(4).Should().ContainInOrder('a', 'b', 'c', 'd');
            ((Action)(() => buffer.Read(5))).ShouldThrow<ArgumentException>();
        }
Example #21
0
        public void ReadingAt()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");

            buffer.ReadAt(0, 2).Should().ContainInOrder('a', 'b');
            buffer.ReadAt(2, 2).Should().ContainInOrder('c', 'd');

            ((Action)(() => buffer.ReadAt(2, 4))).ShouldThrow<ArgumentException>();
            ((Action)(() => buffer.ReadAt(3, 2))).ShouldThrow<ArgumentException>();
        }
Example #22
0
        public void ReadingAtWithExplicitBuffer()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");

            var outBuffer = new char[4];

            buffer.ReadAt(0, outBuffer, 0, 2);
            outBuffer[0].Should().Be('a');
            outBuffer[1].Should().Be('b');

            buffer.ReadAt(2, outBuffer, 0, 2);
            outBuffer[0].Should().Be('c');
            outBuffer[1].Should().Be('d');

            outBuffer[0] = 'x';
            buffer.ReadAt(0, outBuffer, 1, 1);
            outBuffer[0].Should().Be('x');
            outBuffer[1].Should().Be('a');

            ((Action)(() => buffer.ReadAt(0, null, 0, 2))).ShouldThrow<ArgumentNullException>();
            ((Action)(() => buffer.ReadAt(2, outBuffer, 0, 4))).ShouldThrow<ArgumentException>();
            ((Action)(() => buffer.ReadAt(2, outBuffer, 3, 2))).ShouldThrow<ArgumentException>();
        }
Example #23
0
        public void ReplacingAtEnd()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");
            buffer.MoveCursor(SeekOrigin.End, 0);

            Action replacementAction = () => buffer.Replace('x');
            replacementAction.ShouldThrow<Exception>();
        }
Example #24
0
        public void ReplaceWithNullString()
        {
            var buffer = new ConsoleInputBuffer();
            buffer.Insert("abcd");

            Action replacement = () => buffer.Replace(null);
            replacement.ShouldThrow<ArgumentNullException>();
        }