public void ReturnsValueBasedOnMaximum(int?firstMaximum, int?secondMaximum, bool expected)
{
var firstSize = new TestSize(null, firstMaximum);
var secondSize = new TestSize(null, secondMaximum);
Assert.Equal(expected, firstSize.Equals(secondSize));
}
public void ThrowsDescriptiveExceptionWhenValueIsLessThan0()
{
var thrown = Assert.Throws <ArgumentOutOfRangeException>(() => TestSize.Min(-1));
Method method = typeof(TestSize).Method(nameof(TestSize.Min));
Assert.Equal(method.Parameter <int>().Name, thrown.ParamName);
}
public void ReturnsValueBasedOnMinimumAndMaximum(int?minimum, int?maximum)
{
var actual = new TestSize(minimum, maximum);
(int?minimum, int?maximum)expected = (minimum, maximum);
Assert.Equal(expected.GetHashCode(), actual.GetHashCode());
}
public void ReturnsRangeInitializedWithGivenMinimumAndMaximumValues()
{
ConfiguredCall arrange = fuzzy.Build(Arg.Is <FuzzyRange <int> >(s => s.Minimum == minimum && s.Maximum == maximum)).Returns(builtValue);
var sut = TestSize.Between(minimum, maximum);
Assert.Equal(builtValue, sut.Build(fuzzy));
}
public void ThrowsDescriptiveExceptionWhenFuzzIsNull()
{
Size <TestSize> sut = new TestSize();
var thrown = Assert.Throws <ArgumentNullException>(() => sut.Build(null !));
Assert.Equal(sut.Method(nameof(sut.Build)).Parameter <IFuzz>().Name, thrown.ParamName);
}
public void ReturnsRangeInitializedWithGivenValueValue()
{
int expected = random.Next();
ConfiguredCall arrange = fuzzy.Build(Arg.Is <FuzzyRange <int> >(s => s.Minimum == expected && s.Maximum == expected)).Returns(builtValue);
var sut = TestSize.Exactly(expected);
Assert.Equal(builtValue, sut.Build(fuzzy));
}
public void ThrowsDescriptiveExceptionWhenMaxIsLessThanMin()
{
var thrown = Assert.Throws <ArgumentException>(() => TestSize.Between(minimum, minimum - 1));
Method method = typeof(TestSize).Method(nameof(TestSize.Between));
Assert.Equal(method.Parameter <int>("max").Name, thrown.ParamName);
Assert.Contains(minimum.ToString(), thrown.Message);
Assert.Contains((minimum - 1).ToString(), thrown.Message);
}
public void ReturnsFuzzyInt32WhenMinimumIsMoreThanDefaultMaximum(int minimum, int expectedMaximum)
{
ConfiguredCall arrange = fuzzy.Build(Arg.Is <FuzzyRange <int> >(s => s.Minimum == minimum && s.Maximum == expectedMaximum)).Returns(builtValue);
Size <TestSize> sut = TestSize.Min(minimum);
int actual = sut.Build(fuzzy);
Assert.Equal(builtValue, actual);
}
public void ReturnsFuzzyInt32WithDefaultMinimumAndMaximum()
{
ConfiguredCall arrange = fuzzy.Build(Arg.Is <FuzzyRange <int> >(s => s.Minimum == 8 && s.Maximum == 13)).Returns(builtValue);
Size <TestSize> sut = new TestSize();
int actual = sut.Build(fuzzy);
Assert.Equal(builtValue, actual);
}
public void ReturnsFuzzyInt32WithGivenMinimumAndMaximum()
{
ConfiguredCall arrange = fuzzy.Build(Arg.Is <FuzzyRange <int> >(s => s.Minimum == minimum && s.Maximum == maximum)).Returns(builtValue);
Size <TestSize> sut = TestSize.Between(minimum, maximum);
int actual = sut.Build(fuzzy);
Assert.Equal(builtValue, actual);
}
/// <summary>
/// Convert a test size to string
/// </summary>
public static string getValue(this TestSize value)
{
switch (value)
{
case TestSize.SMALL:
return("small");
case TestSize.MEDIUM:
return("medium");
case TestSize.LARGE:
return("large");
default:
throw new ArgumentException("Invalid TestSize " + (int)value);
}
}
private void Awake()
{
ins = this;
}
public void ThrowsDescriptiveExceptionWhenMinIsLessThan0() => Assert.Throws <ArgumentOutOfRangeException>(() => TestSize.Between(-1, maximum));
