TestEnvironment.java

package mvd.jester;

import java.lang.reflect.Constructor;
import java.util.HashSet;
import java.util.Set;
import mvd.jester.info.SchedulingInfo;
import mvd.jester.model.SystemSetup;
import mvd.jester.priority.PriorityManager;
import mvd.jester.simulator.AbstractSimulator;
import mvd.jester.tests.AbstractTest;

/**
 * TestEnvironment
 */
public class TestEnvironment {

    private final long numberOfTaskSets;
    private final SystemSetup systemSetup;
    private final SystemSetup.Builder builder;
    private final Set<Constructor<? extends AbstractTest>> abstractTests;
    private final Set<Constructor<? extends AbstractSimulator>> abstractSimulators;
    private final Set<PriorityManager> schedulingAlgorithms;

    public TestEnvironment(SystemSetup.Builder builder, long numberOfTaskSets) {
        this.numberOfTaskSets = numberOfTaskSets;
        this.abstractTests = new HashSet<>();
        this.abstractSimulators = new HashSet<>();
        this.schedulingAlgorithms = new HashSet<>();

        this.builder = builder;
        this.systemSetup = builder.build();
    }

    public TestEnvironment registerSchedulingAlgorithm(PriorityManager priorityManager) {
        schedulingAlgorithms.add(priorityManager);

        return this;
    }

    public TestEnvironment registerTest(Class<? extends AbstractTest> abstractTest) {
        try {
            abstractTests.add(abstractTest.getConstructor(SystemSetup.class));
        } catch (Exception e) {
            System.out.println("Missing constructor for abstract test!");
        }

        return this;
    }

    public TestEnvironment registerSimulator(Class<? extends AbstractSimulator> abstractSimulator) {
        try {
            abstractSimulators.add(abstractSimulator.getConstructor(SystemSetup.class));
        } catch (Exception e) {
            System.out.println("Missing constructor for abstract simulator!");
        }

        return this;
    }

    public TestEnvironment registerTestPair(Class<? extends AbstractTest> abstractTest,
            Class<? extends AbstractSimulator> abstractSimulator) {
        try {
            abstractTests.add(abstractTest.getConstructor(SystemSetup.class));
        } catch (Exception e) {
            System.out.println("Missing constructor for abstract test!");
        }
        try {
            abstractSimulators.add(abstractSimulator.getConstructor(SystemSetup.class));
        } catch (Exception e) {
            System.out.println("Missing constructor for abstract simulator!");
        }

        return this;
    }

    public void runTests() {
        Set<ResultCollector<AbstractTest>> abstractTestInstances = new HashSet<>();
        Set<ResultCollector<AbstractSimulator>> abstractSimulatorInstances = new HashSet<>();

        for (PriorityManager pm : schedulingAlgorithms) {
            for (Constructor<? extends AbstractTest> c : abstractTests) {
                try {
                    if (pm.hasTest(c.getDeclaringClass())) {
                        abstractTestInstances.add(new ResultCollector<AbstractTest>(pm,
                                c.newInstance(this.systemSetup)));
                    }
                } catch (Exception e) {
                    System.out.println("Could not instantiate object of AbstractTest!");
                    throw new RuntimeException("Could not instantiate object of AbstractTest!");
                }
            }

            for (Constructor<? extends AbstractSimulator> c : abstractSimulators) {
                try {
                    if (pm.hasSimulator(c.getDeclaringClass())) {
                        abstractSimulatorInstances.add(new ResultCollector<AbstractSimulator>(pm,
                                c.newInstance(this.systemSetup)));
                    }
                } catch (Exception e) {
                    System.out.println("Could not instantiate object of AbstractSimulator!");
                    throw new RuntimeException(
                            "Could not instantiate object of AbstractSimulator!");
                }
            }
        }

        long checkedTasksets = 0;

        while (checkedTasksets < numberOfTaskSets) {
            builder.rebuild(this.systemSetup);

            double utilization = this.systemSetup.getUtilization();

            while (utilization <= this.systemSetup.getNumberOfProcessors()
                    && checkedTasksets < numberOfTaskSets) {
                checkedTasksets++;

                if (checkedTasksets % 100 == 0) {
                    System.out.print(Math.round((double) checkedTasksets / numberOfTaskSets * 100)
                            + "% of " + numberOfTaskSets + " tasksets tested!\r");
                }

                for (ResultCollector<AbstractTest> testInstance : abstractTestInstances) {
                    PriorityManager priorityManager = testInstance.getPriorityManager();
                    AbstractTest abstractTest = testInstance.getAbstractValue();

                    SchedulingInfo schedulingInfo =
                            abstractTest.runSchedulabilityCheck(priorityManager);
                    testInstance.addResult(schedulingInfo);
                }

                for (ResultCollector<AbstractSimulator> simulatorInstance : abstractSimulatorInstances) {
                    PriorityManager priorityManager = simulatorInstance.getPriorityManager();
                    AbstractSimulator abstractSimulator = simulatorInstance.getAbstractValue();

                    SchedulingInfo schedulingInfo =
                            abstractSimulator.runSimulation(priorityManager);
                    simulatorInstance.addResult(schedulingInfo);
                }

                builder.addTask(systemSetup);

                utilization = this.systemSetup.getUtilization();
            }
        }
        System.out.println("");
        ResultLogger resultLogger = new ResultLogger(systemSetup.getNumberOfProcessors());

        resultLogger.logTests(abstractTestInstances);
    }

}