TestEarliestDeadlineFirst.java

package mvd.jester.priority;

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import mvd.jester.model.SynchronousTask;
import mvd.jester.model.SystemManager;
import mvd.jester.model.SystemManager.SynchronousTaskBuilder;
import mvd.jester.simulator.DynamicForkJoin;
import mvd.jester.simulator.ParallelSynchronous;
import mvd.jester.simulator.internals.parallelsynchronous.TaskContext;
import mvd.jester.tests.ChwaLee;
import mvd.jester.tests.MaiaBertogna;
import mvd.jester.tests.SchmidMottok;
import mvd.jester.tests.TypeFunction;

/**
 * TestEarliestDeadlineFirst
 */
public class TestEarliestDeadlineFirst {

    @Test
    @DisplayName("Test if priority manager returns the correct priority.")
    public void testPriority() {
        EarliestDeadlineFirst edf = new EarliestDeadlineFirst();

        SynchronousTask t1 = mock(SynchronousTask.class);
        SynchronousTask t2 = mock(SynchronousTask.class);
        when(t1.getDeadline()).thenReturn((long) 100);
        when(t2.getDeadline()).thenReturn((long) 200);

        TaskContext tc1 = mock(TaskContext.class);
        TaskContext tc2 = mock(TaskContext.class);
        when(tc1.getDeadline()).thenReturn((long) 100);
        when(tc2.getDeadline()).thenReturn((long) 200);

        assertTrue(edf.compare(t1, t2) < 0);
        assertTrue(edf.compare(tc1, tc2) < 0);
        assertTrue(edf.compare(t1, t1) == 0);
        assertTrue(edf.compare(tc1, tc1) == 0);
        assertTrue(edf.compare(t2, t1) > 0);
        assertTrue(edf.compare(tc2, tc1) > 0);
    }


    @Test
    @DisplayName("Check Getters, Tests and Simulators.")
    void testGettersTestsAndSimulators() {
        EarliestDeadlineFirst edf = new EarliestDeadlineFirst();
        SystemManager<SynchronousTaskBuilder> manager =
                new SystemManager<>(SynchronousTaskBuilder.class);
        assertTrue(edf.hasTest(ChwaLee.class));
        assertFalse(edf.hasTest(MaiaBertogna.class));
        assertFalse(edf.hasTest(SchmidMottok.class));
        assertTrue(edf.hasSimulator(ParallelSynchronous.class));
        assertTrue(edf.hasSimulator(DynamicForkJoin.class));

        assertTrue(edf.hasTest(new ChwaLee(manager)));
        assertFalse(edf.hasTest(new SchmidMottok(new TypeFunction.KnownStructure(), manager)));
        assertFalse(edf.hasTest(new MaiaBertogna(manager)));
        // assertTrue(edf.hasSimulator(new ParallelSynchronous(mock(SystemSetup.class))));
        // assertTrue(edf.hasSimulator(new DynamicForkJoin(mock(SystemSetup.class))));

        assertTrue(edf.getName().equals("EDF"));
    }

}