source: timeline/src/test/java/geniusweb/progress/ProgressRoundsTest.java@ 29

package geniusweb.progress;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import java.io.IOException;
import java.util.Arrays;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;

import org.junit.Before;
import org.junit.Test;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import geniusweb.deadline.DeadlineRounds;
import tudelft.utilities.junit.GeneralTests;

public class ProgressRoundsTest extends GeneralTests<Progress> {
        private DeadlineRounds deadline = mock(DeadlineRounds.class);
        private final static Integer TESTROUNDS = 10;
        private final static long TESTTIME = 10; // milliseconds!

        private final Date date = new Date(999l);
        private final Date date0 = new Date(0l);

        private final Progress deadline1 = new ProgressRounds(20, 0, date);
        private final Progress deadline2 = new ProgressRounds(20, 0, date);
        private final Progress deadline3 = new ProgressRounds(30, 0, date);
        private final Progress deadline4 = new ProgressTime(20l, date0);
        private final Progress deadline5 = new ProgressTime(20l, date);
        private ProgressRounds progress;
        private final ObjectMapper jackson = new ObjectMapper();
        private final String progressstring = "{\"rounds\":{\"duration\":10,\"currentRound\":0,\"endtime\":999}}";

        private final long start = 1234;
        private final Date end = new Date(start + TESTTIME);
        private final ProgressRounds pr = new ProgressRounds(TESTROUNDS, 4, end);

        @Before
        public void before() {
                when(deadline.getRounds()).thenReturn(TESTROUNDS);
                progress = new ProgressRounds(deadline.getRounds(), 0, date);

        }

        @Override
        public List<List<Progress>> getGeneralTestData() {
                List<List<Progress>> list = new LinkedList<>();
                list.add(Arrays.asList(deadline1, deadline2));
                list.add(Arrays.asList(deadline3));
                list.add(Arrays.asList(deadline4));
                list.add(Arrays.asList(deadline5));
                return list;
        }

        @Override
        public List<String> getGeneralTestStrings() {
                return Arrays.asList("ProgressRounds\\[0.*20\\]",
                                "ProgressRounds\\[0.*30\\]", "ProgressTime\\[0.*20ms\\]",
                                "ProgressTime\\[999.*20ms\\]");
        }

        @Test
        public void testInit() {
                assertEquals((Double) 0d, progress.get(1l));
        }

        @Test
        public void testCurrentRound() {
                assertEquals((Integer) 0, progress.getCurrentRound());
        }

        @Test
        public void testAdvance() {
                ProgressRounds p = progress;
                int n = 0;
                while (n <= TESTROUNDS) {
                        assertEquals((Double) ((double) n / TESTROUNDS), p.get(1l));
                        n++;
                        p = p.advance();
                }
        }

        @Test
        public void testAdvanceWhenDeadlineReached() {
                ProgressRounds p = new ProgressRounds(TESTROUNDS, 9, date);
                p = p.advance();
                assertEquals((Double) 1d, p.get(1l));
        }

        @Test
        public void testSerialize() throws JsonProcessingException {
                System.out.println(jackson.writeValueAsString(progress));
                assertEquals(progressstring, jackson.writeValueAsString(progress));

        }

        @Test
        public void testDeserialize()
                        throws JsonParseException, JsonMappingException, IOException {
                assertEquals(progress,
                                jackson.readValue(progressstring, Progress.class));

        }

        @SuppressWarnings("unused")
        @Test(expected = IllegalArgumentException.class)
        public void testIllegalArg1() {
                new ProgressRounds(10, 11, date);
        }

        @SuppressWarnings("unused")
        @Test(expected = IllegalArgumentException.class)
        public void testIllegalArg2() {
                new ProgressRounds(10, -1, date);
        }

        @Test
        public void pastDeadline() {
                assertFalse(pr.isPastDeadline(start));
                assertTrue(pr.isPastDeadline(start + TESTTIME + 1));
                assertFalse(pr.isPastDeadline(start + TESTTIME - 1));
                assertTrue(new ProgressRounds(TESTROUNDS, TESTROUNDS, end)
                                .isPastDeadline(start + TESTTIME + 1));
        }

        @Test
        public void terminationTime() {
                assertEquals(start + TESTTIME, pr.getTerminationTime().getTime());
        }

        @Test
        public void get() {
                // time does not matter for rounds-based deadline
                assertEquals((Double) 0.4d, pr.get(start));
                assertEquals((Double) 0.4d, pr.get(start + TESTTIME + 1));
                assertEquals((Double) 0.4d, pr.get(start + TESTTIME));
                assertEquals((Double) 0.4d, pr.get(start + TESTTIME / 2));
                assertEquals((Double) 0.4d, pr.get(start - 10));
                assertEquals((Double) 0.4d, pr.get(start + TESTTIME + 10));

                assertEquals((Double) 0.1d,
                                new ProgressRounds(TESTROUNDS, 1, end).get(start));
                assertEquals((Double) 1d,
                                new ProgressRounds(TESTROUNDS, TESTROUNDS, end).get(start));
        }

        @Test
        public void totalRounds() {
                assertEquals((Integer) 10, pr.getTotalRounds());
        }
}