Junit5

M

merv

Mitglied
Hallo,
ich möchte zwei Stack Klassen testen mit Junit5 und zwar StackArray() und StackLinkedList(), die ich selber implementiert habe, der Prof. hat gesagt ich soll die zwei StackKlassen in einer Klasse testen und zwar haben wir ein Beispiel bekommen :
Code: 
@ParameterizedTest
    @ArgumentsSource(MyArgumentsProvider.class)
    void testWithArgumentsSource(String argument) {
        assertNotNull(argument);
    }

    static class MyArgumentsProvider implements ArgumentsProvider {
       
        @Override
        public Stream<? extends Arguments> provideArguments(ExtensionContext context) {
            return Stream.of("foo", "bar").map(Arguments::of);
        }
    }

Ich verstehe aber leider nicht , wie ich das bei meiner Testklasse anpassen soll .... Ich bitte um dringende Hilfe ....

Hier ist das was ich hab : die Tests funktionieren
Code: 
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.*;
import java.util.stream.Stream;
import org.junit.jupiter.api.*;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.ArgumentsProvider;
import org.junit.jupiter.params.provider.ArgumentsSource;

class TestClassStacks {
   
    @ParameterizedTest
    @ArgumentsSource(MyArgumentsProvider.class)
    void testWithArgumentsSource(String argument) {
        assertNotNull(argument);
    }

    static class MyArgumentsProvider implements ArgumentsProvider {

        @Override
        public Stream<? extends Arguments> provideArguments(ExtensionContext context) {
            return Stream.of(new StackArray<Double>(), new StackLinkedList<Double>()).map(Arguments::of);
        }
    }
   
    StackLinkedList<Double> stack;
    //StackArray<Double> stack;
   
    @BeforeEach
    @DisplayName("Create new test stack")
    void createStack() {
         stack = new StackLinkedList<Double>();
         //stack = new StackArray<Double>();
    }
   
    @Test
    @DisplayName("Test push")
    void testPush() {
        try{
            stack.push(1.0);
            assertEquals(1.0, stack.peek(), 0.0001);
            stack.push(2.0);
            assertEquals(2.0, stack.peek(), 0.0001);
            stack.push(3.0);
        }catch(AssertionError e){
            System.out.println("testPush failed");
            throw e;
        }
    }
   
    @Test
    @DisplayName("Test pop")
    void testPop() {
        try{
            stack.push(1.0);
            stack.push(2.0);
            stack.pop();
            assertEquals(1.0, stack.peek(), 0.0001);
            stack.pop();
            assertNull(stack.peek());
        }catch(AssertionError e){
            System.out.println("testPop failed");
            throw e;
        }
    }
   
    @Test
    @DisplayName("Test peek")
    void testPeek() {   
        try{
            stack.push(1.0);
            assertEquals(1.0, stack.peek(), 0.0001);
            stack.pop();
            assertNull(stack.peek());
        }catch(AssertionError e){
            System.out.println("testPeek failed");
            throw e;
        }
    }
   
    @Test
    @DisplayName("Test isEmpty")
    void testEmpty() {
        try {
            assertTrue(stack.isEmpty());
            assertEquals(stack.getSize(), 0);
        }catch (AssertionError e){
            System.out.println("testEmpty failed");
            throw e;
        }
    }
   
    @Test
    @DisplayName("Test getSize")
    void testSize() {       
        try{
            stack.push(1.0);
            stack.push(2.0);
            assertEquals(2, (int)stack.getSize());
            stack.pop();
            assertEquals(1, (int)stack.getSize());
            stack.pop();
            assertEquals(0, (int)stack.getSize());
        }catch(AssertionError e){
            System.out.println("testSize failed");
            throw e;
        }
    }   
}

Danke !!!!
 
looparda

looparda

Top Contributor
Java: 
@ParameterizedTest
@ArgumentsSource(MyArgumentsProvider.class)
void testWithArgumentsSource(Stack<Double> a) {
    assertNotNull(a);
    testPush(a);
}

void testPush(Stack<Double> stackUT) {
    stackUT.push(1.0);
    assertEquals(1.0, stackUT.peek(), 0.0001);
    stackUT.push(2.0);
    assertEquals(2.0, stackUT.peek(), 0.0001);
}

