[JAVA] Comment exécuter une méthode et simuler avec JUnit
Notez s'il vous plaît!
Je le laisse ici à des fins d'étude personnelle! Je ne sais pas si cela sera utile.
Cible
: penser: j'ai des problèmes avec JUnit à l'avenir : débutant: les nouveaux utilisateurs de JUnit : alarm_clock: JUnit n'a pas été depuis longtemps : déçu_relieved: Quelle est la méthode moqueuse? Gens
Ce à quoi vous pouvez vous attendre en lisant cet article
(1) Comment appeler une méthode (avec la source de l'échantillon) (2) Comment se moquer (avec la source de l'échantillon) (3) La relation entre la classe de test et la classe cible de test (avec image)
C'est long, mais si vous suivez l'ordre, pourrez-vous maîtriser (1) et (2)?
table des matières
·environnement ・ (1) Comment appeler une méthode (avec source d'échantillon) ・ (2) Comment se moquer (avec la source de l'échantillon) ・ (3) Relation entre la classe de test et la classe cible de test (avec image) ・ Jetons un coup d'œil à la classe cible de test et à l'ensemble de la classe de test avec des explications. ·Finalement
environnement
・ JUnit4 ・ Jmockit · Éclipse ・ Java SE5 (vérifié par SE7,8)
Génération automatique de classe de test
Ici A été mentionné
(1) Comment appeler une méthode (avec la source de l'échantillon)
▼ Code qui appelle la méthode
Method method =【Nom de la classe】.class.getDeclaredMethod("[Nom de la méthode]",[Type d'argument].class);
method.setAccessible(true);
method.invoke([Nom de l'instance],【argument】);
◆ Explication 1ère ligne: Décrivez la classe, le nom de la méthode à exécuter et l'argument (le cas échéant). Pour l'argument, écrivez le type de l'argument tel que "** String.class " ou " int.class **". Ce que vous écrivez est un ** type d'argument **!
Deuxième ligne: déterminez si la méthode est accessible. Si cela est vrai, à la fois protégé et privé peuvent être appelés de l'extérieur et testés.
Ligne 3: La méthode qui appelle s'exécute. Je vais passer l'argument selon lequel l'instance a été créée ici. Cela peut être utilisé pour une exécution de base, mais si cela ne peut pas être fait **, il n'y a pas suffisamment d'informations pour appeler ** ou ** il manque à l'appelé ** dans la plupart des cas.
Exemple)
//Instance de la classe à tester ... (A)
Test sample = new Test();
//Réglage de l'argument ... (B)
String moji = "Robot de type chat";
int suuji = 2112903;
//Exécution de la méthode ... (C)
Method method = Test.class.getDeclaredMethod("testMethod", String.class, int.class);
method.setAccessible(true);
method.invoke(sample, moji, suuji);
◆ Explication (A): Instanciation de la classe à tester. Ce nom d'instance est utilisé au bas de (C).
(B): Définissez ici les arguments lors de l'exécution de la méthode! Utilisé au bas de (C).
(C): Puisqu'il y a deux arguments cette fois, deux des "String.class" et "int.class" sont décrits dans la première ligne. Ici ** ajoutez autant d'arguments **! Bien sûr, ** non décrit pour les méthodes sans arguments **! Décrivez l'ordre dans l'ordre des arguments de la méthode que vous souhaitez tester.
(2) Comment se moquer (avec la source de l'échantillon)
▼ Code à simuler
new MockUp<【Nom de la classe】>(){
@Mock
[Écriture solide de la méthode dont vous voulez vous moquer ici]{
return [Les articles listés ici seront retournés];
* S'il est nul, il n'y a pas de retour.
}
};
◆ Explication Plutôt que d'expliquer, veuillez copier et coller tel quel et personnaliser l'intérieur de []. Voyons un exemple!
Exemple)
new MockUp<sample>(){
@Mock
public String testMethod(String moji, int suuji) {
String result = "Bonjour, c'est mon Doraemon";
return result ;
}
};
◆ Explication 1ère ligne: Décrivez la classe de test dans <> Ligne 2: @Mock est prêt! Alors ne t'inquiète pas Ligne 3: ** Notez ici la méthode que vous souhaitez tester! ** J'expliquerai plus tard! Lignes 4 et 5: C'est là que le simulacre décide qui va tester ce qu'il veut retourner. Dans ce cas, retournons la valeur qui sera retournée par la méthode testMethod avec "return"! Et cela.
(3) Relation entre la classe de test et la classe cible de test (avec image)
Eh, pourquoi dois-je préparer tous les arguments de la classe de test? !! Vous pouvez obtenir la valeur parce que vous appelez la méthode!
J'ai eu beaucoup de mal à y penser, alors j'ai fait un diagramme et je l'ai compris. (Je suis désolé si c'est difficile à comprendre car c'est à des fins de mémo personnel !!)
▼ Relation que j'ai pensé au début
Je pensais que j'appelais la classe cible de test depuis la classe de test.
▼ En fait, une telle relation
Cela semble être une image de coller à l'arrière. ** Il est attaché au dos = je dois passer la valeur **.
Jetons un coup d'œil à la classe cible de test et à l'ensemble de la classe de test avec des explications
Apprenons JUnit dans le décor de ce merveilleux anime national Doraemon. (Si vous faites quelque chose comme ça avec votre chose préférée, ce sera étonnamment bon.)
[Classe cible de test] ・Nobita.java ・Doraemon.java
[Classe de test] ・NobitaTest.java ・DoraemonTest.java
Nobita.java
package nobita;
import doraemon.Doraemon;
public class Nobita {
public void NobitaHelp() {
Doraemon dora = new Doraemon();
int point = 0;
System.out.println("Nobita "J'ai 0 point! D'une manière ou d'une autre, Doraemon ~"");
String GetTool = dora.help(point);
if (GetTool != null) {
System.out.println("Nobita "Hmm! Je me motive!"");
} else {
System.out.println("Nobita "Suyaa ..."");
System.out.println("Doraemon "Lève-toi!"");
}
}
}
Doraemon.java
package doraemon;
public class doraemon {
public String help(int point) {
String tool = null;
if (point == 0) {
System.out.println("Doraemon "Eh bien, tu es ..."");
tool = secretTool();
} else {
System.out.println("Doraemon "Vous avez fait de votre mieux! Je l'ai examiné, Nobita-kun"");
return null;
}
return tool;
}
public String secretTool() {
String secretTool = "Fan de relooking";
System.out.println("Doraemon "" + secretTool + "!」");
return secretTool;
}
}
▼ Tout d'abord, le code de test de Nobita.java!
NobitaTest.java
package nobita;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;
import doraemon.doraemon;
import mockit.Mock;
import mockit.MockUp;
public class NobitaTest {
/*****************************************
*Test de la méthode NobitaHelp
*les lancers sont automatiquement importés donc je m'en fiche maintenant!
******************************************/
@Test
public void test001_NobitaHelp() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Nobita nobi = new Nobita();
new MockUp<doraemon>(){
@Mock
public String help(int point) {
// Nobita.Commentez le processus ci-dessus lors de l'exécution d'un test qui va à l'intérieur de if avec l'instruction if de java.
String doraemonAction = "Fan de relooking";
// Nobita.Lors de l'exécution du test else avec l'instruction java if, commentez le processus suivant.
//String doraemonAction = null;
return doraemonAction;
}
};
Method method = Nobita.class.getDeclaredMethod("NobitaHelp");
method.setAccessible(true);
method.invoke(nobi);
System.out.println("-----Fin du test-----");
}
}
Lorsque vous exécutez JUnit,
** Nobita "J'ai 0 point! Faites-vous quelque chose?" ** ** Nobita "Hmm! Je me motive!" ** ** ----- Fin du test ----- **
Si vous revenez comme ça, vous réussissez!
▼ Ensuite, le code de test de Doraemon.java
DoraemonTest.java
package doraemon;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;
@FixMethodOrder (MethodSorters.NAME_ASCENDING)
//↑ Cette phrase teste dans l'ordre du nom de la méthode décrite dans cette classe de test et dans l'ordre du plus jeune nombre. Si cela n'est pas indiqué, les tests seront exécutés séparément.
public class DoraemonTest {
/*****************************************
*Test de la méthode d'aide
*les lancers sont automatiquement importés donc je m'en fiche maintenant!
******************************************/
@Test
public void test001_Help() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Doraemon dora = new Doraemon();
int point = 0;
Method method = Doraemon.class.getDeclaredMethod("help", int.class);
method.setAccessible(true);
method.invoke(dora, point);
System.out.println("-----Fin du test-----");
}
/*****************************************
*Test de la méthode SecretTool
*les lancers sont automatiquement importés donc je m'en fiche maintenant!
******************************************/
@Test
public void test002_SecretTool() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Doraemon dora = new Doraemon();
Method method = Doraemon.class.getDeclaredMethod("secretTool");
method.setAccessible(true);
method.invoke(dora);
System.out.println("-----Fin du test-----");
}
}
Lorsque vous exécutez JUnit,
** Doraemon "Eh bien, vous êtes ..." ** ** Doraemon "Transformation Uchiwa!" ** ** ----- Fin du test ----- ** ** Doraemon "Transformation Uchiwa!" ** ** ----- Fin du test ----- **
C'est un succès!
finalement
JUnit progresse rapidement lorsque vous apprenez à exécuter des méthodes et à les simuler. (Histoire d'expérience)
Cet article s'adresse à ceux qui ont des problèmes car ils feront JUnit à l'avenir. Lol
Recommended Posts