public void Less21()
{
Less20 myNumber = new Less20();
bool match = myNumber.IsLessThanMultipleOf20(21);
Assert.AreEqual(false, match);
}
public void MuchLessTwenty()
{
Less20 muchLess = new Less20();
bool result = muchLess.IsLessThanMultipleOf20(15);
Assert.AreEqual(false, result);
}
public void OneLessTwenty()
{
Less20 oneLess = new Less20();
bool result = oneLess.IsLessThanMultipleOf20(19);
Assert.AreEqual(true, result);
}
public void Less19()
{
Less20 myNumber = new Less20();
bool match = myNumber.IsLessThanMultipleOf20(19);
Assert.AreEqual(true, match);
}
public void TwoLessTwenty()
{
Less20 twoLess = new Less20();
bool result = twoLess.IsLessThanMultipleOf20(18);
Assert.AreEqual(true, result);
}
public void IsTwenty()
{
Less20 isTwenty = new Less20();
bool result = isTwenty.IsLessThanMultipleOf20(20);
Assert.AreEqual(false, result);
}
public void Less20Test20()
{
Less20 less20 = new Less20();
bool actual = less20.IsLessThanMultipleOf20(20);
Assert.AreEqual(false, actual);
}
public void IsLessThanMultipleOf20()
{
Less20 lae = new Less20();
Assert.IsTrue(lae.IsLessThanMultipleOf20(18));
Assert.IsTrue(lae.IsLessThanMultipleOf20(19));
Assert.IsFalse(lae.IsLessThanMultipleOf20(20));
}
public void Less20(int n, bool expected)
{
Less20 ex = new Less20();
bool actualResult = ex.IsLessThanMultipleOf20(n);
Assert.AreEqual(expected, actualResult);
}
public void WithinTwo_ReturnFalse()
{
Less20 num = new Less20();
Assert.AreEqual(false, num.IsLessThanMultipleOf20(15));
Assert.AreEqual(false, num.IsLessThanMultipleOf20(45));
Assert.AreEqual(false, num.IsLessThanMultipleOf20(75));
}
public void WithinTwo_ReturnTrue()
{
Less20 num = new Less20();
Assert.AreEqual(true, num.IsLessThanMultipleOf20(19));
Assert.AreEqual(true, num.IsLessThanMultipleOf20(38));
Assert.AreEqual(true, num.IsLessThanMultipleOf20(79));
}
public void Less20Test19()
{
Less20 less20 = new Less20();
bool actual = less20.IsLessThanMultipleOf20(19);
Assert.AreEqual(true, actual);
}
public void IsLessThanMultipleOf20Variables()
{
Less20 lae = new Less20();
Assert.IsFalse(lae.IsLessThanMultipleOf20(0));
Assert.IsFalse(lae.IsLessThanMultipleOf20(-10));
Assert.IsTrue(lae.IsLessThanMultipleOf20(98));
Assert.IsFalse(lae.IsLessThanMultipleOf20(1245));
Assert.IsFalse(lae.IsLessThanMultipleOf20(-6));
}
public void LessThan20Test20()
{
Less20 less20 = new Less20();
int input = 20;
bool expected = false;
bool result;
bool lessTest = less20.IsLessThanMultipleOf20(18);
Assert.AreEqual(true, lessTest);
}
public void IsEighteenTwoLessThanTwenty()
{
//Arrange
Less20 twoLess = new Less20();
//Act
bool result = twoLess.IsLessThanMultipleOf20(18);
//Assert
Assert.AreEqual(true, result);
}
public void IsNineteenOneLessThanTwenty()
{
//Arrange
Less20 oneLess = new Less20();
//Act
bool result = oneLess.IsLessThanMultipleOf20(19);
//Assert
Assert.AreEqual(true, result);
}
public void IsTwentLessThanMultipleOfTwenty()
{
//Arrange
Less20 evenValue = new Less20();
//Act
bool result = evenValue.IsLessThanMultipleOf20(20);
//Assert
Assert.AreEqual(false, result);
}
public void TestLess20_1LessThan20()
{
Less20 oneLess = new Less20();
int[] values = { 19, 39, 59, 79 };
Assert.AreEqual(true, oneLess.IsLessThanMultipleOf20(values[0]));
Assert.AreEqual(true, oneLess.IsLessThanMultipleOf20(values[1]));
Assert.AreEqual(true, oneLess.IsLessThanMultipleOf20(values[2]));
Assert.AreEqual(true, oneLess.IsLessThanMultipleOf20(values[3]));
}
public void TestLess20_2LessThan20()
{
Less20 twoLess = new Less20();
int[] values = { 18, 38, 58, 78 };
Assert.AreEqual(true, twoLess.IsLessThanMultipleOf20(values[0]));
Assert.AreEqual(true, twoLess.IsLessThanMultipleOf20(values[1]));
Assert.AreEqual(true, twoLess.IsLessThanMultipleOf20(values[2]));
Assert.AreEqual(true, twoLess.IsLessThanMultipleOf20(values[3]));
}
public void One_Or_Two_Less_Than_Twenty(int inputNumber, bool expectedResult)
{
// Arrange
Less20 testNumber = new Less20();
// Act
bool actualResult = testNumber.IsLessThanMultipleOf20(inputNumber);
// Assert
Assert.AreEqual(expectedResult, actualResult);
}
public void TestLess20FalseValues()
{
Less20 twoLess = new Less20();
int[] values = { 29, 8, 9, 68 };
Assert.AreEqual(false, twoLess.IsLessThanMultipleOf20(values[0]));
Assert.AreEqual(false, twoLess.IsLessThanMultipleOf20(values[1]));
Assert.AreEqual(false, twoLess.IsLessThanMultipleOf20(values[2]));
Assert.AreEqual(false, twoLess.IsLessThanMultipleOf20(values[3]));
}
public void IsLessThanMultipleOf20Test()
{
var exercise = new Less20();
//less20(18) → true
Assert.AreEqual(true, exercise.IsLessThanMultipleOf20(18));
//less20(19) → true
Assert.AreEqual(true, exercise.IsLessThanMultipleOf20(19));
//less20(20) → false
Assert.AreEqual(false, exercise.IsLessThanMultipleOf20(20));
}
public void Within2LessTest_ExpectTrue()
{
//Arrange
Less20 exercises = new Less20();
//Assert
Assert.AreEqual(true, exercises.IsLessThanMultipleOf20(18));
Assert.AreEqual(false, exercises.IsLessThanMultipleOf20(22));
Assert.AreEqual(true, exercises.IsLessThanMultipleOf20(38));
Assert.AreEqual(false, exercises.IsLessThanMultipleOf20(42));
}
public void IsLessThanMultipleOf20()
{
// Arrange
Less20 ex = new Less20();
// Act
bool actualResult = ex.IsLessThanMultipleOf20(18);
// Assert
Assert.AreEqual(true, actualResult);
}
public void DataTestIsLessThanMultipleOf20(int input1, bool expectedResult)
{
// Arrange
Less20 ex = new Less20();
// Act
bool actualResult = ex.IsLessThanMultipleOf20(input1);
//Assert
Assert.AreEqual(expectedResult, actualResult);
}
public void ShouldReturnFalseWithInputEqualToMultiple()
{
//arrange
Less20 multiples = new Less20();
//act
bool multipleCheck = multiples.IsLessThanMultipleOf20(100);
//assert
Assert.AreEqual(false, multipleCheck);
}
public void ShouldReturnTrueWithInputWithinTwoOfMultiple()
{
//arrange
Less20 multiples = new Less20();
//act
bool multipleCheck = multiples.IsLessThanMultipleOf20(78);
//assert
Assert.AreEqual(true, multipleCheck);
}
public void Within3Test_ExpectFalse()
{
//Arrange
Less20 exercises = new Less20();
//Assert
Assert.AreEqual(false, exercises.IsLessThanMultipleOf20(17));
Assert.AreEqual(false, exercises.IsLessThanMultipleOf20(23));
Assert.AreEqual(false, exercises.IsLessThanMultipleOf20(3));
Assert.AreEqual(false, exercises.IsLessThanMultipleOf20(37));
Assert.AreEqual(false, exercises.IsLessThanMultipleOf20(43));
}
public void NegativeNumberInputCheck()
{ //----Arrangle----------------------------------------
Less20 mattIsTheJavaBatMan = new Less20();
//----Act-----------------------------------------------
bool mattHasBetrayedUs6 = mattIsTheJavaBatMan.IsLessThanMultipleOf20(-20);
//----Assert-------------------------------------------
Assert.AreEqual(false, mattHasBetrayedUs6);
}
public void Less20()
{
Less20 _exercises = new Less20();
bool result = _exercises.IsLessThanMultipleOf20(18);
Assert.AreEqual(true, result, "Input" + ":IsLessThanMultipleOf20(18)");
result = _exercises.IsLessThanMultipleOf20(19);
Assert.AreEqual(true, result, "Input" + ":IsLessThanMultipleOf20(19)");
result = _exercises.IsLessThanMultipleOf20(20);
Assert.AreEqual(false, result, "Input" + ":IsLessThanMultipleOf20(20)");
}