From 3b2455f000538b337301389fd158fb095cff5419 Mon Sep 17 00:00:00 2001
From: MINZHE-XU <mazin.xu@gmail.com>
Date: Thu, 13 Sep 2018 00:14:59 +1000
Subject: [PATCH] 1

---
 classes/swen90006/machine/BoundaryTests.class | Bin 2225 -> 5816 bytes
 classes/swen90006/machine/BugException.class  | Bin 387 -> 387 bytes
 .../machine/InvalidInstructionException.class | Bin 266 -> 266 bytes
 classes/swen90006/machine/Machine.class       | Bin 4003 -> 4003 bytes
 .../machine/NoReturnValueException.class      | Bin 256 -> 256 bytes
 .../swen90006/machine/PartitioningTests.class | Bin 2229 -> 5270 bytes
 classes/swen90006/machine/SimpleDriver.class  | Bin 2109 -> 2109 bytes
 test/swen90006/machine/BoundaryTests.java     | 546 ++++++++++++++++--
 test/swen90006/machine/PartitioningTests.java | 456 +++++++++++++--
 9 files changed, 913 insertions(+), 89 deletions(-)

diff --git a/classes/swen90006/machine/BoundaryTests.class b/classes/swen90006/machine/BoundaryTests.class
index 75ca15dbf4f906cd2b7beec235fa91a8de079579..86291d6fd0ff2a66122c6cb91a7e3342a2a7c931 100644
GIT binary patch
literal 5816
zcmX^0Z`VEs1_l#`D_ji046W=8ZCngY46Pgt?c59<44oVdUF;0qTny|CtstU@gQ1s$
zp^t;1pMzln2g5`ThDpo}j4W9k43jw+rf@J!<zSe`!7!bJVFnk&Oomw;46`{H=5R2~
z<zSe{!7!hLVF3rjLe~FKz`?MHgJCfT!x9dLr5p^)AmaZRm^c`gb1<ynU|7k@00NBv
z|8X#^;$T?K!LWvdVJ!#4Iu3^Q91I&c7&dY+Y~o<p%)zjQgJCOJ`vC?91`dX891Pnz
z7<O<l?BrnB1r~1ri|+;-SpWb3e-4H{91MFo81`{6?B`%Oz`<~kgW(Vd!(k4FBODAz
zIT(&{FdXM#IKj?vlAYlcBLkaFW?p8A9U}v?hGrNe1B-KhN-84*YjJ8xXaOUGWKd~d
zNoH<pSY~l%QckL4US57lVo7FxUNIwskWYS5x_(w^US^5DQ)*g%QK~f~14l_}Vv$RJ
zc^)H!Ad<XeT1je=H6sI4i6J8cmup3GY5~|3c81f83<5|BLsE-NK*pq26r?7Xq^2-3
z==&6xr{-B27#Nu8=O!j+Wag#nd*+oT=47UL<`tI|l_rBsf*T38#0X@Q35YOdWZ(@h
zNlec6O)LmWOv*`RXE*~AH)CYb!eX#reo$&jX;EHSVoqr)s+r~>ZI+A-%q4~fATq@e
zOd5emLonMA!Zrqrn1D%BFlh!R&B3Gvm;{?+1UAPAtk(#v-UzJT2&~=+tlkK$-UzJT
z7_8nHtlk)GmoeBbW3XOhQyzv8hEPTZ;jF~6ME%l|%p85kqN2n~pUmPCMg~q_|1gCh
zT|)&!c7`)N3}+e6F*2|RxrTtm7#Son!`K%R);tX787{!I8yhJYGBWTxy0|C=85_Yc
z%pj1Pc)`{fD(IS-ni`uiGO&TIFl1!l^zsc*fC_Rz6&W%zu!4k*7#Sc!MhXUu3_M`t
z4Hbewh>?LOIMfNkRtPd;WZ-e}41;kE*%>bKFkE7|40E5Mg03Nw5+j8mLq-M^Cz&!b
z@PKVM0y_r81zTqfF%xE;37Cs!9f%9oYY5W|G1>^?TToI1OB=xX5VspB1Q~!`0tpNQ
zn3Ig*=J0|2Xl$qu1j2^!00nsl$$9W_G6qEh#57|@1~yO_>VjMcRtpL?NKpBP`X~f}
z0s+ir_lg4Xj9`&s1apU>g08WVxtRqbXy9Cs0dVuc1{f=VECTz}PywnA9t==EB&`{P
zBLgC5j8F^qsu9Q~L7=3}2R6zW>IQR027%y^AdoCL1(|}wjUOyz3<-545ojDjM0{L=
z6oQOFIzg$-6jZFhMIdIuA{S~ohzqp}<V8jX9)uB~WQ6VzV@3vUunJH#ff6b=)L8}!
zLB@;>5Jy6z6fDBP$RLlIublEr^HLIvDnTV(F(ZQjIJf2`=B4ZVCuOB3m%uVGSSTc;
zD8C$3Y%wzMffbg5vNa?}Gbg5`Ffxd0_<$wA${{9LYeq3Lu%}j}CYP3^GBOB5Rlv1c
zYkD#=2p|e?$KvADq7p_1o<uOiwXifXr<jp}Rm00mGmJrzA&4OuR9P{oFff8j7zRd$
zFa`z&K?X(!Mg|53R;}#}j2poU7#YGDLK&FA(!2}|U}>mS1Oo#D8v`RlBv?3#kg{m7
zvKWR?24=8nrVLCBEDQ_`n!6d8BDXUz`)CWX>||hNVhGn3VuLVtGq6W)XW;PF(cZ?u
zX$NsoECT}r3j-rV90SOHZU#n%cm_s>gk*+921bS?xaoFK(~S_Ob3qK%7UG66cpwat
ztx1MkgT)iP5JR<v_#h0DO;3TF9tZV=1Hu#h5JQ=5WrPG4F$if32|@%~m>8G;e}~6X
zMut=d1_mAmroRlr><np)zZgUq@P=hN+!;DhXDA??0kxGRzhy8mGGxLHb%z>ijbW&^
zkPyUAaNodvNwR%e@Kl+|z`_7(P=#W#PZ(yO2#g^LV~D{R*kaR+g-evBbq9kuBx!;Y
zBq&3~gHw7oKC2~Q#^SMB5~c>b)ttDk&VgH<4E1$5!q-wTW2IpX85lzr#*l+Cuv;y{
zAdlPfTzr-*!VFe|F{o>K9^CRMsL%ZnK39g>33r7GOavbBst^&Bgl5Jf!k~uR!}<8^
z)PR_$Ed&pCO_&JWPA!NChMn5D?JR)Xi6vdbt%Ap}F2n|;oTUd7(T6b5EXR|$3gKBe
z0Gfqe5J3zr7qo>8AjWD7VJ2{FX^K$c4k|l}h_V>dKJ?NA#jC_vTnrCve`um|M)(+>
zmf$Jc5axAk9yMdZ6SO68i?GBhJZRxQG=f=V3}ZlT)D|*<h@f~Cuhpe+t8<`!OhEY2
z6k?jTkQs~tPd?@_5epcDfEz>@EO966GJLMEhS^{PW7xtN)OAHU+!a`gPk4O8U10}v
z1w20NVItV0L4?5pcMwz%WjQ<|oM2WFZ@DvW%PZlQV@c`o1PCuyTw#_&;~Xuy;i(*}
zh_VQt(%s0ms2Xk&zAOdLyYLj{4ztk%#=u@s;_+h*QC7nP6K*v;R6WVIx|S%b;lT^H
znhL(IgIk>iElA=J1qo&nf?Mqc^Q<?F;R9ok9P;&WH{gqO%#inm+2{vjkesj^2F~h6
zxYbzNKJbvojC6mPXR(Jf-o{=N+|CGSZ2Mq|ZA?1@V0Mxmz|C+QZJ{<AVzH5AV_V?H
Qx<QS#!eVS7na*Ya07l~o!~g&Q

literal 2225
zcmX^0Z`VEs1_on>ZY~Bj24_|V2w>u3aA9y|XK>?UU}bRTU~uPV@L=%dVDJLb-XKXI
z4hCN?22}<>b_Rbg20jL75D@^=uglI5$i*NG(i#L4V+Lsp=3ofnVhCjj<6;PBh+t=k
z<YI_oh~{F5VTfgCh~s34XGq{+NaSKjVo2s<kY`BYVu)u*WoJlZXGmvcV6(~0%Pg^D
zWMJ0N3}a+qan4UkWn^G2PAv&7U}TUCD$Og&%uNl;EY3{INp;N2%P&bR$;{6yW@HfZ
z$uCOR&nnH!EYWvLP0KGzwPs}CC`nB$a>*~xV`LCSl6OoiNiDKwWMEAUNi8m6WDr1-
z1BqBOGH@s6<(Fin7J;~o47`bMnK`Nc1*v%uK7V4KYejNu0myEM2p61R%+8R($iR_W
zQIMKklA6NEAnKEqSeB@tnXm8Z4_5`Y!Ywf~Cp86PfIv}dVv1*8aY<2WGRW9sMg|oP
zh|ZkEymbBGlA_GKbZbqBP-#hKj=oQ3afvk}18;CiVsf@`VnIk^QVt{}BiR`;*%`9f
z8R8fjID<3O^Abx+i&7aGEQm1C24VxUrFPal4C)LT><rmF3^@$Bj10nHAAud=SX7i)
z333S|17jjPLlzH19z#AO17i{oLjglR4?`hC5hH^@YDHphK~8G1ej-S@UNH}YC4&_s
zgJf}eYM!Nmfq|KRZensqW?rhkFNEe{C}t>uS%eyNj0_^d`MIeIX^ELRrA4U<xv9m)
ziRq~zr<F1?u!e@X=~}QeWb!bSF_g12RPZoVGE^}#2!Nf8<STZDY959fhFW%pIv$34
zh6b2rU?uQ)VrOXNVQ6A#W@OOt%qvUG$xKnm%qu7@QAo?oNmW$PC<cXnNl{{QszO?R
zPELM#u_il13lBppLmLl6J3|K#LnlKQBZEAqN1gIZ^HLIvDnZd-jN(53q^#6rxaYy{
z3CSqRF9$_0BZCCkBYBzm`pFrIMa8Kl`pyuVk%12^1&$U-j0hm|gky1WYEcOz15YBD
z;aXUlm{ZKiz^dWp1<Gm6i7B9@ikv<m&al>uVr1Y*&d)1J%mn2#E{Oh+qS91G1{RGd
zkY@JOiqz!Nl2k?pVW<IcH&|<WGBSumMZsQyCS-`U>}mN$eu=rMj0}2M)IbwE7Qb3E
zGDw0w3z7pxg+3^Q23HoBq~;bgGH|7*mbj#*C6?xtFfzz!Aen=v)*3lH(c~Bz*wa%>
z0uoCy7#XawxGowqqo7*^(rgV&SSU^{W@O+2<#@-O9G}d*)M7>k2dEWrWnj$^J3wM+
zv5l=HKu+V}pkQQRPAw`zE`kDzGV@A;ONvqxbKwrl%-2T}W@KP504d7JV`LD8x(PYr
zKoQOlRsk+|LO^MskwF5g64fkgkYbk9ip&yFTJh8jV^CyJWl#gxK%5MWphAU#kwKGz
zfkBXgk%5tcfq_+PI|JiJumVN~Ed~t+Ca^Rw0|QtZDy7Z9z`(}9$e;rj)+MA&53Ecd
zu1t)9g@KuYfq_eefk}jcX$J!f#73C024MAuaP>wEObkp63=C?!8CWB?GqCw+3$gEH
z;9z11*B0W0G1zx9a4|9LVBp4PmJ!@64XE8RT0%VA8F+nmGw?-jXW;kM(cZ=&&?>?p
zh{H9;3>pl~;II&3U;>8)$8HAU$n6Xw`@x}Q!oa}5!obL2$^h~OHv=Ps0Rtn0Su%q;
z10#b4+<FNHR<PH3ghauf7u&%gf$3l-Q1J{6`ZNY+22cfWEF`&uLCTlWZwG_4HuGKv
znQaWRIy)HT{FXCFTCr?mP!Lkw#-Jn#Vr^qkX4%1@qPu~Ck%5Cjf<c-=o`I3Unt_2q
ol7Z<zgERvRJA(~7gDpFQ9Xo?P10y?wgD8U|0|NsSgA)S-0BA)PPyhe`

diff --git a/classes/swen90006/machine/BugException.class b/classes/swen90006/machine/BugException.class
index f118d84a4f1eb3cda19ec8de216e3dc339d6090c..f496503ff66231f2e4a9a5188e2a4525f4d4261b 100644
GIT binary patch
delta 17
YcmZo>Zf52<^>5cc1_lO`jU3gC061O+z5oCK

