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 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_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 TestNegativeNumberException()
{
string numbers = "1,-2,-3";
StringCalculator.StringCalculator sc = new StringCalculator.StringCalculator();
Assert.AreEqual(-1, 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 TestDifferentDelimiter()
{
string numbers = "//[;]\n1;2\n3\n4;5;6";
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 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 TestZero()
{
string numbers = "0";
StringCalculator.StringCalculator sc = new StringCalculator.StringCalculator();
Assert.AreEqual(0, 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 TestTwoNumbers()
{
string numbers = "1,5";
StringCalculator.StringCalculator sc = new StringCalculator.StringCalculator();
Assert.AreEqual(6, sc.Add(numbers));
}
public void TestOneNumber()
{
string numbers = "5";
StringCalculator.StringCalculator sc = new StringCalculator.StringCalculator();
Assert.AreEqual(5, sc.Add(numbers));
}
public int AddTest(string input)
{
var stringCalculator = new StringCalculator();
int result = stringCalculator.Add(input);
return result;
}
public void Add_TwoNumbers_ReturnsTheTotal()
{
StringCalculator calculator = new StringCalculator();
int total = calculator.Add( "1,2" );
Assert.AreEqual( 3, 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 Add_EmptyString_ReturnsZero()
{
StringCalculator calculator = new StringCalculator();
int total = calculator.Add( "" );
Assert.AreEqual( 0, total );
}
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_SingleNumber_ReturnsTheNumber()
{
StringCalculator calculator = new StringCalculator();
int total = calculator.Add( "1" );
Assert.AreEqual( 1, total );
}
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_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 Add_NullOrBlankFromSource_ReturnsZero(
[ValueSource( "NullOrBlankCases" )] string input
)
{
StringCalculator calculator = new StringCalculator();
int total = calculator.Add( input );
Assert.AreEqual( 0, total );
}
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_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_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 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 );
}
static void Main(string[] args)
{
string[] input = { "1,-2,-3", "", "1", "1,2", "10,25", "999,1", "10000000000,1000000000", "1,2,3", "1\n2,3\n4", "//[;]\n1;2\n3\n4;5;6", "//[;]\n1;2\n3\n4;5;6;1001;1002", "//[***]\n 1***2\n3\n4***5***6***1001\n1002", "//[***][---][%@!]\n 1---2\n3\n4***5%@!6,1001\n1002" };
StringCalculator sc = new StringCalculator();
for (int i = 0; i < input.Length; i++)
{
Console.WriteLine(string.Format("Sum of {0}:", input[i].Replace("\n", ",")));
Console.WriteLine(string.Format("{0}", sc.Add(input[i]).ToString()));
}
Console.Read();
}
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 Add_ShouldLog3_WhenCalledWith1And2()
{
var logger = new LoggerMock();
var sc = new StringCalculator(logger);
const string expected = "3";
sc.Add("1,2");
var actual = logger.LastEntry;
Assert.Equal(expected, actual);
}
public void Add_NotifiesWebServerOfLoggingExceptions_WhenLoggerThrows()
{
var logger = new LoggerMock();
var webService = new WebServiceMock();
var sc = new StringCalculator(logger, webService);
const string expectedExceptionMessage = "LoggerThrew";
sc.Add("616");
var actualExceptionMessage = webService.LastException.Message;
Assert.Equal(expectedExceptionMessage, actualExceptionMessage);
}
public void Add_Sends3ToConsole_WhenPassed1And2()
{
var logger = new LoggerMock();
var webService = new WebServiceMock();
var output = new OutputMock();
var sc = new StringCalculator(logger, webService, output);
const string expected = "3";
sc.Add("1,2");
var actual = output.LastLine;
Assert.Equal(expected, actual);
}
static void Main(string[] args)
{
while (true)
{
Console.WriteLine("Input '1' to stop the program");
string input = Console.ReadLine();
Console.Clear();
if (input == "1")
{
break;
}
else
{
Console.WriteLine("Input numbers in this format 'x,y,z' to calculate");
string number = Console.ReadLine();
string result = StringCalculator.Add(number);
Console.WriteLine($"The result is {result}");
}
}
}
public void IgnoredNumbersHigherThan1000()
{
var stringCalculator = new StringCalculator.StringCalculator();
Assert.AreEqual(2, stringCalculator.Add("2,1000"));
}
public void TestAdd(int expected, string stringOfSeperatedNumbers, char separator = ',')
{
Assert.AreEqual(expected, StringCalculator.Add(stringOfSeperatedNumbers, separator));
}
public void CustomDemitersVariousCharacters()
{
var stringCalculator = new StringCalculator.StringCalculator();
Assert.AreEqual(3, stringCalculator.Add("//[**]\n1**2"));
}
public void ShouldBeReturnZeroWhenReceiveEmpty()
{
var sum = StringCalculator.Add("");
Assert.AreEqual(0, sum);
}
private int Add(string input)
{
StringCalculator stringCalculator = new StringCalculator();
int result = stringCalculator.Add(input);
return result;
}
private static void Main(string[] args)
{
var result = StringCalculator.Add(null);
Console.WriteLine(result);
}
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"));
}
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();
*/
}
static void Main(string[] args)
{
StringCalculator calculator = new StringCalculator();
calculator.Add("1,1");
}
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 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 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_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 );
}
private int Act(string input)
{
return(calculator.Add(input));
}
public void MoreThan2()
{
var stringCalculator = new StringCalculator.StringCalculator();
Assert.AreEqual(3, stringCalculator.Add("1,1,1"));
Assert.AreEqual(6, stringCalculator.Add("1,2,3"));
}
static void Main(string[] args)
{
var calc = new StringCalculator();
var result = calc.Add("1,2");
}
public void MultipleDelimiters()
{
var stringCalculator = new StringCalculator.StringCalculator();
Assert.AreEqual(10, stringCalculator.Add("//[**][$$]\n1**2$$3,4"));
}
public void Add_ShouldThrow_ForNegativeNumbers()
{
var sc = new StringCalculator();
Assert.Throws <ArgumentException>(() => sc.Add("//;\n1;2;-7"));
}
public static void CalculateTo(this string input, int expected)
{
var item = new StringCalculator();
Assert.Equal(expected, StringCalculator.Add(input));
}
public void when2NumbersAreUsedThenNoExceptionIsThrown( )
{
StringCalculator.Add("1,2");
Assert.True(true);
}
public void ShouldBeReturnTheSameReceiveNumber()
{
var sum = StringCalculator.Add("1");
Assert.AreEqual(1, sum);
}
public void ShouldBeReturnTheAdditionOfReceiveNumbers()
{
var sum = StringCalculator.Add("1, 4, 6, 1, 3");
Assert.AreEqual(15, sum);
}
