cherchertestALL

/*
@author: Herve Audibert
@author: Issam Bouras
@author : Franck Palacios
@date: 22/01/2020
@nom-fichier : TestChercherElt.java
*/

package testchercher;

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;

import chercher.Chercher;

class TestChercherElt {

    /**
     * Entrée : un tableau de 4 éléments .
     * On chercher l'élément 3 dans la liste tab[]
     * Résultat attendu : 2.
     */

    @Test
    void testElementDansListe() {
        int tab[] = {-1,2,3,4};
        int elt = 3;
        Chercher chercher = new Chercher(tab);

        assertEquals(2,chercher.chercherElt(elt, tab));
    }

    /**
     * Entrée : un tableau vide.
     * Résultat attendu : -1.
     */
    @Test
     void testListeVide() {
           int elt = 0;
            int[] tab = new int[0];
            Chercher chercher = new Chercher(tab);

            assertEquals(-1,chercher.chercherElt(elt, tab));
        }


    /**
     * Entrée : un tableau de 4 éléments.
     * L'élément demander n'est pas dans la liste
     * Résultat attendu : -1.
     */
    @Test
    void testElementHorsListe() {
        int tab[] = {1,2,3,4};
        int elt = -1;
        Chercher chercher = new Chercher(tab);

        assertEquals(-1,chercher.chercherElt(elt, tab));
    }

    /**
     * Entrée : un tableau de 4 éléments.
     * L'élément demander apparait plusieurs fois dans la liste
     * Résultat attendu : 1.
     */
    @Test
    void testPresenceMutipleElementRecherche(){
        int tab[] = {1,4,4,6,7,7,8};
        int elt = 4;
        Chercher chercher = new Chercher(tab);

        assertEquals(1,chercher.chercherElt(elt, tab));

    }
    /* Rajouter en txt pour la spéc qu'il doit vérifier une autre solution lorsqu'il y a plusieurs élément multiple   */



}
////////////////////////////////////////////////////////////////////////////////////////////////////////////





/*
@author: Herve Audibert
@author: Issam Bouras
@author : Franck Palacios
@date: 22/01/2020
@nom-fichier : TestChercher1.java
*/

package testchercher;

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.Test;

import chercher.Chercher;

class TestChercher1 {
        /**
         * Entrée : un tableau de 4 éléments .
         * On chercher l'élément 3 dans la liste tab[]
         * Résultat attendu : true.
         */
        @Test
        void testElementDansListe() {
            int tab[] = {-1,2,3,4};
            int elt = 3;
            Chercher chercher = new Chercher(tab);
            assertEquals(true, chercher.chercher1(elt, tab));
        }
        /**
         * Entrée : un tableau vide.
         * Résultat attendu : false.
         */
        @Test
         void testListeVide() {
                int elt = 0;
                int[] tab = new int[0];
                Chercher chercher = new Chercher(tab);
                assertEquals(false, chercher.chercher1(elt, tab));
            }
        /**
         * Entrée : un tableau de 4 éléments.
         * L'élément demander n'est pas dans la liste
         * Résultat attendu : false.
         */
        @Test
        void testElementHorsListe() {
            int tab[] = {1,2,3,4};
            int elt = -1;
            Chercher chercher = new Chercher(tab);
            assertEquals(false, chercher.chercher1(elt, tab));
        }
        /**
         * Entrée : un tableau de 4 éléments.
         * L'élément demander apparait plusieurs fois dans la liste
         * Résultat attendu : true.
         */
        @Test
        void testPresenceMutipleElementRecherche(){
            int tab[] = {1,4,4,4};
            int elt = 4;
            Chercher chercher = new Chercher(tab);
            assertEquals(true,chercher.chercher1(elt, tab));
        }


    }


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



/*
@author: Herve Audibert
@author: Issam Bouras
@author : Franck Palacios
@date: 22/01/2020
@nom-fichier : TestChercher2.java
*/

package testchercher;

import static org.junit.jupiter.api.Assertions.*;


import java.time.Duration;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import chercher.Chercher;

class TestChercher2 {
    /**
     * Entrée : un tableau de 4 éléments .
     * On chercher l'élément 3 dans la liste tab[]
     * Résultat attendu : true.
     */


    private static String traiter() throws InterruptedException {
        Thread.sleep(2000);
        return "";
      }
    /**
     * Entrée : un tableau de 4 éléments .
     * On chercher l'élément 3 dans la liste tab[]
     * Résultat attendu : true.
     */