delta 17
YcmZo>Zf52<^>5cc1_lP>jU3gC0619%y#N3J

diff --git a/classes/swen90006/machine/InvalidInstructionException.class b/classes/swen90006/machine/InvalidInstructionException.class
index b825f28f0bae9bc7d1352fc96ae041000ea4a729..d57723668ac7412ebdf47682cc860ece08bbdfb2 100644
GIT binary patch
delta 17
YcmeBT>SE$J^>5cc1_lO`jT}sj05~oMQ2+n{

delta 17
YcmeBT>SE$J^>5cc1_lP>jT}sj05~ZHPyhe`

diff --git a/classes/swen90006/machine/Machine.class b/classes/swen90006/machine/Machine.class
index bc67cdff3d66160515599de443f4aea563326bac..e8ad0e469a8f1238f60c863da1415d3ab8a51b74 100644
GIT binary patch
delta 1801
zcmZ21zgWKh)W2Q(7#J8#7>=?t6mT(EF%)t#FftS|GcYnRfLO&KqJ)`&;s1Xw1`&o*
zc7`%822O@T5T_hORB$m=GE}iMRC6&fGSq;GTIT=%85p@4>KN)lL<2iRBS>Kr2SYOl
zLko!6%E8da!O+gdAX3lJ0TSrsVCdpt=mzQT0TI0%41FNFpMzlnh@Qy7FbPCY=3tn@
z!7vrXoCYGMb1=*R(K9(1W`XG091L?f80K;^%ww3(&ai-s!HA)dgJB_vUIZc*b1^Jo
zSjx_@jElj7p^%+n`Nn^b7}*Qh85-FcswY2ZS}ViIAX!|VnrCTXU|^=7o0y!DnU|{X
z3!yhpVcx*FIe}G^sh*L+ih+SakU^5cn!$#Fk-?UMfq{uZjzN;a4vDYGAjx2l#8+mJ
zWN<*@t1?J3I3n@Y86+8;koX!5k_^sBd~F6v1{V-t18SizgCv71NC3*$XOLuYL*g4u
zHsH_~WMPnG@MZ9TJCl8K0f(_PlNR$<24*cGmOWfs8CbOh6hJf^Sa9+_4mln+X{{{`
zY%+Qva`FofB~$@1PBZ}*P9+I8S-n{dY|9zMKzfk1*Kz7-u*vAjCJ3=F0Vz-cDFE^3
zfOv4_tRUgZmpJvc*`)PkP!xmsaK&JCAQ7;79WEV4w#kuPie4P7ix{|fGjK+3XW-he
z&Ag3)TcBt@k_gK-1|DB#JDnX2ymreOc&%7qYPDpyGw{o<VPIs?V$f$WV&I#6giDK&
zbMkvGX?b4T<qSN2aFsIK83bfNDw!DA8MqkuCTnu5GICD#=T?%3*t?N|fq{`Bih+TF
zg@K8SogoFxVr1Z)Jb_!nQ*a>zr!*)O;O<0G&x53%fq@~DA&Y^TA%uZ}xtD>3fs28G
z*^}9p*-m>WgV5xU+@kfuObiDYM66gPS+_BW3W*7cZ)1=Uk_1yAK_RJa4ANF?l5EUI
zV6ON!2AP=*BC;$Ac3P2J7?@cSwlXj;|G&D0iBXbONEWJiA95&y^a{y=_1Q|Y?PEs@
zPA$oLHWs7p4Dx2|T9Rz6U>1j#BpVx;#i=FAF3KUwxt&2_Ia40k7)2b$5M_$eawZM1
zDar^_>QP)nlrbvH86Sa-QAHR-x+!YQ8Rtl{G1nUjse_G?*OG+W4i8vR;uK}qTLZRE
z1FQ}+2;th$Lr~KU5rSIF8TG)XXrr1^4^8SwwnL23G{Y7VI?EYefQ``w8)GQRwvP>;
z-$AB;B5^x|-g1U@V4eD4oqCdN`&j2QaM#0g1;qQBX6&+}>?n!rZ!lP&0a%|WF*a^t
zU=wB6o5jE_E6R~zx150;ExG<>+{9qGo53h@JA<LIkjXX%Q&8$R-Ns<Hjlmr5Ab2c*
ibT9vNZa0HP<aP$j$%g!H%$y7sldJd@IhfZlfB^u4pjdGL

delta 1799
zcmZ21zgWKh)W2Q(7#J9g8IE!>STPiEGFUPcGBYqTFo0M^AflL=f#LsuE(T$S5_X1C
zE(Q*U0uZMRM3i$eR4`PsGgNUgSTa<Dh#Kbq{}~v$8EP5oKtw$|Ljy=*BL_nh2SYQ6
z*}}ol%E8bEVzzVDGYB(ua4>XoFm!=*cY}x?4u)P3-N(Vu527b<FiZr|lQ<YAb1+N+
zF{grvX&emGLG%m`hM6FG76-#@4u(0L409Rgu`|r)VlZSV;9yt)q8EaQMO+Mv8J4g!
zEahS_XDDE2SjNt<eB-}IjO@$U85-CbswO{YTDy4z^9DvK$>Q?VJWB%u12g^H#N>?3
zyi|Q(2)#LuRhy~alEI3BfkBW#lEIq6hJlg6mVtqRi9wb@lEDs%ufQP5V2{LCVvuBT
zK;o+~NHRDg@zoe48Jv*#>I{+$&PaSM21y1N5MKjop$>y2gDXe?%GYC%WN<^`>rXb|
z&=+K8kYw;>@PIp$ZE^vJu{5I=^Hv5XEg|MTTw57fv;-7DG%Hwe@;(kZ9#(0sEexzO
zdLVN03l1ez0WnTA0T)gs307IXSqyB;8N@((khRxw>S(aa=*cDsu`K~9Pys0b@#lbe
zaOEr@;mMac^|e{0^<+>KgZOa8V09o7uzDRX9Y)s4kz9&i?5v9zxOX#fL~du`+^@~N
zje$#`Xg-n%%QgmXUuHX<9Sl5n%NcmBSYT?kWVbW$$*y5wWYA*JXE0*moqU8#i;-jU
zdoF2t9^2&%JbrMMGTRyWWk4#K7}y!O7<eaZa;q|OO!ntil84y4k%57Mks*qKfq{jA
ziHn^f1<Yb(;FvstTf$RdAp@s0C=}rCL{ZO!q@IC+A(J7CftewMfq}V~frWvKfq~hR
z*_PQ(dnbe7<d58<^+HSx2N;B{SS4AvF^C9>3W;rF5EqgFQy@Vh$!!c$R&0`N%tm0Y
z*fs{~nG7PbED3g6ky{v;SQ54}FfISTx`l~Rl2u3ss(2rAD1!6~$%6ISO0w-^M+#0Y
z$$B;xqwNfGX6#y$Y^-1whn6H88<@qZCCV<!A<DU(L4G+?9@rQK9L5l3isEu64X`On
z2vh1&Ttk#G%F7uafsIi?7(==#s>>PYNU|~48wsg_jgi-qgxd}eSWw~=W!GB+woV<a
z4l@Yh+R#H#!weCEn#&pWz@})Sno<u<>PWUjjL|T|77^OZ8D4;m(E%G{D9N^u4WHjZ
zrhp=GJA>|WhIL?_dSIP;l5G1}=QD8E!*d11`x<8KvZCxLiR*7LSf4&vpC>UkZed^*
zW!Ia<z%47vkzlu+fgLTm{$<?6V6dCPFmgMCp^=dBHU<+=>NnZOV7iUL4DKL!EP!+`
g|8s6PgL&k328+pt{BFz~4Ca%o_!T*r)-Zqp0Iru?JOBUy

diff --git a/classes/swen90006/machine/NoReturnValueException.class b/classes/swen90006/machine/NoReturnValueException.class
index 8e5254e009b57eb2894b9bb735e33962cd163259..ce73ab21ab69aefcfe43db0ceb7fd6ec61f4c001 100644
GIT binary patch
delta 16
XcmZo*YGC3x^>5cc1_lO`i5x!wGDijy

delta 16
XcmZo*YGC3x^>5cc1_lP>i5x!wGD8Lt

diff --git a/classes/swen90006/machine/PartitioningTests.class b/classes/swen90006/machine/PartitioningTests.class
index af52566636122d3ab4edeca3dfd4fb3e867aa1db..673f41b0cff668eec82f851d750d952047b953f7 100644
GIT binary patch
literal 5270
zcmX^0Z`VEs1_l#`)m#iV3|Z_9*<1`v3|SluIou4n40#+3`Roh@Tny|CSs<d2gQ19n
zp_qfAgoB}!gQ1Lrp`3%Ef`g%wgQ1Fpp_+rChJ&G&gQ1Rtp`L@GfrFuui=m03nUw(o
zm^c_(I2c+v7}_`(+Bq0HI2bxP7`iwZx;YqnI2d|482UIE`Z*XTa4<|{{SO5k43jt*
zCUY=M;b54`!7z=3VLAuH3=W2w91OEK7-n-Y%;8{|%fT>@gJC{9!vc1Og^UbrHko;u
zC3cJq%o>_uj0`N!`6;Q446MbeC7}h343a^mc_o>-sbQJLnMpaRj(K_cC5a`O`FX{R
z3_?EnMd|ukrFoep`cA27`9-PLj0_wlsfk4{`Q>?x41!4Vj%g*SMb?ZA%&EzSj0{|^
z70IauU}M-B7BMmiAgK&VEiM6>lUh-bnp~2a!pNZSQ(T^!XK7$yV5Xm&n4FQBm#XiX
zSC*KQnc|sOTvAk;3^ECBB*YdYuwBMr(gaMJGBRjkG087KD7B=tC@(BAr!*DK5Hqkw
zb1-QECM_8mSW=S>4Iq>ugffCq#t_N`LYYD+GYDl4p)4R2#1tclDMk=ej3A~MK}<1%
zm|_Gm#Ry`G5yTWDh$%)8Q;Z>|7#s31*fQ8LG6-iSmL=+!mSpDWI~ElsR{CTXmoPH$
zIJ&qf1Q{v>87TxAvokE_VOYYjl#zig$TdVE$dHji5;KT>AwkW<u#90jBLlCme;CLB
zT{BZtV>3nuPB7m{LDvw;aFF?o3_M^dLj{mZQ&d@yVkB8JMg|Tj*N~Bc)yp?P!5C(=
zuAzb<BLh3wfgnpD78)BNM2(GL+Km(p7#VniL!Ce_1pAVafyc!Y>|iWhLw1H0JPa!t
zRzdAFVq{<g*{y2?6)*vLBGd;QS`a_6dqshGAeCSj88I?|g$xyp7#aA3LxMoEU=M?X
z6Y5xS=<xfv1Std=!xg|n-I$R<0ICrjsHO@*AR(}7Ly!iDC?f;h0C<q1SqO3hOdDJc
z#B5^)h$&#RA=;oS!0r?PYXhYTs5+Q!Mxc-c`v(*hpr|)cFg7wbvw#IT*yB9D&_FU!
z2m-|bj0-Xlqz@_!G7Oduj6mT4@+d^F35?6Y$e@gw1_Kg{N-{yYJ2NjGR4^1XG6;av
zcTQqny1su>R%&tyEXjj~LNbc-%M+7wQW+WezzV?`0g?xp6H`(c8ALUFz!G5P5EHC5
zqZk?3Q!7%FOG{E28HAxK;99LUJsBAU5QUv%adB!9C{rbZ8Low;i8;lL46GVnUYcPH
ziVW5aHsBImiGdN6Cm9$S>=_ss1Q{3^7#SECShcn@Fm41ZU}SJ$uw!5XOY<@?fTf{Q
zjtmS8Yz&MHPGDhYLdsmg%3K-j7?{DPnKCdjurM$%XzpfUirmh??4vEjvXg<8i6LBD
zhz-Kn&A=YHoq@wwM|&FsryayWZVU_zEDVec?hGLNxfvK4JQx@mJd+u`7#JD6;ikJo
zO}9pv&IK`4TZkLR;DIs7wa*7`A1I7KzA-}B#|tx^55^$Z8ee?Y@WV`p`;S~}{NUE;
zKtoRf;Tr*nH6%reKLaB}0NhY4Q6dO2R9gsYIy~m#A|%@v2)7SQ0uzGSCk$bbWI8B;
z1>rMY1Y)SRkSK&fvgyHa(<7k~;ENFf+CpLw)3t@*=}H_XA^~HNn*>7Oxj2!5g#pye
z3nk43lK5O;#=<4a(z=5|3X+vU85mT6cz{cWP`K4mP^<k&vl^S9%~(Vjq;cCBMwFeh
zFh602JQ;R|!y`EW8p$qL{3%D8orDTUP)>{>%3^uyTO0`wWe;e~+F<c9JT;RMrcrPk
zh)T8!Fh4577*IR4g_Iy7C|TExg%fuYiYC))Wr#&cB_4LG@#L5oxYhp9aCOEKuJA+)
z_ceBl@c1#7G>cTwyoMH-czhHGw}_~CRE1dtw^0oyq7GpYZ*@GGR%<{k(iYN$F`#LQ
zc&iiORwqN_F&tk!V)|MOW;J$Si!f;8PQQt8%d?=C#}Q?@F3e6n7=!!(NP@e8v}o6-
z-0I|kvpNNCbul#L(}@asxUUUh-Zz9Xj9?6svv?}pF}6_07-De@$w@m6Ugu;(E4z4v
zvBoghn!p(Fq-_clF@rJ8VGIix1DhWS)q|imTsquMSSnylH^H3(cLBK;XTU8kfd)nf
hrGa4y3k-@wB@><i+@J}-3gI|-^V|w%ABib}0RZUsbaDUy

literal 2229
zcmX^0Z`VEs1_on>ZY~Bj24_|V2w>u3aA9y|XK>?UU}bRTU~uPV@L=%dVDJLb-XKXI
z4hCN?22}<>b_Rbg20jL75D@^=uglI5$i*NG(i#L4V+Lsp=3ofnVhCjj<6;PBh+t=k
z<YI_oh~{F5VTfgCh~s34XGq{+NaSKjVo2s<kY`BYVu)u*WoJlZXGmvcV6(~0%Pg^D
zWMJ0N3}a+qan4UkWn^G2PAv&7U}TUCD$Og&%uNl;EY3{INp;N2%P&bR$;{6yW@HfZ
z$uCOR&nnH!EYWvLP0KGzwPs}CC`nB$a>*~xV`LCSl6OoiNiDKwWMEAUNi8m6WDr1-
z1BqBOGH@s6<(Fin7J;~o47`bMnK`Nc1*v%uK7V4KYejNu0myEM2p61R%+8R($iR_W
zQIMKklA6NEAnKEqSeB@tnXm8Z4_5`Y!Ywf~Cp86PfIv}dVv1*8aY<2WGRW9sMg|oP
zh|ZkEymbBGlA_GKbZbqBP-#hKj=oQ3afvk}18;CiVsf@`VnIk^QVt{}BiR`;*%`9f
z8R8fjID<3O^Abx+i&7aGEQm1C24VxUrFPal4C)LT><rmF3^@$Bj10nHAAud=SX7i)
z333S|17jjPLlzH19z#AO17i{oLjglR4?`hC5hH^@YDHphK~8G1ej-S@UNH}YC4&_s
zgJf}eYM!Nmfq|KRZensqW?rhkFNEe{C}t>uS%eyNj0_^d`MIeIX^ELRrA4U<xv9m)
ziRq~zr<F1?u!e@X=~}QeWb!bSF_g12RPZoVGE^}#2!Nf8<STZDY959fhFW%pIv$34
zh6b2rU?uQ)VrOXNVQ6A#W@OOt%qvUG$xKnm%qu7@QAo?oNmW$PC<cXnNl{{QszO?R
zPELM#u_il13lBppLmLl6J3|K#LnlKQBZD%gM*|XzN-{w)otc*oN&>|wZuC#eN==3b
z0N70-8AbW!peSZ!kN|roFEd|1IU}*CIJHFI8A3BM@PVbkQ3Ht;0YtuVEG|whDq&>c
zNdz-o3riDoiWwPLHN3n)xs5q71(aNo(+I>F)|yd_3>?Y%c_oRNpuENf(H~M&n##z)
zq7ens%${12np|3v%E%xLH304gYfVo^263n;*elS)46&9yEx*VwF*lWwK@W=>XoAP$
zS8GNFNw8-@a-itY2W8UW%HopL++s!suJqIrm(;Yx(wq`T1{n<`bI{aUBZnuN93umJ
zdTL2PVo3%ggEbb{MPp_bbc;Zmtzn4^#i_-N3_PG*@0gS0lbM%V%*fyXwF0gTtQlel
zNDM8uv6TkM=^Pvsj10`FMMcQPP(V>;UP*9CQEFl?++msd`bffz4D1CUMLBtl45Cms
zAx9i2!ui1}z-3PeDE%`sNI+Ghnq>`A%#vD>SprHco|<6{iVUg@YT#OklYtRburM$(
zXfiM`2r@7-FfuSOuxf2*VB82+z{sG*puxZdmgZ$(082xqv>6x}*cccYbil&8gp}!l
zmFdHki7~J+Ff%YPaEUN5i7+tjU|@mR2s73Itlki=-iU#Tfr){EL2Wk!YvgtYHXm&v
z_MHqIObp@LLYy!L`%VTfCWajh+}O-Af}5oQwOd9@h-W(kug`7<zR2wi{JuKc+ZY5|
zMHmEexW<@4gMk?w79tEx;IQD>%^)1Pok3(jIJ8U{7#LU>7#U0%K)&E+U}P|0U}P{$
zW-w=9WUzo+FTubH_BxM{DA@C2I~XJ|9n1tOqM<>b#=y(~s^pD@BzG`K`7-+LV35{k
z-pe4fjX_pt2ZNm7at28&mQ4%_LW<iMlq5l{Z4AmRI~Y`SH!v_Va4<+PNHfSYFfv#(
rFfd3mF#TtcW?*4wuwiGgWoNKsXRv2rWM^;?WpHF*U|?c!VqgFO^ePw#

diff --git a/classes/swen90006/machine/SimpleDriver.class b/classes/swen90006/machine/SimpleDriver.class
index e2898a8d0db987dacaa7428260b0686b6d57b7e3..48a6bba6927d7bdb6eb1ade861cf2706744f5b38 100644
GIT binary patch
delta 482
zcmdlhuveh|)W2Q(7#J8#7+TmFOt=`78B94D%oxl$7%aFLEE%lW8LYV&*cePX7;Hea
zEr_rK5%ydRW(*D-431n3P7Kam3@!|=><n&P4DJjbTnwHJUhE9s91K2O48jb)AOrn4
z82q^z0vH0h7#JB$K|~N2Loh>#2nRzb$ha^LhHwss2o8owE(XSllN)rs*%?e28Ms_4
zl2Z#xGV}9_85tyt%Tx0#4Gav-^m7xFGcxm1^?f1qW)((9#?6gPkt~c%lW(&r*E0*T
zY-3>E#K63pfh}@71G^B%HU>_uecKqgwlQ#TV_;?3!N4QLyMuwxhtYQj1HTrt5%XRK
zfo%+e+B+D8e3vtb`)y)i782RUz^c26fq5H)C`bdN-zEkzn1SNk7&vuyGDt8ozzyBa
zz!<rmLDG-Ws-8txXB&gm4hCr}79>3~+ZZ?{S++6A3dwC_;DoqjIfErg4YQE^HU?Hn
z7Km-S#~9?19IvpAfm3%IgCg7}kZU$FFfo`gxG{J#2s6YpY-HHNAk4tXpv%C(V8$@{
L54#<+FarYsb_`#B

delta 483
zcmdlhuveh|)W2Q(7#J9g8Ctj)lo?Do8B7_>I2g>i7%Uhp*%_?37+4uhI2f!!v<--`
z1rc^!45keB91IRz42}#=Tnx?(F6<1hTnugu?pzEW44&)^UK|YGTns`CJ|F{qIT-x7
z8T=Un*ck%37$g`>KtvE1Loh>#2nRzb$iy%XhHwss2o8owE(VE-lN$uR*ck#D8Ms_4
zl2Z#xGV}9_H#;yoGRiPANEVl;=2;pT7?|njCMIWO=B4WULg>wnOpz>%jFWG(Dc3Uz
zF>hmF*~GxKn}IcQI|G{#`!)s+t$o`VIJYryZDU|z*}=dq#Iu8e*N4$}2LqoLvk~)N
z2L5df0@^zm1bvq?i2H3~U=kAE#=xSxiGgVwg9u0iqu(Y5QJ8^Z+ZZ@>b~1=FGQbVp
z%^(rEok7x%(W;(BS7#f8)D8w|D;6X@GTRt9Bw4mG$O_4AW8i?eWI2N+NDY&a{5A#_
zNsyDbF^K3MV~|I3yuvmH4&7}Gig24iuGz@I#9+eU#^A{y#1PN0kzosi5CbEFE&~ID
O8N=j1>~_pT3=9DNCtuG1

diff --git a/test/swen90006/machine/BoundaryTests.java b/test/swen90006/machine/BoundaryTests.java
index 61ce1ca..b81f9ce 100644
--- a/test/swen90006/machine/BoundaryTests.java
+++ b/test/swen90006/machine/BoundaryTests.java
@@ -23,68 +23,526 @@ public class BoundaryTests
   @After public void tearDown()
   {
   }
+  //t1
+  @Test(expected = InvalidInstructionException.class)
+  public void t1() throws Throwable
+  {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R-1 1");
+    list.add("RET R-1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+
 
-  //Any method annotation with "@Test" is executed as a test.
-  @Test public void aTest()
+  //t2
+  @Test(expected = InvalidInstructionException.class)
+  public void t2() throws Throwable
   {
-    //the assertEquals method used to check whether two values are
-    //equal, using the equals method
-    final int expected = 2;
-    final int actual = 1 + 1;
-    assertEquals(expected, actual);
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R32 1");
+    list.add("ADD R32 R32 R32");
+    list.add("RET R32");
+    Machine m = new Machine();
+    int actual = m.execute(list);
   }
 
-  @Test public void anotherTest()
+  /**
+   * failed test
+  //t3
+  @Test(expected = InvalidInstructionException.class)
+  public void t3() throws Throwable
   {
     List<String> list = new ArrayList<String>();
-    list.add("a");
-    list.add("b");
+    list.add("RET R1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+  */
 
-    //the assertTrue method is used to check whether something holds.
-    assertTrue(list.contains("a"));
+  //t4
+  @Test(expected = InvalidInstructionException.class)
+  public void t4() throws Throwable
+  {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 -65536");
+    list.add("RET R1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
   }
 
-  //Test test opens a file and executes the machine
-  @Test public void aFileOpenTest()
+  //t5
+  @Test(expected = InvalidInstructionException.class)
+  public void t5() throws Throwable
   {
-    final List<String> lines = readInstructions("examples/array.s");
+    List<String> list = new ArrayList<String>();
+    list.add("JMP 65536");
+    for(int i=0; i<66666;i++){
+      list.add("MOV R1 1");
+    }
+    list.add("RET R1");
     Machine m = new Machine();
-    assertEquals(m.execute(lines), 45);
+    int actual = m.execute(list);
   }
-  
-  //To test an exception, specify the expected exception after the @Test
-  @Test(expected = java.io.IOException.class) 
-    public void anExceptionTest()
-    throws Throwable
+
+  //t6
+  @Test(expected = NoReturnValueException.class)
+  public void t6() throws Throwable
   {
-    throw new java.io.IOException();
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
   }
 
-  //This test should fail.
-  //To provide additional feedback when a test fails, an error message
-  //can be included
-  @Test public void aFailedTest()
+  //t7
+  @Test(expected = NoReturnValueException.class)
+  public void t7() throws Throwable
   {
-    //include a message for better feedback
-    final int expected = 2;
-    final int actual = 1 + 2;
-    assertEquals("Some failure message", expected, actual);
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("JMP 2");
+    list.add("RET R1");
+    list.add("MOV R1 1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
   }
 
-  //Read in a file containing a program and convert into a list of
-  //string instructions
-  private List<String> readInstructions(String file)
+/**
+ * failed test
+  //t8
+  @Test(expected = InvalidInstructionException.class)
+  public void t8() throws Throwable
   {
-    Charset charset = Charset.forName("UTF-8");
-    List<String> lines = null;
-    try {
-      lines = Files.readAllLines(FileSystems.getDefault().getPath(file), charset);
-    }
-    catch (Exception e){
-      System.err.println("Invalid input file! (stacktrace follows)");
-      e.printStackTrace(System.err);
-      System.exit(1);
-    }
-    return lines;
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("ADD R1 R1 R1");
+    list.add("SUB R1 R1 R2");
+    list.add("DIV R1 R1 R2");
+    list.add("RET R1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+  */
+
+  //t9
+  @Test public void t9() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("ADD R1 R1 R1");
+    list.add("SUB R1 R1 R2");
+    list.add("DIV R1 R1 R1");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+  //t10-
+  @Test public void t10() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 -1");
+    list.add("MOV R2 0");
+    list.add("ADD R1 R1 R1");
+    list.add("SUB R1 R1 R2");
+    list.add("DIV R1 R2 R1");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 0;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //td1
+  @Test public void td1() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 -65535");
+    list.add("MOV R2 65535");
+    list.add("ADD R3 R1 R1");
+    list.add("SUB R4 R1 R2");
+    list.add("DIV R1 R1 R2");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = -1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+  //td2
+  @Test public void td2() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 65535");
+    list.add("MOV R2 -65535");
+    list.add("ADD R3 R1 R1");
+    list.add("SUB R4 R1 R2");
+    list.add("DIV R1 R1 R2");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = -1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
   }
+
+  //t11
+  @Test public void t11() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R0 -65535");
+    list.add("MOV R1 65535");
+    list.add("SUB R0 R0 R1");
+    list.add("ADD R1 R1 R1");
+    list.add("RET R0");
+    Machine m = new Machine();
+    final int expected = -65535-65535;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //t12
+  @Test public void t12() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R31 65535");
+    list.add("MOV R1 -65535");
+    list.add("SUB R31 R31 R1");
+    list.add("ADD R1 R1 R1");
+    list.add("RET R31");
+    Machine m = new Machine();
+    final int expected = 65535+65535;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //t13
+  @Test public void t13() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 -65535");
+    list.add("MOV R2 65535");
+    list.add("ADD R3 R1 R2");
+    list.add("JMP 2");
+    list.add("MOV R3 1");
+    list.add("RET R3");
+    Machine m = new Machine();
+    final int expected = 0;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //t14
+  @Test(expected = NoReturnValueException.class)
+  public void t14() throws Throwable
+  {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("JMP -2");
+    list.add("MOV R2 0");
+    list.add("ADD R1 R1 R1");
+    list.add("RET R1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+
+  //t15
+  @Test(expected = NoReturnValueException.class)
+  public void t15() throws Throwable
+  {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("ADD R1 R1 R1");
+    list.add("JMP 2");
+    list.add("RET R1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+
+  //t16
+  @Test public void t16() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 65535");
+    list.add("MOV R2 -65535");
+    list.add("ADD R1 R1 R2");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 0;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //t17
+  @Test public void t17() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("MUL R2 R1 R2");
+    list.add("JZ R2 2");
+    list.add("RET R1");
+    list.add("RET R2");
+    Machine m = new Machine();
+    final int expected = 0;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+
+  //t18
+  @Test public void t18() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 -32768");
+    list.add("MOV R2 32768");
+    list.add("MOV R3 1");
+    list.add("MUL R1 R1 R2");
+    list.add("JZ R3 2");
+    list.add("RET R1");
+    list.add("RET R2");
+    Machine m = new Machine();
+    final int expected = -32768*32768;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //t19
+  @Test public void t19() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 32768");
+    list.add("MOV R2 -32768");
+    list.add("MOV R3 -1");
+    list.add("MUL R1 R1 R2");
+    list.add("JZ R3 2");
+    list.add("RET R1");
+    list.add("RET R2");
+    Machine m = new Machine();
+    final int expected = -32768*32768;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //t20
+  @Test public void t20() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 65535");
+    list.add("MOV R2 -32768");
+    list.add("MOV R31 32768");
+    list.add("MUL R2 R1 R2");
+    list.add("SUB R2 R2 R31");
+    list.add("RET R2");
+    Machine m = new Machine();
+    final int expected = -2147483648;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //t21
+  @Test public void t21() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 65535");
+    list.add("MOV R2 32768");
+    list.add("MOV R31 -32767");
+    list.add("MUL R2 R1 R2");
+    list.add("SUB R2 R2 R31");
+    list.add("RET R2");
+    Machine m = new Machine();
+    final int expected = 2147483647;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+/**
+ * failed test
+  //t22
+  @Test(expected = InvalidInstructionException.class)
+  public void t22() throws Throwable
+  {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 65535");
+    list.add("MOV R2 -32768");
+    list.add("MOV R31 32769");
+    list.add("MUL R2 R1 R2");
+    list.add("SUB R2 R2 R31");
+    list.add("RET R2");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+
+  //t23
+  @Test(expected = InvalidInstructionException.class)
+  public void t23() throws Throwable
+  {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 65535");
+    list.add("MOV R2 32768");
+    list.add("MOV R31 -32768");
+    list.add("MUL R2 R1 R2");
+    list.add("SUB R2 R2 R31");
+    list.add("RET R2");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+  */
+
+  //t24
+  @Test public void t24() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 65535");
+    list.add("STR R2 -65535 R1");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //t25
+  @Test public void t25() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("STR R3 65535 R1");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+
+  //t26
+  @Test public void t26() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 -65535");
+    list.add("MOV R3 -1");
+    list.add("STR R2 65535 R1");
+    list.add("LDR R3 R2 65535");
+    list.add("RET R3");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+  //t27
+  @Test public void t27() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 65535");
+    list.add("MOV R3 -1");
+    list.add("STR R2 -65535 R1");
+    list.add("LDR R3 R2 -65535");
+    list.add("RET R3");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //t28
+  @Test public void t28() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("MOV R3 -1");
+    list.add("STR R2 65535 R1");
+    list.add("LDR R3 R2 65535");
+    list.add("RET R3");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+  //t29
+  @Test public void t29() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 65535");
+    list.add("MOV R3 -1");
+    list.add("SUB R2 R2 R3");
+    list.add("STR R2 -1 R1");
+    list.add("LDR R3 R2 -1");
+    list.add("RET R3");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+  //t30
+  @Test public void t30() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 65535");
+    list.add("MOV R3 -1");
+    list.add("STR R2 -65535 R3");
+    list.add("LDR R1 R3 0");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //t31
+  @Test public void t31() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 65535");
+    list.add("MOV R3 -1");
+    list.add("STR R2 -65535 R3");
+    list.add("LDR R1 R3 0");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+
+  //t32
+  @Test public void t32() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("MOV R3 -1");
+    list.add("STR R3 0 R3");
+    list.add("RET R3");
+    Machine m = new Machine();
+    final int expected = -1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //t33
+  @Test public void t33() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("MOV R3 -1");
+    list.add("STR R1 65535 R3");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //t34
+  @Test public void t34() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+  //t35
+  @Test public void t35() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
 }
diff --git a/test/swen90006/machine/PartitioningTests.java b/test/swen90006/machine/PartitioningTests.java
index 5494b44..332c596 100644
--- a/test/swen90006/machine/PartitioningTests.java
+++ b/test/swen90006/machine/PartitioningTests.java
@@ -1,3 +1,4 @@
+
 package swen90006.machine;
 
 import java.util.List;
@@ -24,67 +25,432 @@ public class PartitioningTests
   {
   }
 
-  //Any method annotation with "@Test" is executed as a test.
-  @Test public void aTest()
+  //ec1
+  @Test(expected = InvalidInstructionException.class)
+  public void ec1() throws Throwable
+  {
+    List<String> list = new ArrayList<String>();
+    list.add("ADD R1 R2 R3");
+    list.add("RET R1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+
+  //ec2
+  @Test(expected = InvalidInstructionException.class)
+  public void ec2() throws Throwable
+  {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 -65536");
+    list.add("MOV R2 -1");
+    list.add("ADD R1 R1 R2");
+    list.add("RET R1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+
+  //ec3
+  @Test(expected = InvalidInstructionException.class)
+  public void ec3() throws Throwable
+  {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 65535");
+    list.add("ADD R1 R1 R1");
+    list.add("RET R1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+
+  //ec4
+  @Test(expected = InvalidInstructionException.class)
+  public void ec4() throws Throwable
+  {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 65536");
+    list.add("MOV R1 -65536");
+    list.add("RET R1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+
+  //ec5
+  @Test(expected = NoReturnValueException.class)
+  public void ec5() throws Throwable
+  {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+
+  //ec6
+  @Test(expected = NoReturnValueException.class)
+  public void ec6() throws Throwable
+  {
+    List<String> list = new ArrayList<String>();
+    list.add("JMP 3");
+    list.add("MOV R1 1");
+    list.add("RET R1");
+    list.add("MOV R1 1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+
+  //ec7
+  @Test(expected = InvalidInstructionException.class)
+  public void ec7() throws Throwable
+  {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R-1 1");
+    list.add("RET R-1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+
+  //ec8
+  @Test(expected = InvalidInstructionException.class)
+  public void ec8() throws Throwable
+  {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R32 1");
+    list.add("RET R32");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+
+  //ec9
+  @Test(expected = InvalidInstructionException.class)
+  public void ec9() throws Throwable
   {
-    //the assertEquals method used to check whether two values are
-    //equal, using the equals method
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("ADD R1 R1 R1");
+    list.add("SUB R1 R1 R2");
+    list.add("DIV R1 R1 R2");
+    list.add("RET R1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+
+  //ec10
+  @Test public void ec10() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("ADD R1 R1 R1");
+    list.add("SUB R1 R1 R2");
+    list.add("DIV R1 R1 R1");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //ec11
+  @Test public void ec11() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("ADD R1 R1 R1");
+    list.add("SUB R1 R1 R2");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 2;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //ec12
+  @Test public void ec12() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("JMP 2");
+    list.add("MOV R2 0");
+    list.add("ADD R1 R1 R1");
+    list.add("RET R1");
+    Machine m = new Machine();
     final int expected = 2;
-    final int actual = 1 + 1;
+    int actual = m.execute(list);
     assertEquals(expected, actual);
   }
 
-  @Test public void anotherTest()
+  //ec13
+  @Test(expected = NoReturnValueException.class)
+  public void ec13() throws Throwable
+  {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("JMP -2");
+    list.add("MOV R2 0");
+    list.add("ADD R1 R1 R1");
+    list.add("RET R1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+
+  //ec14
+  @Test(expected = NoReturnValueException.class)
+  public void ec14() throws Throwable
   {
     List<String> list = new ArrayList<String>();
-    list.add("a");
-    list.add("b");
+    list.add("MOV R1 1");
+    list.add("JMP 4");
+    list.add("MOV R2 0");
+    list.add("ADD R1 R1 R1");
+    list.add("RET R1");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
 
-    //the assertTrue method is used to check whether something holds.
-    assertTrue(list.contains("a"));
+  //ec15
+  @Test public void ec15() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("ADD R1 R1 R1");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 2;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
   }
 
-  //Test test opens a file and executes the machine
-  @Test public void aFileOpenTest()
+  //ec16
+  @Test public void ec16() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("MUL R2 R1 R2");
+    list.add("JZ R2 2");
+    list.add("RET R1");
+    list.add("RET R2");
+    Machine m = new Machine();
+    final int expected = 0;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //ec17
+  @Test public void ec17() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("MUL R2 R1 R2");
+    list.add("JZ R1 2");
+    list.add("RET R1");
+    list.add("RET R2");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //ec18
+  @Test public void ec18() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("MUL R2 R1 R2");
+    list.add("RET R2");
+    Machine m = new Machine();
+    final int expected = 0;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //ec19
+  @Test public void ec19() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("STR R2 65535 R1");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //ec20
+  @Test public void ec20() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("MOV R3 -1");
+    list.add("STR R2 65535 R1");
+    list.add("LDR R3 R2 65535");
+    list.add("RET R3");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //ec21
+  @Test public void ec21() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("MOV R3 -1");
+    list.add("STR R2 -65535 R3");
+    list.add("LDR R1 R3 -65535");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //ec22
+  @Test public void ec22() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("MOV R3 -1");
+    list.add("STR R2 65535 R1");
+    list.add("LDR R3 R1 65535");
+    list.add("RET R3");
+    Machine m = new Machine();
+    final int expected = -1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //ec23
+  @Test public void ec23() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("MOV R3 -1");
+    list.add("STR R2 65535 R2");
+    list.add("LDR R1 R1 65535");
+    list.add("LDR R1 R3 -65535");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //ec24
+  @Test public void ec24() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("MOV R3 -1");
+    list.add("STR R3 -65535 R3");
+    list.add("LDR R1 R3 -65535");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //ec25
+  @Test public void ec25() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("MOV R3 -1");
+    list.add("STR R3 -65535 R3");
+    list.add("LDR R1 R3 -65535");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //ec26
+  @Test public void ec26() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("MOV R2 0");
+    list.add("MOV R3 -1");
+    list.add("STR R3 -65535 R3");
+    list.add("STR R1 65535 R1");
+    list.add("LDR R2 R3 -65535");
+    list.add("LDR R2 R1 65535");
+    list.add("RET R2");
+    Machine m = new Machine();
+    final int expected = 0;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //ec27
+  @Test public void ec27() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
+  }
+
+  //ec28
+  @Test(expected = InvalidInstructionException.class)
+  public void ec28() throws Throwable
   {
-    final List<String> lines = readInstructions("examples/array.s");
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R0 32768");
+    list.add("MOV R1 2");
+    list.add("MOV R3 -1");
+    list.add("MUL R2 R0 R0");
+    list.add("MUL R2 R2 R3");
+    list.add("MUL R2 R2 R1");
+    list.add("ADD R2 R2 R3");
+    list.add("RET R2");
     Machine m = new Machine();
-    assertEquals(m.execute(lines), 45);
+    int actual = m.execute(list);
   }
-  
-  //To test an exception, specify the expected exception after the @Test
-  @Test(expected = java.io.IOException.class) 
-    public void anExceptionTest()
-    throws Throwable
+
+  //ec29
+  @Test(expected = InvalidInstructionException.class)
+  public void ec29() throws Throwable
   {
-    throw new java.io.IOException();
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R0 32768");
+    list.add("MOV R1 2");
+    list.add("MUL R2 R0 R0");
+    list.add("MUL R2 R2 R1");
+    list.add("RET R2");
+    Machine m = new Machine();
+    int actual = m.execute(list);
   }
 
-  //This test should fail.
-  //To provide additional feedback when a test fails, an error message
-  //can be included
-  @Test public void aFailedTest()
+  //ec30
+  @Test(expected = InvalidInstructionException.class)
+  public void ec30() throws Throwable
   {
-    //include a message for better feedback
-    final int expected = 2;
-    final int actual = 1 + 2;
-    assertEquals("Some failure message", expected, actual);
-  }
-
-  //Read in a file containing a program and convert into a list of
-  //string instructions
-  private List<String> readInstructions(String file)
-  {
-    Charset charset = Charset.forName("UTF-8");
-    List<String> lines = null;
-    try {
-      lines = Files.readAllLines(FileSystems.getDefault().getPath(file), charset);
-    }
-    catch (Exception e){
-      System.err.println("Invalid input file! (stacktrace follows)");
-      e.printStackTrace(System.err);
-      System.exit(1);
-    }
-    return lines;
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R0 32768");
+    list.add("MOV R1 2");
+    list.add("MOV R3 -1");
+    list.add("MUL R2 R0 R0");
+    list.add("MUL R2 R2 R3");
+    list.add("MUL R2 R2 R1");
+    list.add("MUL R4 R2 R3");
+    list.add("ADD R2 R2 R3");
+    list.add("RET R2");
+    Machine m = new Machine();
+    int actual = m.execute(list);
+  }
+
+  //ec31
+  @Test public void ec31() {
+    List<String> list = new ArrayList<String>();
+    list.add("MOV R1 1");
+    list.add("");
+    list.add("RET R1");
+    Machine m = new Machine();
+    final int expected = 1;
+    int actual = m.execute(list);
+    assertEquals(expected, actual);
   }
+
 }
+
-- 
GitLab