From fc629749aa6309976dfd876cd946f6556a68d73e Mon Sep 17 00:00:00 2001
From: jttkinnunen <jttkinnunen@gmail.com>
Date: Wed, 26 Sep 2018 20:51:45 +0300
Subject: [PATCH 1/3] test

---
 bin/StringCalculator.class      | Bin 405 -> 2251 bytes
 bin/StringCalculatorTest.class  | Bin 505 -> 1479 bytes
 src/StringCalculator.java       |  89 +++++++++++++++++++++++++++++++-
 tests/StringCalculatorTest.java |  42 ++++++++++++++-
 4 files changed, 127 insertions(+), 4 deletions(-)

diff --git a/bin/StringCalculator.class b/bin/StringCalculator.class
index a937b0c43633d36f133837cd90ddd10fb14ac782..06ec86c8d482fbdaf72db86dcc16d62c075d50eb 100644
GIT binary patch
literal 2251
zcmb_cT~`xF7=9+%WRoQ^d<8)oKT^~LBPe3DV1pQerUp=hU^(rnOR^=aVMCLRwLe8K
zdQR_p!A)<drx*PJ{ZIAunb|c#;i9MQ$w}s&nRnjj<DJQ$?|%OSz$~_P1O)mkZp(Id
zi)N$RX_#)ar9<QDbMvJ+-7uZq>GhrGR@D^<-?1IrEeHfN*-Zhh*sNIwf{4ZtLRcVC
zwjFD&v$tclHq4!dB`{cSR?Wty*|O!_U)0>X-IjYF<Ic0PS*r;oGvyw-mo=X)2^dSS
zs@A@1H=VYQL4mQ4D|Gh_3}Zw`@&g@Sb_}O6Dxll#rM-RkN2O+4=AVgS9G_5TwQjZ+
zsaMOCvPA=DabCwcfuSC!A~VdYYqesyfHalwS}uiKExWpDHab+UWr~WiqwHuCS}N{U
z@Kp&!TUO1R2!t$;k=SN|M(0IGKu~tP;+oYLtLDCMV4q5Rf2gkqag7#r%W)D`i43Am
z$2uYZ`q6w&qF$+Whix6kYz#M%XO)KK?7DSjR4IbnB$bo<b1}^0jzFZ^bX?PR*wgW&
zjgux-tnWLPQ?=%^w77t~Iu-;5dN!0C*V>gfE+WB7`(~?cam@#<Gl<m9TCuseXOgS?
zLz6D^dbK6~attf-lx{mU>(%;qa;+4@mv}%W?aoeHU2B1nOsSMTZoN!jmFa8p!kv^s
zaLcKcWOepN_Jba&aYhp4{97(~0ap?|dRw+zUyFc`L>MGP36+M~t`o_qG&`-TwQS4h
zk@R}fdwEmR8D1%R%?AqTjQF(pt8+HZQE&`R{)Wh}3<5CtE4P6@et?*lz%kC5z$qk{
z)z4VtY(SOyi7O$loWHV~JH${S^%|kzLFx_qbHPK5y+taoCAEX#0ds;1A&m&*ex8#R
zhKMxG`lmTN!zVK?Ux-4V_3HZQM8Kz*AZ~ye7a0Y3dJLCvnRUnc%^*u&ldNqZ@E77b
zhDAT~ubja8CD%1(CO%*t=#d;z;1c8_VJ?x-Ws=M)Vw2v{F0ll1KCw8i`otobQp6;k
zD1=XksM9B~`Gzo(O`L3e(+Vlc#cRna)xR8PSBXD$ghRZ`A&zT4hdx|a9Qv3qEeR5I
z<^<4RxF06QgtFj9AvbvI5TD6ry}>|A`x&v^TYR1mB|`^Cd^xL{euHOc8Qo;vJezO}
z=WrWo%qeaKuWpyyM3-CI=cXftdx~2ENfhan#tL2wLw*azJEUa`<t@E`oWB@lzPzMs
z$N0a-yyTx(ik9-BTre3r#20hnTr#9RJ4AU-9}7!ukuhBk(PShUeU>+p#!;m+<PZMK
z1h7D*cgbLpO7HPK70K{E^)K-sYndx6DDhLq1I1_GW7So^)>U8bs$c1<U+~pm;5A*R
zBT{`D581&m5k~QdkxrZeJmzkM=L}RBMTzM7W%T?izxQk7ANlpf?|08HuKY*8*6G(n
sGJZq`kLg#1er=H96RO#yjx8#9O77eA>+65z*Ot01|F2(9)m!`OZ_RvYD*ylh

delta 130
zcmX>tIF*^})W2Q(7#J8#7(^y=ZJ3<Hs5rTXS&xxv@@i(SL?#AqpcD@SBambT(!4;L
zk%5naA4swT*=9hR2}m<BuK|$^TtJcytePFHQw$;t)d^A|z#s^eXJilps}}|UA$<&P

diff --git a/bin/StringCalculatorTest.class b/bin/StringCalculatorTest.class
index d44b83f48579a95c814a0008fdfcca590443d2de..9eeb2ea25dc11ade0a820ad21bcfa7e9f5353623 100644
GIT binary patch
literal 1479
zcmb7?>rN9<6ouD;UZ!QVP>MiBC?Zm>BLy|e#b7N8X&@1T@#nNmV8}3obMf*3K9GNk
z(ZmPvp^WRyls3Uepg%h2ve#bU*?a%~^WztQWo#wUC6L?mUDG})>sCFmbl-9J4bM*^
zCeVALf7CTgw~w^l+KEy31rn>KZTjm1-Noqxfmqo&G}7osN<|zAflSr3jh*1MX1M!$
z%`ybCRj0072fAy@ee*EpADf=QooXlV6@ipbhRW%g|3x5O`CK>7eABVLB>Dt~FKb%&
zyn7qizIkdKn4U?u4cm5nJ(Th_RmVNjP6G04@`)=+4Dj@Fwls1`DHsxfT;^5W#fU(U
zA!(vufq`PRU7P4|WqM1&C@Zkz6vEho7uGe60`4a<POG;6hUXcsuVMlZ1XMlTRXzl|
z#i9&$$i2NCR-1*a%ZgrRX2lY&;RO~uB(?}E%eQMA<zwAdFw4V|e9OFw1^JegV;fP5
zIOjnAI0kX4DJfVI=voZJAFFs0hTCC3neQT8ZH6x?pmlt)G#4q>RIE!y+W+K4L*QLV
zSkKU5SwT6Jq$5d1#io>G+LCvsf4svadrsiijZITd(LYU>9bAw-z&JRK;VTkcaSHjL
z<X+>KO+<X=9LhKONH!GVH4o9lwHgKRdy6}P+q~^YhU*x2y~sA>`}vhAYt%`rp`XaT
zKj-+)W(OM>Ud!G~jePx%v9?Q=8GsZN`ec}Wkh!H}A<{P;6?#nKA-yt;okEd}0@GJe
z95yNPZHk!&=17r)){&!+9R2hdz%WVL9QhVUw#CuY;#j;nN2!73kmG4bjyyR=$T3Qe
zv1@ZYyE(`623A9k7ach!$T3NdDRLCA&9QNFj+YI*`VYq}Ip)csk>k;|IbL&)y71;N
Do80X4

