source: bidspace/src/test/java/geniusweb/bidspace/IntervalTest.java@ 52

package geniusweb.bidspace;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;

import org.junit.Test;

import tudelft.utilities.junit.GeneralTests;

public class IntervalTest extends GeneralTests<Interval> {

        private static final BigDecimal ZERO = BigDecimal.ZERO;
        private static final BigDecimal ONE = BigDecimal.ONE;
        private static final BigDecimal TWO = BigDecimal.valueOf(2);
        private static final BigDecimal THREE = BigDecimal.valueOf(3);
        private static final BigDecimal TEN = BigDecimal.TEN;
        private static final Interval int1 = new Interval(ZERO, ONE);
        private static final Interval int1a = new Interval(ZERO, ONE);
        private static final Interval int2 = new Interval(ONE, TEN);
        private static final Interval int3 = new Interval(TWO, TEN);

        @Override
        public List<List<Interval>> getGeneralTestData() {
                return Arrays.asList(Arrays.asList(int1, int1a), Arrays.asList(int2),
                                Arrays.asList(int3));
        }

        @Override
        public List<String> getGeneralTestStrings() {
                return Arrays.asList("Interval\\[0,1\\]", "Interval\\[1,10\\]",
                                "Interval\\[2,10\\]");
        }

        @Test
        public void smokeTest() {
                new Interval(BigDecimal.ZERO, BigDecimal.ONE);
        }

        @Test
        public void smokeTestBad() {
                Interval i = new Interval(BigDecimal.TEN, BigDecimal.ONE);
                assertTrue(i.isEmpty());
        }

        @Test(expected = NullPointerException.class)
        public void smokeNull1() {
                new Interval(null, BigDecimal.ZERO);
        }

        @Test(expected = NullPointerException.class)
        public void smokeNull2() {
                new Interval(BigDecimal.ZERO, null);
        }

        @Test
        public void testMin() {
                assertEquals(BigDecimal.ZERO, int1.getMin());
                assertEquals(BigDecimal.ONE, int2.getMin());
        }

        @Test
        public void testMax() {
                assertEquals(BigDecimal.ONE, int1.getMax());
                assertEquals(BigDecimal.TEN, int2.getMax());
        }

        @Test
        public void containsTest() {
                assertTrue(int1.contains(BigDecimal.valueOf(0.3)));
                assertFalse(int1.contains(BigDecimal.valueOf(-0.3)));
                assertFalse(int1.contains(BigDecimal.valueOf(1.3)));

                assertFalse(int3.contains(ZERO));
                assertFalse(int3.contains(ONE));
                assertTrue(int3.contains(TWO));
                assertTrue(int3.contains(THREE));
                assertTrue(int3.contains(TEN));
                assertFalse(int3.contains(BigDecimal.valueOf(10.3)));

        }

        @Test
        public void testIntersect() {
                assertEquals(int1, int1.intersect(int1));
                assertEquals(new Interval(ONE, ONE), int1.intersect(int2));
                assertTrue(int1.intersect(int3).isEmpty());
                assertEquals(new Interval(ONE, TWO),
                                new Interval(ZERO, TEN).intersect(new Interval(ONE, TWO)));
                assertEquals(new Interval(ONE, TWO),
                                new Interval(ONE, TWO).intersect(new Interval(ZERO, TEN)));
                assertEquals(new Interval(ONE, TWO),
                                new Interval(ZERO, TWO).intersect(new Interval(ONE, TEN)));
                assertEquals(new Interval(ONE, TWO),
                                new Interval(ONE, TEN).intersect(new Interval(ZERO, TWO)));
        }

        @Test
        public void subtractTest() {
                assertEquals(new Interval(BigDecimal.valueOf(-1), ZERO),
                                int1.subtract(ONE));
        }

        @Test
        public void invertTest() {
                assertEquals(new Interval(BigDecimal.valueOf(-10), ZERO),
                                int1.invert(int2));
                assertEquals(new Interval(ZERO, TEN), int2.invert(int1));
                assertEquals(
                                new Interval(BigDecimal.valueOf(-9), BigDecimal.valueOf(8)),
                                int2.invert(int3));
        }

}