    @Test
    void testElementDansListe() {
        int tab[] = {-1,2,3,4};
        int elt = 3;
        Chercher chercher = new Chercher(tab);
        Assertions.assertTimeoutPreemptively(Duration.ofMillis(2000), () -> {
        assertEquals(true, chercher.chercher2(elt, tab));
            });

        Assertions.assertTimeoutPreemptively(Duration.ofSeconds(1), TestChercher2::traiter);
    }

    /**
     * Entrée : un tableau vide.
     * Résultat attendu : false.
     */
    @Test
     void testListeVide() {
            int elt = 0;
            int[] tab = new int[0];
            Chercher chercher = new Chercher(tab);
            assertEquals(false, chercher.chercher2(elt, tab));
        }

    /**
     * Entrée : un tableau de 4 éléments.
     * L'élément demander n'est pas dans la liste
     * Résultat attendu : false.
     */
    @Test
    void testElementHorsListe() {
        int tab[] = {1,2,3,4};
        int elt = -1;
        Chercher chercher = new Chercher(tab);
        assertEquals(false, chercher.chercher2(elt, tab));
    }

    /**
     * Entrée : un tableau de 4 éléments.
     * L'élément demander apparait plusieurs fois dans la liste
     * Résultat attendu : 1.
     */
    @Test
    void testPresenceMutipleElementRecherche(){
        int tab[] = {1,4,4,4};
        int elt = 4;
        Chercher chercher = new Chercher(tab);
        assertEquals(1,chercher.chercher2(elt, tab));

    }

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////





/*
@author: Herve Audibert
@author: Issam Bouras
@author : Franck Palacios
@date: 22/01/2020
@nom-fichier : TestChercher3.java
*/

package testchercher;

import static org.junit.jupiter.api.Assertions.*;

import java.time.Duration;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import chercher.Chercher;

class TestChercher3 {

    private static String traiter() throws InterruptedException {
        Thread.sleep(2000);
        return "";
      }
    /**
     * Entrée : un tableau de 4 éléments .
     * On chercher l'élément 3 dans la liste tab[]
     * Résultat attendu : true.
     */
    @Test
    void testElementDansListe() {
        int tab[] = {-1,2,3,4};
        int elt = 3;
        Chercher chercher = new Chercher(tab);
        Assertions.assertTimeoutPreemptively(Duration.ofMillis(2000), () -> {
            assertEquals(true, chercher.chercher3(elt, tab));
            });

            Assertions.assertTimeoutPreemptively(Duration.ofSeconds(1), TestChercher3::traiter);
    }
    /**
     * Entrée : un tableau de 4 éléments.
     * L'élément demander n'est pas dans la liste
     * Résultat attendu : false.
     */
    @Test
    void testElementHorsListe() {
        int tab[] = {1,2,3,4};
        int elt = -1;
        Chercher chercher = new Chercher(tab);
        assertEquals(false, chercher.chercher3(elt, tab));

    }
    /**
     * Entrée : un tableau vide.
     * Résultat attendu : -1.
     * Résultat obtenu : java.lang.ArrayIndexOutOfBoundsException: 0
     */
    @Test
     void testListeVide() {
            int elt = 0;
            int[] tab = new int[0];
            Chercher chercher = new Chercher(tab);
            assertEquals(-1,chercher.chercher3(elt, tab));
        }

    /**
     * Entrée : un tableau de 4 éléments.
     * L'élément demander apparait plusieurs fois dans la liste
     * Résultat attendu : 1.
     */
    @Test
    void testPresenceMutipleElementRecherche(){
        int tab[] = {1,4,4,4};
        int elt = 4;
        Chercher chercher = new Chercher(tab);
        Assertions.assertTimeoutPreemptively(Duration.ofMillis(2000), () -> {
            assertEquals(1,chercher.chercher3(elt, tab));
            });

            Assertions.assertTimeoutPreemptively(Duration.ofSeconds(1), TestChercher3::traiter);

    }




}
/////////////////////////////////////////////////////////////////////////////////////////////////////////


/*
@author: Herve Audibert
@author: Issam Bouras
@author : Franck Palacios
@date: 22/01/2020
@nom-fichier : TestChercher4.java
*/

package testchercher;

import static org.junit.jupiter.api.Assertions.*;

import java.time.Duration;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import chercher.Chercher;

class TestChercher4 {


