SHARE
TWEET

cherchertestALL

AudibertHerve Jan 26th, 2020 (edited) 81 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2. @author: Herve Audibert
  3. @author: Issam Bouras
  4. @author : Franck Palacios
  5. @date: 22/01/2020
  6. @nom-fichier : TestChercherElt.java
  7. */
  8.  
  9. package testchercher;
  10.  
  11. import static org.junit.jupiter.api.Assertions.*;
  12.  
  13. import org.junit.jupiter.api.Test;
  14.  
  15. import chercher.Chercher;
  16.  
  17. class TestChercherElt {
  18.  
  19.     /**
  20.      * Entrée : un tableau de 4 éléments .
  21.      * On chercher l'élément 3 dans la liste tab[]
  22.      * Résultat attendu : 2.
  23.      */
  24.  
  25.     @Test
  26.     void testElementDansListe() {
  27.         int tab[] = {-1,2,3,4};
  28.         int elt = 3;
  29.         Chercher chercher = new Chercher(tab);
  30.        
  31.         assertEquals(2,chercher.chercherElt(elt, tab));
  32.     }
  33.    
  34.     /**
  35.      * Entrée : un tableau vide.
  36.      * Résultat attendu : -1.
  37.      */
  38.     @Test
  39.      void testListeVide() {
  40.            int elt = 0;
  41.             int[] tab = new int[0];
  42.             Chercher chercher = new Chercher(tab);
  43.          
  44.             assertEquals(-1,chercher.chercherElt(elt, tab));
  45.         }
  46.  
  47.    
  48.     /**
  49.      * Entrée : un tableau de 4 éléments.
  50.      * L'élément demander n'est pas dans la liste
  51.      * Résultat attendu : -1.
  52.      */
  53.     @Test
  54.     void testElementHorsListe() {
  55.         int tab[] = {1,2,3,4};
  56.         int elt = -1;
  57.         Chercher chercher = new Chercher(tab);
  58.        
  59.         assertEquals(-1,chercher.chercherElt(elt, tab));
  60.     }
  61.    
  62.     /**
  63.      * Entrée : un tableau de 4 éléments.
  64.      * L'élément demander apparait plusieurs fois dans la liste
  65.      * Résultat attendu : 1.
  66.      */
  67.     @Test
  68.     void testPresenceMutipleElementRecherche(){
  69.         int tab[] = {1,4,4,6,7,7,8};
  70.         int elt = 4;
  71.         Chercher chercher = new Chercher(tab);
  72.        
  73.         assertEquals(1,chercher.chercherElt(elt, tab));
  74.    
  75.     }
  76.     /* Rajouter en txt pour la spéc qu'il doit vérifier une autre solution lorsqu'il y a plusieurs élément multiple   */
  77.    
  78.    
  79.    
  80. }
  81. ////////////////////////////////////////////////////////////////////////////////////////////////////////////
  82.  
  83.  
  84.  
  85.  
  86.  
  87. /*
  88. @author: Herve Audibert
  89. @author: Issam Bouras
  90. @author : Franck Palacios
  91. @date: 22/01/2020
  92. @nom-fichier : TestChercher1.java
  93. */
  94.  
  95. package testchercher;
  96.  
  97. import static org.junit.jupiter.api.Assertions.assertEquals;
  98.  
  99. import org.junit.jupiter.api.Test;
  100.  
  101. import chercher.Chercher;
  102.  
  103. class TestChercher1 {
  104.         /**
  105.          * Entrée : un tableau de 4 éléments .
  106.          * On chercher l'élément 3 dans la liste tab[]
  107.          * Résultat attendu : true.
  108.          */
  109.         @Test
  110.         void testElementDansListe() {
  111.             int tab[] = {-1,2,3,4};
  112.             int elt = 3;
  113.             Chercher chercher = new Chercher(tab);
  114.             assertEquals(true, chercher.chercher1(elt, tab));
  115.         }
  116.         /**
  117.          * Entrée : un tableau vide.
  118.          * Résultat attendu : false.
  119.          */
  120.         @Test
  121.          void testListeVide() {
  122.                 int elt = 0;
  123.                 int[] tab = new int[0];
  124.                 Chercher chercher = new Chercher(tab);
  125.                 assertEquals(false, chercher.chercher1(elt, tab));
  126.             }
  127.         /**
  128.          * Entrée : un tableau de 4 éléments.
  129.          * L'élément demander n'est pas dans la liste
  130.          * Résultat attendu : false.
  131.          */
  132.         @Test
  133.         void testElementHorsListe() {
  134.             int tab[] = {1,2,3,4};
  135.             int elt = -1;
  136.             Chercher chercher = new Chercher(tab); 
  137.             assertEquals(false, chercher.chercher1(elt, tab));
  138.         }
  139.         /**
  140.          * Entrée : un tableau de 4 éléments.
  141.          * L'élément demander apparait plusieurs fois dans la liste
  142.          * Résultat attendu : true.
  143.          */
  144.         @Test
  145.         void testPresenceMutipleElementRecherche(){
  146.             int tab[] = {1,4,4,4};
  147.             int elt = 4;
  148.             Chercher chercher = new Chercher(tab);
  149.             assertEquals(true,chercher.chercher1(elt, tab));   
  150.         }
  151.        
  152.        
  153.     }
  154.  
  155.  
  156. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  157.  
  158.  
  159.  
  160. /*
  161. @author: Herve Audibert
  162. @author: Issam Bouras
  163. @author : Franck Palacios
  164. @date: 22/01/2020
  165. @nom-fichier : TestChercher2.java
  166. */
  167.  
  168. package testchercher;
  169.  
  170. import static org.junit.jupiter.api.Assertions.*;
  171.  
  172.  
  173. import java.time.Duration;
  174.  
  175. import org.junit.jupiter.api.Assertions;
  176. import org.junit.jupiter.api.Test;
  177.  
  178. import chercher.Chercher;
  179.  
  180. class TestChercher2 {
  181.     /**
  182.      * Entrée : un tableau de 4 éléments .
  183.      * On chercher l'élément 3 dans la liste tab[]
  184.      * Résultat attendu : true.
  185.      */
  186.  
  187.  
  188.     private static String traiter() throws InterruptedException {
  189.         Thread.sleep(2000);
  190.         return "";
  191.       }
  192.     /**
  193.      * Entrée : un tableau de 4 éléments .
  194.      * On chercher l'élément 3 dans la liste tab[]
  195.      * Résultat attendu : true.
  196.      */
  197.  
  198.     @Test
  199.     void testElementDansListe() {
  200.         int tab[] = {-1,2,3,4};
  201.         int elt = 3;
  202.         Chercher chercher = new Chercher(tab);
  203.         Assertions.assertTimeoutPreemptively(Duration.ofMillis(2000), () -> {
  204.         assertEquals(true, chercher.chercher2(elt, tab));
  205.             });
  206.            
  207.         Assertions.assertTimeoutPreemptively(Duration.ofSeconds(1), TestChercher2::traiter);
  208.     }
  209.    
  210.     /**
  211.      * Entrée : un tableau vide.
  212.      * Résultat attendu : false.
  213.      */
  214.     @Test
  215.      void testListeVide() {
  216.             int elt = 0;
  217.             int[] tab = new int[0];
  218.             Chercher chercher = new Chercher(tab);
  219.             assertEquals(false, chercher.chercher2(elt, tab));
  220.         }
  221.  
  222.     /**
  223.      * Entrée : un tableau de 4 éléments.
  224.      * L'élément demander n'est pas dans la liste
  225.      * Résultat attendu : false.
  226.      */
  227.     @Test
  228.     void testElementHorsListe() {
  229.         int tab[] = {1,2,3,4};
  230.         int elt = -1;
  231.         Chercher chercher = new Chercher(tab);
  232.         assertEquals(false, chercher.chercher2(elt, tab)); 
  233.     }
  234.    
  235.     /**
  236.      * Entrée : un tableau de 4 éléments.
  237.      * L'élément demander apparait plusieurs fois dans la liste
  238.      * Résultat attendu : 1.
  239.      */
  240.     @Test
  241.     void testPresenceMutipleElementRecherche(){
  242.         int tab[] = {1,4,4,4};
  243.         int elt = 4;
  244.         Chercher chercher = new Chercher(tab);
  245.         assertEquals(1,chercher.chercher2(elt, tab));
  246.  
  247.     }
  248.    
  249. }  
  250.    
  251. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  252.  
  253.  
  254.  
  255.  
  256.  
  257. /*
  258. @author: Herve Audibert
  259. @author: Issam Bouras
  260. @author : Franck Palacios
  261. @date: 22/01/2020
  262. @nom-fichier : TestChercher3.java
  263. */
  264.  
  265. package testchercher;
  266.  
  267. import static org.junit.jupiter.api.Assertions.*;
  268.  
  269. import java.time.Duration;
  270.  
  271. import org.junit.jupiter.api.Assertions;
  272. import org.junit.jupiter.api.Test;
  273.  
  274. import chercher.Chercher;
  275.  
  276. class TestChercher3 {
  277.  
  278.     private static String traiter() throws InterruptedException {
  279.         Thread.sleep(2000);
  280.         return "";
  281.       }
  282.     /**
  283.      * Entrée : un tableau de 4 éléments .
  284.      * On chercher l'élément 3 dans la liste tab[]
  285.      * Résultat attendu : true.
  286.      */
  287.     @Test
  288.     void testElementDansListe() {
  289.         int tab[] = {-1,2,3,4};
  290.         int elt = 3;
  291.         Chercher chercher = new Chercher(tab);
  292.         Assertions.assertTimeoutPreemptively(Duration.ofMillis(2000), () -> {
  293.             assertEquals(true, chercher.chercher3(elt, tab));
  294.             });
  295.            
  296.             Assertions.assertTimeoutPreemptively(Duration.ofSeconds(1), TestChercher3::traiter);
  297.     }
  298.     /**
  299.      * Entrée : un tableau de 4 éléments.
  300.      * L'élément demander n'est pas dans la liste
  301.      * Résultat attendu : false.
  302.      */
  303.     @Test
  304.     void testElementHorsListe() {
  305.         int tab[] = {1,2,3,4};
  306.         int elt = -1;
  307.         Chercher chercher = new Chercher(tab); 
  308.         assertEquals(false, chercher.chercher3(elt, tab));
  309.        
  310.     }
  311.     /**
  312.      * Entrée : un tableau vide.
  313.      * Résultat attendu : -1.
  314.      * Résultat obtenu : java.lang.ArrayIndexOutOfBoundsException: 0
  315.      */
  316.     @Test
  317.      void testListeVide() {
  318.             int elt = 0;
  319.             int[] tab = new int[0];
  320.             Chercher chercher = new Chercher(tab);
  321.             assertEquals(-1,chercher.chercher3(elt, tab));
  322.         }
  323.    
  324.     /**
  325.      * Entrée : un tableau de 4 éléments.
  326.      * L'élément demander apparait plusieurs fois dans la liste
  327.      * Résultat attendu : 1.
  328.      */
  329.     @Test
  330.     void testPresenceMutipleElementRecherche(){
  331.         int tab[] = {1,4,4,4};
  332.         int elt = 4;
  333.         Chercher chercher = new Chercher(tab);
  334.         Assertions.assertTimeoutPreemptively(Duration.ofMillis(2000), () -> {
  335.             assertEquals(1,chercher.chercher3(elt, tab));  
  336.             });
  337.            
  338.             Assertions.assertTimeoutPreemptively(Duration.ofSeconds(1), TestChercher3::traiter);
  339.        
  340.     }
  341.    
  342.    
  343.  
  344.  
  345. }
  346. /////////////////////////////////////////////////////////////////////////////////////////////////////////
  347.  
  348.  
  349. /*
  350. @author: Herve Audibert
  351. @author: Issam Bouras
  352. @author : Franck Palacios
  353. @date: 22/01/2020
  354. @nom-fichier : TestChercher4.java
  355. */
  356.  
  357. package testchercher;
  358.  
  359. import static org.junit.jupiter.api.Assertions.*;
  360.  
  361. import java.time.Duration;
  362.  
  363. import org.junit.jupiter.api.Assertions;
  364. import org.junit.jupiter.api.Test;
  365.  
  366. import chercher.Chercher;
  367.  
  368. class TestChercher4 {
  369.    
  370.    
  371.     private static String traiter() throws InterruptedException {
  372.         Thread.sleep(2000);
  373.         return "";
  374.       }
  375.     /**
  376.      * Entrée : un tableau de 4 éléments .
  377.      * On chercher l'élément 3 dans la liste tab[]
  378.      * Résultat attendu : true.
  379.      */
  380.  
  381.     @Test
  382.     void testElementDansListe() {
  383.         int tab[] = {-1,2,3,4};
  384.         int elt = 3;
  385.         Chercher chercher = new Chercher(tab);
  386.  
  387.          
  388.        
  389.        
  390.         Assertions.assertTimeoutPreemptively(Duration.ofMillis(2000), () -> {
  391.             assertEquals(true, chercher.chercher4(elt, tab));
  392.             });
  393.            
  394.             Assertions.assertTimeoutPreemptively(Duration.ofSeconds(1), TestChercher4::traiter);
  395.     }
  396.     /**
  397.      * Entrée : un tableau de 4 éléments.
  398.      * L'élément demander n'est pas dans la liste
  399.      * Résultat attendu : false.
  400.      */
  401.     @Test
  402.     void testElementHorsListe() {
  403.         int tab[] = {1,2,3,4};
  404.         int elt = -1;
  405.         Chercher chercher = new Chercher(tab);
  406.         assertEquals(false, chercher.chercher4(elt, tab));
  407.         }
  408.     /**
  409.      * Entrée : un tableau vide.
  410.      * Résultat attendu : -1.
  411.      * Résultat obtenu : java.lang.ArrayIndexOutOfBoundsException: 0
  412.      */
  413.     @Test
  414.      void testListeVide() {
  415.         int elt = 0;
  416.         int[] tab = new int[0];
  417.         Chercher chercher = new Chercher(tab);
  418.             assertEquals(-1,chercher.chercher4(elt, tab));
  419.         }
  420.    
  421.     /**
  422.      * Entrée : un tableau de 4 éléments.
  423.      * L'élément demander apparait plusieurs fois dans la liste
  424.      * Résultat attendu : 1.
  425.      */
  426.     @Test
  427.     void testPresenceMutipleElementRecherche(){
  428.         int tab[] = {1,4,4,4};
  429.         int elt = 4;
  430.         Chercher chercher = new Chercher(tab);
  431.         Assertions.assertTimeoutPreemptively(Duration.ofMillis(2000), () -> {
  432.             assertEquals(true, chercher.chercher4(elt, tab));
  433.             });
  434.            
  435.             Assertions.assertTimeoutPreemptively(Duration.ofSeconds(1), TestChercher4::traiter);
  436.         assertEquals(1,chercher.chercher4(elt, tab));  
  437.     }
  438.    
  439.    
  440.    
  441.  
  442. }
  443. ///////////////////////////////////////////////////////////////////////////////
  444.  
  445.  
  446.  
  447. /*
  448. @author: Herve Audibert
  449. @author: Issam Bouras
  450. @author : Franck Palacios
  451. @date: 22/01/2020
  452. @nom-fichier : TestChercher5.java
  453. */
  454.  
  455. package testchercher;
  456.  
  457. import static org.junit.jupiter.api.Assertions.*;
  458.  
  459. import java.time.Duration;
  460.  
  461. import org.junit.jupiter.api.Assertions;
  462. import org.junit.jupiter.api.Test;
  463.  
  464. import chercher.Chercher;
  465.  
  466. class TestChercher5 {
  467.  
  468.     private static String traiter() throws InterruptedException {
  469.         Thread.sleep(2000);
  470.         return "";
  471.       }
  472.     /**
  473.      * Entrée : un tableau de 4 éléments .
  474.      * On chercher l'élément 3 dans la liste tab[]
  475.      * Résultat attendu : true.
  476.      */
  477.     @Test
  478.     void testElementDansListe() {
  479.         int tab[] = {-1,2,3,4};
  480.         int elt = 3;
  481.         Chercher chercher = new Chercher(tab);
  482.         assertEquals(true, chercher.chercher5(elt, tab));
  483.     }
  484.    
  485.     /**
  486.      * Entrée : un tableau vide.
  487.      * Résultat attendu : false.
  488.      */
  489.     @Test
  490.      void testListeVide() {
  491.             int elt = 0;
  492.             int[] tab = new int[0];
  493.             Chercher chercher = new Chercher(tab);      
  494.             assertEquals(false, chercher.chercher5(elt, tab));
  495.         }
  496.     /**
  497.      * Entrée : un tableau de 4 éléments.
  498.      * L'élément demander n'est pas dans la liste
  499.      * Résultat attendu : false.
  500.      */
  501.     @Test
  502.     void testElementHorsListe() {
  503.         int tab[] = {1,2,3,4};
  504.         int elt = -1;
  505.         Chercher chercher = new Chercher(tab);
  506.         assertEquals(false, chercher.chercher5(elt, tab)); 
  507.     }
  508.     /**
  509.      * Entrée : un tableau de 4 éléments.
  510.      * L'élément demander apparait plusieurs fois dans la liste
  511.      * Résultat attendu : 1.
  512.      */
  513.     @Test
  514.     void testPresenceMutipleElementRecherche(){
  515.         int tab[] = {1,4,4,4};
  516.         int elt = 4;
  517.         Chercher chercher = new Chercher(tab);
  518.         Assertions.assertTimeoutPreemptively(Duration.ofMillis(2000), () -> {
  519.             assertEquals(true, chercher.chercher5(elt, tab));
  520.         });
  521.             Assertions.assertTimeoutPreemptively(Duration.ofSeconds(1), TestChercher5::traiter);
  522.             assertEquals(1,chercher.chercher4(elt, tab));  
  523.     }
  524.    
  525.    
  526.    
  527. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top