private CharacterClassExpression ToCharacterClass(params string[] characters)
{
var charClass = new CharacterClassExpression(_alphabet, _randomGenerator, 1);
charClass.AddCharacters(characters.ToList());
return(charClass);
}
public void GetCharacter_ReturnsEmptyString_WhenCharacterClassIsEmpty()
{
var charClassEmpty = new CharacterClassExpression(_alphabet, _randomGenerator, _maxInverseLength);
var result = charClassEmpty.GetRandomCharacter();
Assert.AreEqual(string.Empty, result);
}
public void GetCharacterCount_ReturnsNumberOfPossibleGetCharacterOutComes(IList <string> characters, int expectedValue)
{
var charClass = new CharacterClassExpression(_alphabet, _random, _maxInverseLength);
charClass.AddCharacters(characters);
var result = charClass.GetCharacterCount();
Assert.AreEqual(expectedValue, result);
}
public void GetIntersection_ReturnsEmptyString_WhenCharacterClassContainsFfAndIsIntersectedWithNull()
{
var charClassFf = new CharacterClassExpression(_alphabet, _randomGenerator, _maxInverseLength);
charClassFf.AddCharacters(new List <string> {
"F", "f"
});
var result1 = charClassFf.GetIntersection(null).ToStringBuilder().GenerateString();
Assert.AreEqual(string.Empty, result1);
}
public void GetUnion_ReturnsCharactersJ_WhenCharacterClassContainsJndIsUnitedWithEmptyCharClass()
{
var charClassJA = new CharacterClassExpression(_alphabet, _randomGenerator, _maxInverseLength);
charClassJA.AddCharacters(new List <string> {
"J"
});
var result = charClassJA.GetUnion(new CharacterClassExpression(_alphabet, _randomGenerator, _maxInverseLength));
Assert.AreEqual("J", result.GetRandomCharacter());
}
public void Expand_ReturnsSingleElementListContainingStringBuilderRepresentingCharacterClass()
{
var charClass = new CharacterClassExpression(_alphabet, _random, _maxInverseLength);
charClass.AddCharacters(new List <string> {
"a"
});
var result = charClass.Expand();
Assert.AreEqual(1, result.Count);
Assert.AreEqual("a", result.FirstOrDefault()?.GenerateString());
}
public void GetCharacter_ReturnsFirstCharacter_WhenCharacterClassContainsSingleCharacter()
{
var charClassF = new CharacterClassExpression(_alphabet, _randomGenerator, _maxInverseLength);
charClassF.AddCharacters(new List <string> {
"F"
});
var result = charClassF.GetRandomCharacter();
Assert.AreEqual("F", result);
_randomGenerator.Received(0).GetNextInteger(Arg.Any <int>(), Arg.Any <int>());
}
private List <CharacterClassExpression> ToCharacterClassList(string returnValue)
{
return(returnValue.Select(x =>
{
var alphabet = Substitute.For <IParserAlphabet>();
alphabet.IsValid(Arg.Any <string>()).Returns(true);
var val = new CharacterClassExpression(alphabet, _randomGenerator, 0);
val.AddCharacters(new List <string> {
x.ToString()
});
return val;
}).ToList());
}
public void GetCharacter_ReturnsThirdCharacter_WhenCharacterClassContainsThreeCharactersAndRandomGeneratorReturns2()
{
_randomGenerator.GetNextInteger(Arg.Any <int>(), Arg.Any <int>()).Returns(2);
var charClassF = new CharacterClassExpression(_alphabet, _randomGenerator, _maxInverseLength);
charClassF.AddCharacters(new List <string> {
"F", "r", "a"
});
var result = charClassF.GetRandomCharacter();
Assert.AreEqual("a", result);
_randomGenerator.Received(1).GetNextInteger(Arg.Any <int>(), Arg.Any <int>());
}
protected override IStringBuilder ToSingleStringBuilder()
{
var alphabet = Substitute.For <IParserAlphabet>();
alphabet.IsValid(Arg.Any <string>()).Returns(true);
var charClass = new CharacterClassExpression(alphabet, _randomGenerator, _maxInverseLength);
charClass.AddCharacters(new List <string> {
"F"
});
return(new StringBuilder(new List <CharacterClassExpression> {
charClass
}));
}
public void SetUp()
{
_random = Substitute.For <IRandomGenerator>();
_random.GetNextInteger(Arg.Any <int>(), Arg.Any <int>()).Returns(0);
_alphabet = Substitute.For <IParserAlphabet>();
_alphabet.IsValid(Arg.Any <string>()).Returns(true);
_charClass1 = new CharacterClassExpression(_alphabet, _random, 1);
_charClass1.AddCharacters(new List <string> {
"a", "b", "c"
});
_charClass2 = new CharacterClassExpression(_alphabet, _random, 1);
_charClass2.AddCharacters(new List <string> {
"b", "c", "d"
});
}
public void GenerateString_ReturnsTwoAA_WhenBuilderContainsTwoCharacterClassesWithSingleCharacterA()
{
var charClass = new CharacterClassExpression(_alphabet, _random, 1);
charClass.AddCharacters(new List <string> {
"a"
});
var builder = new StringBuilder(new List <CharacterClassExpression> {
charClass, charClass
});
var result = builder.GenerateString();
Assert.AreEqual("aa", result);
}
public void GetInverse_ReturnsF_WhenCharacterClassContainsAllLettersButF()
{
_randomGenerator = new RandomGenerator(new Random());
_alphabet.GetAllCharacters().Returns(new List <string> {
"J", "F", "r", "a", "n"
});
var expression = new CharacterClassExpression(_alphabet, _randomGenerator, _maxInverseLength);
expression.AddCharacters(new List <string> {
"J", "r", "a", "n"
});
var complement = expression.GetInverse();
var result = complement.ToStringBuilder().GenerateString();
Assert.AreEqual("F", result);
}
public void GetIntersection_ReturnsEmptyString_WhenIntersectedCharacterClassesContainDifferentCharacters()
{
var charClassFr = new CharacterClassExpression(_alphabet, _randomGenerator, _maxInverseLength);
charClassFr.AddCharacters(new List <string> {
"F", "r"
});
var charClassJa = new CharacterClassExpression(_alphabet, _randomGenerator, _maxInverseLength);
charClassJa.AddCharacters(new List <string> {
"J", "a"
});
var result = charClassJa.GetIntersection(charClassFr).ToStringBuilder().GenerateString();
Assert.AreEqual(string.Empty, result);
}
public void GetIntersection_ReturnsF_WhenCharacterClassContainsFfAndIsIntersectedWithF()
{
var charClassFf = new CharacterClassExpression(_alphabet, _randomGenerator, _maxInverseLength);
charClassFf.AddCharacters(new List <string> {
"F", "f"
});
var charClassF = new CharacterClassExpression(_alphabet, _randomGenerator, _maxInverseLength);
charClassF.AddCharacters(new List <string> {
"F"
});
var result1 = charClassFf.GetIntersection(charClassF).ToStringBuilder().GenerateString();
var result2 = charClassF.GetIntersection(charClassFf).ToStringBuilder().GenerateString();
Assert.AreEqual("F", result1, "charClassFf.GetIntersection(charClassF)");
Assert.AreEqual("F", result2, "charClassF.GetIntersection(charClassFf)");
}
public void Clone_ReturnsNewConcatenationInstanceWithSameValues()
{
_randomGenerator.GetNextInteger(Arg.Any <int>(), Arg.Any <int>()).Returns(1);
var charClass = new CharacterClassExpression(_alphabet, _randomGenerator, 2)
{
RepeatRange = new IntegerInterval()
};
charClass.RepeatRange.TrySetValue(1, 3);
charClass.AddCharacters(new List <string> {
"f"
});
var result = charClass.Clone();
Assert.AreNotEqual(charClass, result);
Assert.AreEqual(charClass.RepeatRange.Start, result.RepeatRange.Start);
Assert.AreEqual(charClass.RepeatRange.End, result.RepeatRange.End);
Assert.AreEqual("f", result.ToStringBuilder().GenerateString());
}
public void GetUnion_ReturnsCharactersJAN_WhenCharacterClassContainsJAAndIsUnitedWithCharacterClassContainingAN()
{
var charClassJA = new CharacterClassExpression(_alphabet, _randomGenerator, _maxInverseLength);
charClassJA.AddCharacters(new List <string> {
"J", "A"
});
var charClassNA = new CharacterClassExpression(_alphabet, _randomGenerator, _maxInverseLength);
charClassNA.AddCharacters(new List <string> {
"N", "A"
});
var result = charClassJA.GetUnion(charClassNA);
_randomGenerator.GetNextInteger(Arg.Any <int>(), Arg.Any <int>()).Returns(0);
Assert.AreEqual("J", result.GetRandomCharacter());
_randomGenerator.GetNextInteger(Arg.Any <int>(), Arg.Any <int>()).Returns(1);
Assert.AreEqual("A", result.GetRandomCharacter());
_randomGenerator.GetNextInteger(Arg.Any <int>(), Arg.Any <int>()).Returns(2);
Assert.AreEqual("N", result.GetRandomCharacter());
}
public void Constructor_ThrowsArgumentNullException_WhenAlphabetIsNull()
{
Assert.Throws <ArgumentNullException>(() => _ = new CharacterClassExpression(null, _randomGenerator, _maxInverseLength));
}
