# Junit5



## merv (27. Nov 2017)

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 : 

```
@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 

```
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 (27. Nov 2017)

```
@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.


----------



## merv (27. Nov 2017)

Danke für deine Hilfe aber irgendwie funktioniert es nicht bei mir oder ich hab etwas falsch gemacht.

```
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));       
       
    }
}
```


----------

