public void WhenMinIsLessThanMax_ThenReturnRandomLength()
{
var createdLen2 = false;
var createdLen3 = false;
using (var sut = new CryptoRandomString("A"))
{
for (var i = 0; i < 100; i++)
{
var result = sut.GenerateString(2, 3);
Assert.That(result, Is.EqualTo("AA").Or.EqualTo("AAA"));
if (result.Length == 2)
{
createdLen2 = true;
}
if (result.Length == 3)
{
createdLen3 = true;
}
}
}
Assert.That(createdLen2, Is.True);
Assert.That(createdLen3, Is.True);
}
public void WhenMinIsLessThanMax_ThenReturnRandomLength()
{
var createdLen2 = false;
var createdLen3 = false;
using (var sut = new CryptoRandomString("A"))
{
for (var i = 0; i < 100; i++)
{
var result = sut.GenerateArray(2, 3);
if (result.Length == 2)
{
createdLen2 = true;
Assert.That(result.First(), Is.EqualTo('A'));
Assert.That(result.Second(), Is.EqualTo('A'));
}
else if (result.Length == 3)
{
createdLen3 = true;
Assert.That(result.First(), Is.EqualTo('A'));
Assert.That(result.Second(), Is.EqualTo('A'));
Assert.That(result.Third(), Is.EqualTo('A'));
}
else
{
Assert.Fail($"Array was length {result.Length}.");
}
}
}
Assert.That(createdLen2, Is.True);
Assert.That(createdLen3, Is.True);
}
public void WhenMinIsGreaterThanMax_ThenThrowException()
{
using (var sut = new CryptoRandomString(CharacterSets.Digits))
{
Assert.Throws <ArgumentOutOfRangeException>(() => sut.GenerateString(2, 1));
}
}
public void TestTestThatCorrectCharacterCountIsReturned()
{
const int length = 100;
var randomString = CryptoRandomString.GetCryptoRandomBase95String(length);
Assert.AreEqual(length, randomString.Length);
}
public void WhenMinAndMaxIsEqual_ThenReturnValidString()
{
using (var sut = new CryptoRandomString("A"))
{
var result = sut.GenerateString(2, 2);
Assert.That(result, Is.EqualTo("AA"));
}
}
public void WhenMinAndMaxIsOne_ThenReturnOneLengthString()
{
using (var sut = new CryptoRandomString("A"))
{
var result = sut.GenerateString(1, 1);
Assert.That(result, Is.EqualTo("A"));
}
}
public void WhenOnlyOneValidChar_AndLengthOne_ThenReturnChar()
{
using (var sut = new CryptoRandomString("A"))
{
var result = sut.GenerateArray(1);
Assert.That(result.Single(), Is.EqualTo('A'));
}
}
public void WhenValidChars_ThenReturnOnlyValidChars()
{
using (var sut = new CryptoRandomString(CharacterSets.Digits))
{
var result = sut.GenerateArray(100);
Assert.That(result.IsDigitsOnly, Is.True);
}
}
public void WhenOnlyOneValidChar_ThenReturnSequenceOfChar()
{
using (var sut = new CryptoRandomString("A"))
{
var result = sut.GenerateString(3);
Assert.That(result, Is.EqualTo("AAA"));
}
}
public void WhenOnlyOneValidChar_AndLengthOne_ThenReturnOneCharString()
{
using (var sut = new CryptoRandomString("A"))
{
var result = sut.GenerateString(1);
Assert.That(result, Is.EqualTo("A"));
}
}
public void WhenLengthIsLessThanOne_ThenReturnEmpty(int length)
{
using (var sut = new CryptoRandomString("A"))
{
var result = sut.GenerateString(length);
Assert.That(result, Is.Empty);
}
}
public void WhenLengthIsLessThanOne_ThenReturnEmptyArray(int length)
{
using (var sut = new CryptoRandomString(CharacterSets.Digits))
{
var result = sut.GenerateArray(length);
Assert.That(result, Is.Empty);
}
}
public void WhenMinIsMinusAndMaxIsZero_ThenReturnEmpty()
{
using (var sut = new CryptoRandomString(CharacterSets.Digits))
{
var result = sut.GenerateArray(-1, 0);
Assert.That(result, Is.Empty);
}
}
public void WhenLongEnoughLength_ThenUsesValidCharsEdgeCases()
{
using (var sut = new CryptoRandomString(CharacterSets.Digits))
{
var result = sut.GenerateString(1000, 2000);
StringAssert.Contains(CharacterSets.Digits.First().ToString(), result);
StringAssert.Contains(CharacterSets.Digits.Last().ToString(), result);
}
}
public void GetCryptoRandomAlphaNumericStringTest()
{
const int length = 100000;
var randomString = CryptoRandomString.GetCryptoRandomAlphaNumericString(length);
foreach (char c in randomString)
{
Assert.IsTrue(CryptoRandomString.AlphaNumeric.Contains(c));
}
}
public void WhenLongEnoughLength_ThenUsesValidCharsEdgeCases()
{
using (var sut = new CryptoRandomString(CharacterSets.Digits))
{
var result = sut.GenerateArray(1000);
Assert.That(result.Contains(CharacterSets.Digits.First()), Is.True);
Assert.That(result.Contains(CharacterSets.Digits.Last()), Is.True);
}
}
public void TestPerformanceTenMillionCharacters()
{
Stopwatch watch = new Stopwatch();
watch.Start();
const int length = 1000000;
CryptoRandomString.GetCryptoRandomBase95String(length);
watch.Stop();
Assert.IsTrue(watch.ElapsedMilliseconds < 1000);
} // Elapsed Milliseconds 320 (it fluxuated a few milliseconds each run)
public void TestAllCharactersAreUsed()
{
const int length = 1000000;
var randomString = CryptoRandomString.GetCryptoRandomBase95String(length);
for (int i = 32; i < 126; i++)
{
char c = (char)i;
Assert.IsTrue(randomString.Contains(c.ToString()));
}
}
public void WhenValidLength_ThenReturnCorrectLength()
{
const int length = 50;
using (var sut = new CryptoRandomString(CharacterSets.Digits))
{
var result = sut.GenerateArray(length);
Assert.That(result.Length, Is.EqualTo(length));
}
}
public void WhenOnlyOneValidChar_ThenReturnSequenceOfChar()
{
using (var sut = new CryptoRandomString("A"))
{
var result = sut.GenerateArray(3);
Assert.That(result.First(), Is.EqualTo('A'));
Assert.That(result.Second(), Is.EqualTo('A'));
Assert.That(result.Third(), Is.EqualTo('A'));
}
}
public void WhenMinIsLessThanOneAndMaxIsZero_ThenReturnEmpty(int minLength)
{
using (var sut = new CryptoRandomString("A"))
{
for (var i = 0; i < 100; i++)
{
var result = sut.GenerateString(minLength, 0);
Assert.That(result, Is.Empty);
}
}
}
public void TestPerformanceLoop()
{
Stopwatch watch = new Stopwatch();
const int length = 16;
watch.Start();
for (int i = 0; i < 100000; i++)
{
CryptoRandomString.GetCryptoRandomBase95String(length);
}
watch.Stop();
Assert.IsTrue(watch.ElapsedMilliseconds < 1000);
}
public void TestDistributionInTenMillionCharacters()
{
const int length = 1000000;
const int distibution = length / 95;
int[] margins = new int[9500];
for (int j = 0; j < 100; j++)
{
var randomString = CryptoRandomString.GetCryptoRandomBase95String(length);
for (int i = 32; i < 127; i++)
{
//int count = randomString.Count(c => c == i);
int count = CountInstancesOfChar(randomString, (char)i);
margins[(j * 95) + i - 32] = count;
}
}
Assert.IsTrue(Math.Abs(margins.Average() - distibution) < .5);
}
public void WhenValidCharsStringIsNull_ThenThrowException()
{
Assert.Throws <ArgumentException>(() => _ = new CryptoRandomString(null));
}
public void WhenValidCharsStringIsEmpty_ThenThrowException()
{
Assert.Throws <ArgumentException>(() => _ = new CryptoRandomString(string.Empty));
}
