From c16ef0985f8c5e3f9b1be710edfec3e3f9e9546c Mon Sep 17 00:00:00 2001 From: Simoes Lukas Date: Mon, 26 May 2025 12:07:58 +0200 Subject: [PATCH] JUnit --- DEV2.3/TP01/MonInt.class | Bin 0 -> 2485 bytes DEV2.3/TP01/MonInt.java | 113 +++++++++++++ DEV2.3/TP01/v0/Carte.class | Bin 0 -> 2371 bytes DEV2.3/TP01/v0/Carte.java | 156 ++++++++++++++++++ DEV2.3/TP01/v0/EnsembleCarte.class | Bin 0 -> 1829 bytes DEV2.3/TP01/v0/EnsembleCarte.java | 142 ++++++++++++++++ DEV2.3/TP01/v0/Joueur.class | Bin 0 -> 1481 bytes DEV2.3/TP01/v0/Joueur.java | 95 +++++++++++ DEV2.3/TP01/v0/Table.class | Bin 0 -> 1360 bytes DEV2.3/TP01/v0/Table.java | 123 ++++++++++++++ DEV2.3/TP01/v0/TestCarte.class | Bin 0 -> 1486 bytes DEV2.3/TP01/v0/TestCarte.java | 85 ++++++++++ DEV2.3/TP01/v0Memory.zip | Bin 0 -> 15103 bytes DEV2.3/TP02/Ex2/Largest.class | Bin 0 -> 330 bytes DEV2.3/TP02/Ex2/Largest.java | 20 +++ DEV2.3/TP02/Ex2/TestLargest.class | Bin 0 -> 1150 bytes DEV2.3/TP02/Ex2/TestLargest.java | 46 ++++++ DEV2.3/TP02/Junit4Exemples.tar.gz | Bin 0 -> 4700 bytes DEV2.3/TP02/Junit4Exemples/AssertTests.java | 106 ++++++++++++ DEV2.3/TP02/Junit4Exemples/Calculator.class | Bin 0 -> 833 bytes DEV2.3/TP02/Junit4Exemples/Calculator.java | 30 ++++ .../TP02/Junit4Exemples/CalculatorTest0.java | 30 ++++ .../TP02/Junit4Exemples/CalculatorTest1.java | 18 ++ .../TP02/Junit4Exemples/CalculatorTest2.java | 48 ++++++ .../TP02/Junit4Exemples/CalculatorTest3.java | 20 +++ DEV2.3/TP02/Junit4Exemples/Readme.txt | 43 +++++ DEV2.3/TP02/Junit4Exemples/RunForestRun.java | 24 +++ DEV2.3/TP02/Junit4Exemples/TestParam.java | 47 ++++++ DEV2.3/TP02/Junit4Exemples/TestSuite.java | 26 +++ 29 files changed, 1172 insertions(+) create mode 100644 DEV2.3/TP01/MonInt.class create mode 100644 DEV2.3/TP01/MonInt.java create mode 100644 DEV2.3/TP01/v0/Carte.class create mode 100644 DEV2.3/TP01/v0/Carte.java create mode 100644 DEV2.3/TP01/v0/EnsembleCarte.class create mode 100644 DEV2.3/TP01/v0/EnsembleCarte.java create mode 100644 DEV2.3/TP01/v0/Joueur.class create mode 100644 DEV2.3/TP01/v0/Joueur.java create mode 100644 DEV2.3/TP01/v0/Table.class create mode 100644 DEV2.3/TP01/v0/Table.java create mode 100644 DEV2.3/TP01/v0/TestCarte.class create mode 100644 DEV2.3/TP01/v0/TestCarte.java create mode 100644 DEV2.3/TP01/v0Memory.zip create mode 100644 DEV2.3/TP02/Ex2/Largest.class create mode 100644 DEV2.3/TP02/Ex2/Largest.java create mode 100644 DEV2.3/TP02/Ex2/TestLargest.class create mode 100644 DEV2.3/TP02/Ex2/TestLargest.java create mode 100644 DEV2.3/TP02/Junit4Exemples.tar.gz create mode 100644 DEV2.3/TP02/Junit4Exemples/AssertTests.java create mode 100644 DEV2.3/TP02/Junit4Exemples/Calculator.class create mode 100644 DEV2.3/TP02/Junit4Exemples/Calculator.java create mode 100644 DEV2.3/TP02/Junit4Exemples/CalculatorTest0.java create mode 100644 DEV2.3/TP02/Junit4Exemples/CalculatorTest1.java create mode 100644 DEV2.3/TP02/Junit4Exemples/CalculatorTest2.java create mode 100644 DEV2.3/TP02/Junit4Exemples/CalculatorTest3.java create mode 100644 DEV2.3/TP02/Junit4Exemples/Readme.txt create mode 100644 DEV2.3/TP02/Junit4Exemples/RunForestRun.java create mode 100644 DEV2.3/TP02/Junit4Exemples/TestParam.java create mode 100644 DEV2.3/TP02/Junit4Exemples/TestSuite.java diff --git a/DEV2.3/TP01/MonInt.class b/DEV2.3/TP01/MonInt.class new file mode 100644 index 0000000000000000000000000000000000000000..ca36dcd43a2c4601a329246bfe990941730ced21 GIT binary patch literal 2485 zcmX^0Z`VEs1_mdFN-hQ_24;2!79Ivx1~x_pfvm)`ME#t^ymWp4q^#8B5=I6#o6Nk- z5<5l)W)00SP6iGJPId+^9tLg(9!3T>-~2q!JdmQY#GKU9B1Q&APmmHm9tM5}0Y(Pq zy!>271|c7Wslg>hnR)5f91KE?47xdq3duQ%#l@)#DXDq+xtV#1C8?!F3VEpt1*xSa z3I&P93Wryf6s0QUmFDDdF^DjTvNMSBFo-iqFfs^&%`7d+%z?VJn2~|6D7COOvnbUs zKhLi;Cx?;2LIcTah=;6^M4*n*L=u83;$q-nkm6yGW{_cI;7m^~34?l%SwqtkBqzti zAkUz{$iSAKTH*)tqlgBwDNuuj7#J9oco>u!R2Uh=a}%>uo%8dO6HCG~OER4E^NLFn z^Gb@*90}ElJlJ6#Kf24Dtvio;f+G>4`bPC5a`et`*6t1t3E?81xw# z{GIc2b5j*kGK&*4OB8|=lQR+(+)Fb{iYj#!vQk0uR$Q7{434+r(t^~Y;*!jg%+%5f zh1|r&tXCgj0`5A5Hw|EP}lGzDp)ue z%o!P2ON#O{i$PIk39`V7kwFZr_Am|x8%74U!qUW&qErqBJ4ObUywuV(4h9EC2DXx- z)Xb_>P6j6iXLbe`9tKwiHFu*=YVPp`-BE`tSVUwH#Er7U! z^Gl18Q{6IiKmh>pz8=WMj0^%!`S~TqB}It^zNsY{`6{NY-`yiRtEit(y zzo?RtVFq$Sg(`$t>XDe2l9O7j;*+1BU0Q&pph5CFipG%2f>bQZk;4NPW0*!bC+6e? zXO^T|Gcxda=H;apfnzSUn4O`NkwF#1PuQHw&QQ+CActQmBLf@6Ukr*291Khh3=GT+ zOrTnTfq{VuRN6Bz2uOg+A_fKqb_PZURt75uMus>B1_onL6~n;5z^}EPfl*6(D+9Zh z&Q=EAjSLJ7j12J%3=BdHEDQ_`f($GSLJXV?!VG*2A`Fb6^bR$kj)9qhnSp`9O~Jd z%)kh$HlRkyGJuR`U|(mC9}tsW$a*`2g)fLHz$s+Aox#En%;puc-_BrR z#j=UPQF|MM`!)uzO$?4YaF#BFrK`P-!G9BjBb2MH1K}ccNU}f_E@$AiV%@~xD9O5w zAr!0&RfKUHgFlMMMh0evY=$z1N`_#DW`+)iZiZlnsSL9i<}w5`K;kQjL4tvS!IgoV z!Hq$T!JR>g!Gl4c!IQy~!HdC}!JEOC!H*$`A%G!2?h>^R8SfLCvp>T{4g*G3UO>>h?vE|&a#|=g?TfBDk8Z-B9;qm z1uFv+j{_qEGea6Uy`(c_FfcIiF)%UYGB7e^g2`-#Vg?2VE(S)15{5E{3I<64rvp#} literal 0 HcmV?d00001 diff --git a/DEV2.3/TP01/MonInt.java b/DEV2.3/TP01/MonInt.java new file mode 100644 index 0000000..323aa39 --- /dev/null +++ b/DEV2.3/TP01/MonInt.java @@ -0,0 +1,113 @@ +// notez le s après Object. Permet entre autre de stipuler qu'un objet o n'est pas null avec la méthode Objects.requireNonNull(o, "message d'erreur détaillé"); +import java.util.Objects; + +/* + * Sorte de Int du pauvre à laquelle on ajoute un nom sous forme textuelle. + * + * Classe donnée à titre d'exemple pour illustrer les ingrédients techniques de la prog défensive. + * et les assertions java + */ +public class MonInt { + + // un entier + private int valeur ; + // son nom sous forme textuelle + private String nom ; + + public MonInt(int n, String s){ + this.valeur = n; + this.nom = s; + } + + /** + * division du pauvre. + * + * + * @param c le diviseur par lequel on souhaite diviser this + */ + public void divise (MonInt c){ + Objects.requireNonNull(c, "la classe denominateur ne peut pas être null"); + + int avant = this.valeur; + + this.valeur = this.valeur / c.getValeur(); + this.nom = "(" + this.nom + " divisé par " + c.getNom() +")"; + + assert(this.valeur*c.getValeur() == avant); // NB. un assert qui ne marche pas tout le temps. + } + + /** + * Un getter superstitieux. + * retourne une exception si la valeur vaut 13. + */ + public int getValeur(){ + if (valeur == 13) throw new IllegalStateException("Comme disait Sacha Guitry, je ne suis pas superstitieux mais on ne sait jamais."); + return valeur; + } + + public String getNom(){ + return nom; + } + + /** + * @return String representant l'entier. + */ + public String toString(){ + return this.getValeur() + " " + this.getNom(); + } + + /** + * C'est un peu moche mais on peut pour simplifier mettre des tests manuels dans un main dans chaque classe. + * C'est plutôt mieux que de mettre des print dans chaque méthode car vous êtes plus sûr de la stabilité de vos tests + * (vous pouvez rejouer les tests plus tard). + * + * Idéalement on utilise un outil dédié comme JUnit qui favorise au maximum cette automatisation. + * + * @param args pas de paramètre en ligne de commande prévu. + */ + public static void main(String[] args) { + MonInt c3 = new MonInt(3,"trois"); + MonInt c4 = new MonInt(4,"quatre"); + MonInt c9 = new MonInt(9,"neuf"); + MonInt c13 = new MonInt(13,"treize"); + System.out.println(c3.toString()); + System.out.println(c4.toString()); + System.out.println(c9.toString()); + + + c9.divise(c3); + // 3 + System.out.println(c9.toString()); + + c3.divise(c4); + // 0 + System.out.println(c3.toString()); + + // tester des exceptions pas pratique + // Si on veut tester plusieurs exceptions + // il faut attraper et vérifier que c'est le bon type d'exception. + // ici manuellement en regardant le message. + try { + System.out.println(c13.toString()); // toucher au nbre 13 avec getValeur() + } + catch(Exception e){ + System.out.println(e); + } + + try{ + c9.divise(c3); //division par 0 + } + catch(Exception e){ + System.out.println(e); + } + + try{ + c9.divise(null); //division par null + } + catch(Exception e){ + System.out.println(e); + } + + + } +} diff --git a/DEV2.3/TP01/v0/Carte.class b/DEV2.3/TP01/v0/Carte.class new file mode 100644 index 0000000000000000000000000000000000000000..c4e510b8e3a2c371467b37bd453411f390366b48 GIT binary patch literal 2371 zcmX^0Z`VEs1_mdFJT3+%24;2!79Ivx1~x_pfvm)`ME#t^ymWp4q^#8B5=I6#o6Nk- z5<5l)W)00SP6iGJPId+^9tLg(9!3UM=ft9tR7M8QyriO3D4Wp}q==7)fuBKuk%7G| zvp6#;CzX+bF$yFu#KRyA(#ckqn3Gys#K9oS$Y7t7sE`aYNa64Tg_6|blGGxFg2dwD z!z)u2Qu7oF5{nXZ53eXGN>#{9RVYX;Edj|Y99{($Db2~@Vi0GLU}uozVUS{wW@Hcq z`=PWXGY9I2VnznOqSV6D%%W7k{5-$XoE%053k@HzG9<5BBZ&l;6lLb6TWcZ-LBhkD zgF%*&!3yr;!cz78JcTllqmuJ;3lfV`ixf0UGBS%baX6NpL7tI831PQqPEKliVvb`` zdTDNIUWsc(a%w?IW_}(QgB&Pglo%Q0F%$=vB$lKisZ?ZO=3?MrP~~AzV^C*g;3&z5 zxSx?hL<89i5K(I(1_lOA9tJH2ZAJ$1+{Elu=ls0n#FFsLk__kkyyB9?ypm!@26f~R zg6j0dY8oShF32=JMg~z0Y$`Yy3>X>MlM|CO4zElVVqju00x36UWKhFm1r{4XelrCn zP%}mb77b5ODzsp*WM{DAVX$VfK}od1mBl5gxr_|V`K2X{45EHWVQ^${Vq_2o2QR7`Mh5l*kdB-@ke?u?fKv)I95ll~ZgSyaa0O)= z-je+E^qkZ%NJXr%0z+7N2=z)TZkwL&I zKfk27q$sh#H?<@qKc$$1A(oMWlM$3#b2AkfIT+#@8HAykUm+z`0g~TA5{Zlq+@*P` z&@9i$&&H6<#gM{~%Fd7mN*C#j3@RWyAf-@dURi#2sy-y#A?egDF}WnasFIOk26FO& zDulSkBQY-}C$(6`CqF;Cv;a%SMhXWMjUklVcRoyEYtn?WveJA=Z0Ef`lZayx_ae(fy`f?8V`1Q#%{vn*#|VO|4v zEyzka26hGphF}JEh7blmhA;+EhHwU1hA0LVhG+&IhFAuFuzy%&`S=_d85kJ?7y_a0 zkYxbz85meWR)Nfec!7<9k%56Bk%1AEOQA~L8JNJLf?6Q8v!HI+%D@ZqITP6Dpc;{Z zA%j7HArow+2m_N3I|IjmP|&c00-T+J17u$igF4hub*Q2ITH6>@z`?qUL4$!|14swh zNQg@c7#Kn2GgOlU)X~x)hs>hRoCSgZ* zhF}IxhERquh-r+r49wsNTe6#hBa&r1gNe^326OFg3@Y0gY(YY-+ZjxJH!+y&AcR1w z{5CO|>q3OIw=p;)^yor(P&tse?luOuZ46$R5)kb=5DifCK^kXrJuU_&23<}DF$R4QVF2P9f(RoJVa&xK#$dwEU<%@x z2{AA*SaC6MF<67RHrxza47MP`j-A1ti$RdVL5P8o!HJ83i@_O0IIuIgurs(aGO#D- z=ar=9l`=9&`eY@RCF+-!WajAmWaee3rg$V4X9TB~STizk24|+{C6<&Hr7|)o;ZkSg zi+C738N3)71f25oONvX15(|7&OEU6Piuu_Xyg3+rco=*c{6JRw z^DqQ31oAKhF$D84gfN6MGO&Wfn1?}wL6d_a45ToeharL?l97QI#r2E~0$?|T?e(S(uqwnWFmf?6s3ChBW+SE}7#Y|S3kp*6QWzO@iP8a$VQY4V7*OmaFfyosLmeCu znR#XT*{RSJ2nis!#N?9vqDpp#Bt`}{pZxsn(gH>X9?!hI)FS7c#Ny)AVn&7;$TmaG zfTS3Y#JrT8)M6EgMr%y>BZ;7B45=(g#iBeKNj)^kkmCz#gmYp}PH<*Psx>=9G9!a3 zhX1g+jgdhPzd9C01~CS41_lNu1}0FpVqj#D0`sI9m_RvqZ6!21W)&1_lNp1{MYe20I2824e<( z273k(1_uTf1|7<1 contenu = new LinkedHashSet(); + + /** + * nbre de Cartes de l'ensemble. + * + */ + private int nbreCarte; + + /** + * Constructeur d'Ensemble vide. + */ + public EnsembleCarte(){ + this.nbreCarte=0; + } + + /** + * Ajoute une carte à l'ensemble. + * @param c une carte + * @return true si la carte est ajoutée à l'ensemble + * @throws NullPointerException si la carte est null + * @throws IllegalStateException si la carte ne peut pas être ajoutée car elle est déjà présente dans l'ensemble + */ + protected boolean add(Carte c){ + this.nbreCarte++; + return contenu.add(c); + } + + /** + * Enlève une carte à l'ensemble. + * @param c une carte + * @return true si la carte est retirée à l'ensemble + * @throws NullPointerException si la carte est null + * @throws IllegalStateException si la carte ne peut pas être enlevéé car elle n'est pas présente dans l'ensemble + */ + private boolean remove(Carte c){ + this.nbreCarte++; + return contenu.remove(c); + } + + /** + * Permet de transférer une paire de carte (par exemple depuis la table vers un joueur) + * Si ces cartes sont toutes les deux visibles + * @param target destination du transfert + * @param c1 première carte + * @param c2 seconde carte + * @return true en cas de succès, false sinon + * @throws NullPointerException si un élément passé en paramètre est null. + * @throws IllegalArgumentException si les cartes ne sont pas toutes les deux visibles + * @throws IllegalStateException si this ne contient pas les deux cartes. + */ + public boolean transfer(EnsembleCarte target, Carte c1, Carte c2){ + return this.contenu.contains(c1) && this.contenu.remove(c1) && target.add(c1) && this.contenu.contains(c2) && this.contenu.remove(c2) && target.add(c2); + } + + + public String toString(){ + // Stringbuilder is the most efficient method of building a String like datastructure incrementally. + StringBuilder sb = new StringBuilder(" de taille " + this.contenu.size() + ", contenant : \n"); + for (Carte c : this.contenu){ + sb.append(" _ " + c.toString() +"\n"); + } + return sb.toString(); + } + + + // tests obsolètes [serait OK si classe n'était pas abstraite] + + // public static void main(String[] args) { + + // Carte un = new Carte(1); + // Carte deux = new Carte (2); + // deux.toggleVisible(); + // Carte unBis = new Carte(1); + + // Carte deuxBis = new Carte(2); + + // EnsembleCarte e1 = new EnsembleCarte(); + // System.out.println(e1.add(un) && e1.add(deux)); + // System.out.println(e1.toString()); + + // EnsembleCarte e2 = new EnsembleCarte(); + // System.out.println(e2.add(un) && e2.add(unBis)); + // System.out.println(e2.toString()); + + // e1.transfer(e2,un,deuxBis); + // System.out.println(e1.toString()); + // System.out.println(e2.toString()); + + // } +} + + diff --git a/DEV2.3/TP01/v0/Joueur.class b/DEV2.3/TP01/v0/Joueur.class new file mode 100644 index 0000000000000000000000000000000000000000..a6d492d4c81562908ff2f5d3d4b4de0141aef36f GIT binary patch literal 1481 zcmX^0Z`VEs1_pD6U@it>1_e$ARt7~7OG$`MCfxe7%&)eF&HrzgSaLj!jzrCjFEvkFF%)&LC7a7u`E$PCowNw zKe(hQGcVnmk%7%7GcU8mj*&rB15;WvjFExGIX@+pk%8YQGcVPzG&d==C?qi{CzX+b zqa+_<3L}Gvh9;(FMh2GL#LPTK1~H9jOj(f8T*3LJMaijdnIPl1z4A*_ON;bCZscJQ zV=(7o5MdDIVUS{wW@Hd>%Fiz;E-6YZ@J%hr$WJNeXJfG7V6fz2uwnpt0-~3Zfh8or zBp;+(9K_Bn$ple}C5em-tj>u=C8;1O8%73Juork3Y#Hp>8SHr&92gwg8Ju_+oEcnr z7+e|Lco^InJQx{xUGs`lbCYsX!Fm}Pm^C!RxEMScycij{AT}y6DljrKi039|r#k27 zB`21IXO?6*=jRodB<7VAGcs6U2~;d$fhokuz@p&^3M1ykloUn=E)5^B8>}^>7#RdW zK?IG)%HopLTt)`w{L&Ie22qGPnfdwwMVWae!6ikhiMiH{48mXysKSg4>;)i2IeBPN z@1K;Fnp|QHvYWjqwJbF!wFue%Fi^x7CFT{Ufy5Owd{Dy38tP0ar5VM};0=l+e?|rs zup_{UFEg(!KRXqg1|i|*mY7_UUsTD?5Xi{D=98bFU0T4%z~h;hms;eUlUQ7wTFl5W z1356EWdNlsB+}=3JVV;L!m}EC+6e? zXO^T|voi!SGN@ws51ZQ<8RYP*V^CyZWe{dyU|?im0%ZUO1_ovZMg}nkaRx>P2?hoR zEe0kACI$uuF0Jhhj9S`T8JISLRZB83Fz_)jGcYh1Gq5n2FmN)MGBAR24^*ET0}}%y zNR8GO1}3fT49vS2SQr>K!1c0$Wi1#u8Dtn_A$l0O8CV!N85kIr?`B|)6k^-X!0rQP zacpN`_XV>!w==N&?PlPLWZBNZZN&m&v4U8vAQo7R4a5SAvF~Q!iQLY>YsDeSA<43h zfiGN=Ly{Frvq5Qg5WR_kUy@@RgTN*Re(h}x0ubebk{pt3+ZY5TIkY8NKrEqfGh^x!apvTC-W|NthSz^b?z^tJe#>l|poS%})$iVNDnV0HUnwykb6q1;f zlgh}zoS2fr$iSuHP1Savb6GB9jFb4@e@CxaA&G*tZ-24)5}1_p+V z-3)AzEZZ5_eLxJ>?F{U`AO=Xp55xe8Sh4J8;E3GLz-h%Q335GGxFoC2HUeS!JDCwA()|{GniX7Xr$L6h4p?*gidw zml+fpWEhwjK!B5h5tKw37#ZXk7#L(37#SED7#LW!wlgqpWME)mWRPcIU|<6af|M#S zurV-!m0B?{gN+c|&A=YXvYmm`M|&FskGA$U2L2rk!U(-W3@i)`415fn4Ezkd41x@z z3_=WwP&1XlHYmf*^k-mZU}j)oP)0Em#_`nwS)hY%ffNH90|SFN11Ez7122OlgBXJp zgA{`_gA#)bnnfx^Sj4)WffLyxNrX=z7AY`rGAJ_eGAJ>KF(@-gF{m&oF{q+hqzbpl z4C*5xMjwPXKw%V)Fc%U+S`17K+6>$bIt+pgx?uCT85kLq7#JDUk{Q$)7#TF+hPpxx zm4z7zHXH789W?XB7+4t?7>pP=8H^c(7)%(%7)%*t7|hV^&}3j_(1P26J1QXdfbGx* zMFx^jAR%PUz{z04z{_CEAjV+FAj4qKpv2&SZksj(BZCgnwjm-OBR(q14AGK3queCBZD3T0|OI- FJ^++v8IS+~ literal 0 HcmV?d00001 diff --git a/DEV2.3/TP01/v0/TestCarte.java b/DEV2.3/TP01/v0/TestCarte.java new file mode 100644 index 0000000..540bb33 --- /dev/null +++ b/DEV2.3/TP01/v0/TestCarte.java @@ -0,0 +1,85 @@ +import static org.junit.Assert.assertTrue; // import static : une facilité offerte depuis java5 (pas besoin de mettre le préfixe) +import static org.junit.Assert.assertFalse; // +import org.junit.Test; + + +/** + * Une classe pour faire des tests sur la classe Carte avec JUnit + */ +public class TestCarte { + + // un test pour Junit4 c'est une méthode avec l'annotation @Test devant une méthode avec un type de retour void. + @Test + public void egaleSiIdentiquesEtVisible() { + Carte un = new Carte(1); + un.toggleVisible(); + // on peut stipuler que des choses sont normalement égales (il faut charger de manière statique les Assert si on veut éviter d'avoir à écrire de quelle classe on parle) + assertTrue(un.egale(un)); + } + + // le nom du test doit être le plus explicite possible + @Test + public void egalSiMemeValeurEtVisible() { + Carte un = new Carte(1); + un.toggleVisible(); + Carte unBis = new Carte(1); + unBis.toggleVisible(); + assertTrue(un.egale(unBis)); + } + + @Test + public void pasEgalSiPasMemeValeurEtVisible() { + Carte un = new Carte(1); + un.toggleVisible(); + Carte deux = new Carte(2); + deux.toggleVisible(); + assertFalse(un.egale(deux)); + } + + // un test pour Junit4 qui cherche à vérifier qu'il y a bien une exception + @Test(expected = NullPointerException.class) + public void egalPasFaitPourNull(){ + Carte bad = null; + Carte un = new Carte(1); + un.egale(bad); + } + + // un autre test pour Junit4 qui cherche à vérifier qu'il y a bien une exception + @Test(expected = IllegalArgumentException.class) + public void egalPasFaitPourParametreNonVisible(){ + Carte un = new Carte(1); + Carte deux = new Carte(2); + deux.toggleVisible(); + deux.egale(un); + } + + // un autre test pour Junit4 qui cherche à vérifier qu'il y a bien une exception + @Test(expected = IllegalStateException.class) + public void egalPasFaitPourCarteThisNonVisible(){ + Carte un = new Carte(1); + un.toggleVisible(); + Carte deux = new Carte(2); + deux.egale(un); + un.egale(deux); + } + + //Le monde est mal fait et parfois c'est le test qui est faux. + //Notez que je suis vraiment méchant car ce test est satisfait au début avec le code proposé... + //Moralité : faites des tests très simples et faites vous relire! + @Test + public void egalTestMalFait(){ + Carte un = new Carte(1); + un.toggleVisible(); + Carte deux = new Carte(2); + deux.toggleVisible(); + assertFalse(un.egale(deux)); + } + + // si on ne met pas l'annotation arobase test, le test n'est jamais pris en compte. + // c'est juste une méthode annexe qui n'est pas appellée comme dans n'importe quelle classe. + public void autreTestMalFait(){ + assertFalse(true); + } + + +} diff --git a/DEV2.3/TP01/v0Memory.zip b/DEV2.3/TP01/v0Memory.zip new file mode 100644 index 0000000000000000000000000000000000000000..f898b771770da7449a4f7e240860f1744bbf60a2 GIT binary patch literal 15103 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 literal 0 HcmV?d00001 diff --git a/DEV2.3/TP02/Ex2/Largest.java b/DEV2.3/TP02/Ex2/Largest.java new file mode 100644 index 0000000..d1de4a9 --- /dev/null +++ b/DEV2.3/TP02/Ex2/Largest.java @@ -0,0 +1,20 @@ +public class Largest { + + /** + * Return the largest element in a list. + * + * @param list A list of integers + * @return The largest number in the given list + * @throws NullPointerException si le tableau est null + */ + public static int largest(int[] list) { + int max = list[0]; + + for (int index = 0; index <= list.length-1; index++) { + if (list[index] > max) { + max = list[index]; + } + } + return max; + } +} \ No newline at end of file diff --git a/DEV2.3/TP02/Ex2/TestLargest.class b/DEV2.3/TP02/Ex2/TestLargest.class new file mode 100644 index 0000000000000000000000000000000000000000..aea9a8656e5d893cd478d2304da55d2c35dc85b3 GIT binary patch literal 1150 zcmX^0Z`VEs1_mbvT`mSD24;2!79Ivx1~x_pfvm)`ME#t^ymWp4q^#8B5=I6#o6Nk- z5<5l)W)00SRt5;*tJvBYK7z7vu z*%^d*7=#%_7#Rfei_-P8O7k*H^c{G61~CS4 zb_NL^21y1fn7c|#GIR7Di;5B}iy0YMit|Cb!M234{)d1+>=gN(LjWZ(zs1)Gyt8kPw%pCh%RAT_xpHHDEu%LfsRVCQ<~rKDE) zmzMaaIpvq;r4+kXB&QaD47X-v5CNIwmY30Ra0q~+ z1QLE4aL?O8qeMxBL7E-pe}Rv1Z~XC(WD_`sD_+zX6dBaf%+-XOtHHnsPAwdaKA;dl jiWfcxW(EcZZ3ZR=9R_v=U9bsAaihh+$e_)@0Fnj(BY5O0 literal 0 HcmV?d00001 diff --git a/DEV2.3/TP02/Ex2/TestLargest.java b/DEV2.3/TP02/Ex2/TestLargest.java new file mode 100644 index 0000000..e2853f2 --- /dev/null +++ b/DEV2.3/TP02/Ex2/TestLargest.java @@ -0,0 +1,46 @@ +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import org.junit.Test; +import java.util.Arrays; + +public class TestLargest { + + @Test + public void testSimple() { + assertEquals(9, Largest.largest(new int[] {9,8,7})); + } + + @Test(expected = ArrayIndexOutOfBoundsException.class) + public void testTableauVide() { + Largest.largest(new int[] {}); + } + + @Test + public void testFonctionCorrecte() { + int[] t1 = {5, 4, 8, 1, 4}; + int[] t2 = {15, 4, 8, 49, 5, 89}; + int[] t3 = {4, -5, 8, 9, 4}; + + int maxt1 = Largest.largest(t1); + int maxt2 = Largest.largest(t2); + int maxt3 = Largest.largest(t3); + Arrays.sort(t1); + Arrays.sort(t2); + Arrays.sort(t3); + + assertEquals(t1[t1.length-1], maxt1); + assertEquals(t2[t2.length-1], maxt2); + assertEquals(t3[t3.length-1], maxt3); + } + + @Test + public void testTableauNegatif() { + assertEquals(-4, Largest.largest(new int[] {-15, -5, -4, -58})); + } + + @Test(expected = NullPointerException.class) + public void testTableauNull() { + int[] t = null; + Largest.largest(t); + } +} \ No newline at end of file diff --git a/DEV2.3/TP02/Junit4Exemples.tar.gz b/DEV2.3/TP02/Junit4Exemples.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..9ba521769f078b00e7a11159f20740b58e487821 GIT binary patch literal 4700 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 either(equalTo(3)).or(equalTo(4)))); + assertThat(new Object(), not(sameInstance(new Object()))); + } + + @Test + public void testAssertTrue() { + assertTrue("failure - should be true", true); + } +} diff --git a/DEV2.3/TP02/Junit4Exemples/Calculator.class b/DEV2.3/TP02/Junit4Exemples/Calculator.class new file mode 100644 index 0000000000000000000000000000000000000000..123d5e9370668dc605f509ec20c0d151dbfa0b68 GIT binary patch literal 833 zcmX^0Z`VEs1_mbvQ!WN324;2!79Ivx1~x_pfvm)`ME#t^ymWp4q^#8B5=I6#o6Nk- z5<5l)W)00S4h9ZJ2BsKoE(R_JZgvJ99tK_pJ``=iB}JKe>5L4l#RWN;C5#N}8a@a! zA(Gab(U@Xf3<3;->|wXok4@0L6e6;i$R-_K^W{`R0A0q*b6|$=j1UmuxNN{hA}d*IOnINGBWV{ zWag#%mF6a;7KJ1x<)kt)@CKJ8CTII57J&Ke3mK}-XSEXW3~ z;QZ2}E?85kH0m~FL%*taoo`swa7V_`O96=fA=S;Qcv zE6QqQ#U>-kwu6Cx8-r+qZ3`>o^8Zg|)-W(IFo8`KV_;=qU=UznVi07IWe{S}U=U=` zV-RN0V_;yAU|{;sAi%)J&LGLoz{SYUpwGz2!0>}XmVuMOkiiJ*1~Ud0us6hZGe|~m rXOQ;U#2}-s#cZ^VL1`O<8p8d249pA+4AKl73^EL&U{4x@U10(M2Ar-N literal 0 HcmV?d00001 diff --git a/DEV2.3/TP02/Junit4Exemples/Calculator.java b/DEV2.3/TP02/Junit4Exemples/Calculator.java new file mode 100644 index 0000000..3f8e4a5 --- /dev/null +++ b/DEV2.3/TP02/Junit4Exemples/Calculator.java @@ -0,0 +1,30 @@ + +/** + Calculator est une classe offrant une seule méthode qui évalue une somme, donnée sous la forme d'une chaîne de caractère listant des opérandes séparées par des + + +*/ + +public class Calculator { + + /** + somme les opérandes passées sous forme d'une chaîne de caractères et retourne le résultat sous forme d'entier. + @param expression : chaîne de caractères ("nombres" séparés par des + sans espaces), par exemple "42+3" ou encore "-42+42" (le moins unaire est autorisé). + ici nombre est à comprendre au sens de parseInt(java.lang.String) + @throws NumberFormatException : si l'expression n'est pas dans ce format (par exemple "x+2" ou " 1 +2" -- il y a des espaces -- ou encore "9999999990"). + */ + public int evaluate(String expression) { + int sum = 0; + for (String summand: expression.split("\\+")) + sum += Integer.valueOf(summand); + return sum; + } + + /** + Pour appeller cette super méthode depuis la ligne de commande (on ne regarde que le premier argument, les autres sont ignorés). + + */ + public static void main(String[] args) { + Calculator calculator = new Calculator(); + System.out.println(calculator.evaluate(args[0])); + } +} diff --git a/DEV2.3/TP02/Junit4Exemples/CalculatorTest0.java b/DEV2.3/TP02/Junit4Exemples/CalculatorTest0.java new file mode 100644 index 0000000..38fc2c3 --- /dev/null +++ b/DEV2.3/TP02/Junit4Exemples/CalculatorTest0.java @@ -0,0 +1,30 @@ +import static org.junit.Assert.assertEquals; // import static : une facilité offerte par java5 +import org.junit.Test; + +/** + CalculatorTest0 est un premier exemple de test pour la classe Calculator utilisant junit4 + Assert, ou comment vérifier qu'une méthode donne un résultat correct? + + Remarque en passant, pour tester en ligne de commande (une fois les classes compilées), il faut faire + $java org.junit.runner.JUnitCore CalculatorTest0 + + Remarque, comme expliqué dans la doc de org.junit.runner.JUnitCore +JUnitCore is a *facade* for running tests. It supports running JUnit 4 tests, JUnit 3.8.x tests, and mixtures. To run tests from the command line, run java org.junit.runner.JUnitCore TestClass1 TestClass2 + + Oh le joli design pattern. C'est cadeau. + */ + +public class CalculatorTest0 { + + + // un test pour Junit4 c'est une méthode avec l'annotation suivante devant la méthode. + @Test + public void evaluatesGoodExpression() { + Calculator calculator = new Calculator(); + int sum = calculator.evaluate("1+2+3"); + // on peut stipuler que des choses sont normalement égales (il faut charger de manière statique les Assert si on veut éviter d'avoir à écrire de quelle classe on parle) + assertEquals(6, sum); + } + + +} diff --git a/DEV2.3/TP02/Junit4Exemples/CalculatorTest1.java b/DEV2.3/TP02/Junit4Exemples/CalculatorTest1.java new file mode 100644 index 0000000..f8bed1d --- /dev/null +++ b/DEV2.3/TP02/Junit4Exemples/CalculatorTest1.java @@ -0,0 +1,18 @@ +import static org.junit.Assert.assertEquals; +import org.junit.Test; + +/** + CalculatorTest1 est un exemple de test pour la classe Calculator utilisant junit4. + Comment vérifier qu'on lance bien une exception? + */ + +public class CalculatorTest1 { + + + // un test pour Junit4 qui cherche à vérifier qu'il y a bien une exception + @Test(expected = NumberFormatException.class) + public void doesNotEvaluateBadExpression() { + Calculator calculator = new Calculator(); + int sum = calculator.evaluate("1 +2+3");//notez l'espace qui va génèrez une exception + } +} diff --git a/DEV2.3/TP02/Junit4Exemples/CalculatorTest2.java b/DEV2.3/TP02/Junit4Exemples/CalculatorTest2.java new file mode 100644 index 0000000..25b6590 --- /dev/null +++ b/DEV2.3/TP02/Junit4Exemples/CalculatorTest2.java @@ -0,0 +1,48 @@ +import static org.junit.Assert.assertEquals; +import org.junit.Test; + +import org.junit.BeforeClass; // ne pas oublie de charger le fait qu'on veut l'annotation @BeforeClass +import org.junit.AfterClass; + +/** + + CalculatorTest2 est un exemple de test pour la classe Calculator utilisant junit4 + Il réunit en fait les deux tests des 2 classes précédentes dans une seule classe. + + Typiquement on a en effet tous les tests simples portant sur une classe "métier" regroupée dans une classe de test correspondante. + Avec les annotations, on peut factoriser des choses concernant tous ces tests. + + */ + +public class CalculatorTest2 { + static Calculator calculator; + + // On peut si on le souhaite faire un traitement avant tous les tests (typiquement on fait quelque chose de cher comme se connecter à une base de données, ici j'économise une instance de Calculator (on s'en moque un peu pour être honnête). + @BeforeClass + public static void setUp() { + System.out.println("Avant tous les tests"); + calculator = new Calculator(); + } + + @Test + public void evaluatesGoodExpression() { + System.out.println("Test evaluation bonne expression"); + int sum = calculator.evaluate("1+2+3"); + assertEquals(6, sum); + } + + + @Test(expected = NumberFormatException.class) + public void doesNotEvaluateBadExpression() { + System.out.println("Test evaluation mauvaise expression"); + int sum = calculator.evaluate("1 +2+3"); + } + + // On peut si on le souhaite faire un traitement après tous les tests (typiquement on fait quelque chose de cher comme se connecter à une base de données, ici j'économise une instance de Calculator (on s'en moque un peu pour être honnête). + @AfterClass + public static void tearDown() { + System.out.println("Après tous les Test"); + calculator = null; + } + +} diff --git a/DEV2.3/TP02/Junit4Exemples/CalculatorTest3.java b/DEV2.3/TP02/Junit4Exemples/CalculatorTest3.java new file mode 100644 index 0000000..64caf19 --- /dev/null +++ b/DEV2.3/TP02/Junit4Exemples/CalculatorTest3.java @@ -0,0 +1,20 @@ +import static org.junit.Assert.assertEquals; +import org.junit.Test; + +/** + CalculatorTest3 est un exemple de test pour la classe Calculator utilisant junit4 qui est volontairement non satisfait + + */ + +public class CalculatorTest3 { + + + @Test + public void evaluatesGoodExpression() throws Exception{ + Calculator calculator = new Calculator(); + int sum = calculator.evaluate("1+2+3"); + assertEquals(42, sum); + } + + +} diff --git a/DEV2.3/TP02/Junit4Exemples/Readme.txt b/DEV2.3/TP02/Junit4Exemples/Readme.txt new file mode 100644 index 0000000..993782c --- /dev/null +++ b/DEV2.3/TP02/Junit4Exemples/Readme.txt @@ -0,0 +1,43 @@ +Les fichiers et ce qu'ils illustrent + +Calculator.java le fichier contenant la classe qu'on va prétendre couloir tester. + +CalculatorTest0.java mon premier test avec Junit4 et assert +CalculatorTest1.java mon second test avec Junit4 pour des exceptions +CalculatorTest2.java les deux précédents +CalculatorTest3.java un test volontairement non satisfait + +Jusqu'ici pour exécuter un test, on compile tous les fichiers (une fois le classpath correct) puis on fait : + +$java org.junit.runner.JUnitCore CalculatorTest0 + +voir plusieurs classes de tests suite à suite, en faisant : + +$java org.junit.runner.JUnitCore CalculatorTest0 CalculatorTest1 + +Des choses un peu plus avancées + +RunForestRun.java un exemple de runner (alternative à la ligne de commande qui fait la même chose en java). +TestParam.java mon premier test avancé permettant d'exécuter un test simple sur une liste de paramètres. +TestSuite.java comment combiner plusieurs tests (par exemple si on veut tester plusieurs classes en même temps). +AssertTests.java Squelette de toutes les variantes d'assertion proposées par Junit4 + +=== + +Pour pouvoir utiliser ces tests à bon escients, il faut : +_ avoir installé Junit4 (c'est un jar) +_ faire ce qu'il faut au CLASSPATH pour que Junit4 soit dedans. + +Par exemple sur ma machine, j'ai plusieurs versions de junit: + +$ ls -l /usr/share/java/junit* +-rw-r--r-- 1 root root 108762 mai 18 2012 /usr/share/java/junit-3.8.2.jar +-rw-r--r-- 1 root root 313072 mars 8 2016 /usr/share/java/junit4-4.12.jar +lrwxrwxrwx 1 root root 15 mars 8 2016 /usr/share/java/junit4.jar -> junit4-4.12.jar +lrwxrwxrwx 1 root root 15 mai 18 2012 /usr/share/java/junit.jar -> junit-3.8.2.jar + +Du coup, j'ai fait en sorte que mon CLASSPATH contienne /usr/share/java/junit4.jar + +$ echo $CLASSPATH +.:/usr/lib/jvm/java-8-openjdk-amd64/lib:/usr/share/java/junit4.jar + diff --git a/DEV2.3/TP02/Junit4Exemples/RunForestRun.java b/DEV2.3/TP02/Junit4Exemples/RunForestRun.java new file mode 100644 index 0000000..8626247 --- /dev/null +++ b/DEV2.3/TP02/Junit4Exemples/RunForestRun.java @@ -0,0 +1,24 @@ +/** + + Alternative à la ligne de commande, on peut appeller le runner depuis java avec org.junit.runner.JUnitCore.runClasses +qui retourne un objet de type Result qui modélise les résultats des tests. + +En particulier, on peut accéder à la liste des échecs -- un échec eest un objet Failure -- avec getFailures + + */ + + +import org.junit.runner.JUnitCore; +import org.junit.runner.Result; +import org.junit.runner.notification.Failure; + +public class RunForestRun { + + public static void main(String[] args) { + final Result result = org.junit.runner.JUnitCore.runClasses(CalculatorTest0.class,CalculatorTest1.class,CalculatorTest3.class); + for (final Failure failure : result.getFailures()) { + System.out.println(failure.toString()); // affiche détail sur chaque échec + } + System.out.println(result.wasSuccessful()); // affiche true ssi aucune erreurs + } +} diff --git a/DEV2.3/TP02/Junit4Exemples/TestParam.java b/DEV2.3/TP02/Junit4Exemples/TestParam.java new file mode 100644 index 0000000..2416862 --- /dev/null +++ b/DEV2.3/TP02/Junit4Exemples/TestParam.java @@ -0,0 +1,47 @@ +/** + + Example d'utilisation d'un runner spécial : Parameterized. + + Ce runner permet de facilement itérer des tests similaires sur plusieurs choix de valeurs. + + + */ +import static org.junit.Assert.assertEquals; + +import java.util.Arrays; +import java.util.Collection; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; + + +// l'annotation @RunWith propre aux runners +@RunWith(Parameterized.class) +public class TestParam { + + // l'annotation @Parameters pour aller chercher les paramètres des tests (on itère sur des tuples d'objet) + @Parameters(name = "{index}: {0} = {2}") + public static Iterable data() { + return Arrays.asList(new Object[][] { { "1+2+3", 6 }, { "40+2", 42 }, + { "001+41", 42 }, { "0000", 0 }, { "999+-999", 0 } }); + } + + // les attributs qui correspondent aux éléments de nos tuples + private String expression; + private int res; + + // le constructeur + public TestParam(String expression, int res) { + this.expression = expression; + this.res = res; + } + + // le test qui va manger les paramètres qu'on vient de définir + @Test + public void evaluatesGoodExpressions() { + Calculator calculator=new Calculator(); + assertEquals(res, calculator.evaluate(expression)); + } +} diff --git a/DEV2.3/TP02/Junit4Exemples/TestSuite.java b/DEV2.3/TP02/Junit4Exemples/TestSuite.java new file mode 100644 index 0000000..d342de3 --- /dev/null +++ b/DEV2.3/TP02/Junit4Exemples/TestSuite.java @@ -0,0 +1,26 @@ +/** + Un runner spécial qui sert à créer une collection de tests. + Typiquement, on peut avoir une classe de tests unitaires pour chaque classe métier et une "suite de tests" qui va appeller tous les tests de classes ayant un lien (par exemple dans le même paquet). + + Ceci est de nouveau un test, qu'on peut exécuter en faisant par exemple dans une console + java org.junit.runner.JUnitCore TestSuite + + */ + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; + +// @RunWith permet d'indiquer le runner +@RunWith(Suite.class) + +//les tests à faire et dans quel ordre. +@Suite.SuiteClasses({ + CalculatorTest0.class, + CalculatorTest1.class, + CalculatorTest3.class +}) + +public class TestSuite { + // La classe est vide en fait + // C'est juste un conteneur pour les annotations du dessus, utilisés par Junit4 +}