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)); }