public void TestZero()
{
string numbers = "0";
StringCalculator.StringCalculator sc = new StringCalculator.StringCalculator();
Assert.AreEqual(0, sc.Add(numbers));
}
public void TestOneNumber()
{
string numbers = "5";
StringCalculator.StringCalculator sc = new StringCalculator.StringCalculator();
Assert.AreEqual(5, sc.Add(numbers));
}
public void TestMultipleDelimitersWithLengthGreaterThanOne()
{
string numbers = "//[***][---][%@!]\n 1---2\n3\n4***5%@!6,1001\n1002";
StringCalculator.StringCalculator sc = new StringCalculator.StringCalculator();
Assert.AreEqual(21, sc.Add(numbers));
}
public void Add_WhenEmptyString_ReturnsZero()
{
StringCalculator stringCalculator = new StringCalculator();
var result = stringCalculator.Add("");
Assert.AreEqual(result, 0);
}
public void TestTwoNumbers()
{
string numbers = "1,5";
StringCalculator.StringCalculator sc = new StringCalculator.StringCalculator();
Assert.AreEqual(6, sc.Add(numbers));
}
public void TestNewLineSeperator()
{
string numbers = "1\n2,3\n4";
StringCalculator.StringCalculator sc = new StringCalculator.StringCalculator();
Assert.AreEqual(10, sc.Add(numbers));
}
public void TestException()
{
string numbers = "1000000000,10000000000";
StringCalculator.StringCalculator sc = new StringCalculator.StringCalculator();
Assert.AreEqual(-1, sc.Add(numbers));
}
public void TestNegativeNumberException()
{
string numbers = "1,-2,-3";
StringCalculator.StringCalculator sc = new StringCalculator.StringCalculator();
Assert.AreEqual(-1, sc.Add(numbers));
}
public void TestDifferentDelimiter()
{
string numbers = "//[;]\n1;2\n3\n4;5;6";
StringCalculator.StringCalculator sc = new StringCalculator.StringCalculator();
Assert.AreEqual(21, sc.Add(numbers));
}
public void TestIgnoreNumberGreaterThan1000()
{
string numbers = "//[;]\n1;2\n3\n4;5;6;1001;1002";
StringCalculator.StringCalculator sc = new StringCalculator.StringCalculator();
Assert.AreEqual(21, sc.Add(numbers));
}
public void AddReturnZeroWhenStringEmpty()
{
var calculator = new StringCalculator();
var res = calculator.AddString("");
Assert.AreEqual(0,res);
}
public void CustomDemiters()
{
var stringCalculator = new StringCalculator.StringCalculator();
Assert.AreEqual(3, stringCalculator.Add("//;\n1;2"));
Assert.AreEqual(15, stringCalculator.Add("//;\n12;3"));
Assert.AreEqual(16, stringCalculator.Add("//+\n12+3+1"));
}
public int AddTest(string input)
{
var stringCalculator = new StringCalculator();
int result = stringCalculator.Add(input);
return result;
}
public void Add_EmptyString_ReturnsZero()
{
StringCalculator calculator = new StringCalculator();
int total = calculator.Add( "" );
Assert.AreEqual( 0, total );
}
public void Add_TwoNumbers_ReturnsTheTotal()
{
StringCalculator calculator = new StringCalculator();
int total = calculator.Add( "1,2" );
Assert.AreEqual( 3, total );
}
public void Add_SingleNumber_ReturnsTheNumber()
{
StringCalculator calculator = new StringCalculator();
int total = calculator.Add( "1" );
Assert.AreEqual( 1, total );
}
public void Add_CountTheCalls_ValidOutputAndTheCalls(string input, int expected)
{
var stringCalculator = new StringCalculator.StringCalculator();
var actual = stringCalculator.Add(input);
Assert.AreEqual(expected, actual);
Assert.AreEqual(5, stringCalculator.CalledCount);
}
public void TestSimpleNumbers()
{
var stringCalculator = new StringCalculator.StringCalculator();
Assert.AreEqual(0, stringCalculator.Add(""));
Assert.AreEqual(1, stringCalculator.Add("1"));
Assert.AreEqual(2, stringCalculator.Add("2"));
Assert.AreEqual(21, stringCalculator.Add("21"));
}
public void Add_SimpleInputs_AddsNumbers( string numbers, int expectedTotal )
{
StringCalculator calculator = new StringCalculator();
int total = calculator.Add( numbers );
Assert.AreEqual( expectedTotal, total );
}
public void Add_CallsEventOnAdditionComplete(string input, int expected)
{
var stringCalculator = new StringCalculator.StringCalculator();
stringCalculator.AdditionComplete += StringCalculator_AdditionComplete;
var actual = stringCalculator.Add(input);
Assert.AreEqual(expected, actual);
}
public void TestThreeNumbers()
{
string numbers = "1,5,6";
StringCalculator.StringCalculator sc = new StringCalculator.StringCalculator();
//Assert.AreEqual(-1, sc.Add(numbers));
// JK 10/9 code exercise 2 - Added support for unknown amount of numbers
Assert.AreEqual(12, sc.Add(numbers));
}
public void Add_NullOrBlankFromValues_ReturnsZero(
[Values( null, "", " ", "\t", "\n" )] string input
)
{
StringCalculator calculator = new StringCalculator();
int total = calculator.Add( input );
Assert.AreEqual( 0, total );
}
public void Add_NullOrBlankFromSource_ReturnsZero(
[ValueSource( "NullOrBlankCases" )] string input
)
{
StringCalculator calculator = new StringCalculator();
int total = calculator.Add( input );
Assert.AreEqual( 0, total );
}
public void Add_EvenNumbersBetweenTwoAndTen_ReturnsTheNumber(
[Range( 2, 10, 2 )] int number
)
{
StringCalculator calculator = new StringCalculator();
string numbers = number.ToString();
int total = calculator.Add( numbers );
Assert.AreEqual( number, total );
}
public void Add_AnyRandomNumbers_AddsNumbers(
[ValueSource( "AnyRandomNumber" )] int a,
[ValueSource( "AnyRandomNumber" )] int b
)
{
StringCalculator calculator = new StringCalculator();
string numbers = a + "," + b;
int total = calculator.Add( numbers );
Assert.AreEqual( a + b, total );
}
public void Add_AnyPairBetweenOneAndFive_AddsNumbers(
[Values( 1, 2, 3, 4, 5 )] int a,
[Values( 1, 2, 3, 4, 5 )] int b
)
{
StringCalculator calculator = new StringCalculator();
string numbers = a + "," + b;
int total = calculator.Add( numbers );
Assert.AreEqual( a + b, total );
}
public void AddToConsoleTest()
{
var input = "1\n2,3";
var textWriter = Substitute.For<TextWriter>();
Console.SetOut(textWriter);
var stringCalculator = new StringCalculator();
stringCalculator.AddToConsole(input);
textWriter.Received().WriteLine(6);
}
public void TestLargeNumbers()
{
// Arrange
string input = "1\n2000, 123456789,80,";
var expected = "1+0+0+80+0 = 81";
var stringCalculator = new StringCalculator.StringCalculator(input);
// Act
var actual = stringCalculator.CalculateSum();
// Assert
Assert.AreEqual(expected, actual);
}
public void TestNegativeNumbers()
{
var stringCalculator = new StringCalculator.StringCalculator();
try
{
stringCalculator.Add("-1,2");
}
catch (ArgumentException exception)
{
Assert.AreEqual("negatives not allowed", exception.Message);
throw;
}
}
public void TestSingleCharacterDelimiter()
{
// Arrange
string input = "//;\n2;5";
var expected = "0+2+5 = 7";
var stringCalculator = new StringCalculator.StringCalculator(input);
// Act
var actual = stringCalculator.CalculateSum();
// Assert
Assert.AreEqual(expected, actual);
}
public void Add_NegativeNumbersInput_ThrowsException(string input, string exceptionMessage)
{
var stringCalculator = new StringCalculator.StringCalculator();
Assert.Throws(Is.TypeOf <ArgumentException>()
.And.Message.EqualTo(exceptionMessage),
delegate { stringCalculator.Add(input); });
var ex = Assert.Throws <ArgumentException>(
delegate { stringCalculator.Add(input); });
Assert.That(ex.Message, Is.EqualTo(exceptionMessage));
}
public void TestMultipleDelimiters()
{
// Arrange
string input = "//[**][((]\n11((22**33";
var expected = "11+22+33 = 66";
var stringCalculator = new StringCalculator.StringCalculator(input);
// Act
var actual = stringCalculator.CalculateSum();
// Assert
Assert.AreEqual(expected, actual);
}
public void TestHappyPath()
{
// Arrange
var input = "1,2,3,4,5,6,7,8,9,10,11,12";
var expected = "1+2+3+4+5+6+7+8+9+10+11+12 = 78";
var stringCalculator = new StringCalculator.StringCalculator(input);
// Act
var actual = stringCalculator.CalculateSum();
// Assert
Assert.AreEqual(expected, actual);
}
public void TestMultipleDelimitersWithCharacters()
{
// Arrange
string input = "//[*][!!][r9r]\n11r9r22*33!!44";
var expected = "11+22+33+44 = 110";
var stringCalculator = new StringCalculator.StringCalculator(input);
// Act
var actual = stringCalculator.CalculateSum();
// Assert
Assert.AreEqual(expected, actual);
}
public void TestMultipleDelimitersWithLargeNumber()
{
// Arrange
string input = "//[**][((]\n11((22**33**500000**10";
var expected = "11+22+33+0+10 = 76";
var stringCalculator = new StringCalculator.StringCalculator(input);
// Act
var actual = stringCalculator.CalculateSum();
// Assert
Assert.AreEqual(expected, actual);
}
public void TestWhitespaces()
{
// Arrange
string input = "20 , 40 ";
var expected = "20+40 = 60";
var stringCalculator = new StringCalculator.StringCalculator(input);
// Act
var actual = stringCalculator.CalculateSum();
// Assert
Assert.AreEqual(expected, actual);
}
public void TestOneInput()
{
// Arrange
string input = "5";
var expected = "5 = 5";
var stringCalculator = new StringCalculator.StringCalculator(input);
// Act
var actual = stringCalculator.CalculateSum();
// Assert
Assert.AreEqual(expected, actual);
}
public void TestTwoDelimiters()
{
// Arrange
string input = "1\n2,3";
var expected = "1+2+3 = 6";
var stringCalculator = new StringCalculator.StringCalculator(input);
// Act
var actual = stringCalculator.CalculateSum();
// Assert
Assert.AreEqual(expected, actual);
}
public void TestSingleDelimiterWithEmptyEntry()
{
// Arrange
string input = "1\n2,";
var expected = "1+2+0 = 3";
var stringCalculator = new StringCalculator.StringCalculator(input);
// Act
var actual = stringCalculator.CalculateSum();
// Assert
Assert.AreEqual(expected, actual);
}
public void TestParenthesisMultipleCharacterDelimiter()
{
// Arrange
string input = "//[((]\n11((22((33";
var expected = "11+22+33 = 66";
var stringCalculator = new StringCalculator.StringCalculator(input);
// Act
var actual = stringCalculator.CalculateSum();
// Assert
Assert.AreEqual(expected, actual);
}
public string ExecuteAddTest(string command)
{
var textReader = Substitute.For<TextReader>();
Console.SetIn(textReader);
var textWriter = Substitute.For<TextWriter>();
Console.SetOut(textWriter);
textReader.ReadLine().Returns(command);
string result = null;
textWriter
.When(w => w.WriteLine(Arg.Any<string>()))
.Do(c => result = c.Arg<string>());
var stringCalculator = new StringCalculator();
stringCalculator.ExecuteAdd(Console.ReadLine());
return result;
}
public void TestExceptionForNegativeNumbers()
{
// Arrange
string input = "-50,100,-100,200";
var expectedExceptionMessage = "Unable to process negative numbers: -50, -100";
var stringCalculator = new StringCalculator.StringCalculator(input);
// Act
try
{
var actual = stringCalculator.CalculateSum();
// Fail if no exception thrown
Assert.Fail();
}
// Assert
catch (ArgumentOutOfRangeException ex)
{
Assert.IsTrue(ex.Message.Contains(expectedExceptionMessage));
}
catch (Exception)
{
Assert.Fail();
}
}
public void MoreThan2()
{
var stringCalculator = new StringCalculator.StringCalculator();
Assert.AreEqual(3, stringCalculator.Add("1,1,1"));
Assert.AreEqual(6, stringCalculator.Add("1,2,3"));
}
public void IgnoredNumbersHigherThan1000()
{
var stringCalculator = new StringCalculator.StringCalculator();
Assert.AreEqual(2, stringCalculator.Add("2,1000"));
}
public void CustomDemitersVariousCharacters()
{
var stringCalculator = new StringCalculator.StringCalculator();
Assert.AreEqual(3, stringCalculator.Add("//[**]\n1**2"));
}
public void ExecuteCommandCyclicTes()
{
var textReader = Substitute.For<TextReader>();
Console.SetIn(textReader);
var textWriter = Substitute.For<TextWriter>();
Console.SetOut(textWriter);
textReader.ReadLine().Returns("scalc '1,2,3");
textWriter
.When(t => t.WriteLine("another input please"))
.Do(c => textReader.ReadLine().Returns(string.Empty));
var stringCalculator = new StringCalculator();
stringCalculator.ExecuteAddCyclic();
textWriter.Received().WriteLine("The result is 6");
textWriter.Received().WriteLine("another input please");
}
private int Add(string input)
{
StringCalculator stringCalculator = new StringCalculator();
int result = stringCalculator.Add(input);
return result;
}
public void SetUp()
{
_calculator = new StringCalculator();
}
static void Main(string[] args)
{
StringCalculator c = new StringCalculator();
string numbers = "// \n4 3 8 5";
Console.WriteLine(c.Add(numbers));
Console.WriteLine();
Match match = Regex.Match(numbers, @"\/\/.{1}\n");
Console.WriteLine(match.Success);
string numbers2 = "3,4\n3";
Match matchDelimiter = Regex.Match(numbers2, @"(?<=\/\/).+(?=\n)");
Console.WriteLine(matchDelimiter.Success);
Console.WriteLine(c.Add(numbers2));
Console.WriteLine();
string delimiter = "[!!!][**]";
List <string> delimiterList = new List <string>(); //Regex.Split(delimiter, @"(?<=[\[.+\]])").ToList();
foreach (Match m in Regex.Matches(delimiter, @"\[.+?\]"))
{
delimiterList.Add(m.Value);
}
Console.WriteLine(delimiterList.Count + " elements in list:");
foreach (string s in delimiterList)
{
Console.WriteLine(s);
}
/*
* int[] arr = { 3, 6, 1, 667, 1615, 33 };
* int[] arr2 = arr.Select(n => { if (n > 1000) n = 0; return n; }).ToArray();
* foreach(int i in arr2) {
* Console.WriteLine(i);
* }
*/
Console.ReadKey();
/*
* char delimiter = ';';
*
* string numbers = "//;\n2;2;2";
* //Regex.Split();
*
* Match match = Regex.Match(numbers, @"\/\/[^\s]\n");
* if (match.Success) {
* //set delimiter
* delimiter = match.Value[2];
* numbers = numbers.Substring(4);
* }
* string[] arr = numbers.Split(delimiter, '\n');
* Console.WriteLine(numbers);
* foreach (string s in arr) {
* Console.WriteLine(s);
* }
* Console.WriteLine("Printed out.");
* Console.ReadKey();
*/
}
public void TestAdd(int expected, string stringOfSeperatedNumbers, char separator = ',')
{
Assert.AreEqual(expected, StringCalculator.Add(stringOfSeperatedNumbers, separator));
}
private static void Main(string[] args)
{
var result = StringCalculator.Add(null);
Console.WriteLine(result);
}
public static void CalculateTo(this string input, int expected)
{
var item = new StringCalculator();
Assert.Equal(expected, StringCalculator.Add(input));
}
public void GivenNegNumberErrorMessageShouldContainNegNumber()
{
var error = Assert.Throws <ArgumentOutOfRangeException>(() => StringCalculator.Add("-1,2"));
Assert.Contains("-1", error.Message);
}
public void Add_RangeBetweenOneAndFive_AddsNumbers(
[Range( 1, 5 )] int a,
[Range( 1, 5 )] int b
)
{
StringCalculator calculator = new StringCalculator();
string numbers = a + "," + b;
int total = calculator.Add( numbers );
Assert.AreEqual( a + b, total );
}
public void MultipleDelimiters()
{
var stringCalculator = new StringCalculator.StringCalculator();
Assert.AreEqual(10, stringCalculator.Add("//[**][$$]\n1**2$$3,4"));
}
public void Add_RandomNumbers_AddsNumbers(
[Random( 0, 10, 1 )] int a,
[Random( 0, 10, 1 )] int b
)
{
StringCalculator calculator = new StringCalculator();
string numbers = a + "," + b;
int total = calculator.Add( numbers );
Assert.AreEqual( a + b, total );
}
public void Add_RandomNumberBetweenZeroAndTen_ReturnsTheNumber(
[Random( 0, 10, 1 )] int number
)
{
StringCalculator calculator = new StringCalculator();
string numbers = number.ToString();
int total = calculator.Add( numbers );
Assert.AreEqual( number, total );
}
public void Add_SimpleInputs_AddsNumbers(
[ValueSource( "TestNumbers" )] string numbers,
[ValueSource( "TestTotals" )] int expectedTotal
)
{
StringCalculator calculator = new StringCalculator();
int total = calculator.Add( numbers );
Assert.AreEqual( expectedTotal, total );
}
public void TwoNumbers()
{
var stringCalculator = new StringCalculator.StringCalculator();
Assert.AreEqual(2, stringCalculator.Add("1,1"));
Assert.AreEqual(3, stringCalculator.Add("1,2"));
Assert.AreEqual(33, stringCalculator.Add("11,22"));
}
public void CtorTest()
{
var stringCalculator = new StringCalculator();
stringCalculator.Should().NotBeNull();
}
