source: java/main/src/test/java/com/framsticks/test/TestConfiguration.java @ 193

package com.framsticks.test;

import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import org.testng.annotations.*;

import com.framsticks.params.Source;
import com.framsticks.parsers.FileSource;
import com.framsticks.util.ExceptionHandler;
import com.framsticks.util.FramsticksException;
import com.framsticks.util.dispatching.Dispatcher;
import com.framsticks.util.dispatching.Dispatching;
import com.framsticks.util.dispatching.Dispatching.Waiter;
import com.framsticks.util.dispatching.ExceptionDispatcherHandler;

// import static org.fest.assertions.Assertions.*;

public class TestConfiguration {

        private static final Logger log = LogManager.getLogger(TestConfiguration.class);

        @BeforeClass
        public void setUpConfiguration() {
                log.info("testing {}", this.getClass());
        }

        private final List<AssertionError> asyncAssertions = new LinkedList<>();

        public static AssertionError wrapInAssertion(Throwable throwable) {
                if (throwable instanceof AssertionError) {
                        return (AssertionError) throwable;
                }

                AssertionError ae = new AssertionError();
                ae.initCause(throwable);
                return ae;
        }

        public void addAsyncAssertion(Throwable throwable) {
                synchronized (asyncAssertions) {
                        asyncAssertions.add(wrapInAssertion(throwable));
                }
        }

        public ExceptionDispatcherHandler createExceptionHandler() {
                return new ExceptionDispatcherHandler() {
                        @Override
                        public boolean handle(Dispatcher<?> dispatcher, Throwable throwable) {
                                addAsyncAssertion(throwable);
                                return true;
                        }
                };
        }

        @AfterMethod
        public void waitForWaiters() {
                for (Waiter w : waiters) {
                        try {
                                w.waitFor();
                        } catch (FramsticksException e) {
                                AssertionError ae = new AssertionError();
                                ae.initCause(e);
                                asyncAssertions.add(ae);
                        }
                }
        }

        @AfterMethod(timeOut = 1000, dependsOnMethods = "waitForWaiters")
        public void processAsyncAssertions() {
                synchronized (asyncAssertions) {
                        if (asyncAssertions.isEmpty()) {
                                return;
                        }
                        AssertionError a = asyncAssertions.get(0);
                        asyncAssertions.remove(0);
                        throw a;
                }
        }

        final Set<Waiter> waiters = new HashSet<>();

        @BeforeMethod
        public void clearWaiters() {
                synchronized (waiters) {
                        waiters.clear();
                }
        }

        protected Dispatching.Waiter produceWaiter(double timeOut) {
                Waiter waiter = new Waiter(timeOut, failOnException);
                synchronized (waiters) {
                        waiters.add(waiter);
                }
                return waiter;
        }

        public final ExceptionHandler failOnException = new ExceptionHandler() {
                @Override
                public void handle(FramsticksException e) {
                        log.error("passing exception as assertion in {}", TestConfiguration.this.getClass(), e);
                        addAsyncAssertion(e);
                }
        };

        protected Source getSource(String path) {
                return new FileSource(TestConfiguration.class.getResourceAsStream(path), path);
        }
}