Select Git revision
Forked from
mmcs / Compilers
30 commits behind the upstream repository.
-
nikitaodnorob authored
Установка Culture при тестировании для работы преобразования string в double (дробная часть отделяется точкой)
nikitaodnorob authoredУстановка Culture при тестировании для работы преобразования string в double (дробная часть отделяется точкой)
Tests.cs 19.03 KiB
using System;
using NUnit.Framework;
using Lexer;
namespace TestLexer
{
[TestFixture]
public class TestIntLexer
{
[Test]
public void TestIntParse()
{
Lexer.Lexer l = new IntLexer("154216");
Assert.IsTrue(l.Parse(), "Не разбирает 154216");
l = new IntLexer("1");
Assert.IsTrue(l.Parse(), "Не разбирает 1");
l = new IntLexer("0");
Assert.IsTrue(l.Parse(), "Не разбирает 0");
l = new IntLexer("-0");
Assert.IsTrue(l.Parse(), "Не разбирает -0");
l = new IntLexer("+0");
Assert.IsTrue(l.Parse(), "Не разбирает +0");
l = new IntLexer("+11");
Assert.IsTrue(l.Parse(), "Не разбирает +11");
l = new IntLexer("-12");
Assert.IsTrue(l.Parse(), "Не разбирает -12");
}
[Test]
public void TestIntFailDot()
{
Lexer.Lexer l = new IntLexer("1.54216");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 1.54216");
}
[Test]
public void TestIntFailSymbol()
{
Lexer.Lexer l = new IntLexer("а1");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает a1");
l = new IntLexer("1a");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 1а");
}
[Test]
public void TestIntFailEpty()
{
Lexer.Lexer l = new IntLexer("");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает пустую строку");
}
[Test]
public void TestIntCollectNumber()
{
IntLexer lInt = new IntLexer("12");
Assert.IsTrue(lInt.Parse());
Assert.AreEqual(lInt.parseResult, 12, "Не собирает число 12");
lInt = new IntLexer("-12");
Assert.IsTrue(lInt.Parse());
Assert.AreEqual(lInt.parseResult, -12, "Не собирает число -12");
lInt = new IntLexer("+12");
Assert.IsTrue(lInt.Parse());
Assert.AreEqual(lInt.parseResult, 12, "Не собирает число +12");
lInt = new IntLexer("+0");
Assert.IsTrue(lInt.Parse());
Assert.AreEqual(lInt.parseResult, 0, "Не собирает число +0");
}
}
[TestFixture]
public class TestIdLexer
{
[Test]
public void TestIdParse()
{
IdentLexer l = new IdentLexer("abc22");
Assert.IsTrue(l.Parse(), "Не разбирает аbc22");
l = new IdentLexer("a");
Assert.IsTrue(l.Parse(), "Не разбирает а");
}
[Test]
public void TestIdEmpty()
{
IdentLexer l = new IdentLexer("");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает пустую строку");
}
[Test]
public void TestIdCaps()
{
IdentLexer l = new IdentLexer("AAAAA");
Assert.IsTrue(l.Parse(), "Не разбирает заглавные буквы");
}
[Test]
public void TestIdNumbers()
{
IdentLexer l = new IdentLexer("a12345");
Assert.IsTrue(l.Parse(), "Не разбирает цифры в конце");
}
[Test]
public void TestIdUnderscore()
{
IdentLexer l = new IdentLexer("a12_5");
Assert.IsTrue(l.Parse(), "Не разбирает _");
}
[Test]
public void TestIdDot()
{
IdentLexer l = new IdentLexer("f67.3");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает точку");
}
[Test]
public void TestIdDollar()
{
IdentLexer l = new IdentLexer("f67$3");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает $");
}
}
[TestFixture]
public class TestIntNotZeroLexer
{
[Test]
public void TestIntNotZeroParse()
{
IntNoZeroLexer l = new IntNoZeroLexer("1234");
Assert.IsTrue(l.Parse(), "Не разбирает 1234");
}
[Test]
public void TestIntNotZeroFail()
{
IntNoZeroLexer l = new IntNoZeroLexer("01234");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 0");
l = new IntNoZeroLexer("+01234");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает +0");
l = new IntNoZeroLexer("-01234");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает -0");
l = new IntNoZeroLexer("0");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 0");
}
[Test]
public void TestIntNotZeroPass()
{
IntNoZeroLexer l = new IntNoZeroLexer("12034");
Assert.IsTrue(l.Parse(), "Не разбирает 12034");
l = new IntNoZeroLexer("+12034");
Assert.IsTrue(l.Parse(), "Не разбирает +12034");
l = new IntNoZeroLexer("12034");
Assert.IsTrue(l.Parse(), "Не разбирает 12034");
l = new IntNoZeroLexer("-12034");
Assert.IsTrue(l.Parse(), "Не разбирает -12034");
}
}
[TestFixture]
public class TestLetterDigitLexer
{
[Test]
public void TestLetterDigitParse()
{
LetterDigitLexer l = new LetterDigitLexer("a2f5j3");
Assert.IsTrue(l.Parse(), "Не разбирает a2f5j3");
l = new LetterDigitLexer("a");
Assert.IsTrue(l.Parse(), "Не разбирает a");
l = new LetterDigitLexer("a2");
Assert.IsTrue(l.Parse(), "Не разбирает a2");
l = new LetterDigitLexer("a2B");
Assert.IsTrue(l.Parse(), "Не разбирает a2B");
}
[Test]
public void TestLetterDigitFail()
{
LetterDigitLexer l = new LetterDigitLexer("a25j3");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает a25j3");
l = new LetterDigitLexer("a2jb3");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает a2jb3");
l = new LetterDigitLexer("2a3b");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 2a3b");
l = new LetterDigitLexer("a2f 3b");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает a2f 3b");
}
}
[TestFixture]
public class TestLetterListLexer
{
[Test]
public void TestLetterListParse()
{
LetterListLexer l = new LetterListLexer("a,b,c");
Assert.IsTrue(l.Parse(), "Не пропускает a,b,c");
Assert.AreEqual(l.ParseResult.Count, 3, "неправильно собран список-результат");
Assert.Contains('a', l.ParseResult);
Assert.Contains('b', l.ParseResult);
Assert.Contains('c', l.ParseResult);
l = new LetterListLexer("a");
Assert.IsTrue(l.Parse(), "Не пропускает a");
Assert.AreEqual(l.ParseResult.Count, 1, "неправильно собран список-результат");
Assert.Contains('a', l.ParseResult);
l = new LetterListLexer("a,B");
Assert.IsTrue(l.Parse(), "Не пропускает a,B");
Assert.AreEqual(l.ParseResult.Count, 2, "неправильно собран список-результат");
Assert.Contains('a', l.ParseResult);
Assert.Contains('B', l.ParseResult);
l = new LetterListLexer("a;B");
Assert.IsTrue(l.Parse(), "Не пропускает a;B");
l = new LetterListLexer("a,B;c");
Assert.IsTrue(l.Parse(), "Не пропускает a,B;c");
l = new LetterListLexer("a;b,c;d");
Assert.IsTrue(l.Parse(), "Не пропускает a;b,c;d");
}
[Test]
public void TestLetterListFail()
{
LetterListLexer l = new LetterListLexer("a,b,");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает a,b,");
l = new LetterListLexer(",b");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает ,b");
l = new LetterListLexer(";b");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает ;b");
l = new LetterListLexer("B;");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает B;");
l = new LetterListLexer("a,,b");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает a,,b");
l = new LetterListLexer("a;;b");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает a;;b");
l = new LetterListLexer("a;1");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает цифры");
}
}
[TestFixture]
public class TestDigitListLexer
{
[Test]
public void TestDigitListParse()
{
DigitListLexer l = new DigitListLexer("1 2");
Assert.IsTrue(l.Parse(), "Не пропускает 1 2");
Assert.AreEqual(l.ParseResult.Count, 2, "неправильно собран список-результат");
Assert.Contains(1, l.ParseResult);
Assert.Contains(2, l.ParseResult);
l = new DigitListLexer("1");
Assert.IsTrue(l.Parse(), "Не пропускает 1");
Assert.AreEqual(l.ParseResult.Count, 1, "неправильно собран список-результат");
Assert.Contains(1, l.ParseResult);
l = new DigitListLexer("5 6");
Assert.IsTrue(l.Parse(), "Не пропускает 5 6");
Assert.AreEqual(l.ParseResult.Count, 2, "неправильно собран список-результат");
Assert.Contains(5, l.ParseResult);
Assert.Contains(6, l.ParseResult);
}
[Test]
public void TestDigitListFail()
{
DigitListLexer l = new DigitListLexer("12");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 12");
l = new DigitListLexer(" 1");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает пробелы в начале");
l = new DigitListLexer("1 ");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает пробелы в конце");
l = new DigitListLexer("1, 2");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает ,");
l = new DigitListLexer("1;2");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает ;");
l = new DigitListLexer("1a2");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 1a2");
}
}
[TestFixture]
public class TestLetterDigitGroupLexer
{
[Test]
public void TestLetterDigitGroupParse()
{
LetterDigitGroupLexer l = new LetterDigitGroupLexer("aa12ab23");
Assert.IsTrue(l.Parse(), "Не пропускает aa12ab23");
Assert.AreEqual(l.ParseResult, "aa12ab23", "неправильно собран aa12ab23");
l = new LetterDigitGroupLexer("a1b2");
Assert.IsTrue(l.Parse(), "Не пропускает a1b2");
Assert.AreEqual(l.ParseResult, "a1b2", "неправильно собран a1b2");
l = new LetterDigitGroupLexer("aa");
Assert.IsTrue(l.Parse(), "Не пропускает aa");
Assert.AreEqual(l.ParseResult, "aa", "неправильно собран aa");
l = new LetterDigitGroupLexer("A11");
Assert.IsTrue(l.Parse(), "Не пропускает A11");
Assert.AreEqual(l.ParseResult, "A11", "неправильно собран A11");
l = new LetterDigitGroupLexer("ab33cd58e3n5ss32");
Assert.IsTrue(l.Parse(), "Не пропускает ab33cd58e3n5ss32");
Assert.AreEqual(l.ParseResult, "ab33cd58e3n5ss32", "неправильно собран ab33cd58e3n5ss32");
}
[Test]
public void TestLetterDigitGroupFail()
{
LetterDigitGroupLexer l = new LetterDigitGroupLexer("1a");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 1a");
l = new LetterDigitGroupLexer("a111b");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает a111b");
l = new LetterDigitGroupLexer("A_34b");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает A_34b");
l = new LetterDigitGroupLexer("");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает пустую строку");
l = new LetterDigitGroupLexer("11");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 11");
l = new LetterDigitGroupLexer("_A34");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает _A34");
}
}
[TestFixture]
public class TestDoubleLexer
{
public TestDoubleLexer()
{
System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US");
}
[Test]
public void TestDoubleParse()
{
DoubleLexer l = new DoubleLexer("123.4");
Assert.IsTrue(l.Parse(), "Не понимает 123.4");
Assert.AreEqual(123.4, l.ParseResult, 0.01, "Неправильно прочитал 123.4");
l = new DoubleLexer("123");
Assert.IsTrue(l.Parse(), "Не понимает 123");
Assert.AreEqual(123, l.ParseResult, 0.01, "Неправильно прочитал 123");
l = new DoubleLexer("0.4");
Assert.IsTrue(l.Parse(), "Не понимает 0.4");
Assert.AreEqual(0.4, l.ParseResult, 0.01, "Неправильно прочитал 0.4");
}
[Test]
public void TestDoubleFail()
{
DoubleLexer l = new DoubleLexer(".4");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает .4");
l = new DoubleLexer("4.");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 4.");
l = new DoubleLexer(".");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает .");
l = new DoubleLexer("");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает пустую строку");
}
}
[TestFixture]
public class TestQuotedStringLexer
{
[Test]
public void TestQuotedStringParse()
{
StringLexer l = new StringLexer("''");
Assert.IsTrue(l.Parse(), "Не пропускает ''");
l = new StringLexer("'aa#2N3@_3-x//45'");
Assert.IsTrue(l.Parse(), "Не пропускает 'aa#2N3@_3-x//45'");
l = new StringLexer("'23 3 a'");
Assert.IsTrue(l.Parse(), "Не пропускает '23 3 a'");
}
[Test]
public void TestQuotedStringFail()
{
StringLexer l = new StringLexer("'");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает '");
l = new StringLexer("aa'");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает aa'");
l = new StringLexer("b 'add'");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает b 'add'");
l = new StringLexer("'add' d");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 'add' d");
}
}
[TestFixture]
public class TestCommentLexer
{
[Test]
public void TestCommentParse()
{
CommentLexer l = new CommentLexer("/**/");
Assert.IsTrue(l.Parse(), "Не пропускает /**/");
l = new CommentLexer("/*as3 @4&*_ -dd %~f*/");
Assert.IsTrue(l.Parse(), "Не пропускает /*as3 @4&*_ -dd %~f*/");
l = new CommentLexer("/*asda \n */");
Assert.IsTrue(l.Parse(), "Не пропускает перенос строки");
}
[Test]
public void TestCommentFail()
{
CommentLexer l = new CommentLexer("*/");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает */'");
l = new CommentLexer("/*");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает /*'");
l = new CommentLexer("/* \n");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает */ \n'");
l = new CommentLexer("/**/*/");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает /**/*/'");
}
}
[TestFixture]
public class TestIdChainLexer
{
[Test]
public void TestIdChainParse()
{
IdentChainLexer l = new IdentChainLexer("Id1");
Assert.IsTrue(l.Parse(), "Не пропускает Id1");
l = new IdentChainLexer("Id1.Id2");
Assert.IsTrue(l.Parse(), "Не пропускает Id1.Id2");
l = new IdentChainLexer("uUd.k_22.sa3");
Assert.IsTrue(l.Parse(), "Не пропускает uUd.k_22.sa3");
}
[Test]
public void TestIdChainFail()
{
IdentChainLexer l = new IdentChainLexer("3Id1");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает 3Id1");
l = new IdentChainLexer(".Id2");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает .Id2");
l = new IdentChainLexer("uUd.");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает uUd.");
l = new IdentChainLexer("uUd.3sa");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает uUd.3sa");
l = new IdentChainLexer("uUd. _sa");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает uUd. _sa");
l = new IdentChainLexer("uUd,sa");
Assert.Throws<LexerException>(() => { l.Parse(); }, "Пропускает uUd,sa");
}
}
}