Developer Vago 1

1, 1 , 2 , 3 , 5 , 8 , 13 , 21 , 34 , 55 , 89 , 144

public class BadFibonacci {

    // Fixme: very bad performance
    private static int fibonacci(int n) {
        if (n <= 1) return n; else
            return fibonacci(n-1) + fibonacci(n-2);
    }

    public static void main(String[] args) {
        System.out.println("Result: " + fibonacci(4));
    }
}

    @Test
    public void fibonacciTestSimple() {
        FibonacciWithJUnit4 f = new FibonacciWithJUnit4();
        assertTrue(f.fibonacci(4) == 3);
    }

    @Test
    public void fibonacciTestZero() {
        FibonacciWithJUnit4 f = new FibonacciWithJUnit4();
        assertFalse(f.fibonacci(1) == 0 );
    }

    @Test
    public void improvedFibonacciTestSimple() {
        FibonacciWithJUnit4 f = new FibonacciWithJUnit4();
        assertEquals(f.fibonacci(4), 3);
    }

    @Ignore("Demo, no hacerlo en casa")
    @Test
    public void ignoredFibonacciTestSimple() {
        FibonacciWithJUnit4 f = new FibonacciWithJUnit4();
        assertEquals(f.fibonacci(4), 0);
    }

    @Test
    public void testAssertThatBothContainsString() {
        FibonacciWithJUnit4 f = new FibonacciWithJUnit4();
        String temp = fibonacci(1) + " " + fibonacci(4);
        assertThat(temp, both(containsString("0")).and(containsString("3")));
    }

    @Test(expected = NullPointerException.class)
    public void testException() {
        FibonacciWithJUnit4 f = new FibonacciWithJUnit4();
        Integer i = 0;
        i = null;
        f.fibonacci(i.intValue());
    }

    @Test(timeout = 5000)
    public void testTimeout() {
        try {
            fibonacci(100);
        } catch (Exception e) {
            // Don't do this at home
        }
    }

    private static FibonacciWithJUnit4 f2;

    @BeforeClass
    public static void setupTest() {
        f2 = new FibonacciWithJUnit4();
    }

    @AfterClass
    public static void clear() {
        f2 = null;
    }

    @Test
    public void fibonacciTestSimpleWithBefore() {
        assert (f2.fibonacci(4) == 3);
    }

    @After
    public void done() {
        System.out.println("Done!");
    }

    @Test
    public void fibonacciTestSimple() {
        FibonacciWithJUnit5 f = new FibonacciWithJUnit5();
        Assertions.assertTrue(
                fibonacci(4) == 3,
                () -> "Fibonnaci number " + 4 + " is " + 3);
    }

    @Disabled("Demo, non o facer na casa ;-)")
    @Test
    public void ignoredFibonacciTestSimple() {
        FibonacciWithJUnit5 f = new FibonacciWithJUnit5();
        assertEquals(f.fibonacci(4), 0);
    }

    @Test
    public void testAssertThatBothContainsString() {
        FibonacciWithJUnit5 f = new FibonacciWithJUnit5();
        String temp = f.fibonacci(1) + " " + f.fibonacci(4);
        Assertions.assertAll("Our composed test",
                () -> Assertions.assertTrue(temp.contains("1")),
                () -> Assertions.assertTrue(temp.contains("3"))
        );
    }

    @Test()
    public void testException() {
        FibonacciWithJUnit5 f = new FibonacciWithJUnit5();
        Integer i = null;
        Assertions.assertThrows(NullPointerException.class, () -> f.fibonacci(i.intValue()));
    }

    @Test()
    public void testTimeout() throws InterruptedException {
        Assertions.assertTimeout(Duration.ofMillis(1), () -> fibonacci(30));
        //Assertions.assertTimeoutPreemptively(Duration.ofSeconds(1), () -> fibonacci(100));
    }

    private static FibonacciWithJUnit5 f2;

    @BeforeAll
    public static void setupTest() {
        f2 = new FibonacciWithJUnit5();
    }

    @AfterAll
    public static void clear() {
        f2 = null;
    }

    @Test
    public void fibonacciTestSimpleWithBefore() {
        assert (f2.fibonacci(4) == 3);
    }

    @AfterEach
    public void done() {
        System.out.println("Done!");
    }

    def "Simple test"() {
        setup:
        BadFibonacci f = new BadFibonacci()

        expect:
        f.fibonacci(1) == 1
        assert f.fibonacci(4) == 3
    }

    def "Simple test with Zero"() {
        setup:
        BadFibonacci f = new BadFibonacci()

        expect:
        f.fibonacci(1) != 0

    def "not assertEquals but Groovy Truth"() {
        setup:
        BadFibonacci f = new BadFibonacci()

        expect:
        assert f.fibonacci(1)
    }

    @Ignore
    // @IgnoreRest
    def "Simple ignored test"() {
        setup:
        BadFibonacci f = new BadFibonacci()

        expect:
        f.fibonacci(1) == 0
    }

    @FailsWith(MissingMethodException)
    // @FailsWith(SpockAssertionError)
    def "Simple test with Exception"() {
        setup:
        BadFibonacci f = new BadFibonacci()
        Integer i = 0

        when:
        i = null

        then:
        notThrown(f.fibonacci(i))

    }

    def "composed test with string"() {
        setup:
        BadFibonacci f = new BadFibonacci()

        when:
        def temp = f.fibonacci(1) + " " + f.fibonacci(4);

        then:
        temp.contains '1'
        and:
        temp.contains '3'
    }

    @Ignore
    @Timeout(value = 200, unit = MILLISECONDS)
    def "Simple test with TimeOut"() {
        setup:
        BadFibonacci f = new BadFibonacci()

        expect:
        f.fibonacci(100) == 0
    }

    def setup() {}          // run before every feature method
    def cleanup() {}        // run after every feature method
    def setupSpec() {}     // run before the first feature method
    def cleanupSpec() {}   // run after the last feature method

    @Subject
    BadFibonacci f2 = new BadFibonacci()

    def "parametrized test"() {
        setup:
        BadFibonacci f = new BadFibonacci()

        expect:
        f.fibonacci(index) == fibonacciNumber

        where:
        index     | fibonacciNumber
        1         | 1
        2         | 1
        3         | 2
    }

interface Subscriber {
    String receive(String message)
}

Subscriber subscriber = Mock()

subscriber.receive(_) >> "ok"