public void RegexParserShouldParseMultipleRanges()
{
var regexParser = new RegexParser();
var actual = regexParser.Parse("[a-zA-Z0-9]");
var expected = new RegexDefinition(
startsWith: false,
endsWith: false,
expression: new RegexExpressionTerm(
term: new RegexTerm(
factor: new RegexFactor(
atom: new RegexAtomSet(
set: new RegexSet(
negate: false,
characterClass: new RegexCharacterClassAlteration(
characterClass: new RegexCharacterClassAlteration(
characterClass: new RegexCharacterClass(
characterRange: new RegexCharacterRange(
startCharacter: new RegexCharacterClassCharacter(value: '0'),
endCharacter: new RegexCharacterClassCharacter(value: '9'))),
characterRange: new RegexCharacterRange(
startCharacter: new RegexCharacterClassCharacter(value: 'A'),
endCharacter: new RegexCharacterClassCharacter(value: 'Z'))),
characterRange: new RegexCharacterRange(
startCharacter: new RegexCharacterClassCharacter(value: 'a'),
endCharacter: new RegexCharacterClassCharacter(value: 'z')))))))));
Assert.AreEqual(expected, actual);
}
public void RegexToStringShouldCreateSingleCharacterString()
{
var regex = new RegexDefinition(
false,
new RegexExpressionTerm(
new RegexTerm(
new RegexFactor(
new RegexAtomCharacter(
new RegexCharacter('a'))))),
false);
Assert.AreEqual("a", regex.ToString());
}
public void RegexParserShouldParseSingleCharacter()
{
var regexParser = new RegexParser();
var actual = regexParser.Parse("a");
var expected = new RegexDefinition(
false,
new RegexExpressionTerm(
new RegexTerm(
new RegexFactor(
new RegexAtomCharacter(
new RegexCharacter(
'a'))))),
false);
Assert.AreEqual(expected, actual);
}
public void RegexParserShouldParseEscape()
{
var regexParser = new RegexParser();
var actual = regexParser.Parse(@"\.");
var expected = new RegexDefinition(
false,
new RegexExpressionTerm(
new RegexTerm(
new RegexFactor(
new RegexAtomCharacter(
new RegexCharacter('.', true))))),
false);
Assert.AreEqual(expected, actual);
}
public void RegexToStringShouldCreateSetString()
{
var regex = new RegexDefinition(
false,
new RegexExpressionTerm(
new RegexTerm(
new RegexFactor(
new RegexAtomSet(
new RegexSet(
false,
new RegexCharacterClass(
new RegexCharacterUnitRange(
new RegexCharacterClassCharacter('a')))))))),
false);
Assert.AreEqual("[a]", regex.ToString());
}
public void RegexParserShouldParsePositiveSet()
{
var regexParser = new RegexParser();
var actual = regexParser.Parse("[a]");
var expected = new RegexDefinition(
false,
new RegexExpressionTerm(
new RegexTerm(
new RegexFactor(
new RegexAtomSet(
new RegexSet(false,
new RegexCharacterClass(
new RegexCharacterUnitRange(
new RegexCharacterClassCharacter('a')))))))),
false);
Assert.AreEqual(expected, actual);
}
public void RegexToStringShouldCreateNegativeRangeString()
{
var regex = new RegexDefinition(
false,
new RegexExpressionTerm(
new RegexTerm(
new RegexFactor(
new RegexAtomSet(
new RegexSet(
true,
new RegexCharacterClass(
new RegexCharacterRange(
new RegexCharacterClassCharacter('a'),
new RegexCharacterClassCharacter('z')))))))),
false);
Assert.AreEqual("[^a-z]", regex.ToString());
}
public void RegexParserShouldParseAlteration()
{
var regexParser = new RegexParser();
var actual = regexParser.Parse("a|b");
var expected = new RegexDefinition(
startsWith: false,
endsWith: false,
expression: new RegexExpressionAlteration(
term: new RegexTerm(
factor: new RegexFactor(
atom: new RegexAtomCharacter(
character: new RegexCharacter('a')))),
expression: new RegexExpressionTerm(
term: new RegexTerm(
factor: new RegexFactor(
atom: new RegexAtomCharacter(
character: new RegexCharacter('b')))))));
Assert.AreEqual(expected, actual);
}
public void PdlGeneratorShouldGenerateTrivia()
{
var whiteSpaceRegex = new RegexDefinition(
false,
new RegexExpressionTerm(
new RegexTerm(
new RegexFactorIterator(
new RegexAtomSet(
new RegexSet(
false,
new RegexCharacterClass(
new RegexCharacterUnitRange(
new RegexCharacterClassCharacter(' '))))),
RegexIterator.OneOrMany))),
false);
var definition = new PdlDefinitionConcatenation(
new PdlBlockRule(
new PdlRule(
new PdlQualifiedIdentifier("S"),
new PdlExpression(
new PdlTerm(
new PdlFactorLiteral("a"))))),
new PdlDefinitionConcatenation(
new PdlBlockLexerRule(
new PdlLexerRule(
new PdlQualifiedIdentifier("whitespace"),
new PdlLexerRuleExpression(
new PdlLexerRuleTerm(
new PdlLexerRuleFactorRegex(
whiteSpaceRegex))))),
new PdlDefinition(
new PdlBlockSetting(
new PdlSetting(
new PdlSettingIdentifier("trivia"),
new PdlQualifiedIdentifier("whitespace"))))));
var grammar = GenerateGrammar(definition);
Assert.IsNotNull(grammar.Trivia);
Assert.AreEqual(1, grammar.Trivia.Count);
}
public PdlFactorRegex(RegexDefinition regex)
{
Regex = regex;
_hashCode = ComputeHashCode();
}
public RegexLexer(RegexDefinition regex)
{
this.Regex = regex;
}
