public void TextNavigator_SkipWhitespace_1()
        {
            TextNavigator navigator = new TextNavigator(" \t\r\nABC ");

            Assert.IsTrue(navigator.SkipWhitespace());
            Assert.AreEqual('A', navigator.ReadChar());
            navigator.ReadChar();
            navigator.ReadChar();
            Assert.IsFalse(navigator.SkipWhitespace());
            Assert.IsTrue(navigator.IsEOF);
        }
        public void TextNavigator_ReadChar_1()
        {
            const string  text      = "ABC";
            TextNavigator navigator = new TextNavigator(text);

            Assert.AreEqual('A', navigator.ReadChar());
            Assert.AreEqual('B', navigator.ReadChar());
            Assert.AreEqual('C', navigator.ReadChar());
            Assert.AreEqual(TextNavigator.EOF, navigator.ReadChar());
            Assert.AreEqual(TextNavigator.EOF, navigator.ReadChar());
        }
        public void TextNavigator_IsWhiteSpace_1()
        {
            const string  text      = " A\t";
            TextNavigator navigator = new TextNavigator(text);

            Assert.IsTrue(navigator.IsWhiteSpace());
            navigator.ReadChar();
            Assert.IsFalse(navigator.IsWhiteSpace());
            navigator.ReadChar();
            Assert.IsTrue(navigator.IsWhiteSpace());
        }
        public void TextNavigator_IsSeparator_1()
        {
            const string  text      = "\u2028A ";
            TextNavigator navigator = new TextNavigator(text);

            Assert.IsTrue(navigator.IsSeparator());
            navigator.ReadChar();
            Assert.IsFalse(navigator.IsSeparator());
            navigator.ReadChar();
            Assert.IsTrue(navigator.IsSeparator());
        }
        public void TextNavigator_IsSymbol_1()
        {
            const string  text      = "$A+";
            TextNavigator navigator = new TextNavigator(text);

            Assert.IsTrue(navigator.IsSymbol());
            navigator.ReadChar();
            Assert.IsFalse(navigator.IsSymbol());
            navigator.ReadChar();
            Assert.IsTrue(navigator.IsSymbol());
        }
        public void TextNavigator_IsPunctuation_1()
        {
            const string  text      = ".A,";
            TextNavigator navigator = new TextNavigator(text);

            Assert.IsTrue(navigator.IsPunctuation());
            navigator.ReadChar();
            Assert.IsFalse(navigator.IsPunctuation());
            navigator.ReadChar();
            Assert.IsTrue(navigator.IsPunctuation());
        }
        public void TextNavigator_IsNumber_1()
        {
            const string  text      = "1+²";
            TextNavigator navigator = new TextNavigator(text);

            Assert.IsTrue(navigator.IsNumber());
            navigator.ReadChar();
            Assert.IsFalse(navigator.IsNumber());
            navigator.ReadChar();
            Assert.IsTrue(navigator.IsNumber());
        }
        public void TextNavigator_IsLetterOrDigit_1()
        {
            const string  text      = "A_1";
            TextNavigator navigator = new TextNavigator(text);

            Assert.IsTrue(navigator.IsLetterOrDigit());
            navigator.ReadChar();
            Assert.IsFalse(navigator.IsLetterOrDigit());
            navigator.ReadChar();
            Assert.IsTrue(navigator.IsLetterOrDigit());
        }
        public void TextNavigator_SkipWhitespaceAndPunctuation_1()
        {
            TextNavigator navigator = new TextNavigator(" \t,\r\nABC. ");

            Assert.IsTrue(navigator.SkipWhitespaceAndPunctuation());
            Assert.AreEqual('A', navigator.ReadChar());
            navigator.ReadChar();
            navigator.ReadChar();
            Assert.IsFalse(navigator.SkipWhitespaceAndPunctuation());
            Assert.IsTrue(navigator.IsEOF);
        }
        public void TextNavigator_SkipWhileNot_1()
        {
            char[]        good      = { 'A', 'B' };
            TextNavigator navigator = new TextNavigator("123ABC");

            Assert.IsTrue(navigator.SkipWhileNot(good));
            Assert.AreEqual('A', navigator.ReadChar());
            Assert.IsTrue(navigator.SkipWhileNot(good));
            Assert.AreEqual('B', navigator.ReadChar());
            Assert.IsFalse(navigator.SkipWhileNot(good));
            Assert.AreEqual(TextNavigator.EOF, navigator.ReadChar());
        }
        public void TextNavigator_RestorePosition_1()
        {
            TextNavigator navigator = new TextNavigator("Hello, world!");
            TextPosition  saved     = navigator.SavePosition();

            navigator.ReadChar();
            navigator.RestorePosition(saved);
            Assert.AreEqual(saved.Position, navigator.Position);
            Assert.AreEqual(saved.Line, navigator.Line);
            Assert.AreEqual(saved.Column, navigator.Column);
            Assert.AreEqual('H', navigator.ReadChar());
        }
        public void TextNavigator_PeekString_1()
        {
            const string  text      = "ABC";
            TextNavigator navigator = new TextNavigator(text);

            Assert.AreEqual("AB", navigator.PeekString(2));
            navigator.ReadChar();
            Assert.AreEqual("BC", navigator.PeekString(2));
            navigator.ReadChar();
            Assert.AreEqual("C", navigator.PeekString(2));
            navigator.ReadChar();
            Assert.IsNull(navigator.PeekString(2));
        }
        public void TextNavigator_LookAhead_2()
        {
            const string  text      = "ABC";
            TextNavigator navigator = new TextNavigator(text);

            Assert.AreEqual('C', navigator.LookAhead(2));
            navigator.ReadChar();
            Assert.AreEqual(TextNavigator.EOF, navigator.LookAhead(2));
            navigator.ReadChar();
            Assert.AreEqual(TextNavigator.EOF, navigator.LookAhead(2));
            navigator.ReadChar();
            Assert.AreEqual(TextNavigator.EOF, navigator.LookAhead(2));
        }
        public void TextNavigator_ReadUntil_4()
        {
            char[]        stop      = { ']', '>' };
            TextNavigator navigator = new TextNavigator("ABC>]DEF");

            Assert.AreEqual("ABC", navigator.ReadUntil(stop));
            navigator.ReadChar();
            Assert.AreEqual(string.Empty, navigator.ReadUntil(stop));
            navigator.ReadChar();
            Assert.AreEqual("DEF", navigator.ReadUntil(stop));
            navigator.ReadChar();
            Assert.IsNull(navigator.ReadUntil(stop));
        }
        public void TextNavigator_GetRemainingText_1()
        {
            const string  text      = "ABC";
            TextNavigator navigator = new TextNavigator(text);

            Assert.AreEqual(text, navigator.GetRemainingText());
            navigator.ReadChar();
            Assert.AreEqual("BC", navigator.GetRemainingText());
            navigator.ReadChar();
            Assert.AreEqual("C", navigator.GetRemainingText());
            navigator.ReadChar();
            Assert.IsNull(navigator.GetRemainingText());
        }
        public void TextNavigator_Position_1()
        {
            const string  text      = "ABC";
            TextNavigator navigator = new TextNavigator(text);

            Assert.AreEqual(0, navigator.Position);
            navigator.ReadChar();
            Assert.AreEqual(1, navigator.Position);
            navigator.ReadChar();
            Assert.AreEqual(2, navigator.Position);
            navigator.ReadChar();
            Assert.AreEqual(3, navigator.Position);
            navigator.ReadChar();
            Assert.AreEqual(3, navigator.Position);
        }
        public void TextNavigator_FromFile_2()
        {
            string        fileName  = Path.Combine(TestDataPath, "record.txt");
            TextNavigator navigator = TextNavigator.FromFile(fileName, Encoding.UTF8);

            Assert.AreEqual('#', navigator.ReadChar());
        }
        public void TextNavigator_PeekUntil_1()
        {
            const string  text      = "ABC]DEF";
            TextNavigator navigator = new TextNavigator(text);

            Assert.AreEqual("ABC", navigator.PeekUntil(']'));
            navigator.ReadChar();
            Assert.AreEqual("BC", navigator.PeekUntil(']'));
            navigator.ReadChar();
            navigator.ReadChar();
            Assert.AreEqual(string.Empty, navigator.PeekUntil(']'));
            navigator.ReadChar();
            Assert.AreEqual("DEF", navigator.PeekUntil(']'));
            navigator.Move(3);
            Assert.IsNull(navigator.PeekUntil(']'));
        }
        public void TextNavigator_SkipNonWord_2()
        {
            TextNavigator navigator = new TextNavigator(". (<ABC");

            Assert.IsTrue(navigator.SkipNonWord('<', '>'));
            Assert.AreEqual('<', navigator.ReadChar());
        }
        public void TextNavigator_SkipTo_1()
        {
            TextNavigator navigator = new TextNavigator("123ABC");

            Assert.IsTrue(navigator.SkipTo('A'));
            Assert.AreEqual('A', navigator.ReadChar());
            Assert.IsFalse(navigator.SkipTo('A'));
        }
        public void TextNavigator_Column_1()
        {
            const string  text      = "ABC";
            TextNavigator navigator = new TextNavigator(text);

            Assert.AreEqual(1, navigator.Column);
            navigator.ReadChar();
            Assert.AreEqual(2, navigator.Column);
        }
        public void TextNavigator_SkipWhile_1()
        {
            TextNavigator navigator = new TextNavigator("111ABC");

            Assert.IsTrue(navigator.SkipWhile('1'));
            Assert.AreEqual('A', navigator.ReadChar());
            navigator.Move(2);
            Assert.IsFalse(navigator.SkipWhile('1'));
        }
        public void TextNavigator_SkipRange_1()
        {
            TextNavigator navigator = new TextNavigator("123ABC");

            Assert.IsTrue(navigator.SkipRange('0', '9'));
            Assert.AreEqual('A', navigator.ReadChar());
            navigator.Move(2);
            Assert.IsFalse(navigator.SkipRange('0', '9'));
        }
        public void TextNavigator_SkipPunctuation_1()
        {
            TextNavigator navigator = new TextNavigator(".,ABC");

            Assert.IsTrue(navigator.SkipPunctuation());
            Assert.AreEqual('A', navigator.ReadChar());
            navigator.Move(2);
            Assert.IsFalse(navigator.SkipPunctuation());
        }
        public void TextNavigator_SkipControl_1()
        {
            TextNavigator navigator = new TextNavigator("\t\tABC");

            Assert.IsTrue(navigator.SkipControl());
            Assert.AreEqual('A', navigator.ReadChar());
            navigator.Move(2);
            Assert.IsFalse(navigator.SkipControl());
        }
        public void TextNavigator_SkipChar_2()
        {
            TextNavigator navigator = new TextNavigator("123456");

            Assert.IsTrue(navigator.SkipChar(3));
            Assert.AreEqual('4', navigator.ReadChar());
            Assert.IsFalse(navigator.SkipChar(3));
            Assert.IsTrue(navigator.IsEOF);
        }
        public void TextNavigator_SkipWhile_2()
        {
            char[]        digits    = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
            TextNavigator navigator = new TextNavigator("314ABC");

            Assert.IsTrue(navigator.SkipWhile(digits));
            Assert.AreEqual('A', navigator.ReadChar());
            navigator.Move(2);
            Assert.IsFalse(navigator.SkipWhile(digits));
        }
        public void TextNavigator_SkipChar_3()
        {
            char[]        allowed   = { '1', '2' };
            TextNavigator navigator = new TextNavigator("123456");

            Assert.IsTrue(navigator.SkipChar(allowed));
            Assert.IsTrue(navigator.SkipChar(allowed));
            Assert.IsFalse(navigator.SkipChar(allowed));
            Assert.AreEqual('3', navigator.ReadChar());
        }
        public void TextNavigator_SkipChar_1()
        {
            TextNavigator navigator = new TextNavigator("111234");

            Assert.IsTrue(navigator.SkipChar('1'));
            Assert.IsTrue(navigator.SkipChar('1'));
            Assert.IsTrue(navigator.SkipChar('1'));
            Assert.AreEqual('2', navigator.ReadChar());
            Assert.IsFalse(navigator.SkipChar('1'));
        }
        public void TextNavigator_ReadEscapedUntil_2()
        {
            const string  text      = "AB[tC";
            TextNavigator navigator = new TextNavigator(text);
            string        expected  = "ABtC";
            string        actual    = navigator.ReadEscapedUntil('[', ']');

            Assert.AreEqual(expected, actual);
            Assert.AreEqual(TextNavigator.EOF, navigator.ReadChar());
        }