Discussion :

[CliffeCSTL]

Bonjour,

Voilà se que je souhaite faire : j'ai un objet en java 'mon_objet' et je souhaite le tester avec des fonctions :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class mainClass {
    public static void main() {
        mon_objet A = new mon_objet("X");
        test(A);
    }
 
    public Boolean test(mon_objet A) {
        Boolean res_of_test = false;
        if (test_001(A)) {
            if (test_002(A)) {
                if (test_003(A)) {
                    [...]
                        if (test_00n(A)) {
                            res_of_test = true;
                        }
                }
            }
        }
        return res_of_test;
    }
}

j'aimerais simplifier mon code avec un truc du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
public class mainClass {
    public static void main() {
        mon_objet A = new mon_objet("X");
        test(A);
    }
 
    public Boolean test(mon_objet A) {
        list_of_test list_of_test = new list_of_test();
        while (list_of_test(A))
           list_of_test.next();
        return list_of_test.isFinished();
    }
}

comment faire svp ?
Merci.

[Monolulu]

Bonjour,

Ce que tu cherches à faire me semble assez tordu... Tu voudrais faire une liste de fonction?
À ma connaissance, ce n'est pas possible. En revanche, tu peux te tourner vers les tests unitaires avec JUnit qui feront ce que tu recherches, ensuite tu ne pourras plus t'en passer

Je te conseil donc de te pencher sur divers tutos que tu pourras facilement trouver sur internet.

[wax78]

Peut être en utilisant l'API Reflection. Mais j'avoue ne pas avoir bien saisi l'idée de base.

[CliffeCSTL]

L'idée c'est de faire passer une batterie de test à mon objet A.
On doit s'arrête lorsqu'un test échoue.

Je voulais juste faire ça de manière propre et évité de mettre des 'if' tout moche partout .

[wax78]

Alors JUnit comme proposé par monolulu.

[thelvin]

Voui enfin, JUnit ne s'arrête pas quand un test est mauvais.

Et en fait je comprends pas l'intérêt de s'arrêter quand on veut faire des tests unitaires. Du coup j'ai l'impression que le besoin est autre.

[hwoarang]

Si c'est réellement des tests unitaires, utiliser JUnit eviterai de réinventer la roue.

Mais pour revenir au probleme de base, ce que tu cherches à faire ressemble beaucoup à quelque chose facilement réalisable avec du polymorphisme de base.

Un truc du genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// Utiliser une classe ou une interface selon ce qui est le plus simple
abstract class Test
{
   // Dans les methodes de executeTest, tu mettrais ce que tu as mis dans test_XXX(A)
   abstract boolean executeTest(mon_objet A);
}
 
class Test1 extends Test
{
   boolean executeTest(mon_objet A)
   {
      return A.getId() == 12;
   }
}
 
 
class Test2 extends Test
{
   boolean executeTest(mon_objet A)
   {
      return A.getValue() == 42;
   }
}
 
// A mettre la ou tu veux faire tes tests
boolean executeTests(mon_objet A)
{
   // Creation de la batterie de tests
   ArrayList<Test> listTests = new ArrayList<Test>();
   listTests.add(new Test1());
   listTests.add(new Test2());
   for(Test test : listTests)
   {
      if(test.executeTest(A) == false)
         return false;
   }
   return true;
}

Note que je n'ai pas testé ce code donc il pourrait ne pas compiler. Mais l'idée est la...

[CliffeCSTL]

Je précise que ça n'a rien a voir avec des test unitaires

[joel.drigo]

Salut,

Pourtant ça ressemble pas mal à des tests unitaires. Maintenant de façon plus générale (donc pas obligé que ça soit des tests, ça pourrait être des transformations successives), ce que propose @hwoarang est une solution à ton problème (la méthode s'appelle executeTest, mais elle pourrait s'appeler n'importe comment d'ailleurs - ça pourrait même être une java.util.Function par exemple).

[thelvin]

Sinon la solution polymorphique, depuis Java 1.8 ya pas vraiment besoin de créer une classe Test, il y a déjà la classe Predicate.

Du coup définir un ensemble de tests ça ressemble à ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
public static final Predicate<MonObjet> tests =
  Arrays.<Predicate<MonObjet>>asList(
    // ici les tests, là j'en mets 3
    o -> o != null,
    o -> o.hashCode() != 0,
    o -> o.toString().length() < 10
 
  ).stream().reduce(o -> true, (p1, p2) -> p1.and(p2));

et ça s'utilise comme ça (dans la même classe) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
MonObjet a = obtenirMonObjet();
if(tests.test(a)) {
	// ...
} else {
	// ...
}

Évidemment, une fois qu'on en arrive là, il faut savoir se demander pourquoi on a pas fait tout simplement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
if(
  a != null &&
  a.hashCode() != 0 &&
  a.toString().lenght() < 10
) {
	// ...
} else {
	// ...
}

ou pour reprendre l'exemple de la question initiale :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
if(
  test_001(a) &&
  test_002(a) &&
  test_003(a) &&
  test_004(a)
) {
	// ...
} else {
	// ...
}

Suivant les cas l'un ou l'autre peut être plus simple. Mais il faut pas trop chercher la complexité non plus.