    private static String traiter() throws InterruptedException {
        Thread.sleep(2000);
        return "";
      }
    /**
     * Entrée : un tableau de 4 éléments .
     * On chercher l'élément 3 dans la liste tab[]
     * Résultat attendu : true.
     */

    @Test
    void testElementDansListe() {
        int tab[] = {-1,2,3,4};
        int elt = 3;
        Chercher chercher = new Chercher(tab);




        Assertions.assertTimeoutPreemptively(Duration.ofMillis(2000), () -> {
            assertEquals(true, chercher.chercher4(elt, tab));
            });

            Assertions.assertTimeoutPreemptively(Duration.ofSeconds(1), TestChercher4::traiter);
    }
    /**
     * Entrée : un tableau de 4 éléments.
     * L'élément demander n'est pas dans la liste
     * Résultat attendu : false.
     */
    @Test
    void testElementHorsListe() {
        int tab[] = {1,2,3,4};
        int elt = -1;
        Chercher chercher = new Chercher(tab);
        assertEquals(false, chercher.chercher4(elt, tab));
        }
    /**
     * Entrée : un tableau vide.
     * Résultat attendu : -1.
     * Résultat obtenu : java.lang.ArrayIndexOutOfBoundsException: 0
     */
    @Test
     void testListeVide() {
        int elt = 0;
        int[] tab = new int[0];
        Chercher chercher = new Chercher(tab);
            assertEquals(-1,chercher.chercher4(elt, tab));
        }

    /**
     * Entrée : un tableau de 4 éléments.
     * L'élément demander apparait plusieurs fois dans la liste
     * Résultat attendu : 1.
     */
    @Test
    void testPresenceMutipleElementRecherche(){
        int tab[] = {1,4,4,4};
        int elt = 4;
        Chercher chercher = new Chercher(tab);
        Assertions.assertTimeoutPreemptively(Duration.ofMillis(2000), () -> {
            assertEquals(true, chercher.chercher4(elt, tab));
            });

            Assertions.assertTimeoutPreemptively(Duration.ofSeconds(1), TestChercher4::traiter);
        assertEquals(1,chercher.chercher4(elt, tab));
    }




}
///////////////////////////////////////////////////////////////////////////////



/*
@author: Herve Audibert
@author: Issam Bouras
@author : Franck Palacios
@date: 22/01/2020
@nom-fichier : TestChercher5.java
*/

package testchercher;

import static org.junit.jupiter.api.Assertions.*;

import java.time.Duration;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import chercher.Chercher;

class TestChercher5 {

    private static String traiter() throws InterruptedException {
        Thread.sleep(2000);
        return "";
      }
    /**
     * Entrée : un tableau de 4 éléments .
     * On chercher l'élément 3 dans la liste tab[]
     * Résultat attendu : true.
     */
    @Test
    void testElementDansListe() {
        int tab[] = {-1,2,3,4};
        int elt = 3;
        Chercher chercher = new Chercher(tab);
        assertEquals(true, chercher.chercher5(elt, tab));
    }

    /**
     * Entrée : un tableau vide.
     * Résultat attendu : false.
     */
    @Test
     void testListeVide() {
            int elt = 0;
            int[] tab = new int[0];
            Chercher chercher = new Chercher(tab);
            assertEquals(false, chercher.chercher5(elt, tab));
        }
    /**
     * Entrée : un tableau de 4 éléments.
     * L'élément demander n'est pas dans la liste
     * Résultat attendu : false.
     */
    @Test
    void testElementHorsListe() {
        int tab[] = {1,2,3,4};
        int elt = -1;
        Chercher chercher = new Chercher(tab);
        assertEquals(false, chercher.chercher5(elt, tab));
    }
    /**
     * Entrée : un tableau de 4 éléments.
     * L'élément demander apparait plusieurs fois dans la liste
     * Résultat attendu : 1.
     */
    @Test
    void testPresenceMutipleElementRecherche(){
        int tab[] = {1,4,4,4};
        int elt = 4;
        Chercher chercher = new Chercher(tab);
        Assertions.assertTimeoutPreemptively(Duration.ofMillis(2000), () -> {
            assertEquals(true, chercher.chercher5(elt, tab));
        });
            Assertions.assertTimeoutPreemptively(Duration.ofSeconds(1), TestChercher5::traiter);
            assertEquals(1,chercher.chercher4(elt, tab));
    }



}