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 WhenMinIsGreaterThanMax_ThenThrowException()
 {
     using (var sut = new CryptoRandomString(CharacterSets.Digits))
     {
         Assert.Throws <ArgumentOutOfRangeException>(() => sut.GenerateString(2, 1));
     }
 }
            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 WhenValidChars_ThenReturnOnlyValidChars()
            {
                using (var sut = new CryptoRandomString(CharacterSets.Digits))
                {
                    var result = sut.GenerateString(100);

                    Assert.That(result.IsDigits(), 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 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 WhenValidLength_ThenReturnCorrectLength()
            {
                const int length = 50;

                using (var sut = new CryptoRandomString(CharacterSets.Digits))
                {
                    var result = sut.GenerateString(length);

                    Assert.That(result.Length, Is.EqualTo(length));
                }
            }
            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);
                    }
                }
            }