public void TestThatUserRuleParsingSuccessChoose()
{
// Arrange
var ruleName = "example0Rul1";
var stream = new MemoryStream().FromString(ruleName);
var rule1 = new UserRule(ruleName, "", new TokenExpression("", new Dictionary <string, int>()));
var rule2 = new UserRule(new string(ruleName.ToCharArray().Reverse().ToArray()), "", new TokenExpression("", new Dictionary <string, int>()));
var context = new DefaultParserContext(stream);
context.ParsedRules.Push(rule1);
context.ParsedRules.Push(rule2);
var ruleParser = new RuleCallParser();
// Act
var parsed = ruleParser.Parse(context);
// Assert
Assert.IsNotNull(parsed);
Assert.AreSame(parsed, rule1);
}
public void TestThatRuleArgumentIsCorrect()
{
// Arrange
var stream = new MemoryStream().FromString($"{this._terminateSequence}fgadcbv");
var context = new DefaultParserContext(stream: stream);
var parser = this._parserFactory.GetNewParser();
var leftArgument1 = new SymbolRule('a');
var leftArgument2 = new SymbolRule('b');
var leftArgument3 = new SymbolRule('c');
context.ParsedRules.Push(leftArgument1);
context.ParsedRules.Push(leftArgument2);
context.ParsedRules.Push(leftArgument3);
// Act
var result = parser.Parse(context) as ISingleArgumentRule;
// Assert
Assert.AreSame(result.ArgumentRule, leftArgument3);
}
public void TestThatUserRuleParsingSuccesAndStreamPositionSuccess()
{
// Arrange
var ruleName = "example0Rul1";
var stream = new MemoryStream().FromString(ruleName + "\'");
var rule = new UserRule(ruleName, "", new TokenExpression("", new Dictionary <string, int>()));
var context = new DefaultParserContext(stream);
context.ParsedRules.Push(rule);
var ruleParser = new RuleCallParser();
// Act
var startPos = stream.Position;
var parsed = ruleParser.Parse(context);
var endPos = stream.Position;
// Assert
Assert.AreEqual(endPos, ruleName.Length + startPos);
}
public void TestPositionAfterMultiParsing()
{
// Arrange
var stream = new MemoryStream().FromString("\'t\'\'t\'\'t\'\'t\'\'t\'");
var context = new DefaultParserContext(stream: stream);
var parser = new SymbolParser();
// Act
var startStreamPos = stream.Position;
var result = new List <IRule> {
parser.Parse(context),
parser.Parse(context),
parser.Parse(context),
parser.Parse(context),
parser.Parse(context)
};
var endStreamPosition = stream.Position;
// Assert
Assert.AreEqual(startStreamPos + (result.Count * 3), endStreamPosition);
}
public void TestThatAfterSuccessParsingStreamCursorHasRightPosition()
{
// Arrange
var symbol1 = 'a';
var symbol2 = 'c';
var additionRule = $"\'{symbol2}\'";
var str = $"{DisjunctionRuleParser.Symbol}\'{symbol2}\'{additionRule}";
var stream = new MemoryStream().FromString(str);
var parser = new DisjunctionRuleParser();
var context = new DefaultParserContext(stream: stream);
var leftArgument = new SymbolRule(symbol1);
context.ParsedRules.Push(leftArgument);
context.LexerBuilder = new LexerBuilder(new SimpleParserInjector());
// Act
parser.Parse(context);
// Assert
Assert.AreEqual(str.Length - additionRule.Length, context.CurrentStream.Position);
}
public IParserContext Parse(Stream stream)
{
this._context = new DefaultParserContext(stream);
var rule = "Rule";
while (stream.NextWithSkipedEmpty() != null)
{
var name = this.ReadBlockMeta(stream);
if (name == rule)
{
var rules = new UserRuleStructureParser(new UserRuleParser()).Parse(this._context);
foreach (var userRule in rules)
{
this._context.ParsedRules.Push(userRule);
}
}
if (name == null)
{
return(this._context);
}
}
return(this._context);
}
public void TestThatSuccessParsingGroup()
{
// Arrange
var symbol1 = 'a';
var symbol2 = 'b';
var stream = new MemoryStream().FromString($"{DisjunctionRuleParser.Symbol}(\'{symbol2}\'\'{symbol2}\')");
var parser = new DisjunctionRuleParser();
var context = new DefaultParserContext(stream: stream);
var leftArgument = new SymbolRule(symbol1);
context.ParsedRules.Push(leftArgument);
context.LexerBuilder = new LexerBuilder(new SimpleParserInjector());
// Act
var canParsed = parser.IsCurrentRule(context);
// Assert
Assert.IsTrue(canParsed);
}
public void TestParseRuleSuccessWithFilledStack()
{
// Arrange
var stream = new MemoryStream().FromString($"{this._terminateSequence}fgadcbv");
var context = new DefaultParserContext(stream: stream);
var parser = this._parserFactory.GetNewParser();
var leftArgument1 = new SymbolRule('a');
var leftArgument2 = new SymbolRule('b');
var leftArgument3 = new SymbolRule('c');
context.ParsedRules.Push(leftArgument1);
context.ParsedRules.Push(leftArgument2);
context.ParsedRules.Push(leftArgument3);
// Act
var streamStart = stream.Position;
var checkResult = parser.IsCurrentRule(context);
var result = parser.Parse(context) as ISingleArgumentRule;
// Assert
Assert.IsNotNull(result);
Assert.IsTrue(checkResult);
Assert.AreSame(result.ArgumentRule, leftArgument3);
Assert.AreEqual(stream.Position, streamStart + 1);
}
public void TestThatSuccessParsingManyRule()
{
// Arrange
var name = "Name";
var pattern =
"((\'a\'..\'z\')|(\'A\'..\'Z\')|(\'0\'..\'9\'+))+\' \'*\':\'\' \'*(\'!\'..\':\'+)|(\'<\'..\'~\')\';\' ";
var token = $"{UserRuleParser.NameTokenString}{UserRuleParser.TokenKeyValueDivider} \"Name\"{UserRuleParser.TokenExpressionDivider} first{UserRuleParser.TokenKeyValueDivider} 1{UserRuleParser.TokenExpressionDivider} second{UserRuleParser.TokenKeyValueDivider} 2";
var str =
$"{name}{UserRuleParser.RuleNameEndTerminator}{pattern}{UserRuleParser.ConvertionOperator}{token}{UserRuleParser.RuleEndTerminator}";
str += str;
str += str;
str += "}";
var stream = new MemoryStream().FromString(str);
var context = new DefaultParserContext(stream: stream);
var parser = new UserRuleStructureParser(new UserRuleParser());
// Act
var checkResult = parser.Parse(context);
// Assert
Assert.AreEqual(checkResult.Count, 4);
Assert.AreEqual(checkResult.First().Name, name);
}
public IRule ParseNextRule(Stream stream)
{
this._context = new DefaultParserContext(stream)
{
LexerBuilder = this._selfBuilder
};
return(this.ParseRule(stream).ParsedRules.FirstOrDefault());
}
public IParserContext Parse(Stream stream)
{
this._context = new DefaultParserContext(stream)
{
LexerBuilder = this._selfBuilder
};
var symbol = stream.CurrentSymbol();
while (symbol != null)
{
/**
* switch (symbol)
* {
*
* case Lexer.StartGroup:
*
* this._context.CurrentStream.TryToSeekToNext();
* var context = this._selfBuilder.Build(this._context.CurrentStream);
* var result = context.Parse(this._context.CurrentStream).ParsedRules.ToArray().Reverse();
*
*
* if (this._context.CurrentStream.CurrentSymbol() != Lexer.EndGroup)
* {
* throw new LexerBadEndGroupDeclarationException(this._context);
* }
*
* this._context.CurrentStream.TryToSeekToNext();
*
* var rule = new GroupRule(result.ToImmutableList());
* this._context.ParsedRules.Push(rule);
*
* break;
*
* case Lexer.EndGroup:
* return this._context;
*
* default:
* if (this._parser.IsCurrentRule(this._context))
* {
* this._context.ParsedRules.Push(this._parser.Parse(this._context));
* break;
* }
*
* throw new ArgumentOutOfRangeException(
* $"{symbol} не разобран ни одним из существующих правил.{Environment.NewLine}Контекст: {this._context}");
*
* }
*/
this.ParseRule(stream);
symbol = stream.CurrentSymbol();
if (symbol == EndGroup)
{
return(this._context);
}
}
return(this._context);
}
public void TestThrowsNullLeftArgumentException()
{
// Arrange
var stream = new MemoryStream().FromString($"{this._terminateSequence}hgasfdhgasdfghagshd");
var context = new DefaultParserContext(stream: stream);
var parser = this._parserFactory.GetNewParser();
// Act
var action = new Action(() => { parser.Parse(context); });
// Assert
Assert.ThrowsException <RuleParserNotExistedLeftArgumentException>(action);
}
public void TestParseRuleFailWithOneSymbol()
{
// Arrange
var stream = new MemoryStream().FromString("a");
var context = new DefaultParserContext(stream: stream);
var parser = new SymbolParser();
// Act
var result = parser.Parse(context);
// Assert
Assert.IsNull(result);
}
public void TestParseRuleSuccessWithManySymbols()
{
// Arrange
var stream = new MemoryStream().FromString("\'t\'sdjhfgjhsdgf");
var context = new DefaultParserContext(stream: stream);
var parser = new SymbolParser();
// Act
var result = parser.Parse(context);
// Assert
Assert.IsNotNull(result);
}
public void TestThatChekMethodDoentThrowsException()
{
// Arrange
var stream = new MemoryStream().FromString($"{this._terminateSequence}hgasfdhgasdfghagshd");
var context = new DefaultParserContext(stream: stream);
var parser = this._parserFactory.GetNewParser();
// Act
var result = parser.IsCurrentRule(context);
// Assert
Assert.IsFalse(result);
}
public void TestParseRuleFailWithSymbolParserTooMuchSymbolsException()
{
// Arrange
var stream = new MemoryStream().FromString("\'asfasdasdasd\'werwer");
var context = new DefaultParserContext(stream: stream);
var parser = new SymbolParser();
// Act
var action = new Action(() => { parser.Parse(context); });
// Assert
Assert.ThrowsException <SymbolParserTooMuchSymbolsException>(action);
}
public void TestThatFailedParsingWithoutArguments()
{
// Arrange
var stream = new MemoryStream().FromString($"{DisjunctionRuleParser.Symbol}");
var parser = new DisjunctionRuleParser();
var context = new DefaultParserContext(stream: stream);
context.LexerBuilder = new LexerBuilder(new SimpleParserInjector());
// Act
var action = new Action(() => parser.Parse(context));
// Assert
Assert.ThrowsException <RuleParserNotExistedLeftArgumentException>(action);
}
public void TestThatFailedChekingWithoutArguments()
{
// Arrange
var stream = new MemoryStream().FromString($"{DisjunctionRuleParser.Symbol}");
var parser = new DisjunctionRuleParser();
var context = new DefaultParserContext(stream: stream);
context.LexerBuilder = new LexerBuilder(new SimpleParserInjector());
// Act
var canParsed = parser.IsCurrentRule(context);
// Assert
Assert.IsFalse(canParsed);
}
public void TestThatUserRuleParsingFailedBecaouseOfUbdefindName()
{
// Arrange
var ruleName = "example0Rul1";
var stream = new MemoryStream().FromString(ruleName);
var context = new DefaultParserContext(stream);
var ruleParser = new RuleCallParser();
// Act
var action = new Action(() => ruleParser.Parse(context));
// Assert
Assert.ThrowsException <BadRuleNameException>(action);
}
public void TestThatCheckingtDoesNotAffectOnStreamPositionInFailedCaseWithoutSymbolAndArgument()
{
// Arrange
var stream = new MemoryStream().FromString($"fgadcbv");
var context = new DefaultParserContext(stream: stream);
var parser = this._parserFactory.GetNewParser();
context.ParsedRules.Push(null);
// Act
var streamStart = stream.Position;
parser.IsCurrentRule(context);
// Assert
Assert.AreEqual(stream.Position, streamStart);
}
public void TestPositionAfterFailedParsing()
{
// Arrange
var stream = new MemoryStream().FromString("a");
var context = new DefaultParserContext(stream: stream);
var parser = new SymbolParser();
// Act
var startPos = stream.Position;
parser.Parse(context);
var endPos = stream.Position;
// Assert
Assert.AreEqual(endPos, startPos);
}
public void TestThatFailedChekingWithoutFirstSymbol()
{
// Arrange
var symbol1 = 'a';
var stream = new MemoryStream().FromString($"{RangeRuleParser.Symbol}\'{symbol1}\'");
var parser = new RangeRuleParser();
var context = new DefaultParserContext(stream: stream);
context.LexerBuilder = new LexerBuilder(new SimpleParserInjector());
// Act
var canParsed = parser.IsCurrentRule(context);
// Assert
Assert.IsFalse(canParsed);
}
public void TestParseRuleSuccessWithOneSymbol()
{
// Arrange
var stream = new MemoryStream().FromString(this._terminateSequence);
var context = new DefaultParserContext(stream: stream);
var parser = this._parserFactory.GetNewParser();
var leftArgument = new SymbolRule('b');
context.ParsedRules.Push(leftArgument);
// Act
var checkResult = parser.IsCurrentRule(context);
var result = parser.Parse(context);
// Assert
Assert.IsNotNull(result);
Assert.IsTrue(checkResult);
}
public void TestParseRuleFailedWithoutSymbol()
{
// Arrange
var stream = new MemoryStream().FromString("hgasfdhgasdfghagshd");
var context = new DefaultParserContext(stream: stream);
var parser = this._parserFactory.GetNewParser();
var leftArgument = new SymbolRule('b');
context.ParsedRules.Push(leftArgument);
// Act
var checkResult = parser.IsCurrentRule(context);
var result = parser.Parse(context);
// Assert
Assert.IsNull(result);
Assert.IsFalse(checkResult);
}
public void TestThatCheckingtDoesNotAffectOnStreamPositionInSuccessCase()
{
// Arrange
var stream = new MemoryStream().FromString($"{this._terminateSequence}fgadcbv");
var context = new DefaultParserContext(stream: stream);
var parser = this._parserFactory.GetNewParser();
var leftArgument1 = new SymbolRule('a');
context.ParsedRules.Push(leftArgument1);
// Act
var streamStart = stream.Position;
parser.IsCurrentRule(context);
// Assert
Assert.AreEqual(stream.Position, streamStart);
}
public void TestParseRuleSuccessManySymbols()
{
// Arrange
var stream = new MemoryStream().FromString("\'t\'\'t\'\'t\'\'t\'\'t\'");
var context = new DefaultParserContext(stream: stream);
var parser = new SymbolParser();
// Act
var result = new List <IRule> {
parser.Parse(context),
parser.Parse(context),
parser.Parse(context),
parser.Parse(context),
parser.Parse(context)
};
// Assert
result.ForEach(Assert.IsNotNull);
}
public void TestThatStreamPositionAfterSuccessedParsingIsCorrect()
{
// Arrange
var stream = new MemoryStream().FromString($"{this._terminateSequence}fgadcbv");
var context = new DefaultParserContext(stream: stream);
var parser = this._parserFactory.GetNewParser();
var leftArgument = new SymbolRule('a');
context.ParsedRules.Push(leftArgument);
// Act
var streamStart = stream.Position;
parser.Parse(context);
// Assert
Assert.AreEqual(stream.Position, streamStart + 1);
}
public void TestThatSuccessParsing()
{
// Arrange
var symbol1 = 'a';
var symbol2 = 'c';
var stream = new MemoryStream().FromString($"{DisjunctionRuleParser.Symbol}\'{symbol2}\'");
var parser = new DisjunctionRuleParser();
var context = new DefaultParserContext(stream: stream);
var leftArgument = new SymbolRule(symbol1);
context.ParsedRules.Push(leftArgument);
context.LexerBuilder = new LexerBuilder(new SimpleParserInjector());
// Act
var parsed = parser.Parse(context);
// Assert
Assert.IsInstanceOfType(parsed, typeof(DisjunctionRule));
var converted = (DisjunctionRule)parsed;
Assert.IsNotNull(converted.LeftArgumentRule);
Assert.IsNotNull(converted.RightArgumentRule);
var leftConverted = (SymbolRule)converted.LeftArgumentRule;
var rightConverted = (SymbolRule)converted.RightArgumentRule;
Assert.AreSame(leftArgument, leftConverted);
Assert.AreEqual(leftConverted.Symbol, symbol1);
Assert.AreEqual(rightConverted.Symbol, symbol2);
Assert.IsNotNull(converted.LeftArgumentRule);
}
public void TestThatFailedParsingWithoutLastSymbol()
{
// Arrange
var symbol1 = 'a';
var stream = new MemoryStream().FromString($"{DisjunctionRuleParser.Symbol}");
var parser = new DisjunctionRuleParser();
var context = new DefaultParserContext(stream: stream);
var leftArgument = new SymbolRule(symbol1);
context.ParsedRules.Push(leftArgument);
context.LexerBuilder = new LexerBuilder(new SimpleParserInjector());
// Act
var action = new Action(() => parser.Parse(context));
// Assert
Assert.ThrowsException <CantParseRightArgumentException>(action);
}