delta 190
zcmX@k{gavN)W2Q(7#J8#7^Ek1&17XMNi8m!cvIhjgF%RqLD(<9M4>XZL?JV`ASX39
zHLoN!g^NLiL5!V2l#xLozbIWlt28gOMBlNvIJKyRhe4b{f{}qGEip4^vLmB7W7y=S
zOeTy>lW#G(1Tr!31Fd0W0O|wM>|iSyfjpp?kl+pm;f+8R69X5J<O0$R44e$CKo&QU
U#RE|Vq<MinMg~bB$;2Q90A1=Kp#T5?

diff --git a/src/StringCalculator.java b/src/StringCalculator.java
index 487916b..51abe29 100644
--- a/src/StringCalculator.java
+++ b/src/StringCalculator.java
@@ -1,9 +1,94 @@
+/*Implement a simple String calculator with a method int Add(string numbers)
+1. The method can take 0, 1 or 2 numbers, and will return their sum (for an empty string it will
+return 0) for example “” or “1” or “1,2”
+2. Add method to handle an unknown amount of numbers
+3. Add method to handle new lines between numbers (instead of commas).
+1. the following input is ok: “1\n2,3” (will equal 6)
+2. the following input is NOT ok: “1,\n”
+4. Calling Add with a negative numbers or invalid input (not numbers) will throw an
+StringCalculatorException*/
 
 public class StringCalculator {
-	public int add(String numbersStr) {
+	
+	
+	public int add(String numbersStr) throws StringCalculatorException {
 		// Returns the sum of the numbers given in numbersStr
+		String redString = numbersStr;
+		boolean empty = redString.isEmpty();
 		
-		// not yet implemented
+		if(empty) {
+			return 0;
+		}
+		
+		else if(!empty) {
+			//int x = Character.getNumericValue(element.charAt(2));
+			
+			int luku = Character.getNumericValue(redString.charAt(0));
+			return luku;
+			
+			
+			 
+		}
+		return 0;
+	
+	}
+	public int emptyString(String numbersStr0) throws StringCalculatorException {
+		String redString0 = numbersStr0;
+		boolean empty0 = redString0.isEmpty();
+		if(empty0) {
 		return 0;
+		}
+		return -1;
+	}
+	public int oneString(String numbersStr1) throws StringCalculatorException {
+		String redString1 = numbersStr1;
+		int luku = Character.getNumericValue(redString1.charAt(0));
+		return luku;
+		
+		
+	}
+	public int numberOne(String numbersStr1) throws StringCalculatorException {
+		String redString1 = numbersStr1;
+		int lenght = redString1.length();
+		boolean hadComma = redString1.contains(",");
+		if(!hadComma && (lenght >=1)) {
+			int luku = Integer.parseInt(redString1);
+			return luku;
+		}
+		else return -1;
+	}
+	
+	public int twoNumbers(String numbersStr1) throws StringCalculatorException {
+		String redString1 = numbersStr1;
+		int lenght = redString1.length();
+		boolean hadComma = redString1.contains(",");
+		if(hadComma && (lenght >=1)) {
+			int endIndex = redString1.indexOf(",");
+			String luku1 = redString1.substring(0, endIndex);
+			String luku2 = redString1.substring(endIndex+1);
+			int luku_1 = Integer.parseInt(luku1);
+			int luku_2 = Integer.parseInt(luku2);
+			int luku = luku_1 + luku_2;
+			
+			return luku;
+		}
+		else return -1;
+	}
+
+	public int twoNumbersWithN(String numbersStr1) throws StringCalculatorException {
+		String redString1 = numbersStr1;
+		int lenght = redString1.length();
+		boolean hadSlashN = redString1.contains("\n");
+		if(hadSlashN && (lenght >=1)) {
+			int endIndex = redString1.indexOf("\n");
+			String luku1 = redString1.substring(0, endIndex);
+			String luku2 = redString1.substring(endIndex+1);
+			int luku_1 = Integer.parseInt(luku1);
+			int luku_2 = Integer.parseInt(luku2);
+			int luku = luku_1 + luku_2;
+			
+			return luku;
+		}
+		else return -1;
 	}
 }
diff --git a/tests/StringCalculatorTest.java b/tests/StringCalculatorTest.java
index 4ec9afe..ccf88e7 100644
--- a/tests/StringCalculatorTest.java
+++ b/tests/StringCalculatorTest.java
@@ -5,8 +5,46 @@
 public class StringCalculatorTest {
 
 	@Test
-	public void test() {
-		fail("Not yet implemented");
+	public void testEmpty() throws StringCalculatorException {
+		StringCalculator calc = new StringCalculator();
+		
+		int result = calc.emptyString("");
+		// Assert
+		assertEquals("No empty string", 0, result);
+	}
+	@Test
+	public void testOneChar() throws StringCalculatorException {
+		StringCalculator calc = new StringCalculator();
+		
+		int result = calc.oneString("2");
+		// Assert
+		assertEquals("No empty string", 2, result);
+		
+	}
+	@Test
+	public void test2() throws StringCalculatorException {
+		StringCalculator calc = new StringCalculator();
+	
+		int result = calc.numberOne("12");
+		// Assert
+		assertEquals("No empty string", 12, result);
+	}
+
+	@Test
+	public void test3() throws StringCalculatorException {
+		StringCalculator calc = new StringCalculator();
+	
+		int result = calc.twoNumbers("12,12");
+		// Assert
+		assertEquals("No empty string", 24, result);
+	}
+	@Test
+	public void test4() throws StringCalculatorException {
+		StringCalculator calc = new StringCalculator();
+	
+		int result = calc.twoNumbersWithN("12\n12");
+		// Assert
+		assertEquals("No empty string", 24, result);
 	}
 
 }

From f3395c5477b7da2b8acb3b8b34a31192bf8132c5 Mon Sep 17 00:00:00 2001
From: JTTK <jttkinnunen@gmail.com>
Date: Wed, 26 Sep 2018 22:34:04 +0300
Subject: [PATCH 2/3] test2

---
 bin/StringCalculator.class      | Bin 2251 -> 2749 bytes
 bin/StringCalculatorTest.class  | Bin 1479 -> 2154 bytes
 src/StringCalculator.java       |  23 +++++++++++++++++++++++
 tests/StringCalculatorTest.java |  32 ++++++++++++++++++++++++++++++++
 4 files changed, 55 insertions(+)

diff --git a/bin/StringCalculator.class b/bin/StringCalculator.class
index 06ec86c8d482fbdaf72db86dcc16d62c075d50eb..74f166a5a6b45f875c8fead9c879e7b21d292141 100644
GIT binary patch
delta 536
zcmZXPyKWOv5Qe|myO)@dI9r&Tkcfy48^v6-60t~=3W=adX&@%xjqTX$>^hMhQ_#5K
z4X7xoC~$+2EQCZJ0A7Vh0Kynoh||nJbN<WB_l2*4|LymeQ{W!mkAB}AxxHbw-|7!M
zb_FB!J)Q|xE%f(%mUuqL3+jSBI8KujVWsq_8^4U#(zw@N+d1hcy>_)+`+p|nJ8^UK
zD9hrVG#+#Wr`bxAY#<c=p<kVO=zlsq9CqVr)KFD|Brc6Nugr>gpFWtE?9n_17j$zA
zVF4GUiixk2?OR*ngu=#^x7g-5Tzop=eq;rfw#Im|wr+<-d&1tjQ*=%v*Ni+f%Dtx$
zctt13-TBOedgQ&%NstTNcV|BWZ>*j(=MCl+*EKmFY2-fVXppBxzyTL&bD4x|bSZJj
zDk&8*B6@6U-QrmJDD&@<%&Btvww1N4M;JWjwjx8FA98~g4GpLgE3(wJqIt{M>RsXq
zyA2$TxK5L@3MxuyDe}0hiySD*aZ}C9Sii`-EXhyK%Na#{7tww?n$@<5poa+^6&NIc
E0JR5RC;$Ke

delta 36
scmdlhdRma{)W2Q(7#J8#7@{_E6){hiX3=A0-|WRA&C1Haz{C&<0NZQ{AOHXW

diff --git a/bin/StringCalculatorTest.class b/bin/StringCalculatorTest.class
index 9eeb2ea25dc11ade0a820ad21bcfa7e9f5353623..a23bd9891d1bea68bf50aa09c86e98aa6285b10a 100644
GIT binary patch
delta 422
zcmX@k{YrrA)W2Q(7#J8#7~(c^<uPfqm82Gz7#nghI5RRZ8ye{_GO&U~OgI?afJ{Rp
zE+AqMVesH#@SHr6Nvs|$Ys$gk!^j{Amem1j0wbtOKOP2u1{p>M_Po;Eq|~BfR-k1d
z-~lz+jDsNrXqANy7wdm0fXbM2FhnvkuvqAra=|q5GBR)l=a&{Gr@Ce4q%tx{PTtC-
z!pODx7Sj|aMw`j;EYg#^Sj`w+CNE?*VsYKZ;66E@RhrkBfrG)6fuF&gL6X5@@_%Mc
zMlX;89q(-nzP3WLA`AgCtveXxHv(P7#J~k4g&0_Xq%}~REl`_1P@4l-TM$@VFicx0
tR&6doZEiqq9zboLU~S=GZ4oeSQCPM40JZr6wFLmR1%kA($AH}v3jnGSRVM%d

delta 100
zcmaDQaGaa#)W2Q(7#J8#7(6#}<uU29mZTP!m~b#SGcvFm8gT&;g9w8w4}%+n3?l=7
zNqN3sX>L+#QE_-?NrvBK4Q3NYw#~83Q<&IYY=vY+80;q}u!v6PWiw-U2O7%6-~j+3
Cs~0l>

diff --git a/src/StringCalculator.java b/src/StringCalculator.java
index 51abe29..2491ffc 100644
--- a/src/StringCalculator.java
+++ b/src/StringCalculator.java
@@ -91,4 +91,27 @@ public int twoNumbersWithN(String numbersStr1) throws StringCalculatorException
 		}
 		else return -1;
 	}
+
+	public int numbers(String numbersStr1) throws StringCalculatorException {
+		String redString1 = numbersStr1;
+		boolean empty = redString1.isEmpty();
+			if(empty) {
+				return 0;
+			}
+		boolean hadCommaSlash = redString1.contains(",\n");
+		if(hadCommaSlash) {
+			return -1;
+		}		
+		String delims = "[,\n]";
+		String[] numbers = redString1.split(delims);
+		int lukuja = numbers.length;
+		int summa = 0;
+		for (int i = 0; i < lukuja ; i++ ) {
+			summa = summa+ Integer.parseInt(numbers[i]);
+		}
+		return summa;
+		
+			
+		}
+			
 }
diff --git a/tests/StringCalculatorTest.java b/tests/StringCalculatorTest.java
index ccf88e7..b8db52f 100644
--- a/tests/StringCalculatorTest.java
+++ b/tests/StringCalculatorTest.java
@@ -39,6 +39,14 @@ public void test3() throws StringCalculatorException {
 		assertEquals("No empty string", 24, result);
 	}
 	@Test
+	public void test31() throws StringCalculatorException {
+		StringCalculator calc = new StringCalculator();
+	
+		int result = calc.twoNumbers("12,");
+		// Assert
+		assertEquals("No empty string", 12, result);
+	}
+	@Test
 	public void test4() throws StringCalculatorException {
 		StringCalculator calc = new StringCalculator();
 	
@@ -46,5 +54,29 @@ public void test4() throws StringCalculatorException {
 		// Assert
 		assertEquals("No empty string", 24, result);
 	}
+	@Test
+	public void test5() throws StringCalculatorException {
+		StringCalculator calc = new StringCalculator();
+	
+		int result = calc.numbers("12\n12,12,12,12\n12");
+		// Assert
+		assertEquals("No empty string", 72, result);
+	}
+
+	@Test
+	public void test6() throws StringCalculatorException {
+	StringCalculator calc = new StringCalculator();
 
+	int result = calc.numbers("8,\n");
+	// Assert
+	assertEquals("No empty string", -1, result);
+	}
+	@Test
+	public void test7() throws StringCalculatorException {
+	StringCalculator calc = new StringCalculator();
+
+	int result = calc.numbers("8,5\n");
+	// Assert
+	assertEquals("No empty string", 13, result);
+	}
 }

From a537ac570b005c292fbc794da0a2af1c43407e7b Mon Sep 17 00:00:00 2001
From: JTTK <jttkinnunen@gmail.com>
Date: Sun, 30 Sep 2018 23:41:50 +0300
Subject: [PATCH 3/3] assignment	finished

---
 bin/StringCalculator.class      | Bin 2749 -> 3292 bytes
 bin/StringCalculatorTest.class  | Bin 2154 -> 2350 bytes
 src/StringCalculator.java       |  30 ++++++++++++++++++++++++++++++
 tests/StringCalculatorTest.java |   9 +++++++++
 4 files changed, 39 insertions(+)

diff --git a/bin/StringCalculator.class b/bin/StringCalculator.class
index 74f166a5a6b45f875c8fead9c879e7b21d292141..d2f6bcf1e8c05c835b7c9ed93cb1919975e12b80 100644
GIT binary patch
delta 502
zcmX|+yH8Vb7>1wU;n1F2BLvS-MdM&<OC&*r4n`BnkpW{!bW#}fv{X6thNtCHG*(U3
zc!^6V-P~P_i6JJkxcN8ux2P`+E??g7`n=zd@OR$(_2>HmFvs2(Z`|(ZT3gLZE$u9~
ztLt&<ah#2SIt_#0ZAU6Cq-oqU*u~On<Z+r-K$}fNkaQLro9l6<)=jF1{iV{%VLuJ%
z&^2U}&b8!0B4rn&(u%=o%36&KPP3NQ>$Q#8;0-73Y2$vqZnrWgk6|$;Yc_^)vS3~_
zLZC`-_|%>6U(RPjclH~}B`@zCl>NLH`u5t~KFyDu`ky@fz*y)UjqY>hUfCJACUnE>
zr@uc#=d+HD;3+OMp|~aFwop6x?2==TkVl;0F_S#u41J0`W18p8&>v9d1y^~=BCoi`
z8}9O!1_PaVuLEfP$gN^dnS5*QtiG`XxFBT-l~UlGOoXfvOWDHQp`z}nU^lr<m5h)#
w)Guj%h9zoJPJxR=+?RA^;=H_X>yt&D*ip@AO28>bhwr>XFmH*vtAa)EA7#B&*Z=?k

