Package org.libreplan.business.resources.entities

Examples of org.libreplan.business.resources.entities.Interval

48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
        Interval.range(CriterionSatisfactionDAOTest.year(1990), null);
    }

    @Test
    public void testContainsPointInTime() {
        Interval openEnded = Interval.from(CriterionSatisfactionDAOTest
                .year(1990));
        Interval range = Interval.range(
                CriterionSatisfactionDAOTest.year(1990),
                CriterionSatisfactionDAOTest.year(2000));
        Interval startPoint = Interval.point(year(1990));
        Interval endPoint = Interval.point(year(2000));
        assertTrue(openEnded.contains(CriterionSatisfactionDAOTest.year(5000)));
        assertFalse(range.contains(year(5000)));
        assertTrue(range.contains(year(1990)));
        assertFalse(range.contains(year(2000)));
        assertTrue(range.contains(year(1991)));
View Full Code Here
67
68
69
70
71
72
73
74
75
76
        assertFalse(range.includes(endPoint));
    }

    @Test
    public void testPointsOnlyContainsThemselves() {
        Interval point = Interval
                .point(CriterionSatisfactionDAOTest.year(1990));
        assertTrue(point.contains(CriterionSatisfactionDAOTest.year(1990)));
        assertFalse(point.contains(CriterionSatisfactionDAOTest.year(2010)));
    }
View Full Code Here
76
77
78
79
80
81
82
83
84
85
86
    }

    @Test
    public void testIntervalsAreStartInclusiveAndEndExclusive()
            {
        Interval range = Interval.range(year(1990), year(2000));
        assertTrue(range.contains(year(1990)));
        assertFalse(range.contains(year(2000)));
        assertFalse(range.contains(year(1990).minusDays(1)));
        assertFalse(range.contains(year(2000).plusDays(1)));
    }
View Full Code Here
85
86
87
88
89
90
91
92
93
94
95
96
        assertFalse(range.contains(year(2000).plusDays(1)));
    }

    @Test
    public void testIncludes() {
        Interval bigRange = Interval.range(year(1990), year(2000));
        Interval included = Interval.range(year(1990), year(1998));
        Interval point = Interval.point(year(1996));
        assertTrue(bigRange.includes(included));
        assertTrue(bigRange.includes(point));
        assertTrue(included.includes(point));
    }
View Full Code Here
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
        assertTrue(included.includes(point));
    }

    @Test
    public void testStartPointDoesntOverlapsWithRange() {
        Interval range = Interval.range(year(1990), year(2005));
        Interval openEndedRange = Interval.from(year(1990));
        Interval point = Interval.point(year(1990));
        Interval internalPoint = Interval.point(year(1991));

        assertFalse(point.overlapsWith(range));
        assertFalse(point.overlapsWith(openEndedRange));
        assertFalse(range.overlapsWith(point));
        assertFalse(openEndedRange.overlapsWith(point));

        assertTrue(internalPoint.overlapsWith(range));
        assertTrue(internalPoint.overlapsWith(openEndedRange));
        assertTrue(range.overlapsWith(internalPoint));
        assertTrue(openEndedRange.overlapsWith(internalPoint));
    }
View Full Code Here
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
        assertTrue(openEndedRange.overlapsWith(internalPoint));
    }

    @Test
    public void testOverlapsWith() {
        Interval firstRange = Interval.range(year(1990), year(2005));
        Interval igalia = Interval.from(year(2001));
        Interval distantPoint = Interval.point(year(2030));
        Interval pointInFirstRange = Interval.point(year(2000));
        Interval outRange = Interval.range(year(2020), year(2030));
        assertTrue(firstRange.overlapsWith(igalia));
        assertTrue(firstRange.overlapsWith(Interval.range(year(1980),
                year(1991))));
        assertTrue(igalia.overlapsWith(firstRange));
        assertTrue(outRange.overlapsWith(igalia));
        assertFalse(outRange.overlapsWith(firstRange));
        assertTrue(distantPoint.overlapsWith(igalia));
        assertFalse(distantPoint.overlapsWith(firstRange));
        assertTrue(igalia.overlapsWith(distantPoint));
        assertTrue(distantPoint.overlapsWith(igalia));
        assertFalse(firstRange.overlapsWith(distantPoint));
View Full Code Here
135
136
137
138
139
140
141
142
143
144
145
146
147
148
    }

    @Test
    public void testIntervalFinishingAtTheStartOfOtherDontOverlap()
            {
        Interval range = Interval.range(year(2000), year(2005));
        Interval from = Interval.from(year(2000));
        Interval before = Interval.range(year(1995), year(2000));
        assertFalse(range.overlapsWith(before));
        assertFalse(before.overlapsWith(range));

        assertFalse(from.overlapsWith(before));
        assertFalse(before.overlapsWith(from));
    }
View Full Code Here
147
148
149
150
151
152
153
154
155
156
157
158
159
        assertFalse(before.overlapsWith(from));
    }

    @Test
    public void testStartPointDoesntOverlapsWithRanges() {
        Interval range = Interval.range(year(2010), year(2030));
        Interval point = Interval.point(year(2010));
        Interval otherRange = Interval.from(year(2010));
        assertFalse(point.overlapsWith(range));
        assertFalse(range.overlapsWith(point));
        assertFalse(point.overlapsWith(otherRange));
        assertFalse(otherRange.overlapsWith(point));
    }
View Full Code Here
158
159
160
161
162
163
164
165
166
        assertFalse(otherRange.overlapsWith(point));
    }

    @Test
    public void testCreatingPointWithRange() {
        Interval point = Interval.point(year(1990));
        Interval range = Interval.range(year(1990), year(1990));
        assertEquals(point, range);
    }
View Full Code Here
165
166
167
168
169
170
171
172
173
174
        assertEquals(point, range);
    }

    @Test
    public void testOverlappingWhenContained() {
        Interval range = Interval.range(year(1990), year(2000));
        Interval contained = Interval.range(year(1995), year(1997));
        assertTrue(range.overlapsWith(contained));
        assertTrue(contained.overlapsWith(range));
    }
View Full Code Here
TOP

Related Classes of org.libreplan.business.resources.entities.Interval

  • org.apache.commons.lang.builder.HashCodeBuilder
  • org.libreplan.business.test.resources.daos.ResourceDAOTest
  • org.libreplan.business.test.resources.entities.IntervalTest
  • org.libreplan.business.test.resources.entities.ResourceTest
  • org.libreplan.web.resources.machine.AssignedMachineCriterionsModel
  • org.libreplan.web.resources.worker.AssignedCriterionsModel
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.