From 50177bd4ba2f81d5f4fdfc3cb9f51e2749d3126d Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sun, 23 Oct 2016 20:03:34 +0300 Subject: [PATCH 01/26] added tests --- .../Common/RandomExtensions/NextBoolTests.cs | 57 +++++++++++++++++++ .../Common/RandomExtensions/NextCharTests.cs | 20 +++++++ .../Common/RandomExtensions/NextDateTime.cs | 20 +++++++ .../RandomExtensions/NextDoubleTests.cs | 21 +++++++ .../RandomExtensions/NextStringTests.cs | 51 +++++++++++++++++ .../RandomExtensions/NextTimeSpanTests.cs | 20 +++++++ .../Common/RandomExtensions/OneOfTests.cs | 33 +++++++++++ .../MoreDotNet.Test/MoreDotNet.Tests.csproj | 7 +++ 8 files changed, 229 insertions(+) create mode 100644 Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs create mode 100644 Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs create mode 100644 Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs create mode 100644 Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs create mode 100644 Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs create mode 100644 Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs create mode 100644 Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs new file mode 100644 index 0000000..11e4b3f --- /dev/null +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs @@ -0,0 +1,57 @@ +namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions +{ + using System; + + using MoreDotNet.Extensions.Common; + + using Xunit; + + public class NextBoolTests + { + [Fact] + public void NextBool_ShouldReturnTrue() + { + var random = new Random(); + var result = random.NextBool(1); + + Assert.True(result); + } + + [Fact] + public void NextBool_ShouldReturnTrue_MoreThanOrEqualTo50Times() + { + var random = new Random(); + int counter = 0; + int count = 10; + for (int i = 0; i < count; i++) + { + int currentCount = 100; + int currentCounter = 0; + var nextBools = new bool[currentCount]; + for (int j = 0; j < currentCount; j++) + { + if (random.NextBool(0.5)) + { + currentCounter++; + } + } + + if (currentCount >= 50) + { + counter++; + } + } + + Assert.True(counter >= count / 2); + } + + [Fact] + public void NextBool_ShouldReturnFalse() + { + var random = new Random(); + var result = random.NextBool(0); + + Assert.False(result); + } + } +} diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs new file mode 100644 index 0000000..bcce391 --- /dev/null +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs @@ -0,0 +1,20 @@ +namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions +{ + using System; + + using MoreDotNet.Extensions.Common; + + using Xunit; + + public class NextCharTests + { + [Fact] + public void NextChar_ShouldReturnChar() + { + var random = new Random(); + var result = random.NextChar(); + + Assert.IsType(result); + } + } +} diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs new file mode 100644 index 0000000..7195847 --- /dev/null +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs @@ -0,0 +1,20 @@ +namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions +{ + using System; + + using MoreDotNet.Extensions.Common; + + using Xunit; + + public class NextDateTime + { + [Fact] + public void NextDateTime_ShouldReturnDateTime() + { + var random = new Random(); + var result = random.NextDateTime(); + + Assert.IsType(result); + } + } +} diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs new file mode 100644 index 0000000..85bb73b --- /dev/null +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs @@ -0,0 +1,21 @@ +namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions +{ + using System; + + using MoreDotNet.Extensions.Common; + + using Xunit; + + public class NextDoubleTests + { + [Fact] + public void NextDouble_ShouldReturnDoubleBetweenZeroAndTen() + { + var random = new Random(); + var result = random.NextDouble(0, 10); + + Assert.IsType(result); + Assert.True(result >= 0 && result < 10); + } + } +} diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs new file mode 100644 index 0000000..166c664 --- /dev/null +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs @@ -0,0 +1,51 @@ +namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions +{ + using System; + + using MoreDotNet.Extensions.Common; + + using Xunit; + + public class NextStringTests + { + [Fact] + public void NextString_ShouldReturnStringWithLenghtZero() + { + var zero = 0; + var random = new Random(); + var result = random.NextString(zero); + + Assert.IsType(result); + Assert.Equal(zero, result.Length); + } + + [Fact] + public void NextString_ShouldReturnStringWithLenghtFiveChars() + { + var length = 5; + + var random = new Random(); + var result = random.NextString(length); + + Assert.IsType(result); + Assert.Equal(length, result.Length); + } + + [Fact] + public void NextString_ShouldReturnStringContainingOnlyNumericsWithLenghtFiveChars() + { + var length = 5; + + var random = new Random(); + var result = random.NextString(length, MoreDotNet.Models.CharType.Numeric); + + Assert.IsType(result); + Assert.Equal(length, result.Length); + for (int i = 0; i < length; i++) + { + var currentChar = (char)result[i]; + Assert.True(currentChar > 48 && currentChar < 58); + } + } + } +} diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs new file mode 100644 index 0000000..29ca8c5 --- /dev/null +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs @@ -0,0 +1,20 @@ +namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions +{ + using System; + + using MoreDotNet.Extensions.Common; + + using Xunit; + + public class NextTimeSpanTests + { + [Fact] + public void NextTimeSpan_ShouldReturnTimeSpan() + { + var random = new Random(); + var result = random.NextTimeSpan(); + + Assert.IsType(result); + } + } +} diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs new file mode 100644 index 0000000..bb3d8ff --- /dev/null +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs @@ -0,0 +1,33 @@ +namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions +{ + using System; + using System.Collections.Generic; + using System.Linq; + + using MoreDotNet.Extensions.Common; + + using Xunit; + + public class OneOfTests + { + [Fact] + public void OneOf_ShouldReturnOneOfIntArray() + { + var random = new Random(); + var numbers = new[] { 1, 2, 3, 4, 5, 6 }; + var number = random.OneOf(numbers); + + Assert.True(numbers.Contains(number)); + } + + [Fact] + public void OneOf_ShouldReturnOneOfIntCollection() + { + var random = new Random(); + var numbers = new List { 1, 2, 3, 4, 5, 6 }; + var number = random.OneOf(numbers); + + Assert.True(numbers.Contains(number)); + } + } +} diff --git a/Source/MoreDotNet.Test/MoreDotNet.Tests.csproj b/Source/MoreDotNet.Test/MoreDotNet.Tests.csproj index d4147bd..3d70cb9 100644 --- a/Source/MoreDotNet.Test/MoreDotNet.Tests.csproj +++ b/Source/MoreDotNet.Test/MoreDotNet.Tests.csproj @@ -125,6 +125,13 @@ + + + + + + + From f1f7bccec6f2280934829b6e681a85bc8298716a Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sun, 23 Oct 2016 21:00:38 +0300 Subject: [PATCH 02/26] added next char tests --- .../Common/RandomExtensions/NextCharTests.cs | 121 +++++++++++++++++- 1 file changed, 120 insertions(+), 1 deletion(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs index bcce391..3b975b4 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs @@ -2,8 +2,8 @@ { using System; + using Moq; using MoreDotNet.Extensions.Common; - using Xunit; public class NextCharTests @@ -16,5 +16,124 @@ public void NextChar_ShouldReturnChar() Assert.IsType(result); } + + [Fact] + public void NextChar_ShoudReturnChar_CapitalLetter() + { + char mockedResult = 'A'; + var randomMock = new Mock(); + randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); + randomMock.Setup(r => r.NextDouble()).Returns(0.168); + char result = randomMock.Object.NextChar(); + + Assert.Equal((int)mockedResult, (int)result); + } + + [Fact] + public void NextChar_ShoudReturnChar_Number() + { + char mockedResult = '1'; + var randomMock = new Mock(); + randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); + randomMock.Setup(r => r.NextDouble()).Returns(0.15); + char result = randomMock.Object.NextChar(); + + Assert.Equal((int)mockedResult, (int)result); + } + + [Fact] + public void NextChar_ShoudReturnChar_AlphabeticLower() + { + char mockedResult = 'a'; + var randomMock = new Mock(); + randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); + randomMock.Setup(r => r.NextDouble()).Returns(0.51); + char result = randomMock.Object.NextChar(MoreDotNet.Models.CharType.AlphabeticLower); + + Assert.Equal((int)mockedResult, (int)result); + } + + [Fact] + public void NextChar_ShoudReturnChar_AlphabeticUpper() + { + char mockedResult = 'A'; + var randomMock = new Mock(); + randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); + randomMock.Setup(r => r.NextDouble()).Returns(0.49); + char result = randomMock.Object.NextChar(MoreDotNet.Models.CharType.AlphabeticUpper); + + Assert.Equal((int)mockedResult, (int)result); + } + + [Fact] + public void NextChar_ShoudReturnChar_AlphabeticAny() + { + char mockedResult = 'A'; + var randomMock = new Mock(); + randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); + randomMock.Setup(r => r.NextDouble()).Returns(0.49); + char result = randomMock.Object.NextChar(MoreDotNet.Models.CharType.AlphabeticAny); + + Assert.Equal((int)mockedResult, (int)result); + } + + [Fact] + public void NextChar_ShoudReturnChar_AlphanumericAny() + { + char mockedResult = 'A'; + var randomMock = new Mock(); + randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); + randomMock.Setup(r => r.NextDouble()).Returns(0.49); + char result = randomMock.Object.NextChar(MoreDotNet.Models.CharType.AlphanumericAny); + + Assert.Equal((int)mockedResult, (int)result); + } + + [Fact] + public void NextChar_ShoudReturnChar_AlphanumericLower() + { + char mockedResult = 'a'; + var randomMock = new Mock(); + randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); + randomMock.Setup(r => r.NextDouble()).Returns(0.51); + char result = randomMock.Object.NextChar(MoreDotNet.Models.CharType.AlphanumericLower); + + Assert.Equal((int)mockedResult, (int)result); + } + + [Fact] + public void NextChar_ShoudReturnChar_AlphanumericUpper() + { + char mockedResult = 'A'; + var randomMock = new Mock(); + randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); + randomMock.Setup(r => r.NextDouble()).Returns(0.49); + char result = randomMock.Object.NextChar(MoreDotNet.Models.CharType.AlphanumericUpper); + + Assert.Equal((int)mockedResult, (int)result); + } + + [Fact] + public void NextChar_ShoudReturnChar_Numeric() + { + char mockedResult = '2'; + var randomMock = new Mock(); + randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); + randomMock.Setup(r => r.NextDouble()).Returns(0.1); + char result = randomMock.Object.NextChar(MoreDotNet.Models.CharType.Numeric); + + Assert.Equal((int)mockedResult, (int)result); + } + + [Fact] + public void NextChar_ShoudReturnChar_AnyUnicode() + { + char mockedResult = '2'; + var randomMock = new Mock(); + randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); + char result = randomMock.Object.NextChar(MoreDotNet.Models.CharType.AnyUnicode); + + Assert.Equal((int)mockedResult, (int)result); + } } } From 7a7f6404e457c6030dbc4a2f7ab0186a168a956a Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sun, 23 Oct 2016 21:17:17 +0300 Subject: [PATCH 03/26] added next datetime test --- .../Common/RandomExtensions/NextDateTime.cs | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs index 7195847..c6fe18d 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs @@ -1,9 +1,9 @@ namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions { using System; + using System.Linq; using MoreDotNet.Extensions.Common; - using Xunit; public class NextDateTime @@ -16,5 +16,19 @@ public void NextDateTime_ShouldReturnDateTime() Assert.IsType(result); } + + [Fact] + public void NextDateTime_ShouldReturnDateTime_NewYear() + { + var random = new Random(); + var counter = 100; + var dates = new DateTime[counter]; + for (int i = 0; i < counter; i++) + { + dates[i] = random.NextDateTime(); + } + + Assert.Equal(counter, dates.Distinct().Count()); + } } } From b2aa8b423caae6acd6eee4c96a9b8d5335fe019d Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sun, 23 Oct 2016 21:31:10 +0300 Subject: [PATCH 04/26] added next double tests --- .../RandomExtensions/NextDoubleTests.cs | 22 +++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs index 85bb73b..93dc817 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs @@ -2,20 +2,38 @@ { using System; + using Moq; using MoreDotNet.Extensions.Common; - using Xunit; public class NextDoubleTests { [Fact] - public void NextDouble_ShouldReturnDoubleBetweenZeroAndTen() + public void NextDouble_ShouldReturnDouble() { var random = new Random(); var result = random.NextDouble(0, 10); Assert.IsType(result); + } + + [Fact] + public void NextDouble_ShouldReturnDouble_BetweenZeroAndTen() + { + var random = new Random(); + var result = random.NextDouble(0, 10); + Assert.True(result >= 0 && result < 10); } + + [Fact] + public void NextDouble_ShouldReturnDouble_Zero() + { + var randomMock = new Mock(); + randomMock.Setup(r => r.NextDouble()).Returns(0); + var result = randomMock.Object.NextDouble(0, double.MaxValue); + + Assert.Equal(0, result); + } } } From 0c6eab3221565d96884857a793a67f892abfc039 Mon Sep 17 00:00:00 2001 From: georgimanov Date: Mon, 24 Oct 2016 22:21:56 +0300 Subject: [PATCH 05/26] added next string and next datetime tests --- .../Common/RandomExtensions/NextDateTime.cs | 13 +- .../RandomExtensions/NextStringTests.cs | 120 +++++++++++++++++- 2 files changed, 127 insertions(+), 6 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs index c6fe18d..98b3ce3 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs @@ -18,7 +18,7 @@ public void NextDateTime_ShouldReturnDateTime() } [Fact] - public void NextDateTime_ShouldReturnDateTime_NewYear() + public void NextDateTime_ShouldReturnDateTime_OneHundredDistinctValues() { var random = new Random(); var counter = 100; @@ -30,5 +30,16 @@ public void NextDateTime_ShouldReturnDateTime_NewYear() Assert.Equal(counter, dates.Distinct().Count()); } + + [Fact] + public void NextDateTime_ShouldReturnDateTime_BetweenMinAndMaxValue() + { + var random = new Random(); + var mivValue = new DateTime(2016, 1, 1, 0, 0, 0); + var maxValue = new DateTime(2018, 1, 1, 0, 0, 0); + var result = random.NextDateTime(mivValue, maxValue); + + Assert.True(result > mivValue && result < maxValue); + } } } diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs index 166c664..fbe58b1 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs @@ -3,7 +3,6 @@ using System; using MoreDotNet.Extensions.Common; - using Xunit; public class NextStringTests @@ -20,7 +19,7 @@ public void NextString_ShouldReturnStringWithLenghtZero() } [Fact] - public void NextString_ShouldReturnStringWithLenghtFiveChars() + public void NextString_ShouldReturnString_WithLenghtFiveChars() { var length = 5; @@ -32,7 +31,119 @@ public void NextString_ShouldReturnStringWithLenghtFiveChars() } [Fact] - public void NextString_ShouldReturnStringContainingOnlyNumericsWithLenghtFiveChars() + public void NextString_ShouldReturnString_OfAlphabeticChars() + { + var length = 100; + + var random = new Random(); + var result = random.NextString(length, MoreDotNet.Models.CharType.AlphabeticAny); + + Assert.IsType(result); + Assert.Equal(length, result.Length); + for (int i = 0; i < length; i++) + { + Assert.True(char.IsLetter(result[i])); + } + } + + [Fact] + public void NextString_ShouldReturnString_OfAlphabeticLowerChars() + { + var length = 100; + + var random = new Random(); + var result = random.NextString(length, MoreDotNet.Models.CharType.AlphabeticLower); + + Assert.IsType(result); + Assert.Equal(length, result.Length); + for (int i = 0; i < length; i++) + { + Assert.True(char.IsLower(result[i])); + } + } + + [Fact] + public void NextString_ShouldReturnString_OfAlphabeticUpperChars() + { + var length = 100; + + var random = new Random(); + var result = random.NextString(length, MoreDotNet.Models.CharType.AlphabeticUpper); + + Assert.IsType(result); + Assert.Equal(length, result.Length); + for (int i = 0; i < length; i++) + { + Assert.True(char.IsUpper(result[i])); + } + } + + [Fact] + public void NextString_ShouldReturnString_OfAlphanumericChars() + { + var length = 100; + + var random = new Random(); + var result = random.NextString(length, MoreDotNet.Models.CharType.AlphanumericAny); + + Assert.IsType(result); + Assert.Equal(length, result.Length); + for (int i = 0; i < length; i++) + { + Assert.True(char.IsLetterOrDigit(result[i])); + } + } + + [Fact] + public void NextString_ShouldReturnString_OfAlphanumericLowerChars() + { + var length = 100; + + var random = new Random(); + var result = random.NextString(length, MoreDotNet.Models.CharType.AlphanumericLower); + + Assert.IsType(result); + Assert.Equal(length, result.Length); + for (int i = 0; i < length; i++) + { + Assert.True(char.IsLetterOrDigit(result[i]) && char.IsLower(result[i])); + } + } + + [Fact] + public void NextString_ShouldReturnString_OfAlphanumericUpperChars() + { + var length = 100; + + var random = new Random(); + var result = random.NextString(length, MoreDotNet.Models.CharType.AlphanumericUpper); + + Assert.IsType(result); + Assert.Equal(length, result.Length); + for (int i = 0; i < length; i++) + { + Assert.True(char.IsLetterOrDigit(result[i]) && char.IsUpper(result[i])); + } + } + + [Fact] + public void NextString_ShouldReturnString_OfAnyUnicodeChars() + { + var length = 100; + + var random = new Random(); + var result = random.NextString(length, MoreDotNet.Models.CharType.AnyUnicode); + + Assert.IsType(result); + Assert.Equal(length, result.Length); + for (int i = 0; i < length; i++) + { + Assert.True(result[i] >= 0 && result[i] < 65536); + } + } + + [Fact] + public void NextString_ShouldReturnString_OfNumericChars() { var length = 5; @@ -43,8 +154,7 @@ public void NextString_ShouldReturnStringContainingOnlyNumericsWithLenghtFiveCha Assert.Equal(length, result.Length); for (int i = 0; i < length; i++) { - var currentChar = (char)result[i]; - Assert.True(currentChar > 48 && currentChar < 58); + Assert.True(char.IsNumber(result[i])); } } } From 6a21b4f460d9599aff18149951231630aa75958a Mon Sep 17 00:00:00 2001 From: georgimanov Date: Tue, 25 Oct 2016 00:06:58 +0300 Subject: [PATCH 06/26] edited tests --- .../Common/RandomExtensions/NextCharTests.cs | 12 +++ .../Common/RandomExtensions/NextDateTime.cs | 7 +- .../RandomExtensions/NextDoubleTests.cs | 23 ++++- .../RandomExtensions/NextStringTests.cs | 99 +++++++++---------- .../RandomExtensions/NextTimeSpanTests.cs | 1 + .../Common/RandomExtensions/OneOfTests.cs | 2 + .../Extensions/Common/RandomExtensions.cs | 21 +++- 7 files changed, 106 insertions(+), 59 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs index 3b975b4..2a249fb 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs @@ -4,11 +4,13 @@ using Moq; using MoreDotNet.Extensions.Common; + using Xunit; public class NextCharTests { [Fact] + [MemberData(nameof(Random))] public void NextChar_ShouldReturnChar() { var random = new Random(); @@ -18,6 +20,7 @@ public void NextChar_ShouldReturnChar() } [Fact] + [MemberData(nameof(Random))] public void NextChar_ShoudReturnChar_CapitalLetter() { char mockedResult = 'A'; @@ -30,6 +33,7 @@ public void NextChar_ShoudReturnChar_CapitalLetter() } [Fact] + [MemberData(nameof(Random))] public void NextChar_ShoudReturnChar_Number() { char mockedResult = '1'; @@ -42,6 +46,7 @@ public void NextChar_ShoudReturnChar_Number() } [Fact] + [MemberData(nameof(Random))] public void NextChar_ShoudReturnChar_AlphabeticLower() { char mockedResult = 'a'; @@ -54,6 +59,7 @@ public void NextChar_ShoudReturnChar_AlphabeticLower() } [Fact] + [MemberData(nameof(Random))] public void NextChar_ShoudReturnChar_AlphabeticUpper() { char mockedResult = 'A'; @@ -66,6 +72,7 @@ public void NextChar_ShoudReturnChar_AlphabeticUpper() } [Fact] + [MemberData(nameof(Random))] public void NextChar_ShoudReturnChar_AlphabeticAny() { char mockedResult = 'A'; @@ -78,6 +85,7 @@ public void NextChar_ShoudReturnChar_AlphabeticAny() } [Fact] + [MemberData(nameof(Random))] public void NextChar_ShoudReturnChar_AlphanumericAny() { char mockedResult = 'A'; @@ -90,6 +98,7 @@ public void NextChar_ShoudReturnChar_AlphanumericAny() } [Fact] + [MemberData(nameof(Random))] public void NextChar_ShoudReturnChar_AlphanumericLower() { char mockedResult = 'a'; @@ -102,6 +111,7 @@ public void NextChar_ShoudReturnChar_AlphanumericLower() } [Fact] + [MemberData(nameof(Random))] public void NextChar_ShoudReturnChar_AlphanumericUpper() { char mockedResult = 'A'; @@ -114,6 +124,7 @@ public void NextChar_ShoudReturnChar_AlphanumericUpper() } [Fact] + [MemberData(nameof(Random))] public void NextChar_ShoudReturnChar_Numeric() { char mockedResult = '2'; @@ -126,6 +137,7 @@ public void NextChar_ShoudReturnChar_Numeric() } [Fact] + [MemberData(nameof(Random))] public void NextChar_ShoudReturnChar_AnyUnicode() { char mockedResult = '2'; diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs index 98b3ce3..8422032 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs @@ -4,11 +4,13 @@ using System.Linq; using MoreDotNet.Extensions.Common; + using Xunit; public class NextDateTime { [Fact] + [MemberData(nameof(Random))] public void NextDateTime_ShouldReturnDateTime() { var random = new Random(); @@ -18,8 +20,10 @@ public void NextDateTime_ShouldReturnDateTime() } [Fact] + [MemberData(nameof(Random))] public void NextDateTime_ShouldReturnDateTime_OneHundredDistinctValues() { + // TODO: Fix test var random = new Random(); var counter = 100; var dates = new DateTime[counter]; @@ -32,6 +36,7 @@ public void NextDateTime_ShouldReturnDateTime_OneHundredDistinctValues() } [Fact] + [MemberData(nameof(Random))] public void NextDateTime_ShouldReturnDateTime_BetweenMinAndMaxValue() { var random = new Random(); @@ -39,7 +44,7 @@ public void NextDateTime_ShouldReturnDateTime_BetweenMinAndMaxValue() var maxValue = new DateTime(2018, 1, 1, 0, 0, 0); var result = random.NextDateTime(mivValue, maxValue); - Assert.True(result > mivValue && result < maxValue); + Assert.True(result >= mivValue && result < maxValue); } } } diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs index 93dc817..501b664 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs @@ -4,11 +4,13 @@ using Moq; using MoreDotNet.Extensions.Common; + using Xunit; public class NextDoubleTests { [Fact] + [MemberData(nameof(Random))] public void NextDouble_ShouldReturnDouble() { var random = new Random(); @@ -18,15 +20,20 @@ public void NextDouble_ShouldReturnDouble() } [Fact] + [MemberData(nameof(Random))] public void NextDouble_ShouldReturnDouble_BetweenZeroAndTen() { var random = new Random(); - var result = random.NextDouble(0, 10); + for (int i = 0; i < 1000; i++) + { + var result = random.NextDouble(0, 10); - Assert.True(result >= 0 && result < 10); + Assert.True(result >= 0 && result < 10); + } } [Fact] + [MemberData(nameof(Random))] public void NextDouble_ShouldReturnDouble_Zero() { var randomMock = new Mock(); @@ -35,5 +42,17 @@ public void NextDouble_ShouldReturnDouble_Zero() Assert.Equal(0, result); } + + [Fact] + [MemberData(nameof(Random))] + public void NextDouble_ShouldReturnDouble_PredifinedValue() + { + var expectedResult = 12.8951; + var randomMock = new Mock(); + randomMock.Setup(r => r.NextDouble()).Returns(expectedResult); + var result = randomMock.Object.NextDouble(0, double.MaxValue); + + Assert.Equal(expectedResult, result); + } } } diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs index fbe58b1..b0ab46a 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs @@ -3,156 +3,153 @@ using System; using MoreDotNet.Extensions.Common; + using Xunit; public class NextStringTests { + private const int Zero = 0; + private const int OneHundred = 100; + [Fact] + [MemberData(nameof(Random))] public void NextString_ShouldReturnStringWithLenghtZero() { - var zero = 0; var random = new Random(); - var result = random.NextString(zero); + var result = random.NextString(Zero); Assert.IsType(result); - Assert.Equal(zero, result.Length); + Assert.Equal(Zero, result.Length); } [Fact] - public void NextString_ShouldReturnString_WithLenghtFiveChars() + [MemberData(nameof(Random))] + public void NextString_ShouldReturnString_WithLenght100Chars() { - var length = 5; - var random = new Random(); - var result = random.NextString(length); + var result = random.NextString(OneHundred); Assert.IsType(result); - Assert.Equal(length, result.Length); + Assert.Equal(OneHundred, result.Length); } [Fact] + [MemberData(nameof(Random))] public void NextString_ShouldReturnString_OfAlphabeticChars() { - var length = 100; - var random = new Random(); - var result = random.NextString(length, MoreDotNet.Models.CharType.AlphabeticAny); + var result = random.NextString(OneHundred, MoreDotNet.Models.CharType.AlphabeticAny); Assert.IsType(result); - Assert.Equal(length, result.Length); - for (int i = 0; i < length; i++) + Assert.Equal(OneHundred, result.Length); + for (int i = 0; i < OneHundred; i++) { Assert.True(char.IsLetter(result[i])); } } [Fact] + [MemberData(nameof(Random))] public void NextString_ShouldReturnString_OfAlphabeticLowerChars() { - var length = 100; - var random = new Random(); - var result = random.NextString(length, MoreDotNet.Models.CharType.AlphabeticLower); + var result = random.NextString(OneHundred, MoreDotNet.Models.CharType.AlphabeticLower); Assert.IsType(result); - Assert.Equal(length, result.Length); - for (int i = 0; i < length; i++) + Assert.Equal(OneHundred, result.Length); + for (int i = 0; i < OneHundred; i++) { Assert.True(char.IsLower(result[i])); } } [Fact] + [MemberData(nameof(Random))] public void NextString_ShouldReturnString_OfAlphabeticUpperChars() { - var length = 100; - var random = new Random(); - var result = random.NextString(length, MoreDotNet.Models.CharType.AlphabeticUpper); + var result = random.NextString(OneHundred, MoreDotNet.Models.CharType.AlphabeticUpper); Assert.IsType(result); - Assert.Equal(length, result.Length); - for (int i = 0; i < length; i++) + Assert.Equal(OneHundred, result.Length); + for (int i = 0; i < OneHundred; i++) { Assert.True(char.IsUpper(result[i])); } } [Fact] + [MemberData(nameof(Random))] public void NextString_ShouldReturnString_OfAlphanumericChars() { - var length = 100; - var random = new Random(); - var result = random.NextString(length, MoreDotNet.Models.CharType.AlphanumericAny); + var result = random.NextString(OneHundred, MoreDotNet.Models.CharType.AlphanumericAny); Assert.IsType(result); - Assert.Equal(length, result.Length); - for (int i = 0; i < length; i++) + Assert.Equal(OneHundred, result.Length); + for (int i = 0; i < OneHundred; i++) { Assert.True(char.IsLetterOrDigit(result[i])); } } [Fact] + [MemberData(nameof(Random))] public void NextString_ShouldReturnString_OfAlphanumericLowerChars() { - var length = 100; - var random = new Random(); - var result = random.NextString(length, MoreDotNet.Models.CharType.AlphanumericLower); + var result = random.NextString(OneHundred, MoreDotNet.Models.CharType.AlphanumericLower); Assert.IsType(result); - Assert.Equal(length, result.Length); - for (int i = 0; i < length; i++) + Assert.Equal(OneHundred, result.Length); + for (int i = 0; i < OneHundred; i++) { - Assert.True(char.IsLetterOrDigit(result[i]) && char.IsLower(result[i])); + var currentChar = result[i]; + Assert.True((currentChar >= 48 && currentChar < 58) || (currentChar >= 97 && currentChar < 123)); } } [Fact] + [MemberData(nameof(Random))] public void NextString_ShouldReturnString_OfAlphanumericUpperChars() { - var length = 100; - var random = new Random(); - var result = random.NextString(length, MoreDotNet.Models.CharType.AlphanumericUpper); + var result = random.NextString(OneHundred, MoreDotNet.Models.CharType.AlphanumericUpper); Assert.IsType(result); - Assert.Equal(length, result.Length); - for (int i = 0; i < length; i++) + Assert.Equal(OneHundred, result.Length); + for (int i = 0; i < OneHundred; i++) { - Assert.True(char.IsLetterOrDigit(result[i]) && char.IsUpper(result[i])); + var currentChar = result[i]; + Assert.True((currentChar >= 48 && currentChar < 58) || (currentChar >= 65 && currentChar < 91)); } } [Fact] + [MemberData(nameof(Random))] public void NextString_ShouldReturnString_OfAnyUnicodeChars() { - var length = 100; - - var random = new Random(); - var result = random.NextString(length, MoreDotNet.Models.CharType.AnyUnicode); + var random = new Random(); + var result = random.NextString(OneHundred, MoreDotNet.Models.CharType.AnyUnicode); Assert.IsType(result); - Assert.Equal(length, result.Length); - for (int i = 0; i < length; i++) + Assert.Equal(OneHundred, result.Length); + for (int i = 0; i < OneHundred; i++) { Assert.True(result[i] >= 0 && result[i] < 65536); } } [Fact] + [MemberData(nameof(Random))] public void NextString_ShouldReturnString_OfNumericChars() { - var length = 5; - var random = new Random(); - var result = random.NextString(length, MoreDotNet.Models.CharType.Numeric); + var result = random.NextString(OneHundred, MoreDotNet.Models.CharType.Numeric); Assert.IsType(result); - Assert.Equal(length, result.Length); - for (int i = 0; i < length; i++) + Assert.Equal(OneHundred, result.Length); + for (int i = 0; i < OneHundred; i++) { Assert.True(char.IsNumber(result[i])); } diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs index 29ca8c5..53eef3a 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs @@ -9,6 +9,7 @@ public class NextTimeSpanTests { [Fact] + [MemberData(nameof(Random))] public void NextTimeSpan_ShouldReturnTimeSpan() { var random = new Random(); diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs index bb3d8ff..05a2f36 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs @@ -11,6 +11,7 @@ public class OneOfTests { [Fact] + [MemberData(nameof(Random))] public void OneOf_ShouldReturnOneOfIntArray() { var random = new Random(); @@ -21,6 +22,7 @@ public void OneOf_ShouldReturnOneOfIntArray() } [Fact] + [MemberData(nameof(Random))] public void OneOf_ShouldReturnOneOfIntCollection() { var random = new Random(); diff --git a/Source/MoreDotNet/Extensions/Common/RandomExtensions.cs b/Source/MoreDotNet/Extensions/Common/RandomExtensions.cs index 8370c86..969734a 100644 --- a/Source/MoreDotNet/Extensions/Common/RandomExtensions.cs +++ b/Source/MoreDotNet/Extensions/Common/RandomExtensions.cs @@ -78,7 +78,9 @@ public static bool NextBool(this Random random, double probability = 0.5) throw new ArgumentNullException(nameof(random)); } - return random.NextDouble() <= probability; + var nextBool = random.NextDouble() <= probability; + + return nextBool; } /// @@ -301,10 +303,14 @@ private static char NextAlphanumericChar(this Random random) if (numeric) { - return random.NextNumericChar(); + var number = random.NextNumericChar(); + + return number; } - return random.NextAlphabeticChar(random.NextBool()); + var aphabeticChar = random.NextAlphabeticChar(random.NextBool()); + + return aphabeticChar; } private static char NextAlphabeticChar(this Random random, bool uppercase) @@ -314,12 +320,17 @@ private static char NextAlphabeticChar(this Random random, bool uppercase) throw new ArgumentNullException(nameof(random)); } + char alphabeticChar; if (uppercase) { - return (char)random.Next(65, 91); + alphabeticChar = (char)random.Next(65, 91); + + return alphabeticChar; } - return (char)random.Next(97, 123); + alphabeticChar = (char)random.Next(97, 123); + + return alphabeticChar; } private static char NextAlphabeticChar(this Random random) From c637921fc7f522fffd85ed40b7012ca242bf3cda Mon Sep 17 00:00:00 2001 From: Georgi Manov Date: Fri, 28 Oct 2016 12:20:43 +0300 Subject: [PATCH 07/26] fixed NextBoolTests --- .../Common/RandomExtensions/NextBoolTests.cs | 31 +++++++++---------- 1 file changed, 14 insertions(+), 17 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs index 11e4b3f..5aec90c 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs @@ -1,4 +1,4 @@ -namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions +namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions { using System; @@ -8,6 +8,14 @@ public class NextBoolTests { + [Fact] + public void NextBool_ShouldReturnArgumentException() + { + Random random = null; + + Assert.Throws(() => random.Next()); + } + [Fact] public void NextBool_ShouldReturnTrue() { @@ -21,28 +29,17 @@ public void NextBool_ShouldReturnTrue() public void NextBool_ShouldReturnTrue_MoreThanOrEqualTo50Times() { var random = new Random(); - int counter = 0; - int count = 10; + int returnedTrueAsResult = 0; + int count = 1000; for (int i = 0; i < count; i++) { - int currentCount = 100; - int currentCounter = 0; - var nextBools = new bool[currentCount]; - for (int j = 0; j < currentCount; j++) - { - if (random.NextBool(0.5)) - { - currentCounter++; - } - } - - if (currentCount >= 50) + if (random.NextBool()) { - counter++; + returnedTrueAsResult++; } } - Assert.True(counter >= count / 2); + Assert.True(returnedTrueAsResult >= count / 2); } [Fact] From fb53b5be8be18a5e83c78636eaf5688e5f748f19 Mon Sep 17 00:00:00 2001 From: Georgi Manov Date: Fri, 28 Oct 2016 12:22:21 +0300 Subject: [PATCH 08/26] fixed naming --- .../Extensions/Common/RandomExtensions/NextBoolTests.cs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs index 5aec90c..9362338 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs @@ -9,7 +9,7 @@ namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions public class NextBoolTests { [Fact] - public void NextBool_ShouldReturnArgumentException() + public void NextBool_ShouldHThrow_NullReferenceException() { Random random = null; @@ -17,7 +17,7 @@ public void NextBool_ShouldReturnArgumentException() } [Fact] - public void NextBool_ShouldReturnTrue() + public void NextBool_ShouldReturn_True() { var random = new Random(); var result = random.NextBool(1); @@ -43,7 +43,7 @@ public void NextBool_ShouldReturnTrue_MoreThanOrEqualTo50Times() } [Fact] - public void NextBool_ShouldReturnFalse() + public void NextBool_ShouldReturn_False() { var random = new Random(); var result = random.NextBool(0); From 5398a4ba38793e69297afcb53637f0a7a09e20ab Mon Sep 17 00:00:00 2001 From: Georgi Manov Date: Fri, 28 Oct 2016 13:11:44 +0300 Subject: [PATCH 09/26] edited NextCharTests --- .../Common/RandomExtensions/NextCharTests.cs | 140 +++++------------- 1 file changed, 40 insertions(+), 100 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs index 80ae5c1..dc204d3 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs @@ -1,140 +1,80 @@ -namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions +namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions { using System; using Moq; using MoreDotNet.Extensions.Common; - + using MoreDotNet.Models; using Xunit; public class NextCharTests { [Fact] - public void NextChar_ShouldReturnChar() - { - var random = new Random(); - var result = random.NextChar(); - - Assert.IsType(result); - } - - [Fact] - public void NextChar_ShoudReturnChar_CapitalLetter() - { - char mockedResult = 'A'; - var randomMock = new Mock(); - randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); - randomMock.Setup(r => r.NextDouble()).Returns(0.168); - char result = randomMock.Object.NextChar(); - - Assert.Equal((int)mockedResult, (int)result); - } - - [Fact] - public void NextChar_ShoudReturnChar_Number() - { - char mockedResult = '1'; - var randomMock = new Mock(); - randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); - randomMock.Setup(r => r.NextDouble()).Returns(0.15); - char result = randomMock.Object.NextChar(); - - Assert.Equal((int)mockedResult, (int)result); - } - - [Fact] - public void NextChar_ShoudReturnChar_AlphabeticLower() + public void NextChar_ShouldThrow_ArgumentNullException() { - char mockedResult = 'a'; - var randomMock = new Mock(); - randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); - randomMock.Setup(r => r.NextDouble()).Returns(0.51); - char result = randomMock.Object.NextChar(MoreDotNet.Models.CharType.AlphabeticLower); + Random random = null; - Assert.Equal((int)mockedResult, (int)result); + Assert.Throws(() => random.NextChar()); } [Fact] - public void NextChar_ShoudReturnChar_AlphabeticUpper() + public void NextChar_ShouldReturn_AlphanumericChar() { - char mockedResult = 'A'; - var randomMock = new Mock(); - randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); - randomMock.Setup(r => r.NextDouble()).Returns(0.49); - char result = randomMock.Object.NextChar(MoreDotNet.Models.CharType.AlphabeticUpper); + Random random = new Random(); + var result = random.NextChar((CharType)(-1)); - Assert.Equal((int)mockedResult, (int)result); + Assert.True(char.IsLetterOrDigit(result)); } [Fact] - public void NextChar_ShoudReturnChar_AlphabeticAny() + public void NextChar_ShouldReturn_AlphanumericCharAny() { - char mockedResult = 'A'; - var randomMock = new Mock(); - randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); - randomMock.Setup(r => r.NextDouble()).Returns(0.49); - char result = randomMock.Object.NextChar(MoreDotNet.Models.CharType.AlphabeticAny); - - Assert.Equal((int)mockedResult, (int)result); - } - - [Fact] - public void NextChar_ShoudReturnChar_AlphanumericAny() - { - char mockedResult = 'A'; - var randomMock = new Mock(); - randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); - randomMock.Setup(r => r.NextDouble()).Returns(0.49); - char result = randomMock.Object.NextChar(MoreDotNet.Models.CharType.AlphanumericAny); - - Assert.Equal((int)mockedResult, (int)result); - } - - [Fact] - public void NextChar_ShoudReturnChar_AlphanumericLower() - { - char mockedResult = 'a'; - var randomMock = new Mock(); - randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); - randomMock.Setup(r => r.NextDouble()).Returns(0.51); - char result = randomMock.Object.NextChar(MoreDotNet.Models.CharType.AlphanumericLower); + var random = new Random(); + var result = random.NextChar(); - Assert.Equal((int)mockedResult, (int)result); + Assert.IsType(result); } - [Fact] - public void NextChar_ShoudReturnChar_AlphanumericUpper() + [Theory] + [InlineData('A', 0.168)] + [InlineData('1', 0.15)] + public void NextChar_ShoudReturnChar_CapitalLetter(char expectedResult, double returns) { - char mockedResult = 'A'; var randomMock = new Mock(); - randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); - randomMock.Setup(r => r.NextDouble()).Returns(0.49); - char result = randomMock.Object.NextChar(MoreDotNet.Models.CharType.AlphanumericUpper); + randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns(expectedResult); + randomMock.Setup(r => r.NextDouble()).Returns(returns); + char actualResult = randomMock.Object.NextChar(); - Assert.Equal((int)mockedResult, (int)result); + Assert.Equal(expectedResult, actualResult); } - [Fact] - public void NextChar_ShoudReturnChar_Numeric() + [Theory] + [InlineData('2', CharType.AnyUnicode)] + public void NextChar_ShoudReturnChar_AnyUnicode(char expectedResult, CharType charType) { - char mockedResult = '2'; var randomMock = new Mock(); - randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); - randomMock.Setup(r => r.NextDouble()).Returns(0.1); - char result = randomMock.Object.NextChar(MoreDotNet.Models.CharType.Numeric); + randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns(expectedResult); + char actualResult = randomMock.Object.NextChar(charType); - Assert.Equal((int)mockedResult, (int)result); + Assert.Equal(expectedResult, actualResult); } - [Fact] - public void NextChar_ShoudReturnChar_AnyUnicode() + [Theory] + [InlineData('a', 0.51, CharType.AlphabeticLower)] + [InlineData('A', 0.49, CharType.AlphabeticUpper)] + [InlineData('A', 0.49, CharType.AlphabeticAny)] + [InlineData('a', 0.51, CharType.AlphanumericLower)] + [InlineData('A', 0.49, CharType.AlphanumericUpper)] + [InlineData('A', 0.49, CharType.AlphanumericAny)] + [InlineData('2', 0.1, CharType.Numeric)] + public void NextChar_ShoudReturn_ValidChar(char expectedResult, double returns, CharType charType) { - char mockedResult = '2'; var randomMock = new Mock(); - randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns((int)mockedResult); - char result = randomMock.Object.NextChar(MoreDotNet.Models.CharType.AnyUnicode); + randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns(expectedResult); + randomMock.Setup(r => r.NextDouble()).Returns(returns); + char actualResult = randomMock.Object.NextChar(charType); - Assert.Equal((int)mockedResult, (int)result); + Assert.Equal(expectedResult, actualResult); } } } From 78f4bff84f15b3bedb707e61398026626ae1720d Mon Sep 17 00:00:00 2001 From: Georgi Manov Date: Fri, 28 Oct 2016 13:19:03 +0300 Subject: [PATCH 10/26] work on DateTimeTests --- .../Common/RandomExtensions/NextDateTime.cs | 28 ++++++++++++++----- 1 file changed, 21 insertions(+), 7 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs index a27e17e..fb00f68 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs @@ -1,4 +1,4 @@ -namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions +namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions { using System; using System.Linq; @@ -9,6 +9,18 @@ public class NextDateTime { + private const int Counter = 1000; + + [Fact] + public void NextDateTime_ShouldThrow_ArgumentNullException() + { + Random random = null; + + Assert.Throws(() => random.NextDateTime()); + } + + // TODO: minValue => null / maxValue => null ; + [Fact] public void NextDateTime_ShouldReturnDateTime() { @@ -23,14 +35,13 @@ public void NextDateTime_ShouldReturnDateTime_OneHundredDistinctValues() { // TODO: Fix test var random = new Random(); - var counter = 100; - var dates = new DateTime[counter]; - for (int i = 0; i < counter; i++) + var dates = new DateTime[Counter]; + for (int i = 0; i < Counter; i++) { dates[i] = random.NextDateTime(); } - Assert.Equal(counter, dates.Distinct().Count()); + Assert.Equal(Counter, dates.Distinct().Count()); } [Fact] @@ -39,9 +50,12 @@ public void NextDateTime_ShouldReturnDateTime_BetweenMinAndMaxValue() var random = new Random(); var mivValue = new DateTime(2016, 1, 1, 0, 0, 0); var maxValue = new DateTime(2018, 1, 1, 0, 0, 0); - var result = random.NextDateTime(mivValue, maxValue); + for (int i = 0; i < Counter; i++) + { + var result = random.NextDateTime(mivValue, maxValue); - Assert.True(result >= mivValue && result < maxValue); + Assert.True(result >= mivValue && result < maxValue); + } } } } From 141e08f599e640f9bc282c325754701afd7b1617 Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sat, 29 Oct 2016 17:20:59 +0300 Subject: [PATCH 11/26] removed test from NextCharTests --- .../Extensions/Common/RandomExtensions/NextCharTests.cs | 9 --------- 1 file changed, 9 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs index dc204d3..87135d5 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs @@ -26,15 +26,6 @@ public void NextChar_ShouldReturn_AlphanumericChar() Assert.True(char.IsLetterOrDigit(result)); } - [Fact] - public void NextChar_ShouldReturn_AlphanumericCharAny() - { - var random = new Random(); - var result = random.NextChar(); - - Assert.IsType(result); - } - [Theory] [InlineData('A', 0.168)] [InlineData('1', 0.15)] From 4f67d09e871e12191834531673c0ab455c296fab Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sat, 29 Oct 2016 17:21:23 +0300 Subject: [PATCH 12/26] fixed tests NextDateTimeTests --- .../Common/RandomExtensions/NextDateTime.cs | 30 ++++++++----------- 1 file changed, 13 insertions(+), 17 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs index fb00f68..9874626 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs @@ -1,60 +1,56 @@ namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions { using System; + using System.Collections.Generic; using System.Linq; using MoreDotNet.Extensions.Common; - using Xunit; public class NextDateTime { private const int Counter = 1000; + private DateTime minDate = new DateTime(1999, 10, 31); + private DateTime maxDate = new DateTime(1999, 10, 31); [Fact] - public void NextDateTime_ShouldThrow_ArgumentNullException() + public void NextDateTime_RandomIsNull_ShouldThrow_ArgumentNullException() { Random random = null; Assert.Throws(() => random.NextDateTime()); } - // TODO: minValue => null / maxValue => null ; - [Fact] - public void NextDateTime_ShouldReturnDateTime() + public void NextDateTime_MinValueIsGreaterThanMaxValue_ShouldThrow_ArgumentException() { - var random = new Random(); - var result = random.NextDateTime(); + Random random = new Random(); - Assert.IsType(result); + Assert.Throws(() => random.NextDateTime(this.maxDate, this.minDate)); } [Fact] - public void NextDateTime_ShouldReturnDateTime_OneHundredDistinctValues() + public void NextDateTime_ShouldReturnDateTime_99PercentOfTimes() { - // TODO: Fix test var random = new Random(); - var dates = new DateTime[Counter]; + var dates = new HashSet(); for (int i = 0; i < Counter; i++) { - dates[i] = random.NextDateTime(); + dates.Add(random.NextDateTime()); } - Assert.Equal(Counter, dates.Distinct().Count()); + Assert.True(dates.Count() >= (Counter * 99 / 100)); } [Fact] public void NextDateTime_ShouldReturnDateTime_BetweenMinAndMaxValue() { var random = new Random(); - var mivValue = new DateTime(2016, 1, 1, 0, 0, 0); - var maxValue = new DateTime(2018, 1, 1, 0, 0, 0); for (int i = 0; i < Counter; i++) { - var result = random.NextDateTime(mivValue, maxValue); + var result = random.NextDateTime(this.minDate, this.maxDate); - Assert.True(result >= mivValue && result < maxValue); + Assert.True(result >= this.minDate && result < this.maxDate); } } } From 6f638e91690e0f4e22a33349262cb5e370472086 Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sat, 29 Oct 2016 18:14:30 +0300 Subject: [PATCH 13/26] fixed NextDoubleTests --- .../RandomExtensions/NextDoubleTests.cs | 76 ++++++++++++++----- 1 file changed, 55 insertions(+), 21 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs index e9563cf..6886ba4 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs @@ -9,49 +9,83 @@ public class NextDoubleTests { + private const int Counter = 1000; + private const double DoubleResult = 0.15; + private const double MinValue = -50; + private const double MaxValue = 150; + [Fact] - public void NextDouble_ShouldReturnDouble() + public void NextDouble_RandomIsNull_ShouldThrow_NullReferenceException() { - var random = new Random(); - var result = random.NextDouble(0, 10); + Random random = null; - Assert.IsType(result); + Assert.Throws(() => random.NextDouble()); } [Fact] - public void NextDouble_ShouldReturnDouble_BetweenZeroAndTen() + public void NextDouble_ShouldReturnDouble_BetweenMinAndMaxValue() { var random = new Random(); - for (int i = 0; i < 1000; i++) + for (int i = 0; i < Counter; i++) { - var result = random.NextDouble(0, 10); + var result = random.NextDouble(MinValue, MaxValue); - Assert.True(result >= 0 && result < 10); + Assert.True(result >= MinValue && result < MaxValue); } } [Fact] - public void NextDouble_ShouldReturnDouble_Zero() + public void NextDouble_MinValueIsGreaterThanMaxValue_ShouldThrow_ArgumentException() { - var randomMock = new Mock(); - randomMock.Setup(r => r.NextDouble()).Returns(0); - var result = randomMock.Object.NextDouble(0, double.MaxValue); + var random = new Random(); - Assert.Equal(0, result); + Assert.Throws(() => random.NextDouble(minValue: MaxValue, maxValue: MinValue)); } [Fact] - public void NextDouble_ShouldReturnDouble_PredifinedValue() + public void NextDouble_MockedRandom_ShouldReturn_PredifinedValue() { - var mockedValue = 0.15; - var minValue = 0; - var maxValue = 30; - var randomMock = new Mock(); - randomMock.Setup(r => r.NextDouble()).Returns(mockedValue); - var result = randomMock.Object.NextDouble(minValue, maxValue); + randomMock.Setup(r => r.NextDouble()).Returns(DoubleResult); + var actualResult = randomMock.Object.NextDouble(MinValue, MaxValue); + var expectedResult = MinValue + (DoubleResult * (MaxValue - MinValue)); + + Assert.Equal(expectedResult, actualResult); + } + + [Theory] + [InlineData(double.MinValue, double.MaxValue)] + [InlineData(MinValue, MaxValue)] + public void NextDouble_ShoulReturn_ValidResults(double min, double max) + { + var random = new Random(); + var result = random.NextDouble(min, max); + + Assert.True(result >= min && result < max); + } + + [Theory] + [InlineData(double.NaN, MaxValue)] + [InlineData(MinValue, double.NaN)] + [InlineData(double.NaN, double.NaN)] + [InlineData(double.NegativeInfinity, double.PositiveInfinity)] + [InlineData(double.NegativeInfinity, MaxValue)] + public void NextDouble_InfinityOrNanValuesParams_ShoulReturn_NaNValues(double min, double max) + { + var random = new Random(); + var result = random.NextDouble(min, max); + + Assert.Equal(double.NaN, result); + } + + [Theory] + [InlineData(MinValue, double.PositiveInfinity)] + public void NextDouble_PositiveInfinity_ShoulReturn_PositiveInfinity(double min, double max) + { + var random = new Random(); + var result = random.NextDouble(min, max); - Assert.Equal(mockedValue * maxValue, result); + Assert.Equal(double.PositiveInfinity, result); } } } From dbe2897dcd53e281f72580338cfddad95243cd41 Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sat, 29 Oct 2016 23:38:23 +0300 Subject: [PATCH 14/26] fixed NextStringTests --- .../RandomExtensions/NextStringTests.cs | 141 ++++++++---------- 1 file changed, 63 insertions(+), 78 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs index 5a3ceb2..f9f21d3 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs @@ -1,148 +1,133 @@ namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions { using System; + using System.Linq; using MoreDotNet.Extensions.Common; - + using MoreDotNet.Wrappers; using Xunit; public class NextStringTests { private const int Zero = 0; - private const int OneHundred = 100; + private const int StringLength = 100; + private const int StringLengthLarge = 1000; [Fact] - public void NextString_ShouldReturnStringWithLenghtZero() + public void NextString_RandomIsNull_ShouldThrow_ArgumentNullException() { - var random = new Random(); - var result = random.NextString(Zero); + Random random = null; - Assert.IsType(result); - Assert.Equal(Zero, result.Length); + Assert.Throws(() => random.NextString(StringLength)); } [Fact] - public void NextString_ShouldReturnString_WithLenght100Chars() + public void NextString_ShouldReturn_ExpectedLenght() { var random = new Random(); - var result = random.NextString(OneHundred); + var result = random.NextString(StringLength); - Assert.IsType(result); - Assert.Equal(OneHundred, result.Length); + Assert.Equal(StringLength, result.Length); } [Fact] public void NextString_ShouldReturnString_OfAlphabeticChars() { var random = new Random(); - var result = random.NextString(OneHundred, MoreDotNet.Models.CharType.AlphabeticAny); - - Assert.IsType(result); - Assert.Equal(OneHundred, result.Length); - for (int i = 0; i < OneHundred; i++) - { - Assert.True(char.IsLetter(result[i])); - } + var result = random.NextString(StringLength, MoreDotNet.Models.CharType.AlphabeticAny); + var check = result.Select(x => x.IsLetter()).All(x => x); + + Assert.True(check); } [Fact] public void NextString_ShouldReturnString_OfAlphabeticLowerChars() { var random = new Random(); - var result = random.NextString(OneHundred, MoreDotNet.Models.CharType.AlphabeticLower); - - Assert.IsType(result); - Assert.Equal(OneHundred, result.Length); - for (int i = 0; i < OneHundred; i++) - { - Assert.True(char.IsLower(result[i])); - } + var result = random.NextString(StringLength, MoreDotNet.Models.CharType.AlphabeticLower); + var check = result.Select(x => x.IsLower()).All(x => x); + + Assert.True(check); } [Fact] public void NextString_ShouldReturnString_OfAlphabeticUpperChars() { var random = new Random(); - var result = random.NextString(OneHundred, MoreDotNet.Models.CharType.AlphabeticUpper); - - Assert.IsType(result); - Assert.Equal(OneHundred, result.Length); - for (int i = 0; i < OneHundred; i++) - { - Assert.True(char.IsUpper(result[i])); - } + var result = random.NextString(StringLength, MoreDotNet.Models.CharType.AlphabeticUpper); + var check = result.Select(x => x.IsUpper()).All(x => x); + + Assert.True(check); } [Fact] public void NextString_ShouldReturnString_OfAlphanumericChars() { var random = new Random(); - var result = random.NextString(OneHundred, MoreDotNet.Models.CharType.AlphanumericAny); - - Assert.IsType(result); - Assert.Equal(OneHundred, result.Length); - for (int i = 0; i < OneHundred; i++) - { - Assert.True(char.IsLetterOrDigit(result[i])); - } + var result = random.NextString(StringLength, MoreDotNet.Models.CharType.AlphanumericAny); + var check = result.Select(x => x.IsLetterOrDigit()).All(x => x); + + Assert.True(check); } [Fact] public void NextString_ShouldReturnString_OfAlphanumericLowerChars() { var random = new Random(); - var result = random.NextString(OneHundred, MoreDotNet.Models.CharType.AlphanumericLower); - - Assert.IsType(result); - Assert.Equal(OneHundred, result.Length); - for (int i = 0; i < OneHundred; i++) - { - var currentChar = result[i]; - Assert.True((currentChar >= 48 && currentChar < 58) || (currentChar >= 97 && currentChar < 123)); - } + var result = random.NextString(StringLength, MoreDotNet.Models.CharType.AlphanumericLower); + var check = result.Select(x => this.IsAlphanumericLowerChar(x)).All(x => x); + + Assert.True(check); } [Fact] public void NextString_ShouldReturnString_OfAlphanumericUpperChars() { var random = new Random(); - var result = random.NextString(OneHundred, MoreDotNet.Models.CharType.AlphanumericUpper); - - Assert.IsType(result); - Assert.Equal(OneHundred, result.Length); - for (int i = 0; i < OneHundred; i++) - { - var currentChar = result[i]; - Assert.True((currentChar >= 48 && currentChar < 58) || (currentChar >= 65 && currentChar < 91)); - } + var result = random.NextString(StringLength, MoreDotNet.Models.CharType.AlphanumericUpper); + var check = result.Select(x => this.IsAlphanumericUpperChar(x)).All(x => x); + + Assert.True(check); } [Fact] public void NextString_ShouldReturnString_OfAnyUnicodeChars() { - var random = new Random(); - var result = random.NextString(OneHundred, MoreDotNet.Models.CharType.AnyUnicode); - - Assert.IsType(result); - Assert.Equal(OneHundred, result.Length); - for (int i = 0; i < OneHundred; i++) - { - Assert.True(result[i] >= 0 && result[i] < 65536); - } + var random = new Random(); + var result = random.NextString(StringLengthLarge, MoreDotNet.Models.CharType.AnyUnicode); + var check = result.Select(x => x.GetType() == typeof(char)).All(x => x); + + Assert.True(check); + } + + [Fact] + public void NextString_ShouldThrow_OutOfMemoryException() + { + var random = new Random(); + Assert.Throws(() => random.NextString(int.MaxValue, MoreDotNet.Models.CharType.AnyUnicode)); + //var check = result.Select(x => x.GetType() == typeof(char)).All(x => x); + + //Assert.True(check); } [Fact] public void NextString_ShouldReturnString_OfNumericChars() { var random = new Random(); - var result = random.NextString(OneHundred, MoreDotNet.Models.CharType.Numeric); - - Assert.IsType(result); - Assert.Equal(OneHundred, result.Length); - for (int i = 0; i < OneHundred; i++) - { - Assert.True(char.IsNumber(result[i])); - } + var result = random.NextString(StringLength, MoreDotNet.Models.CharType.Numeric); + var check = result.Select(x => x.IsNumber()).All(x => x); + + Assert.True(check); + } + + private bool IsAlphanumericLowerChar(char currentChar) + { + return currentChar.IsNumber() || currentChar.IsLower(); + } + + private bool IsAlphanumericUpperChar(char currentChar) + { + return currentChar.IsNumber() || currentChar.IsUpper(); } } } From 5763334dd793d59db7784e0b9b9783863d32c36b Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sat, 29 Oct 2016 23:41:12 +0300 Subject: [PATCH 15/26] fixed NextTimeSpanTests --- .../Common/RandomExtensions/NextTimeSpanTests.cs | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs index 29ca8c5..d99991a 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs @@ -9,12 +9,11 @@ public class NextTimeSpanTests { [Fact] - public void NextTimeSpan_ShouldReturnTimeSpan() + public void NextTimeSpan_ShouldThow_ArgumentNullException() { - var random = new Random(); - var result = random.NextTimeSpan(); + Random random = null; - Assert.IsType(result); + Assert.Throws(() => random.NextTimeSpan()); } } } From 5dcb2425c870e14f166e0601b84ee8ce5541f9c4 Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sun, 30 Oct 2016 03:54:38 +0300 Subject: [PATCH 16/26] fixed NextTimeSpanTests --- .../Common/RandomExtensions/NextDateTime.cs | 2 +- .../RandomExtensions/NextTimeSpanTests.cs | 42 ++++++++++++++++++- 2 files changed, 41 insertions(+), 3 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs index 9874626..b5ec639 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs @@ -30,7 +30,7 @@ public void NextDateTime_MinValueIsGreaterThanMaxValue_ShouldThrow_ArgumentExcep } [Fact] - public void NextDateTime_ShouldReturnDateTime_99PercentOfTimes() + public void NextDateTime_ShouldReturnDateTime_DistinctValues99PercentOfTimes() { var random = new Random(); var dates = new HashSet(); diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs index d99991a..0db09c9 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs @@ -1,19 +1,57 @@ namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions { using System; + using System.Collections.Generic; + using System.Linq; using MoreDotNet.Extensions.Common; - using Xunit; public class NextTimeSpanTests { + private const int Counter = 1000; + private TimeSpan minTimeSpan = new TimeSpan(0, 0, 0, 0, 1); + private TimeSpan maxTimeSpan = new TimeSpan(1000, 59, 59, 59); + [Fact] - public void NextTimeSpan_ShouldThow_ArgumentNullException() + public void NextTimeSpan_NullInit_ShouldThow_ArgumentNullException() { Random random = null; Assert.Throws(() => random.NextTimeSpan()); } + + [Fact] + public void NextTimeSpan_MinIsGreaterThanMax_ShouldThow_ArgumentException() + { + Random random = new Random(); + + Assert.Throws(() => random.NextTimeSpan(this.maxTimeSpan, this.minTimeSpan)); + } + + [Fact] + public void NextTimeSpan_ShouldReturnTimeSpan_DistinctValues99PercentOfTimes() + { + var random = new Random(); + var dates = new HashSet(); + for (int i = 0; i < Counter; i++) + { + dates.Add(random.NextTimeSpan()); + } + + Assert.True(dates.Count() >= (Counter * 99 / 100)); + } + + [Fact] + public void NextTimeSpan_ShouldReturn_TimeSpan() + { + var random = new Random(); + for (int i = 0; i < Counter; i++) + { + var result = random.NextTimeSpan(this.minTimeSpan, this.maxTimeSpan); + + Assert.True(result >= this.minTimeSpan && result < this.maxTimeSpan); + } + } } } From b80938a185c6d57114a423dcfa7b5bb15f45dea5 Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sun, 30 Oct 2016 03:07:47 +0200 Subject: [PATCH 17/26] fixed OneOfTests --- .../RandomExtensions/NextTimeSpanTests.cs | 2 +- .../Common/RandomExtensions/OneOfTests.cs | 25 ++++++++++++------- 2 files changed, 17 insertions(+), 10 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs index 0db09c9..0b43f28 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs @@ -52,6 +52,6 @@ public void NextTimeSpan_ShouldReturn_TimeSpan() Assert.True(result >= this.minTimeSpan && result < this.maxTimeSpan); } - } + } } } diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs index bb3d8ff..2268e57 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs @@ -10,24 +10,31 @@ public class OneOfTests { + private int[] numbersArr = new[] { 1, 2, 3, 4, 5, 6 }; + [Fact] - public void OneOf_ShouldReturnOneOfIntArray() + public void OneOf_RandomNull_ShouldHThrow_NullReferenceException() { - var random = new Random(); - var numbers = new[] { 1, 2, 3, 4, 5, 6 }; - var number = random.OneOf(numbers); + Random random = null; + + Assert.Throws(() => random.OneOf(this.numbersArr)); + } + + [Fact] + public void OneOf_NullCollection_ShouldHThrow_NullReferenceException() + { + Random random = new Random(); - Assert.True(numbers.Contains(number)); + Assert.Throws(() => random.OneOf(null)); } [Fact] - public void OneOf_ShouldReturnOneOfIntCollection() + public void OneOf_ShouldReturn_OneOfIntArray() { var random = new Random(); - var numbers = new List { 1, 2, 3, 4, 5, 6 }; - var number = random.OneOf(numbers); + var number = random.OneOf(this.numbersArr); - Assert.True(numbers.Contains(number)); + Assert.True(this.numbersArr.Contains(number)); } } } From c5c2b0eff53cc5698dc918d2156895d7bac8657a Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sun, 30 Oct 2016 10:21:31 +0200 Subject: [PATCH 18/26] fixed tests --- .../Common/RandomExtensions/NextBoolTests.cs | 15 +++++++++++---- .../Common/RandomExtensions/NextDateTime.cs | 2 +- .../Common/RandomExtensions/OneOfTests.cs | 8 ++++---- .../Extensions/Common/RandomExtensions.cs | 12 +++--------- 4 files changed, 19 insertions(+), 18 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs index 9362338..049ff22 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs @@ -8,6 +8,8 @@ namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions public class NextBoolTests { + private const int Counter = 10; + [Fact] public void NextBool_ShouldHThrow_NullReferenceException() { @@ -26,20 +28,25 @@ public void NextBool_ShouldReturn_True() } [Fact] - public void NextBool_ShouldReturnTrue_MoreThanOrEqualTo50Times() + public void NextBool_ShouldReturn_TrueOrFalse_AtLeastOnce() { var random = new Random(); int returnedTrueAsResult = 0; - int count = 1000; - for (int i = 0; i < count; i++) + int returnedFalseAsResult = 0; + for (int i = 0; i < Counter; i++) { if (random.NextBool()) { returnedTrueAsResult++; } + else + { + returnedFalseAsResult++; + } } - Assert.True(returnedTrueAsResult >= count / 2); + Assert.True(returnedTrueAsResult > 0); + Assert.True(returnedFalseAsResult > 0); } [Fact] diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs index b5ec639..776c907 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs @@ -11,7 +11,7 @@ public class NextDateTime { private const int Counter = 1000; private DateTime minDate = new DateTime(1999, 10, 31); - private DateTime maxDate = new DateTime(1999, 10, 31); + private DateTime maxDate = new DateTime(2019, 10, 31); [Fact] public void NextDateTime_RandomIsNull_ShouldThrow_ArgumentNullException() diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs index 2268e57..4244f7b 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs @@ -13,19 +13,19 @@ public class OneOfTests private int[] numbersArr = new[] { 1, 2, 3, 4, 5, 6 }; [Fact] - public void OneOf_RandomNull_ShouldHThrow_NullReferenceException() + public void OneOf_RandomNull_ShouldHThrow_ArgumentNullException() { Random random = null; - Assert.Throws(() => random.OneOf(this.numbersArr)); + Assert.Throws(() => random.OneOf(this.numbersArr)); } [Fact] - public void OneOf_NullCollection_ShouldHThrow_NullReferenceException() + public void OneOf_NullCollection_ShouldHThrow_ArgumentNullException() { Random random = new Random(); - Assert.Throws(() => random.OneOf(null)); + Assert.Throws(() => random.OneOf(null)); } [Fact] diff --git a/Source/MoreDotNet/Extensions/Common/RandomExtensions.cs b/Source/MoreDotNet/Extensions/Common/RandomExtensions.cs index 969734a..f039203 100644 --- a/Source/MoreDotNet/Extensions/Common/RandomExtensions.cs +++ b/Source/MoreDotNet/Extensions/Common/RandomExtensions.cs @@ -78,9 +78,7 @@ public static bool NextBool(this Random random, double probability = 0.5) throw new ArgumentNullException(nameof(random)); } - var nextBool = random.NextDouble() <= probability; - - return nextBool; + return random.NextDouble() <= probability; } /// @@ -303,14 +301,10 @@ private static char NextAlphanumericChar(this Random random) if (numeric) { - var number = random.NextNumericChar(); - - return number; + return random.NextNumericChar(); } - var aphabeticChar = random.NextAlphabeticChar(random.NextBool()); - - return aphabeticChar; + return random.NextAlphabeticChar(random.NextBool()); } private static char NextAlphabeticChar(this Random random, bool uppercase) From bcc1303c8c8bf8e724f08344cc09896acb5962f8 Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sun, 30 Oct 2016 20:55:56 +0200 Subject: [PATCH 19/26] extenden NextBoolTests --- .../Common/RandomExtensions/NextBoolTests.cs | 41 +++++++++++-------- 1 file changed, 24 insertions(+), 17 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs index 049ff22..eb85b45 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextBoolTests.cs @@ -8,32 +8,48 @@ namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions public class NextBoolTests { - private const int Counter = 10; + private const int NumberOfTests = 10; [Fact] - public void NextBool_ShouldHThrow_NullReferenceException() + public void NextBool_RandomIsNull_ShouldThrowArgumentNullException() { Random random = null; - Assert.Throws(() => random.Next()); + Assert.Throws(() => random.NextBool()); } - [Fact] - public void NextBool_ShouldReturn_True() + [Theory] + [InlineData(double.NegativeInfinity)] + [InlineData(double.NaN)] + [InlineData(-NumberOfTests)] + [InlineData(0)] + public void NextBool_ArgumentValueNotPositive_ShouldReturnFalse(double param) + { + var random = new Random(); + var result = random.NextBool(param); + + Assert.False(result); + } + + [Theory] + [InlineData(double.PositiveInfinity)] + [InlineData(NumberOfTests)] + [InlineData(1)] + public void NextBool_ArgumentValuePositive_ShouldReturnTrue(double param) { var random = new Random(); - var result = random.NextBool(1); + var result = random.NextBool(param); Assert.True(result); } [Fact] - public void NextBool_ShouldReturn_TrueOrFalse_AtLeastOnce() + public void NextBool_IteratesGenerations_ShouldReturnTrueOrFalseAtLeastOnce() { var random = new Random(); int returnedTrueAsResult = 0; int returnedFalseAsResult = 0; - for (int i = 0; i < Counter; i++) + for (int i = 0; i < NumberOfTests; i++) { if (random.NextBool()) { @@ -48,14 +64,5 @@ public void NextBool_ShouldReturn_TrueOrFalse_AtLeastOnce() Assert.True(returnedTrueAsResult > 0); Assert.True(returnedFalseAsResult > 0); } - - [Fact] - public void NextBool_ShouldReturn_False() - { - var random = new Random(); - var result = random.NextBool(0); - - Assert.False(result); - } } } From e5be414771abd7d380d9a48394f05b475be82a70 Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sun, 30 Oct 2016 21:08:02 +0200 Subject: [PATCH 20/26] fixed naming for NextDateTimeTests --- .../Common/RandomExtensions/NextDateTime.cs | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs index 776c907..3dee83c 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDateTime.cs @@ -9,9 +9,9 @@ namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions public class NextDateTime { - private const int Counter = 1000; - private DateTime minDate = new DateTime(1999, 10, 31); - private DateTime maxDate = new DateTime(2019, 10, 31); + private const int NumberOfTests = 1000; + private readonly DateTime minDate = new DateTime(1999, 10, 31); + private readonly DateTime maxDate = new DateTime(2019, 10, 31); [Fact] public void NextDateTime_RandomIsNull_ShouldThrow_ArgumentNullException() @@ -22,31 +22,31 @@ public void NextDateTime_RandomIsNull_ShouldThrow_ArgumentNullException() } [Fact] - public void NextDateTime_MinValueIsGreaterThanMaxValue_ShouldThrow_ArgumentException() + public void NextDateTime_MinValueIsGreaterThanMaxValue_ShouldThrowArgumentException() { - Random random = new Random(); + var random = new Random(); Assert.Throws(() => random.NextDateTime(this.maxDate, this.minDate)); } [Fact] - public void NextDateTime_ShouldReturnDateTime_DistinctValues99PercentOfTimes() + public void NextDateTime_ValidArguments_ShouldReturnDistinctValues99PercentOfTimes() { var random = new Random(); var dates = new HashSet(); - for (int i = 0; i < Counter; i++) + for (int i = 0; i < NumberOfTests; i++) { dates.Add(random.NextDateTime()); } - Assert.True(dates.Count() >= (Counter * 99 / 100)); + Assert.True(dates.Count() >= (NumberOfTests * 99 / 100)); } [Fact] - public void NextDateTime_ShouldReturnDateTime_BetweenMinAndMaxValue() + public void NextDateTime_ValidArguments_ShouldReturnResultBetweenMinAndMaxValue() { var random = new Random(); - for (int i = 0; i < Counter; i++) + for (int i = 0; i < NumberOfTests; i++) { var result = random.NextDateTime(this.minDate, this.maxDate); From 67bb18c09321dfce7263e0690127a915413a502d Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sun, 30 Oct 2016 21:11:33 +0200 Subject: [PATCH 21/26] fixed naming NextCharTests --- .../Common/RandomExtensions/NextCharTests.cs | 21 ++++++++++--------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs index 87135d5..cc62d1e 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextCharTests.cs @@ -10,7 +10,7 @@ namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions public class NextCharTests { [Fact] - public void NextChar_ShouldThrow_ArgumentNullException() + public void NextChar_RandomIsNull_ShouldThrowArgumentNullException() { Random random = null; @@ -18,7 +18,7 @@ public void NextChar_ShouldThrow_ArgumentNullException() } [Fact] - public void NextChar_ShouldReturn_AlphanumericChar() + public void NextChar_InvalidCharType_ShouldReturnAlphanumericChar() { Random random = new Random(); var result = random.NextChar((CharType)(-1)); @@ -29,7 +29,7 @@ public void NextChar_ShouldReturn_AlphanumericChar() [Theory] [InlineData('A', 0.168)] [InlineData('1', 0.15)] - public void NextChar_ShoudReturnChar_CapitalLetter(char expectedResult, double returns) + public void NextChar_ValidArguments_ShoudReturnAlphanumeriAny(char expectedResult, double returns) { var randomMock = new Mock(); randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns(expectedResult); @@ -39,15 +39,16 @@ public void NextChar_ShoudReturnChar_CapitalLetter(char expectedResult, double r Assert.Equal(expectedResult, actualResult); } - [Theory] - [InlineData('2', CharType.AnyUnicode)] - public void NextChar_ShoudReturnChar_AnyUnicode(char expectedResult, CharType charType) + [Fact] + public void NextChar_ValidArguments_ShoudReturnAnyUnicodeChar() { + var expectedChar = '2'; + var randomMock = new Mock(); - randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns(expectedResult); - char actualResult = randomMock.Object.NextChar(charType); + randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns(expectedChar); + char actualResult = randomMock.Object.NextChar(CharType.AnyUnicode); - Assert.Equal(expectedResult, actualResult); + Assert.Equal(expectedChar, actualResult); } [Theory] @@ -58,7 +59,7 @@ public void NextChar_ShoudReturnChar_AnyUnicode(char expectedResult, CharType ch [InlineData('A', 0.49, CharType.AlphanumericUpper)] [InlineData('A', 0.49, CharType.AlphanumericAny)] [InlineData('2', 0.1, CharType.Numeric)] - public void NextChar_ShoudReturn_ValidChar(char expectedResult, double returns, CharType charType) + public void NextChar_ValidArguments_ShoudReturnExpectedCharType(char expectedResult, double returns, CharType charType) { var randomMock = new Mock(); randomMock.Setup(r => r.Next(It.IsAny(), It.IsAny())).Returns(expectedResult); From c34786b291dc2f70da2ea02805015404c523a2f5 Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sun, 30 Oct 2016 21:17:23 +0200 Subject: [PATCH 22/26] fixed naming NextDoubleTests --- .../RandomExtensions/NextDoubleTests.cs | 21 +++++++++---------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs index 6886ba4..bc5c9db 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextDoubleTests.cs @@ -9,24 +9,24 @@ public class NextDoubleTests { - private const int Counter = 1000; + private const int NumberOfTests = 1000; private const double DoubleResult = 0.15; private const double MinValue = -50; private const double MaxValue = 150; [Fact] - public void NextDouble_RandomIsNull_ShouldThrow_NullReferenceException() + public void NextDouble_RandomIsNull_ShouldThrow_ArgumentNullException() { Random random = null; - Assert.Throws(() => random.NextDouble()); + Assert.Throws(() => random.NextDouble(MinValue, MaxValue)); } [Fact] - public void NextDouble_ShouldReturnDouble_BetweenMinAndMaxValue() + public void NextDouble_ValidArguments_ShouldReturnResultsBetweenMinAndMaxValue() { var random = new Random(); - for (int i = 0; i < Counter; i++) + for (int i = 0; i < NumberOfTests; i++) { var result = random.NextDouble(MinValue, MaxValue); @@ -39,7 +39,7 @@ public void NextDouble_MinValueIsGreaterThanMaxValue_ShouldThrow_ArgumentExcepti { var random = new Random(); - Assert.Throws(() => random.NextDouble(minValue: MaxValue, maxValue: MinValue)); + Assert.Throws(() => random.NextDouble(MaxValue, MinValue)); } [Fact] @@ -56,7 +56,7 @@ public void NextDouble_MockedRandom_ShouldReturn_PredifinedValue() [Theory] [InlineData(double.MinValue, double.MaxValue)] [InlineData(MinValue, MaxValue)] - public void NextDouble_ShoulReturn_ValidResults(double min, double max) + public void NextDouble_ValidArguments_ShoulReturnValidResults(double min, double max) { var random = new Random(); var result = random.NextDouble(min, max); @@ -78,12 +78,11 @@ public void NextDouble_InfinityOrNanValuesParams_ShoulReturn_NaNValues(double mi Assert.Equal(double.NaN, result); } - [Theory] - [InlineData(MinValue, double.PositiveInfinity)] - public void NextDouble_PositiveInfinity_ShoulReturn_PositiveInfinity(double min, double max) + [Fact] + public void NextDouble_PositiveInfinityAsMaxValue_ShoulReturnPositiveInfinity() { var random = new Random(); - var result = random.NextDouble(min, max); + var result = random.NextDouble(MinValue, double.PositiveInfinity); Assert.Equal(double.PositiveInfinity, result); } From 752cfcf6e39beaca14a1ccbda18fe35cf3fc19a7 Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sun, 30 Oct 2016 21:31:02 +0200 Subject: [PATCH 23/26] fixed naming for NextStringTests and removed a test --- .../RandomExtensions/NextStringTests.cs | 59 ++++++++----------- 1 file changed, 24 insertions(+), 35 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs index f9f21d3..8194c81 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs @@ -5,16 +5,17 @@ using MoreDotNet.Extensions.Common; using MoreDotNet.Wrappers; + using MoreDotNet.Models; + using Xunit; public class NextStringTests { - private const int Zero = 0; private const int StringLength = 100; private const int StringLengthLarge = 1000; [Fact] - public void NextString_RandomIsNull_ShouldThrow_ArgumentNullException() + public void NextString_RandomIsNull_ShouldThrowArgumentNullException() { Random random = null; @@ -22,7 +23,7 @@ public void NextString_RandomIsNull_ShouldThrow_ArgumentNullException() } [Fact] - public void NextString_ShouldReturn_ExpectedLenght() + public void NextString_ValidArgument_ShouldReturnExpectedLenght() { var random = new Random(); var result = random.NextString(StringLength); @@ -31,90 +32,78 @@ public void NextString_ShouldReturn_ExpectedLenght() } [Fact] - public void NextString_ShouldReturnString_OfAlphabeticChars() + public void NextString_ValidArguments_ShouldReturnStringOfAlphabeticChars() { var random = new Random(); - var result = random.NextString(StringLength, MoreDotNet.Models.CharType.AlphabeticAny); + var result = random.NextString(StringLength, CharType.AlphabeticAny); var check = result.Select(x => x.IsLetter()).All(x => x); Assert.True(check); } [Fact] - public void NextString_ShouldReturnString_OfAlphabeticLowerChars() + public void NextString_ValidArguments_ShouldReturnStringOfAlphabeticLowerChars() { var random = new Random(); - var result = random.NextString(StringLength, MoreDotNet.Models.CharType.AlphabeticLower); + var result = random.NextString(StringLength, CharType.AlphabeticLower); var check = result.Select(x => x.IsLower()).All(x => x); Assert.True(check); } [Fact] - public void NextString_ShouldReturnString_OfAlphabeticUpperChars() + public void NextString_ValidArguments_ShouldReturnStringOfAlphabeticUpperChars() { var random = new Random(); - var result = random.NextString(StringLength, MoreDotNet.Models.CharType.AlphabeticUpper); + var result = random.NextString(StringLength, CharType.AlphabeticUpper); var check = result.Select(x => x.IsUpper()).All(x => x); Assert.True(check); } [Fact] - public void NextString_ShouldReturnString_OfAlphanumericChars() + public void NextString_ValidArguments_ShouldReturnStringOfAlphanumericChars() { var random = new Random(); - var result = random.NextString(StringLength, MoreDotNet.Models.CharType.AlphanumericAny); + var result = random.NextString(StringLength, CharType.AlphanumericAny); var check = result.Select(x => x.IsLetterOrDigit()).All(x => x); Assert.True(check); } [Fact] - public void NextString_ShouldReturnString_OfAlphanumericLowerChars() - { - var random = new Random(); - var result = random.NextString(StringLength, MoreDotNet.Models.CharType.AlphanumericLower); - var check = result.Select(x => this.IsAlphanumericLowerChar(x)).All(x => x); - - Assert.True(check); - } - - [Fact] - public void NextString_ShouldReturnString_OfAlphanumericUpperChars() + public void NextString_ValidArguments_ShouldReturnStringOfAlphanumericLowerChars() { var random = new Random(); - var result = random.NextString(StringLength, MoreDotNet.Models.CharType.AlphanumericUpper); - var check = result.Select(x => this.IsAlphanumericUpperChar(x)).All(x => x); + var result = random.NextString(StringLength, CharType.AlphanumericLower); + var check = result.Select(this.IsAlphanumericLowerChar).All(x => x); Assert.True(check); } [Fact] - public void NextString_ShouldReturnString_OfAnyUnicodeChars() + public void NextString_ValidArguments_ShouldReturnStringOfAlphanumericUpperChars() { var random = new Random(); - var result = random.NextString(StringLengthLarge, MoreDotNet.Models.CharType.AnyUnicode); - var check = result.Select(x => x.GetType() == typeof(char)).All(x => x); + var result = random.NextString(StringLength, CharType.AlphanumericUpper); + var check = result.Select(this.IsAlphanumericUpperChar).All(x => x); Assert.True(check); } - - [Fact] - public void NextString_ShouldThrow_OutOfMemoryException() + + [Fact(Skip = "Need further investigation")] + public void NextString_LenghtMaxAllowedValue_ShouldThrowOutOfMemoryException() { var random = new Random(); - Assert.Throws(() => random.NextString(int.MaxValue, MoreDotNet.Models.CharType.AnyUnicode)); - //var check = result.Select(x => x.GetType() == typeof(char)).All(x => x); - //Assert.True(check); + Assert.Throws(() => random.NextString(int.MaxValue, CharType.AnyUnicode)); } [Fact] - public void NextString_ShouldReturnString_OfNumericChars() + public void NextString_ValidArguments_ShouldReturnStringOfNumericChars() { var random = new Random(); - var result = random.NextString(StringLength, MoreDotNet.Models.CharType.Numeric); + var result = random.NextString(StringLength, CharType.Numeric); var check = result.Select(x => x.IsNumber()).All(x => x); Assert.True(check); From 9caac5183e1a4ea4d916c25fc7d33dc23f9a36d8 Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sun, 30 Oct 2016 21:37:07 +0200 Subject: [PATCH 24/26] fixed names OneOfTests --- .../Common/RandomExtensions/NextStringTests.cs | 7 +++---- .../Common/RandomExtensions/NextTimeSpanTests.cs | 4 ++-- .../Extensions/Common/RandomExtensions/OneOfTests.cs | 9 ++++----- 3 files changed, 9 insertions(+), 11 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs index 8194c81..1ea9b84 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextStringTests.cs @@ -4,9 +4,8 @@ using System.Linq; using MoreDotNet.Extensions.Common; - using MoreDotNet.Wrappers; using MoreDotNet.Models; - + using MoreDotNet.Wrappers; using Xunit; public class NextStringTests @@ -90,8 +89,8 @@ public void NextString_ValidArguments_ShouldReturnStringOfAlphanumericUpperChars Assert.True(check); } - - [Fact(Skip = "Need further investigation")] + + [Fact(Skip = "//TODO: Needs further investigation")] public void NextString_LenghtMaxAllowedValue_ShouldThrowOutOfMemoryException() { var random = new Random(); diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs index 0b43f28..8cba3ca 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs @@ -10,8 +10,8 @@ public class NextTimeSpanTests { private const int Counter = 1000; - private TimeSpan minTimeSpan = new TimeSpan(0, 0, 0, 0, 1); - private TimeSpan maxTimeSpan = new TimeSpan(1000, 59, 59, 59); + private readonly TimeSpan minTimeSpan = new TimeSpan(0, 0, 0, 0, 1); + private readonly TimeSpan maxTimeSpan = new TimeSpan(1000, 59, 59, 59); [Fact] public void NextTimeSpan_NullInit_ShouldThow_ArgumentNullException() diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs index 4244f7b..73ddc52 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs @@ -1,7 +1,6 @@ namespace MoreDotNet.Tests.Extensions.Common.RandomExtensions { using System; - using System.Collections.Generic; using System.Linq; using MoreDotNet.Extensions.Common; @@ -10,14 +9,14 @@ public class OneOfTests { - private int[] numbersArr = new[] { 1, 2, 3, 4, 5, 6 }; + private int[] numbersArray = new[] { 1, 2, 3, 4, 5, 6 }; [Fact] public void OneOf_RandomNull_ShouldHThrow_ArgumentNullException() { Random random = null; - Assert.Throws(() => random.OneOf(this.numbersArr)); + Assert.Throws(() => random.OneOf(this.numbersArray)); } [Fact] @@ -32,9 +31,9 @@ public void OneOf_NullCollection_ShouldHThrow_ArgumentNullException() public void OneOf_ShouldReturn_OneOfIntArray() { var random = new Random(); - var number = random.OneOf(this.numbersArr); + var number = random.OneOf(this.numbersArray); - Assert.True(this.numbersArr.Contains(number)); + Assert.True(this.numbersArray.Contains(number)); } } } From 448a6d49f9f7516d2f687d3c2e8adbdcc1d9f68e Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sun, 30 Oct 2016 21:42:37 +0200 Subject: [PATCH 25/26] removed unnecessary 'new[]' --- .../Extensions/Common/RandomExtensions/OneOfTests.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs index 73ddc52..2d97bed 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/OneOfTests.cs @@ -9,7 +9,7 @@ public class OneOfTests { - private int[] numbersArray = new[] { 1, 2, 3, 4, 5, 6 }; + private int[] numbersArray = { 1, 2, 3, 4, 5, 6 }; [Fact] public void OneOf_RandomNull_ShouldHThrow_ArgumentNullException() From 172308290b28aa48174057ab80337f436d942603 Mon Sep 17 00:00:00 2001 From: georgimanov Date: Sun, 30 Oct 2016 21:42:52 +0200 Subject: [PATCH 26/26] fixed name for constant --- .../Common/RandomExtensions/NextTimeSpanTests.cs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs index 8cba3ca..0c261be 100644 --- a/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs +++ b/Source/MoreDotNet.Test/Extensions/Common/RandomExtensions/NextTimeSpanTests.cs @@ -9,7 +9,7 @@ public class NextTimeSpanTests { - private const int Counter = 1000; + private const int NumberOfTests = 1000; private readonly TimeSpan minTimeSpan = new TimeSpan(0, 0, 0, 0, 1); private readonly TimeSpan maxTimeSpan = new TimeSpan(1000, 59, 59, 59); @@ -34,19 +34,19 @@ public void NextTimeSpan_ShouldReturnTimeSpan_DistinctValues99PercentOfTimes() { var random = new Random(); var dates = new HashSet(); - for (int i = 0; i < Counter; i++) + for (int i = 0; i < NumberOfTests; i++) { dates.Add(random.NextTimeSpan()); } - Assert.True(dates.Count() >= (Counter * 99 / 100)); + Assert.True(dates.Count() >= (NumberOfTests * 99 / 100)); } [Fact] public void NextTimeSpan_ShouldReturn_TimeSpan() { var random = new Random(); - for (int i = 0; i < Counter; i++) + for (int i = 0; i < NumberOfTests; i++) { var result = random.NextTimeSpan(this.minTimeSpan, this.maxTimeSpan);