Vérifier si une méthode a été appelée à l'intérieur d'une autre méthode

Est-il possible en java pour vérifier si une certaine méthode a été appelée à l'intérieur d'une autre méthode? Je suis en train de tester une de la classe et de la méthode que je vais avoir des ennuis avec joue son et il n'y a pratiquement aucun moyen d'en obtenir le fichier audio qui est lu(attribut privé à l'intérieur d'un intérieur de classe), sans en modifier le code. Cependant, la façon dont la méthode joue des sons est-il appelle une méthode qui joue un son unique (playSadMusic, playHappyMusic, etc). Ces méthodes sont dans une interface que je dois créer un objet fantaisie pour. Je suis un peu coincé sur la façon dont je voudrais exactement tester cette. Toutes les pensées? D'autres idées sur comment je pourrais peut-être tester cette autre que de vérifier si une certaine méthode était l'appel sont les bienvenus.

Je suis en utilisant JMock 2.6.0 et JUnit 4

l'audio interface

public interface StockTickerAudioInterface {

    public abstract void playHappyMusic();

    public abstract void playSadMusic();

    public abstract void playErrorMusic();
}

anthère interface je dois créer une maquette pour

public interface StockQuoteGeneratorInterface {
    public abstract StockQuoteInterface getCurrentQuote() throws Exception;

    public abstract String getSymbol();

    public abstract void setSymbol(String symbol);

    public abstract StockQuoteGeneratorInterface createNewInstance(String symbol);

}

la classe testée

public class StockQuoteAnalyzer {
private StockTickerAudioInterface audioPlayer = null;
private String symbol;
private StockQuoteGeneratorInterface stockQuoteSource = null;
private StockQuoteInterface lastQuote = null;
private StockQuoteInterface currentQuote = null;
public StockQuoteAnalyzer(String symbol,
StockQuoteGeneratorInterface stockQuoteSource,
StockTickerAudioInterface audioPlayer)
throws InvalidStockSymbolException, NullPointerException,
StockTickerConnectionError {
super(); 
//Check the validity of the symbol.
if (StockTickerListing.getSingleton().isValidTickerSymbol(symbol) == true){
this.symbol = symbol;
} else {
throw new InvalidStockSymbolException("Symbol " + symbol
+ "not found.");
}
if (stockQuoteSource == null) {
throw new NullPointerException(
"The source for stock quotes can not be null");
}
this.stockQuoteSource = stockQuoteSource;
this.audioPlayer = audioPlayer;
}
public double getChangeSinceLast() {
double retVal = 0.0;
if (this.lastQuote != null) {
double delta = this.currentQuote.getLastTrade() - this.lastQuote.getLastTrade();
retVal = 100 * (delta / this.lastQuote.getLastTrade());
}
return retVal;
}
public double getChangeSinceYesterday() {
double delta = (this.currentQuote.getLastTrade() - this.currentQuote
.getClose());
return 100 * (delta / this.currentQuote.getClose());
}
public void playAppropriateAudio() {
if ((this.getChangeSinceYesterday() > 2)
|| (this.getChangeSinceLast() > 0.5)) {
audioPlayer.playHappyMusic();
}
if ((this.getChangeSinceYesterday() < -2)
|| (this.getChangeSinceLast() < -0.5)) {
audioPlayer.playSadMusic();
}
}
}

ma sphère de cristal dit "oui" oh et s'il vous plaît fournir un peu de code et de dire ce que vous avez essayé jusqu'à présent
Vous pouvez vérifier la trace de la pile.
Suivez John Snow. Mockito est la réponse. Vous pouvez créer junit sur combien de fois une méthode appelée.
Je suis à l'aide de jmock2.6.0 et JUnit 4
Il semble être en mesure d'obtenir un comportement similaire avec jMock. Vérifier édité mon post

OriginalL'auteur user2337029 | 2013-05-15

7

Si vous utilisez Mockito vous pouvez utiliser verify() de vérifier le nombre de fois qu'une méthode est appelée. L'utiliser comme ceci:
```
verify(mockedObject, times(1)).methodToValidate();
```
Vous pouvez vérifier si methodToValidate() a été appelé avec une chaîne de caractères, e.je verify(mockedObject, times(1)).methodToValidate("a specific value"); ou vous pouvez l'utiliser avec anyString() comme ceci: verify(mockedObject, times(1)).methodToValidate(anyString());.

À moins que cette méthode est appelée avec votre paramterer, le test échouera

Lire plus à propos de vérifier ici.

Mise à JOUR

Depuis votre édité le post indique que vous utilisez jMock, un rapide googeling m'a montré qu'il est possible d'obtenir un comportement similaire avec jMock et c'est expect méthode. Il est utilisé comme ci-dessous:
```
mockedObject.expects(once()).method("nameOfMethod").with( eq("An optional paramter") );
```
Explication plus détaillée peut être trouvée en lisant jMocks page mise en route.

OriginalL'auteur John Snow

dire que vous avez une méthode child() qui est appelé dans parent()

public void parent() {
child();
}

Dans child() pour obtenir la dernière méthode qu'il a obtenu appelé à partir, vous pouvez utiliser StackTraceElement

public void child() {
StackTraceElement[] traces = Thread.currentThread().getStackTrace();
boolean check = false;
for(StackTraceElement element : traces) {
if(check) {
System.out.println("Calling method - " + element.getMethodName());
}
if(element.getMethodName().equals("child")) {
check = true;
}
}
}

OriginalL'auteur sanbhat

0

Si vous écrivez un objet fantaisie avec les méthodes que vous voulez vérifier si ils ont été appelés, vous pouvez mettre en œuvre les méthodes d'une manière qu'ils soulèvent certaines drapeau quand ils sont appelés, par exemple
```
public void playHappyMusic() {
this.wasCalled = true;
}
```
wasCalled être un public (ou avec des getters) variable de classe. Alors que vous venez de vérifier le drapeau.

OriginalL'auteur Humungus

-1

Vous fournissons sont dans le même thread que l'appel de la méthode, vous pouvez vérifier la trace de la pile à un moment donné de cette façon:

Thread.currentThread().getStackTrace()

Vous pouvez voir quelle méthode sont appelés à le faire comme ceci:

for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
System.out.println(ste);
}

Par exemple:

public class Test {
public static void main (String[]s){
Test  test = new Test();
test.makeTest();
}
public void makeTest(){
for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
System.out.println(ste);
}
}

résultats dans

java.lang.Thread.getStackTrace(Unknown Source)
Test.makeTest(Test.java:17)
Test.main(Test.java:11)

OriginalL'auteur Averroes

Vous devez vous connecter pour publier un commentaire.