public void Default_NonRegexControlCharactersAreAlwaysValid_WhenCalledWithArgument(bool isValid)
{
var defaultAlphabet = RegexAlphabetFactory.Default(isValid);
var result = defaultAlphabet.IsValid("J");
Assert.IsTrue(result);
}
public void TryLoadRegex_ResultValueHasIntersectionIsFalse_WhenPatternDoesNotContainIntersectionToken(string pattern)
{
var factory = new RegularExpressionFactory(RegexAlphabetFactory.Default(), Substitute.For <IRandomGenerator>(), 1);
var result = factory.TryGetRegularExpression(pattern, out _);
Assert.IsFalse(result.Value.HasIntersection);
}
public void TryLoadRegex_ReturnedExpressionYieldsExpectedMinExpansionLength_WhenCalledForPattern(string pattern, int expectedMinExpansionLength)
{
var factory = new RegularExpressionFactory(RegexAlphabetFactory.Default(), Substitute.For <IRandomGenerator>(), 1);
factory.TryGetRegularExpression(pattern, out var union);
var result = union.MaxExpansionRange.Start;
Assert.AreEqual(expectedMinExpansionLength, result);
}
public void Default_ReturnedAlphabetContainsAllLetters()
{
var alphabet = RegexAlphabetFactory.Default();
for (var i = 'a'; i <= 'z'; i++)
{
Assert.IsTrue(alphabet.IsValid(i.ToString()), $"Failed character: {i}");
}
}
public void Minimal_SetsIsValidValueForRegexControlLettersToExpectedResult_WhenCalledWithExplicitIsValidValue(bool isValid)
{
var minimal = RegexAlphabetFactory.Minimal(isValid);
var result = minimal.GetAllCharacters();
foreach (var letter in result)
{
Assert.AreEqual(isValid, minimal.IsValid(letter), letter);
}
}
public void ConstructorWithPattern_GenerateCreatesString_WhenCalledWithParserAlphabet()
{
var alphabet = RegexAlphabetFactory.Minimal();
var primitiveParser = new PrimitiveParser(alphabet);
alphabet.Add("a", new CharacterParser(primitiveParser));
var regseed = new RegSeed("a", new Random(), alphabet);
var result = regseed.Generate();
Assert.AreEqual("a", result);
}
public void DefaultExtendedBy_NonRegexControlCharactersAreAlwaysValid_WhenCalledWithArgument(bool isValid)
{
var defaultAlphabet = RegexAlphabetFactory.DefaultExtendedBy(new List <string> {
"Ü"
}, isValid);
var resultJ = defaultAlphabet.IsValid("J");
var resultUe = defaultAlphabet.IsValid("Ü");
Assert.IsTrue(resultJ);
Assert.IsTrue(resultUe);
}
public void MinimalExtendedBy_SetsIsValidValueForAdditionalLettersToTrue_IndependentOfIsValidValueOfRegexControlLetters(bool isValid)
{
var minimalExtendedBy = RegexAlphabetFactory.MinimalExtendedBy(new List <string> {
"F"
}, isValid);
var result = minimalExtendedBy.IsValid("F");
var regexControlResult = minimalExtendedBy.IsValid("{");
Assert.IsTrue(result);
Assert.AreEqual(isValid, regexControlResult);
}
public void Default_RegexControlCharactersHaveSpecifiedIsValidValue_WhenCalledWithArgument(bool isValid)
{
var defaultAlphabet = RegexAlphabetFactory.Default(isValid);
Assert.AreEqual(isValid, defaultAlphabet.IsValid("*"));
Assert.AreEqual(isValid, defaultAlphabet.IsValid("+"));
Assert.AreEqual(isValid, defaultAlphabet.IsValid("{"));
Assert.AreEqual(isValid, defaultAlphabet.IsValid("?"));
Assert.AreEqual(isValid, defaultAlphabet.IsValid("["));
Assert.AreEqual(isValid, defaultAlphabet.IsValid("]"));
Assert.AreEqual(isValid, defaultAlphabet.IsValid("("));
Assert.AreEqual(isValid, defaultAlphabet.IsValid(")"));
Assert.AreEqual(isValid, defaultAlphabet.IsValid("|"));
Assert.AreEqual(isValid, defaultAlphabet.IsValid("."));
Assert.AreEqual(isValid, defaultAlphabet.IsValid("~"));
Assert.AreEqual(isValid, defaultAlphabet.IsValid("\\"));
}
public void ConstructorWithPattern_UsesCustomRandomGenerator_WhenCustomRandomGeneratorAndAlphabetProvidedProvided()
{
var alphabet = RegexAlphabetFactory.Minimal();
var primitiveParser = new PrimitiveParser(alphabet);
alphabet.Add("a", new CharacterParser(primitiveParser))
.Add("b", new CharacterParser(primitiveParser));
var random = Substitute.For <IRandomGenerator>();
random.GetNextInteger(Arg.Any <int>(), Arg.Any <int>()).Returns(1);
var regeseed = new RegSeed(random);
regeseed.TryLoadRegexPattern("[a-b]");
var result = regeseed.Generate();
Assert.AreEqual("b", result);
}
public void Generate_ReturnsExpectedResult_WhenRegexIsComplementOfCharacterClassWithInverseLength1AndContainingCharactersButA(string regexPattern, string expectedResult)
{
_random = new RandomGenerator(new Random());
var alphabet = RegexAlphabetFactory.Default();
var alphabetCharacters = alphabet.GetAllCharacters();
var alphabetAsString = alphabetCharacters.Aggregate(string.Empty, (current, character) => $"{current}\\{character}");
var alphabetWithoutF = alphabetAsString.Replace("\\F", string.Empty);
var alphabetWithoutR = alphabetAsString.Replace("\\R", string.Empty);
var regex = string.Format(regexPattern, alphabetWithoutF, alphabetWithoutR);
var regseed = new RegSeed(_random, alphabet).SetMaxCharClassInverseLength(1);
var loadResult = regseed.TryLoadRegexPattern(regex);
Assert.IsTrue(loadResult.IsSuccess, $"faulty pattern: {regex}");
var result = regseed.Generate();
Assert.AreEqual(expectedResult, result, regex);
}
public void Minimal_ReturnedAlphabetContainsOnlyRegexControlLetters()
{
var minimal = RegexAlphabetFactory.Minimal();
var result = minimal.GetAllCharacters();
Assert.True(result.Any(x => x.Equals("*")));
Assert.True(result.Any(x => x.Equals("+")));
Assert.True(result.Any(x => x.Equals("{")));
Assert.True(result.Any(x => x.Equals("?")));
Assert.True(result.Any(x => x.Equals("[")));
Assert.True(result.Any(x => x.Equals("]")));
Assert.True(result.Any(x => x.Equals("(")));
Assert.True(result.Any(x => x.Equals(")")));
Assert.True(result.Any(x => x.Equals("|")));
Assert.True(result.Any(x => x.Equals(".")));
Assert.True(result.Any(x => x.Equals("~")));
Assert.True(result.Any(x => x.Equals("\\")));
}
public void Default_ReturnedAlphabetContainsSpecialCharacter(char specialCharacter)
{
var alphabet = RegexAlphabetFactory.Default();
Assert.IsTrue(alphabet.IsValid(specialCharacter.ToString()));
}
public void Default_DoesNotThrow_WhenCalled()
{
Assert.DoesNotThrow(() => RegexAlphabetFactory.Default());
}
