public void NegativeNumberErrorMessageShouldContainNegativeNumber()
{
var calculator = new StringCalculator();
var error = Assert.Throws(typeof(ArgumentOutOfRangeException), () => calculator.Add("-1,2"));
Assert.True(error.Message.Contains("-1"));
}
public void GivenNewLineAsDelimeterShouldReturnSumOfAllNumbers()
{
var calculator = new StringCalculator();
var expected = 6;
Assert.AreEqual(expected, calculator.Add("1\n2\n3"));
}
public void GivenTwoNumbersShouldReturnTheSumOfBothNumbers()
{
var calculator = new StringCalculator();
var expected = 3;
Assert.AreEqual(expected, calculator.Add("1,2"));
}
public void GivenConsecutiveDelimetersShouldThrowException()
{
var calculator = new StringCalculator();
var expected = -1;
Assert.Throws(typeof(ArgumentException), () => calculator.Add(",,"));
}
public void GivenMultipleNumbersShouldReturnSumOfAllNumbers()
{
var calculator = new StringCalculator();
var expected = 6;
Assert.AreEqual(expected, calculator.Add("1,2,3"));
}
public void GivenAnEmptyStringShouldReturnZero()
{
var calculator = new StringCalculator();
var expected = 0;
Assert.AreEqual(expected, calculator.Add(string.Empty));
}
public void GivenASingleNumberShouldReturnNumber()
{
var calculator = new StringCalculator();
var expected = 1;
Assert.AreEqual(expected, calculator.Add("1"));
}
public void GivenANegativeNumberShouldReturnThrowAnException()
{
var calculator = new StringCalculator();
var expected = -1;
Assert.Throws(typeof(ArgumentOutOfRangeException), () => calculator.Add("-1,2"));
}
public void QuandoEseguoIlCalcolo()
{
var stringa = ScenarioContext.Current.Get<string>("stringa");
var stringCalculator = new StringCalculator();
var result = stringCalculator.Add(stringa);
ScenarioContext.Current.Add("somma", result);
}
public void Add_ShouldBeAbleToHandleUserDefinedDelimiter()
{
var calculator = new StringCalculator();
var result = calculator.Add(@"//;
1;2");
Assert.AreEqual(3, result);
}
public void Add_ShouldBeAbleToHandleNewLineInParameterString()
{
var calculator = new StringCalculator();
var result = calculator.Add(@"1
2");
Assert.AreEqual(3, result);
}
public void Add_ShouldBeAbleToHandleBothNewLineAndCommaParameterString()
{
var calculator = new StringCalculator();
var result = calculator.Add(@"1,
2,3");
Assert.AreEqual(6, result);
}
public void Add_WhenAnEmptyStringIsUsedThenZeroIsReturned()
{
StringCalculator sc = new StringCalculator();
string emptyParameter = string.Empty;
var result = sc.Add(emptyParameter);
Assert.AreEqual(0, result);
}
public void Add_ProvidedNumbersInStringWithCustomDelimiters_ReturnValue(string input, int expectedOutput)
{
var stringCalculator = new StringCalculator();
var result = stringCalculator.Add(input);
Assert.AreEqual(expectedOutput, result);
}
public void Add_WhenAMultipleCharacterDelimiterIsSpecfiedInTheNumberParameterThenItIsUsedToSeparateTheNumbers()
{
StringCalculator sc = new StringCalculator();
string numbersParameter = "//[---]\n1---2---3---4---5";
var result = sc.Add(numbersParameter);
Assert.AreEqual(1 + 2 + 3 + 4 + 5, result);
}
public void OneAndTwoShouldReturn3()
{
var stringCalculator = new StringCalculator();
int three = stringCalculator.Sum("1,2");
three.Should().Be(3);
}
public void AddNumbersFromStringArray_ProvidedArrayOfNumbers_ReturnValue(string[] input, int expectedOutput)
{
var stringCalculator = new StringCalculator();
var result = stringCalculator.AddNumbersFromStringArray(input);
Assert.AreEqual(expectedOutput, result);
}
public void NewLineShouldWorkAsComma()
{
var stringCalculator = new StringCalculator();
int three = stringCalculator.Sum("1\n2");
three.Should().Be(3);
}
public void SeveralStringNumbersShouldReturnSummetValue(string number, int expectedValue)
{
var stringCalculator = new StringCalculator();
int actualValue = stringCalculator.Sum(number);
actualValue.Should().Be(expectedValue);
}
public void DelimiterShouldBeChangeable()
{
var stringCalculator = new StringCalculator();
int three = stringCalculator.Sum("\\;\n1;2");
three.Should().Be(3);
}
public void NegativeValuesShouldThrowException()
{
var stringCalculator = new StringCalculator();
Action action = () => stringCalculator.Sum("-1,-2,5");
action.ShouldThrow<Exception>()
.WithMessage("Negatives not allowed: -1, -2");
}
public void Add_WhenOneNumberIsUsedThenThatNumberIsReturned()
{
StringCalculator sc = new StringCalculator();
string oneNumberParameter = "1";
var result = sc.Add(oneNumberParameter);
Assert.AreEqual(1, result);
}
public void Add_WhenANewLineCharacterIsUsedThenItIsTreatedAsADelimiterAndTheSumOfTheNumbersIsReturned()
{
StringCalculator sc = new StringCalculator();
string twoNumberParameter = "1,2\n3,4,5";
var result = sc.Add(twoNumberParameter);
Assert.AreEqual(1 + 2 + 3 + 4 + 5, result);
}
public void Add_WhenAnyNumbersofNumbersAreUsedThenTheSumOfTheNumbersIsReturned()
{
StringCalculator sc = new StringCalculator();
string twoNumberParameter = "1,2,3,4,5";
var result = sc.Add(twoNumberParameter);
Assert.AreEqual(1 + 2 + 3 + 4 + 5, result);
}
public void Add_WhenADelimiterParameterIsSpecfiedThenItIsUsedToSeparateTheNumbers()
{
StringCalculator sc = new StringCalculator();
string twoNumberParameter = "1;2;3;4;5";
string[] delimiters = new string[] { ";" };
var result = sc.Add(twoNumberParameter, delimiters);
Assert.AreEqual(1 + 2 + 3 + 4 + 5, result);
}
public void Calc_EmptyExpression_0Returned ()
{
//arrange
StringCalculator calculator = new StringCalculator();
//act
int result = calculator.Calc("");
//assert
Assert.AreEqual(0, result);
}
public void Calc_1Summ2_3Retuned()
{
//arrange
StringCalculator calculator = new StringCalculator();
//act
int result = calculator.Calc("1+2");
//assert
Assert.AreEqual(3, result);
}
public void should_return_zero_for_empty_string()
{
//arrange
var calc = new StringCalculator();
//act
var result = calc.Add("");
//accert
result.ShouldBeEquivalentTo(0);
}
public void should_handle_new_line_separator()
{
//arrange
var calc = new StringCalculator();
//act
var result = calc.Add("1\n2,3");
//accert
result.ShouldBeEquivalentTo(6);
}
public void should_handle_one_number()
{
//arrange
var calc = new StringCalculator();
var randomNumber = new Random().Next(10);
//act
var result = calc.Add(randomNumber.ToString());
//accert
result.ShouldBeEquivalentTo(randomNumber);
}
public void InputStringWithNegativeNnumberShouldThrowException()
{
var input = "11, -11, 0";
Assert.Throws <System.ArgumentException>(() => StringCalculator.Add(input));
}
//Setup and Shortcut Method
private int StringAddMethod(string input)
{
StringCalculator StringCalc = new StringCalculator();
return(StringCalc.Add(input));
}
public void whenMoreThan2NumbersAreUsedThenExceptionIsThrown()
{
StringCalculator stringCalculator = new StringCalculator();
stringCalculator.Add("1,2,3");
}
public void Add_NewLineDelimitersInString_ReturnSum(string numbers, int expectedResult)
{
var result = StringCalculator.Add(numbers);
Assert.That(result, Is.EqualTo(expectedResult));
}
public int testAdd_AnyNumberOfDelimiters_ReturnSum(string input)
{
StringCalculator StringCalc = new StringCalculator();
return(StringCalc.Add(input));
}
public void CreateCalculator()
{
_stringCalculator = new StringCalculator();
}
public void Add_MultipleDelimiters_Accepts()
{
int result = new StringCalculator().Add("//[*][%]\n1*2%3");
Assert.AreEqual(6, result);
}
public void Add_DefineDelimiterInString_UseNewDelimiter(string numbers, int expectedResult)
{
var result = StringCalculator.Add(numbers);
Assert.That(result, Is.EqualTo(expectedResult));
}
public int testAdd_UnkownAmountOfNumbers_ReturnSum(string input)
{
StringCalculator StringCalc = new StringCalculator();
return(StringCalc.Add(input));
}
public int testAdd_CarriageDelimeter_ReturnSum(string input)
{
StringCalculator StringCalc = new StringCalculator();
return(StringCalc.Add(input));
}
public void Given_many_delimiters_but_no_new_line_delimiter_should_throw_an_exception(string inputString,
StringCalculator sut)
{
var exception = Assert.Throws <ArgumentException>(() => sut.Add(inputString));
Assert.Contains("Newline delimiter not found", exception.Message);
}
public void Given_many_numbers_greater_than_1000_should_return_sum_ignoring_those_numbers(string inputString, int expectedResult, StringCalculator sut)
{
var result = sut.Add(inputString);
Assert.Equal(expectedResult, result);
}
public void Given_numbers_greater_than_1000_should_return_sum_ignoring_those_numbers(int smallNumber, int bigNumber, StringCalculator sut)
{
var inputString = $"{string.Join(",", smallNumber, bigNumber)}";
var result = sut.Add(inputString);
Assert.Equal(smallNumber, result);
}
public StringCalculatorTests()
{
_testee = new StringCalculator();
}
public void Add_MultipleCustomLengthDelimiters_Accepts()
{
int result = new StringCalculator().Add("//[**][%%%%]\n1**2%%%%3");
Assert.AreEqual(6, result);
}
public void Given_consecutive_delimiters_should_return_format_exception(string inputString, StringCalculator sut)
{
var exception = Assert.Throws <FormatException>(() => sut.Add(inputString));
Assert.Contains("Two consecutive delimiters are not allowed.", exception.Message);
}
public void SetUp()
{
_stringCalculator = new StringCalculator();
}
public void SetupStringCalculatorObj()
{
calculator = new StringCalculator();
}
public int testAdd_TwoDiffrentDelimiters_ReturnSum(string input)
{
StringCalculator StringCalc = new StringCalculator();
return(StringCalc.Add(input));
}
public int testAdd_LargerThanThousand_ThousandDiscardedInSum(string input)
{
StringCalculator StringCalc = new StringCalculator();
return(StringCalc.Add(input));
}
public void Given_a_custom_delimiter_definition_should_return_the_sum_of_all_number(char customDelimiter, StringCalculator sut,
int multipleNumbers, Generator <int> intGenerator)
{
var integersToTest = intGenerator.Take(multipleNumbers).ToList();
var lowercaseCharacterDelimiter = customDelimiter.ToString().ToLower();
var inputString = $"//{lowercaseCharacterDelimiter}\n{string.Join(lowercaseCharacterDelimiter, integersToTest)}";
var result = sut.Add(inputString);
Assert.Equal(integersToTest.Sum(), result);
}
public StringCalculatorFixture()
{
Sut = new StringCalculator();
}
public void ReturnsZero_WhenStringEmpty()
{
Int32 result = StringCalculator.Add(String.Empty);
Assert.AreEqual(0, result);
}
public void whenNegativeNumbersAreUsedThenRuntimeExceptionIsThrown()
{
StringCalculator stringCalculator = new StringCalculator();
int res = stringCalculator.Add("2,3,-9,2,4,5");
}
public void Given_unknown_amount_of_numbers_should_return_the_sum_of_all_numbers(StringCalculator sut, int multipleNumbers, Generator <int> intGenerator)
{
var integersToTest = intGenerator.Take(multipleNumbers).ToList();
var inputString = string.Join(",", integersToTest);
var result = sut.Add(inputString);
Assert.Equal(integersToTest.Sum(), result);
}
public int testAdd_ChangeDefaultDelimter_ReturnSum(string input)
{
StringCalculator StringCalc = new StringCalculator();
return(StringCalc.Add(input));
}
public void Given_new_line_as_a_delimiter_should_return_the_sum_of_all_numbers(StringCalculator sut, int multipleNumbers, Generator <int> intGenerator)
{
var integersToTest = intGenerator.Take(multipleNumbers).ToList();
var inputString = $"{integersToTest[0]}\n{string.Join(",", integersToTest.Skip(1).ToList())}";
var result = sut.Add(inputString);
Assert.Equal(integersToTest.Sum(), result);
}
public void Given_new_line_as_a_delimiter_after_comma_should_return_format_exception(StringCalculator sut)
{
var inputString = "1,\n";
var exception = Assert.Throws <FormatException>(() => sut.Add(inputString));
Assert.Contains("Two consecutive delimiters are not allowed.", exception.Message);
}
public void Given_an_empty_string_should_return_zero()
{
var result = new StringCalculator().Add(string.Empty);
Assert.Equal(0, result);
}
public void Add_MoreThanThousandNumberInString_IgnoreThatNumber(string numbers, int expectedResult)
{
var result = StringCalculator.Add(numbers);
Assert.That(result, Is.EqualTo(expectedResult));
}