delta 36
scmca3xmT3y)W2Q(7#J8#7_v5U39?L{$)d-|vH1i`9vdqI0~13g0O-OBN&o-=

diff --git a/bin/StringCalculatorTest.class b/bin/StringCalculatorTest.class
index a23bd9891d1bea68bf50aa09c86e98aa6285b10a..a7384b5350168c59fb94cf0d1976bcde586e8933 100644
GIT binary patch
delta 138
zcmaDQuuh2U)W2Q(7#J8#7}7R!DKJ~HmZTP!Sa2}JF*0yl=$LYu=@jc2>ZEfqh%hAZ
zFeEa_Ff#DwmF6a;78U#DCubxUu>v)NfXHMGW)nv4&9TfJtdr+6%S}GbBFq)LjUnDv
mNLGX)X>tOKC~qhO2SYdmKSLygBtz6>E>=zU6rfHfhExCxB^{gq

delta 36
scmZ1{^h$v1)W2Q(7#J8#7~(c^DKJk?V>V*s+B}n)gO!zmfr%j&0N$JlZU6uP

diff --git a/src/StringCalculator.java b/src/StringCalculator.java
index 2491ffc..723d208 100644
--- a/src/StringCalculator.java
+++ b/src/StringCalculator.java
@@ -112,6 +112,36 @@ public int numbers(String numbersStr1) throws StringCalculatorException {
 		return summa;
 		
 			
+		}
+	public int numbersNochar(String numbersStr1) throws StringCalculatorException {
+		String redString1 = numbersStr1;
+		boolean empty = redString1.isEmpty();
+			if(empty) {
+				return 0;
+			}
+		boolean hadCommaSlash = redString1.contains(",\n");
+		if(hadCommaSlash) {
+			return -1;
+		}		
+		String delims = "[,\n]";
+		String[] numbers = redString1.split(delims);
+		
+		int lukuja = numbers.length;
+		int summa = 0;
+		
+		for (int i = 0; i < lukuja ; i++ ) {
+			char[] c = numbers[i].toCharArray();
+			int  merkkeja = c.length;
+			if(Character.isAlphabetic(c[merkkeja-1])) {
+				//do nothing
+				
+			}else if (Character.isDigit(c[merkkeja-1])) {
+			summa = summa+ Integer.parseInt(numbers[i]);
+			}
+		}
+		return summa;
+		
+			
 		}
 			
 }
diff --git a/tests/StringCalculatorTest.java b/tests/StringCalculatorTest.java
index b8db52f..5296beb 100644
--- a/tests/StringCalculatorTest.java
+++ b/tests/StringCalculatorTest.java
@@ -79,4 +79,13 @@ public void test7() throws StringCalculatorException {
 	// Assert
 	assertEquals("No empty string", 13, result);
 	}
+
+	@Test
+	public void test8() throws StringCalculatorException {
+	StringCalculator calc = new StringCalculator();
+
+	int result = calc.numbersNochar("8,5\n6,s,1,g");
+	// Assert
+	assertEquals("No empty string", 20, result);
+	}
 }