public void EnumerateList()
        {
            var list = new[] { 0, 1, 2 };
            var e    = CircularEnumerator.Create(list);

            e.Should().NotBeNull();
            e.CursorIndex.Should().NotHaveValue();
            e.Values.Should().BeSameAs(list);
            e.Started.Should().BeFalse();

            Action currentItem = () => { var x = e.GetCurrentItem(); };

            currentItem.Should().Throw <InvalidOperationException>();

            e.MovePrevious();
            e.GetCurrentItem().Should().Be(2);

            e.MoveNext();
            e.GetCurrentItem().Should().Be(0);

            e.MoveNext();
            e.GetCurrentItem().Should().Be(1);

            e.MoveNext();
            e.GetCurrentItem().Should().Be(2);

            e.MoveNext();
            e.GetCurrentItem().Should().Be(0);
        }
        private void ReplaceCurrentTokenWithCompletion(bool reverseOrder, bool lastOperationWasCompletion)
        {
            if (TokenCompleter == null)
            {
                return;
            }

            // If we can't pull a completion from the cache, then generate new ones.
            if (!lastOperationWasCompletion || (_lastCompletions == null))
            {
                _lastCompletions      = TokenCompletionSet.Create(Buffer.Contents, Buffer.CursorIndex, TokenCompleter);
                _completionEnumerator = CircularEnumerator.Create(_lastCompletions.Completions);
            }

            // Bail if no completions are available.
            if (_lastCompletions.Empty)
            {
                return;
            }

            // Find the existing token length.
            var existingTokenLength = _completionEnumerator.Started
                ? _completionEnumerator.GetCurrentItem().Length
                : _lastCompletions.OriginalToken.InnerLength;

            // Find the existing token start.
            var existingTokenStart =
                _lastCompletions.OriginalToken.InnerStartingOffset;

            // Select the new completion.
            if (reverseOrder)
            {
                _completionEnumerator.MovePrevious();
            }
            else
            {
                _completionEnumerator.MoveNext();
            }

            // Select the completion.
            var completion = _completionEnumerator.GetCurrentItem();

            // Replace the current token in the buffer with the completion.
            MoveConsoleAndBufferCursors(SeekOrigin.Begin, existingTokenStart);
            Buffer.Remove(existingTokenLength);
            Buffer.Insert(completion);

            // Rewrite the input text.
            SyncBufferToConsole(
                existingTokenStart,
                Buffer.Length - existingTokenStart,
                (existingTokenLength > completion.Length) ? existingTokenLength - completion.Length : 0);

            MoveConsoleAndBufferCursors(SeekOrigin.Current, completion.Length);
        }
        public void EnumerationTest()
        {
            int[] src = { 1, 2, 5, 8, -9 };
            var   i   = new CircularEnumerator <int>(src);

            foreach (var num in src)
            {
                Assert.AreEqual(num, i.Next());
            }
            foreach (var num in src)
            {
                Assert.AreEqual(num, i.Next());
            }
        }
Exemple #4
0
        public void EnumerateEmptyList()
        {
            var list = new string[] { };
            var e    = CircularEnumerator.Create(list);

            e.Should().NotBeNull();
            e.CursorIndex.Should().NotHaveValue();
            e.Values.Should().BeSameAs(list);
            e.Started.Should().BeFalse();

            Action currentItem = () => { var x = e.CurrentItem; };

            currentItem.ShouldThrow <IndexOutOfRangeException>();

            e.MoveNext();
            currentItem.ShouldThrow <IndexOutOfRangeException>();

            e.MovePrevious();
            currentItem.ShouldThrow <IndexOutOfRangeException>();
        }
        public GradeCheck()
        {
            this.InitializeComponent();
            this.Loaded += LoadDataAsync;

            var color2 = Resources["Color2"] as SolidColorBrush;
            var color3 = Resources["Color3"] as SolidColorBrush;

            var color = new CircularEnumerator <SolidColorBrush>(color2, color3);

            for (var row = 1; row <= 20; ++row)
            {
                var border = new Border()
                {
                    Background = color.Next()
                };
                Grid.SetRow(border, row);
                Grid.SetColumnSpan(border, 6);
                gradesContainer.Children.Add(border);
            }
        }
        public void NullTest()
        {
            var i = new CircularEnumerator <int>();

            Assert.AreEqual(default(int), i.Next());
        }
Exemple #7
0
        private void ReplaceCurrentTokenWithCompletion(bool reverseOrder, bool lastOperationWasCompletion)
        {
            if (CompletionHandler == null)
            {
                return;
            }

            // If we can't pull a completion from the cache, then generate new ones.
            if (!lastOperationWasCompletion || (_lastCompletions == null))
            {
                _lastCompletions = TokenCompletionSet.Create(Buffer.Contents, Buffer.CursorIndex, CompletionHandler);
                _completionEnumerator = CircularEnumerator.Create(_lastCompletions.Completions);
            }

            // Bail if no completions are available.
            if (_lastCompletions.Empty)
            {
                return;
            }

            // Find the existing token length.
            var existingTokenLength = _completionEnumerator.Started
                ? _completionEnumerator.CurrentItem.Length
                : _lastCompletions.OriginalToken.InnerLength;

            // Find the existing token start.
            var existingTokenStart =
                _lastCompletions.OriginalToken.InnerStartingOffset;

            // Select the new completion.
            if (reverseOrder)
            {
                _completionEnumerator.MovePrevious();
            }
            else
            {
                _completionEnumerator.MoveNext();
            }

            // Select the completion.
            var completion = _completionEnumerator.CurrentItem;

            // Replace the current token in the buffer with the completion.
            MoveConsoleAndBufferCursors(SeekOrigin.Begin, existingTokenStart);
            Buffer.Remove(existingTokenLength);
            Buffer.Insert(completion);

            // Rewrite the input text.
            SyncBufferToConsole(
                existingTokenStart,
                Buffer.Length - existingTokenStart,
                (existingTokenLength > completion.Length) ? existingTokenLength - completion.Length : 0);

            MoveConsoleAndBufferCursors(SeekOrigin.Current, completion.Length);
        }