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 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 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