testWithArgumentsSource wird mit jedem Argument einmal aufgerufen und du kannst dann deine Tests darüber jagen. Allderings finde ich ist das ein Missbrauch von @ParameterizedTest, da er zum Laden von Daten gedacht ist, bei Testfällen mit gleicher Struktur aber nur unterschiedlichen Daten. Nicht zum Ausführen von den gleichen Tests auf mehrere Instanzen. Außerdem verlierst du die Aufteilung in verschiede @test, was die Ausgabe und Struktuierung hässlich macht.
Was besseres kenne ich aber auch nicht in junit.
 
M

merv

Mitglied
Danke für deine Hilfe aber irgendwie funktioniert es nicht bei mir oder ich hab etwas falsch gemacht.
Code: 
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.*;

import org.junit.Rule;
import org.junit.jupiter.api.*;
import java.util.stream.Stream;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.ArgumentsProvider;
import org.junit.jupiter.params.provider.ArgumentsSource;
import org.junit.rules.ExpectedException;

class TestClassStacks {
   
   
    @ParameterizedTest
    @ArgumentsSource(MyArgumentsProvider.class)
    void testWithArgumentsSource(Stack <Double> a) {
        assertNotNull(a);
        testPush(a);
    }

    static class MyArgumentsProvider implements ArgumentsProvider {

        @Override
        public Stream<? extends Arguments> provideArguments(ExtensionContext context) {
            return Stream.of(new StackArray<Double>(), new StackLinkedList<Double>()).map(Arguments::of);
        }
    }
   
   
    @Test
    @DisplayName("Test push")
    void testPush(Stack <Double> stack) {
        try{
            stack.push(1.0);
            assertEquals(1.0, stack.peek(), 0.0001);
            stack.push(2.0);
            assertEquals(2.0, stack.peek(), 0.0001);
            stack.push(3.0);
        }catch(AssertionError e){
            System.out.println("testPush failed");
            throw e;
        }
    }
   
    @Test
    @DisplayName("Test pop")
    void testPop(Stack <Double> stack) {
        try{
            stack.push(1.0);
            stack.push(2.0);
            stack.pop();
            assertEquals(1.0, stack.peek(), 0.0001);
            stack.pop();
            assertNull(stack.peek());
        }catch(AssertionError e){
            System.out.println("testPop failed");
            throw e;
        }
    }
   
    @Test
    @DisplayName("Test peek")
    void testPeek(Stack <Double> stack) {   
        try{
            stack.push(1.0);
            assertEquals(1.0, stack.peek(), 0.0001);
            stack.pop();
            assertNull(stack.peek());
        }catch(AssertionError e){
            System.out.println("testPeek failed");
            throw e;
        }
    }
   
    @Test
    @DisplayName("Test isEmpty")
    void testEmpty(Stack <Double> stack) {
        try {
            assertTrue(stack.isEmpty());
            assertEquals(stack.getSize(), 0);
        }catch (AssertionError e){
            System.out.println("testEmpty failed");
            throw e;
        }
    }
   
    @Test
    @DisplayName("Test getSize")
    void testSize(Stack <Double> stack) {       
        try{
            stack.push(1.0);
            stack.push(2.0);
            assertEquals(2, (int)stack.getSize());
            stack.pop();
            assertEquals(1, (int)stack.getSize());
            stack.pop();
            assertEquals(0, (int)stack.getSize());
        }catch(AssertionError e){
            System.out.println("testSize failed");
            throw e;
        }
    }   
   
    @Test
    @DisplayName("Test Pop Exception")
    void testPopException(Stack <Double> stack){
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> stack.pop());
    }   
   
    @Test
    @DisplayName("Test Push Exception")
    void testPushException(Stack <Double> stack){
       
        stack.push(1.9);
        stack.push(1.9);
        stack.push(1.9);
        stack.push(1.9);
        stack.push(1.9);
        stack.push(1.9);
        stack.push(1.9);
        stack.push(1.9);
        stack.push(1.9);
        stack.push(1.9);
       
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> stack.push(1.9));       
       
    }
}
 

Aktuelle Jobs

Neue Themen


Oben