1   /* Copyright 2002-2022 CS GROUP
2    * Licensed to CS GROUP (CS) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * CS licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *   http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.orekit.utils;
18  
19  
20  import java.util.Iterator;
21  
22  import org.junit.Assert;
23  import org.junit.Before;
24  import org.junit.Test;
25  import org.orekit.Utils;
26  import org.orekit.time.AbsoluteDate;
27  import org.orekit.utils.TimeSpanMap.Span;
28  import org.orekit.utils.TimeSpanMap.Transition;
29  
30  public class TimeSpanMapTest {
31  
32      @Test
33      public void testSingleEntry() {
34          String single = "single";
35          TimeSpanMap<String> map = new TimeSpanMap<>(single);
36          checkCountConsistency(map);
37          Assert.assertSame(single, map.get(AbsoluteDate.CCSDS_EPOCH));
38          Assert.assertSame(single, map.get(AbsoluteDate.FIFTIES_EPOCH));
39          Assert.assertSame(single, map.get(AbsoluteDate.FUTURE_INFINITY));
40          Assert.assertSame(single, map.get(AbsoluteDate.GALILEO_EPOCH));
41          Assert.assertSame(single, map.get(AbsoluteDate.GPS_EPOCH));
42          Assert.assertSame(single, map.get(AbsoluteDate.J2000_EPOCH));
43          Assert.assertSame(single, map.get(AbsoluteDate.JAVA_EPOCH));
44          Assert.assertSame(single, map.get(AbsoluteDate.JULIAN_EPOCH));
45          Assert.assertSame(single, map.get(AbsoluteDate.MODIFIED_JULIAN_EPOCH));
46          Assert.assertSame(single, map.get(AbsoluteDate.PAST_INFINITY));
47          Assert.assertEquals(1, map.getSpansNumber());
48      }
49  
50      @Test
51      public void testForwardAdd() {
52          final AbsoluteDate ref = AbsoluteDate.J2000_EPOCH;
53          TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
54          checkCountConsistency(map);
55          for (int i = 1; i < 100; ++i) {
56              Integer entry = Integer.valueOf(i);
57              TimeSpanMap.Span<Integer> span = map.addValidAfter(entry, ref.shiftedBy(i), false);
58              Assert.assertSame(entry, span.getData());
59              checkCountConsistency(map);
60          }
61          Assert.assertEquals(0, map.get(ref.shiftedBy(-1000.0)).intValue());
62          Assert.assertEquals(0, map.get(ref.shiftedBy( -100.0)).intValue());
63          TimeSpanMap.Span<Integer> span = map.getSpan(ref.shiftedBy(-1000.0));
64          Assert.assertEquals(0, span.getData().intValue());
65          Assert.assertTrue(span.getStart().durationFrom(AbsoluteDate.J2000_EPOCH) < -Double.MAX_VALUE);
66          Assert.assertEquals(1.0, span.getEnd().durationFrom(AbsoluteDate.J2000_EPOCH), 1.0e-15);
67          for (int i = 0; i < 100; ++i) {
68              Assert.assertEquals(i, map.get(ref.shiftedBy(i + 0.1)).intValue());
69              Assert.assertEquals(i, map.get(ref.shiftedBy(i + 0.9)).intValue());
70              span = map.getSpan(ref.shiftedBy(i + 0.1));
71              Assert.assertEquals(i, span.getData().intValue());
72              if (i == 0) {
73                  Assert.assertTrue(span.getStart().durationFrom(AbsoluteDate.J2000_EPOCH) < -Double.MAX_VALUE);
74              } else {
75                  Assert.assertEquals(i, span.getStart().durationFrom(AbsoluteDate.J2000_EPOCH), 1.0e-15);
76              } if (i == 99) {
77                  Assert.assertTrue(span.getEnd().durationFrom(AbsoluteDate.J2000_EPOCH) > Double.MAX_VALUE);
78              } else {
79                  Assert.assertEquals(i + 1, span.getEnd().durationFrom(AbsoluteDate.J2000_EPOCH), 1.0e-15);
80              }
81          }
82          Assert.assertEquals(99, map.get(ref.shiftedBy(  100.0)).intValue());
83          Assert.assertEquals(99, map.get(ref.shiftedBy( 1000.0)).intValue());
84          checkCountConsistency(map);
85      }
86  
87      @Test
88      public void testBackwardAdd() {
89          final AbsoluteDate ref = AbsoluteDate.J2000_EPOCH;
90          TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
91          checkCountConsistency(map);
92          for (int i = -1; i > -100; --i) {
93              Integer entry = Integer.valueOf(i);
94              TimeSpanMap.Span<Integer> span = map.addValidBefore(entry, ref.shiftedBy(i), false);
95              Assert.assertSame(entry, span.getData());
96              checkCountConsistency(map);
97          }
98          Assert.assertEquals(0, map.get(ref.shiftedBy( 1000.0)).intValue());
99          Assert.assertEquals(0, map.get(ref.shiftedBy(  100.0)).intValue());
100         for (int i = 0; i > -100; --i) {
101             Assert.assertEquals(i, map.get(ref.shiftedBy(i - 0.1)).intValue());
102             Assert.assertEquals(i, map.get(ref.shiftedBy(i - 0.9)).intValue());
103         }
104         Assert.assertEquals(-99, map.get(ref.shiftedBy( -100.0)).intValue());
105         Assert.assertEquals(-99, map.get(ref.shiftedBy(-1000.0)).intValue());
106         checkCountConsistency(map);
107     }
108 
109     @Deprecated
110     @Test
111     public void testDeprecatedAddValid() {
112         final AbsoluteDate ref = AbsoluteDate.J2000_EPOCH;
113         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
114         map.addValidAfter(Integer.valueOf(10), ref.shiftedBy(10.0));
115         map.addValidAfter(Integer.valueOf( 3), ref.shiftedBy( 2.0));
116         map.addValidAfter(Integer.valueOf( 9), ref.shiftedBy( 5.0));
117         map.addValidBefore(Integer.valueOf( 2), ref.shiftedBy( 3.0));
118         map.addValidBefore(Integer.valueOf( 5), ref.shiftedBy( 9.0));
119         Assert.assertEquals( 0, map.get(ref.shiftedBy( -1.0)).intValue());
120         Assert.assertEquals( 0, map.get(ref.shiftedBy(  1.9)).intValue());
121         Assert.assertEquals( 2, map.get(ref.shiftedBy(  2.1)).intValue());
122         Assert.assertEquals( 2, map.get(ref.shiftedBy(  2.9)).intValue());
123         Assert.assertEquals( 3, map.get(ref.shiftedBy(  3.1)).intValue());
124         Assert.assertEquals( 3, map.get(ref.shiftedBy(  4.9)).intValue());
125         Assert.assertEquals( 5, map.get(ref.shiftedBy(  5.1)).intValue());
126         Assert.assertEquals( 5, map.get(ref.shiftedBy(  8.9)).intValue());
127         Assert.assertEquals( 9, map.get(ref.shiftedBy(  9.1)).intValue());
128         Assert.assertEquals( 9, map.get(ref.shiftedBy(  9.9)).intValue());
129         Assert.assertEquals(10, map.get(ref.shiftedBy( 10.1)).intValue());
130         Assert.assertEquals(10, map.get(ref.shiftedBy(100.0)).intValue());
131     }
132 
133     @Deprecated
134     @Test
135     public void testDeprecatedNavigableMap() {
136 
137         TimeSpanMap<Integer> map = new TimeSpanMap<>(null);
138         Assert.assertEquals(1, map.getSpansNumber());
139         Assert.assertTrue(map.getTransitions().isEmpty());
140 
141         map.addValidAfter(0, AbsoluteDate.ARBITRARY_EPOCH, false);
142         map.addValidAfter(1, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(1.0), false);
143         map.addValidAfter(2, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(2.0), false);
144         Assert.assertEquals(4, map.getSpansNumber());
145         Assert.assertFalse(map.getTransitions().isEmpty());
146         Assert.assertEquals(3, map.getTransitions().size());
147         final Iterator<Transition<Integer>> iterator = map.getTransitions().iterator();
148         Assert.assertEquals(0.0, iterator.next().getDate().durationFrom(AbsoluteDate.ARBITRARY_EPOCH), 1.0e-15);
149         Assert.assertEquals(1.0, iterator.next().getDate().durationFrom(AbsoluteDate.ARBITRARY_EPOCH), 1.0e-15);
150         Assert.assertEquals(2.0, iterator.next().getDate().durationFrom(AbsoluteDate.ARBITRARY_EPOCH), 1.0e-15);
151 
152     }
153 
154     @Test
155     public void testRandomAddNoErase() {
156         final AbsoluteDate ref = AbsoluteDate.J2000_EPOCH;
157         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
158         map.addValidAfter(Integer.valueOf(10), ref.shiftedBy(10.0), false);
159         map.addValidAfter(Integer.valueOf( 3), ref.shiftedBy( 2.0), false);
160         map.addValidAfter(Integer.valueOf( 9), ref.shiftedBy( 5.0), false);
161         map.addValidBefore(Integer.valueOf( 2), ref.shiftedBy( 3.0), false);
162         map.addValidBefore(Integer.valueOf( 5), ref.shiftedBy( 9.0), false);
163         Assert.assertEquals( 0, map.get(ref.shiftedBy( -1.0)).intValue());
164         Assert.assertEquals( 0, map.get(ref.shiftedBy(  1.9)).intValue());
165         Assert.assertEquals( 2, map.get(ref.shiftedBy(  2.1)).intValue());
166         Assert.assertEquals( 2, map.get(ref.shiftedBy(  2.9)).intValue());
167         Assert.assertEquals( 3, map.get(ref.shiftedBy(  3.1)).intValue());
168         Assert.assertEquals( 3, map.get(ref.shiftedBy(  4.9)).intValue());
169         Assert.assertEquals( 5, map.get(ref.shiftedBy(  5.1)).intValue());
170         Assert.assertEquals( 5, map.get(ref.shiftedBy(  8.9)).intValue());
171         Assert.assertEquals( 9, map.get(ref.shiftedBy(  9.1)).intValue());
172         Assert.assertEquals( 9, map.get(ref.shiftedBy(  9.9)).intValue());
173         Assert.assertEquals(10, map.get(ref.shiftedBy( 10.1)).intValue());
174         Assert.assertEquals(10, map.get(ref.shiftedBy(100.0)).intValue());
175         final StringBuilder builder = new StringBuilder();
176         map.forEach(i -> builder.append(' ').append(i));
177         Assert.assertEquals(" 0 2 3 5 9 10", builder.toString());
178         Assert.assertEquals(6, map.getSpansNumber());
179         checkCountConsistency(map);
180     }
181 
182     @Test
183     public void testRandomAddErase() {
184         final AbsoluteDate ref = AbsoluteDate.J2000_EPOCH;
185         TimeSpanMap<Integer> map = new TimeSpanMap<>(null);
186         map.addValidAfter(Integer.valueOf(10), ref.shiftedBy(10.0), false);
187         map.addValidAfter(Integer.valueOf( 3), ref.shiftedBy( 2.0), false);
188         map.addValidBefore(Integer.valueOf( 5), ref.shiftedBy( 7.0), false);
189         map.addValidAfter(null, ref.shiftedBy( 5.0), true);
190         map.addValidAfter(Integer.valueOf( 1), ref.shiftedBy( 1.0), false);
191         map.addValidBefore(null, ref.shiftedBy( 3.0), true);
192         map.addValidBefore(Integer.valueOf( 7), ref.shiftedBy( 9.0), false);
193         Assert.assertNull(map.get(ref.shiftedBy( -1.0)));
194         Assert.assertNull(map.get(ref.shiftedBy(  1.9)));
195         Assert.assertNull(map.get(ref.shiftedBy(  2.1)));
196         Assert.assertNull(map.get(ref.shiftedBy(  2.9)));
197         Assert.assertEquals( 5, map.get(ref.shiftedBy(  3.1)).intValue());
198         Assert.assertEquals( 5, map.get(ref.shiftedBy(  4.9)).intValue());
199         Assert.assertEquals( 7, map.get(ref.shiftedBy(  5.1)).intValue());
200         Assert.assertEquals( 7, map.get(ref.shiftedBy(  6.9)).intValue());
201         Assert.assertEquals( 7, map.get(ref.shiftedBy(  7.1)).intValue());
202         Assert.assertEquals( 7, map.get(ref.shiftedBy(  8.9)).intValue());
203         Assert.assertNull(map.get(ref.shiftedBy(  9.1)));
204         Assert.assertNull(map.get(ref.shiftedBy(  9.9)));
205         Assert.assertNull(map.get(ref.shiftedBy( 10.1)));
206         Assert.assertNull(map.get(ref.shiftedBy(100.0)));
207         final StringBuilder builder = new StringBuilder();
208         map.forEach(i -> builder.append(' ').append(i));
209         Assert.assertEquals(" 5 7", builder.toString());
210         Assert.assertEquals(4, map.getSpansNumber());
211         checkCountConsistency(map);
212     }
213 
214     @Test
215     public void testAddBetweenEmpty() {
216         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
217         map.addValidBetween(1, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-2), AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(+2));
218         Assert.assertEquals(3, map.getSpansNumber());
219         Assert.assertEquals(0, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-3)).intValue());
220         Assert.assertEquals(1, map.get(AbsoluteDate.ARBITRARY_EPOCH).intValue());
221         Assert.assertEquals(0, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(+3)).intValue());
222         checkCountConsistency(map);
223     }
224 
225     @Test
226     public void testAddBetweenBefore() {
227         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
228         map.addValidBefore(1, AbsoluteDate.ARBITRARY_EPOCH, false);
229         map.addValidBetween(7, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-4), AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-2));
230         Assert.assertEquals(4, map.getSpansNumber());
231         Assert.assertEquals(1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-5)).intValue());
232         Assert.assertEquals(7, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-3)).intValue());
233         Assert.assertEquals(1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-1)).intValue());
234         Assert.assertEquals(0, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(+3)).intValue());
235         checkCountConsistency(map);
236     }
237 
238     @Test
239     public void testAddBetweenAfter() {
240         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
241         map.addValidBefore(1, AbsoluteDate.ARBITRARY_EPOCH, false);
242         map.addValidBetween(7, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(2), AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(4));
243         Assert.assertEquals(4, map.getSpansNumber());
244         Assert.assertEquals(1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-3)).intValue());
245         Assert.assertEquals(0, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy( 1)).intValue());
246         Assert.assertEquals(7, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy( 3)).intValue());
247         Assert.assertEquals(0, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy( 5)).intValue());
248         checkCountConsistency(map);
249     }
250 
251     @Test
252     public void testAddBetweenCoveringAll() {
253         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
254         map.addValidAfter(1, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(1), false);
255         map.addValidAfter(2, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(2), false);
256         map.addValidAfter(3, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(3), false);
257         map.addValidAfter(4, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(4), false);
258         map.addValidAfter(5, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(5), false);
259         Assert.assertEquals(6, map.getSpansNumber());
260         map.addValidBetween(-1, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-1), AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(6));
261         Assert.assertEquals( 3, map.getSpansNumber());
262         Assert.assertEquals( 0, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-5)).intValue());
263         Assert.assertEquals(-1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy( 2)).intValue());
264         Assert.assertEquals( 5, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(+7)).intValue());
265         checkCountConsistency(map);
266     }
267 
268     @Test
269     public void testAddBetweenCoveringSome() {
270         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
271         map.addValidAfter(1, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(1), false);
272         map.addValidAfter(2, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(2), false);
273         map.addValidAfter(3, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(3), false);
274         map.addValidAfter(4, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(4), false);
275         map.addValidAfter(5, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(5), false);
276         Assert.assertEquals(6, map.getSpansNumber());
277         Integer entry = Integer.valueOf(-1);
278         TimeSpanMap.Span<Integer> span = map.addValidBetween(entry, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(1.5), AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(4.5));
279         Assert.assertSame(entry, span.getData());
280         Assert.assertEquals(5, map.getSpansNumber());
281         Assert.assertEquals( 0, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(0.75)).intValue());
282         Assert.assertEquals( 1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(1.25)).intValue());
283         Assert.assertEquals(-1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(1.75)).intValue());
284         Assert.assertEquals(-1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(4.25)).intValue());
285         Assert.assertEquals( 4, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(4.75)).intValue());
286         Assert.assertEquals( 5, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(5.25)).intValue());
287         checkCountConsistency(map);
288     }
289 
290     @Test
291     public void testAddBetweenSplittingOneSpanOnly() {
292         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
293         map.addValidAfter(1, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(1), false);
294         map.addValidAfter(2, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(2), false);
295         map.addValidAfter(3, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(3), false);
296         map.addValidAfter(4, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(4), false);
297         map.addValidAfter(5, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(5), false);
298         Assert.assertEquals(6, map.getSpansNumber());
299         map.addValidBetween(-1, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(2.25), AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(2.75));
300         Assert.assertEquals(8, map.getSpansNumber());
301         Assert.assertEquals( 0, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(0.75)).intValue());
302         Assert.assertEquals( 1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(1.99)).intValue());
303         Assert.assertEquals( 2, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(2.01)).intValue());
304         Assert.assertEquals(-1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(2.50)).intValue());
305         Assert.assertEquals( 2, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(2.99)).intValue());
306         Assert.assertEquals( 3, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(3.01)).intValue());
307         Assert.assertEquals( 4, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(4.25)).intValue());
308         Assert.assertEquals( 5, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(5.25)).intValue());
309         checkCountConsistency(map);
310     }
311 
312     @Test
313     public void testAddBetweenExistingDates() {
314         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
315         map.addValidAfter(1, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(1), false);
316         map.addValidAfter(2, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(2), false);
317         map.addValidAfter(3, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(3), false);
318         map.addValidAfter(4, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(4), false);
319         map.addValidAfter(5, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(5), false);
320         Assert.assertEquals(6, map.getSpansNumber());
321         map.addValidBetween(-1, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(2), AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(4));
322         Assert.assertEquals(5, map.getSpansNumber());
323         Assert.assertEquals( 0, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(0.99)).intValue());
324         Assert.assertEquals( 1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(1.01)).intValue());
325         Assert.assertEquals( 1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(1.99)).intValue());
326         Assert.assertEquals(-1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(2.01)).intValue());
327         Assert.assertEquals(-1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(3.99)).intValue());
328         Assert.assertEquals( 4, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(4.01)).intValue());
329         Assert.assertEquals( 4, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(4.99)).intValue());
330         Assert.assertEquals( 5, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(5.01)).intValue());
331         checkCountConsistency(map);
332     }
333 
334     @Test
335     public void testExtractRangeInfinity() {
336         final AbsoluteDate ref = AbsoluteDate.J2000_EPOCH;
337         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
338         map.addValidAfter(Integer.valueOf(10), ref.shiftedBy(10.0), false);
339         map.addValidAfter(Integer.valueOf( 3), ref.shiftedBy( 2.0), false);
340         map.addValidAfter(Integer.valueOf( 9), ref.shiftedBy( 5.0), false);
341         map.addValidBefore(Integer.valueOf( 2), ref.shiftedBy( 3.0), false);
342         map.addValidBefore(Integer.valueOf( 5), ref.shiftedBy( 9.0), false);
343         TimeSpanMap<Integer> range = map.extractRange(AbsoluteDate.PAST_INFINITY, AbsoluteDate.FUTURE_INFINITY);
344         Assert.assertEquals(map.getSpansNumber(), range.getSpansNumber());
345         checkCountConsistency(map);
346     }
347 
348     @Test
349     public void testExtractRangeSingleEntry() {
350         final AbsoluteDate ref = AbsoluteDate.J2000_EPOCH;
351         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
352         map.addValidAfter(Integer.valueOf(10), ref.shiftedBy(10.0), false);
353         map.addValidAfter(Integer.valueOf( 3), ref.shiftedBy( 2.0), false);
354         map.addValidAfter(Integer.valueOf( 9), ref.shiftedBy( 5.0), false);
355         map.addValidBefore(Integer.valueOf( 2), ref.shiftedBy( 3.0), false);
356         map.addValidBefore(Integer.valueOf( 5), ref.shiftedBy( 9.0), false);
357         TimeSpanMap<Integer> range = map.extractRange(ref.shiftedBy(6), ref.shiftedBy(8));
358         Assert.assertEquals(1, range.getSpansNumber());
359         Assert.assertEquals(5, range.get(ref.shiftedBy(-10000)).intValue());
360         Assert.assertEquals(5, range.get(ref.shiftedBy(+10000)).intValue());
361         checkCountConsistency(map);
362     }
363 
364     @Test
365     public void testExtractFromPastInfinity() {
366         final AbsoluteDate ref = AbsoluteDate.J2000_EPOCH;
367         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
368         map.addValidAfter(Integer.valueOf(10), ref.shiftedBy(10.0), false);
369         map.addValidAfter(Integer.valueOf( 3), ref.shiftedBy( 2.0), false);
370         map.addValidAfter(Integer.valueOf( 9), ref.shiftedBy( 5.0), false);
371         map.addValidBefore(Integer.valueOf( 2), ref.shiftedBy( 3.0), false);
372         map.addValidBefore(Integer.valueOf( 5), ref.shiftedBy( 9.0), false);
373         TimeSpanMap<Integer> range = map.extractRange(AbsoluteDate.PAST_INFINITY, ref.shiftedBy(8));
374         Assert.assertEquals(4, range.getSpansNumber());
375         Assert.assertEquals( 0, range.get(ref.shiftedBy( -1.0)).intValue());
376         Assert.assertEquals( 0, range.get(ref.shiftedBy(  1.9)).intValue());
377         Assert.assertEquals( 2, range.get(ref.shiftedBy(  2.1)).intValue());
378         Assert.assertEquals( 2, range.get(ref.shiftedBy(  2.9)).intValue());
379         Assert.assertEquals( 3, range.get(ref.shiftedBy(  3.1)).intValue());
380         Assert.assertEquals( 3, range.get(ref.shiftedBy(  4.9)).intValue());
381         Assert.assertEquals( 5, range.get(ref.shiftedBy(  5.1)).intValue());
382         Assert.assertEquals( 5, range.get(ref.shiftedBy(  8.9)).intValue());
383         Assert.assertEquals( 5, range.get(ref.shiftedBy(  9.1)).intValue());
384         Assert.assertEquals( 5, range.get(ref.shiftedBy( 99.0)).intValue());
385         checkCountConsistency(map);
386     }
387 
388     @Test
389     public void testExtractToFutureInfinity() {
390         final AbsoluteDate ref = AbsoluteDate.J2000_EPOCH;
391         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
392         map.addValidAfter(Integer.valueOf(10), ref.shiftedBy(10.0), false);
393         map.addValidAfter(Integer.valueOf( 3), ref.shiftedBy( 2.0), false);
394         map.addValidAfter(Integer.valueOf( 9), ref.shiftedBy( 5.0), false);
395         map.addValidBefore(Integer.valueOf( 2), ref.shiftedBy( 3.0), false);
396         map.addValidBefore(Integer.valueOf( 5), ref.shiftedBy( 9.0), false);
397         TimeSpanMap<Integer> range = map.extractRange(ref.shiftedBy(4), AbsoluteDate.FUTURE_INFINITY);
398         Assert.assertEquals(4, range.getSpansNumber());
399         Assert.assertEquals( 3, range.get(ref.shiftedBy(-99.0)).intValue());
400         Assert.assertEquals( 3, range.get(ref.shiftedBy(  4.9)).intValue());
401         Assert.assertEquals( 5, range.get(ref.shiftedBy(  5.1)).intValue());
402         Assert.assertEquals( 5, range.get(ref.shiftedBy(  8.9)).intValue());
403         Assert.assertEquals( 9, range.get(ref.shiftedBy(  9.1)).intValue());
404         Assert.assertEquals( 9, range.get(ref.shiftedBy(  9.9)).intValue());
405         Assert.assertEquals(10, range.get(ref.shiftedBy( 10.1)).intValue());
406         Assert.assertEquals(10, range.get(ref.shiftedBy(100.0)).intValue());
407         checkCountConsistency(map);
408     }
409 
410     @Test
411     public void testExtractIntermediate() {
412         final AbsoluteDate ref = AbsoluteDate.J2000_EPOCH;
413         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
414         map.addValidAfter(Integer.valueOf(10), ref.shiftedBy(10.0), false);
415         map.addValidAfter(Integer.valueOf( 3), ref.shiftedBy( 2.0), false);
416         map.addValidAfter(Integer.valueOf( 9), ref.shiftedBy( 5.0), false);
417         map.addValidBefore(Integer.valueOf( 2), ref.shiftedBy( 3.0), false);
418         map.addValidBefore(Integer.valueOf( 5), ref.shiftedBy( 9.0), false);
419         TimeSpanMap<Integer> range = map.extractRange(ref.shiftedBy(4), ref.shiftedBy(8));
420         Assert.assertEquals(2, range.getSpansNumber());
421         Assert.assertEquals( 3, range.get(ref.shiftedBy(-99.0)).intValue());
422         Assert.assertEquals( 3, range.get(ref.shiftedBy(  4.9)).intValue());
423         Assert.assertEquals( 5, range.get(ref.shiftedBy(  5.1)).intValue());
424         Assert.assertEquals( 5, range.get(ref.shiftedBy(  8.9)).intValue());
425         Assert.assertEquals( 5, range.get(ref.shiftedBy(  9.1)).intValue());
426         Assert.assertEquals( 5, range.get(ref.shiftedBy(999.9)).intValue());
427         checkCountConsistency(map);
428     }
429 
430     @Test
431     public void testSpanToTransitionLinkEmpty() {
432         TimeSpanMap.Span<Integer> span = new TimeSpanMap<>(1).getSpan(AbsoluteDate.ARBITRARY_EPOCH);
433         Assert.assertEquals(1, span.getData().intValue());
434         Assert.assertSame(AbsoluteDate.PAST_INFINITY, span.getStart());
435         Assert.assertNull(span.getStartTransition());
436         Assert.assertSame(AbsoluteDate.FUTURE_INFINITY, span.getEnd());
437         Assert.assertNull(span.getEndTransition());
438     }
439 
440     @Test
441     public void testSpanToTransitionLink() {
442         final AbsoluteDate ref = AbsoluteDate.ARBITRARY_EPOCH;
443         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
444         map.addValidAfter(Integer.valueOf(10), ref.shiftedBy(10.0), false);
445         map.addValidAfter(Integer.valueOf( 3), ref.shiftedBy( 2.0), false);
446         map.addValidAfter(Integer.valueOf( 9), ref.shiftedBy( 5.0), false);
447         map.addValidBefore(Integer.valueOf( 2), ref.shiftedBy( 3.0), false);
448         map.addValidBefore(Integer.valueOf( 5), ref.shiftedBy( 9.0), false);
449 
450         TimeSpanMap.Span<Integer> first = map.getSpan(ref.shiftedBy(-99.0));
451         Assert.assertEquals(0, first.getData().intValue());
452         Assert.assertSame(AbsoluteDate.PAST_INFINITY, first.getStart());
453         Assert.assertNull(first.getStartTransition());
454         Assert.assertEquals(2.0, first.getEnd().durationFrom(ref), 1.0e-15);
455         Assert.assertNotNull(first.getEndTransition());
456 
457         TimeSpanMap.Span<Integer> middle = map.getSpan(ref.shiftedBy(6.0));
458         Assert.assertEquals(5, middle.getData().intValue());
459         Assert.assertEquals(5.0, middle.getStart().durationFrom(ref), 1.0e-15);
460         Assert.assertNotNull(middle.getStartTransition());
461         Assert.assertEquals(9.0, middle.getEnd().durationFrom(ref), 1.0e-15);
462         Assert.assertNotNull(middle.getEndTransition());
463         Assert.assertSame(middle.getStartTransition().getAfter(), middle.getEndTransition().getBefore());
464         Assert.assertEquals(3, middle.getStartTransition().getBefore().intValue());
465         Assert.assertEquals(5, middle.getStartTransition().getAfter().intValue());
466         Assert.assertEquals(5, middle.getEndTransition().getBefore().intValue());
467         Assert.assertEquals(9, middle.getEndTransition().getAfter().intValue());
468 
469         TimeSpanMap.Span<Integer> last = map.getSpan(ref.shiftedBy(+99.0));
470         Assert.assertEquals(10, last.getData().intValue());
471         Assert.assertEquals(10.0, last.getStart().durationFrom(ref), 1.0e-15);
472         Assert.assertNotNull(last.getStartTransition());
473         Assert.assertSame(AbsoluteDate.FUTURE_INFINITY, last.getEnd());
474         Assert.assertNull(last.getEndTransition());
475 
476         checkCountConsistency(map);
477 
478     }
479 
480     @Test
481     public void testTransitionToSpanLink() {
482         final AbsoluteDate ref = AbsoluteDate.ARBITRARY_EPOCH;
483         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
484         map.addValidAfter(Integer.valueOf(10), ref.shiftedBy(10.0), false);
485         map.addValidAfter(Integer.valueOf( 3), ref.shiftedBy( 2.0), false);
486         map.addValidAfter(Integer.valueOf( 9), ref.shiftedBy( 5.0), false);
487         map.addValidBefore(Integer.valueOf( 2), ref.shiftedBy( 3.0), false);
488         map.addValidBefore(Integer.valueOf( 5), ref.shiftedBy( 9.0), false);
489 
490         TimeSpanMap.Transition<Integer> first = map.getSpan(ref.shiftedBy(-99.0)).getEndTransition();
491         Assert.assertEquals(2.0, first.getDate().durationFrom(ref), 1.0e-15);
492         Assert.assertEquals(0, first.getBefore().intValue());
493         Assert.assertEquals(2, first.getAfter().intValue());
494 
495         TimeSpanMap.Transition<Integer> middle = map.getSpan(ref.shiftedBy(6.0)).getStartTransition();
496         Assert.assertEquals( 5.0, middle.getDate().durationFrom(ref), 1.0e-15);
497         Assert.assertEquals( 3, middle.getBefore().intValue());
498         Assert.assertEquals( 5, middle.getAfter().intValue());
499 
500         TimeSpanMap.Transition<Integer> last = map.getSpan(ref.shiftedBy(+99.0)).getStartTransition();
501         Assert.assertEquals(10.0, last.getDate().durationFrom(ref), 1.0e-15);
502         Assert.assertEquals( 9, last.getBefore().intValue());
503         Assert.assertEquals(10, last.getAfter().intValue());
504 
505         checkCountConsistency(map);
506 
507     }
508 
509     @Test
510     public void tesFirstLastEmpty() {
511         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
512         Assert.assertNull(map.getFirstTransition());
513         Assert.assertNull(map.getLastTransition());
514         Assert.assertSame(map.getFirstSpan(), map.getLastSpan());
515         Assert.assertNull(map.getFirstSpan().getStartTransition());
516         Assert.assertNull(map.getFirstSpan().getEndTransition());
517         Assert.assertNull(map.getFirstSpan().previous());
518         Assert.assertNull(map.getLastSpan().next());
519         checkCountConsistency(map);
520     }
521 
522     @Test
523     public void testSpansNavigation() {
524         final AbsoluteDate ref = AbsoluteDate.ARBITRARY_EPOCH;
525         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
526         map.addValidAfter(Integer.valueOf(10), ref.shiftedBy(10.0), false);
527         map.addValidAfter(Integer.valueOf( 3), ref.shiftedBy( 2.0), false);
528         map.addValidAfter(Integer.valueOf( 9), ref.shiftedBy( 5.0), false);
529         map.addValidBefore(Integer.valueOf( 2), ref.shiftedBy( 3.0), false);
530         map.addValidBefore(Integer.valueOf( 5), ref.shiftedBy( 9.0), false);
531         Assert.assertNull(map.getFirstSpan().previous());
532         Assert.assertNull(map.getLastSpan().next());
533 
534         TimeSpanMap.Span<Integer> span = map.getFirstSpan();
535         Assert.assertEquals(0, span.getData().intValue());
536         span = span.next();
537         Assert.assertEquals(2, span.getData().intValue());
538         span = span.next();
539         Assert.assertEquals(3, span.getData().intValue());
540         span = span.next();
541         Assert.assertEquals(5, span.getData().intValue());
542         span = span.next();
543         Assert.assertEquals(9, span.getData().intValue());
544         span = span.next();
545         Assert.assertEquals(10, span.getData().intValue());
546         Assert.assertNull(span.next());
547         span = span.previous();
548         Assert.assertEquals(9, span.getData().intValue());
549         span = span.previous();
550         Assert.assertEquals(5, span.getData().intValue());
551         span = span.previous();
552         Assert.assertEquals(3, span.getData().intValue());
553         span = span.previous();
554         Assert.assertEquals(2, span.getData().intValue());
555         span = span.previous();
556         Assert.assertEquals(0, span.getData().intValue());
557         Assert.assertNull(span.previous());
558 
559         checkCountConsistency(map);
560 
561     }
562 
563     @Test
564     public void testTransitionsNavigation() {
565         final AbsoluteDate ref = AbsoluteDate.ARBITRARY_EPOCH;
566         TimeSpanMap<Integer> map = new TimeSpanMap<>(Integer.valueOf(0));
567         map.addValidAfter(Integer.valueOf(10), ref.shiftedBy(10.0), false);
568         map.addValidAfter(Integer.valueOf( 3), ref.shiftedBy( 2.0), false);
569         map.addValidAfter(Integer.valueOf( 9), ref.shiftedBy( 5.0), false);
570         map.addValidBefore(Integer.valueOf( 2), ref.shiftedBy( 3.0), false);
571         map.addValidBefore(Integer.valueOf( 5), ref.shiftedBy( 9.0), false);
572 
573         Assert.assertEquals( 2.0, map.getFirstTransition().getDate().durationFrom(ref), 1.0e-15);
574         Assert.assertEquals(10.0, map.getLastTransition().getDate().durationFrom(ref), 1.0e-15);
575 
576         Transition<Integer> transition = map.getLastTransition();
577         Assert.assertEquals(10.0, transition.getDate().durationFrom(ref), 1.0e-15);
578         transition = transition.previous();
579         Assert.assertEquals( 9.0, transition.getDate().durationFrom(ref), 1.0e-15);
580         transition = transition.previous();
581         Assert.assertEquals( 5.0, transition.getDate().durationFrom(ref), 1.0e-15);
582         transition = transition.previous();
583         Assert.assertEquals( 3.0, transition.getDate().durationFrom(ref), 1.0e-15);
584         transition = transition.previous();
585         Assert.assertEquals( 2.0, transition.getDate().durationFrom(ref), 1.0e-15);
586         Assert.assertNull(transition.previous());
587         transition = transition.next();
588         Assert.assertEquals( 3.0, transition.getDate().durationFrom(ref), 1.0e-15);
589         transition = transition.next();
590         Assert.assertEquals( 5.0, transition.getDate().durationFrom(ref), 1.0e-15);
591         transition = transition.next();
592         Assert.assertEquals( 9.0, transition.getDate().durationFrom(ref), 1.0e-15);
593         transition = transition.next();
594         Assert.assertEquals(10.0, transition.getDate().durationFrom(ref), 1.0e-15);
595         Assert.assertNull(transition.next());
596 
597         checkCountConsistency(map);
598 
599     }
600 
601     @Test
602     public void testDuplicatedBeforeAfterAtEnd() {
603         TimeSpanMap<Integer> map = new TimeSpanMap<>(null);
604         map.addValidBefore(-1, AbsoluteDate.ARBITRARY_EPOCH, false);
605         map.addValidAfter(+1, AbsoluteDate.ARBITRARY_EPOCH, false);
606         Assert.assertEquals(2, map.getSpansNumber());
607         Assert.assertEquals(-1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-1)).intValue());
608         Assert.assertEquals(+1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(+1)).intValue());
609         checkCountConsistency(map);
610     }
611 
612     @Test
613     public void testDuplicatedBeforeAfterMiddle() {
614         TimeSpanMap<Integer> map = new TimeSpanMap<>(null);
615         map.addValidBefore(-2, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-2), false);
616         map.addValidAfter(+2, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(+2), false);
617         map.addValidBefore(-1, AbsoluteDate.ARBITRARY_EPOCH, false);
618         map.addValidAfter(+1, AbsoluteDate.ARBITRARY_EPOCH, false);
619         Assert.assertEquals(4, map.getSpansNumber());
620         Assert.assertEquals(-1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-1)).intValue());
621         Assert.assertEquals(+1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(+1)).intValue());
622         checkCountConsistency(map);
623     }
624 
625     @Test
626     public void testDuplicatedBeforeBefore() {
627         TimeSpanMap<Integer> map = new TimeSpanMap<>(null);
628         map.addValidBefore(-2, AbsoluteDate.ARBITRARY_EPOCH, false); // first call at ARBITRARY_EPOCH
629         map.addValidAfter(0, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-2), false);
630         map.addValidBefore(-1, AbsoluteDate.ARBITRARY_EPOCH, false); // second call at ARBITRARY_EPOCH
631         Assert.assertEquals(3, map.getSpansNumber());
632         Assert.assertEquals(-2, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-10)).intValue());
633         Assert.assertEquals(-1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-1)).intValue());
634         Assert.assertNull(map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(+1)));
635         checkCountConsistency(map);
636     }
637 
638     @Test
639     public void testDuplicatedAfterBeforeAtEnd() {
640         TimeSpanMap<Integer> map = new TimeSpanMap<>(null);
641         map.addValidAfter(+1, AbsoluteDate.ARBITRARY_EPOCH, false);
642         map.addValidBefore(-1, AbsoluteDate.ARBITRARY_EPOCH, false);
643         Assert.assertEquals(2, map.getSpansNumber());
644         Assert.assertEquals(-1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-1)).intValue());
645         Assert.assertEquals(+1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(+1)).intValue());
646         checkCountConsistency(map);
647     }
648 
649     @Test
650     public void testDuplicatedAfterBeforeMiddle() {
651         TimeSpanMap<Integer> map = new TimeSpanMap<>(null);
652         map.addValidBefore(-2, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-2), false);
653         map.addValidAfter(+2, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(+2), false);
654         map.addValidAfter(+1, AbsoluteDate.ARBITRARY_EPOCH, false);
655         map.addValidBefore(-1, AbsoluteDate.ARBITRARY_EPOCH, false);
656         Assert.assertEquals(4, map.getSpansNumber());
657         Assert.assertEquals(-1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-1)).intValue());
658         Assert.assertEquals(+1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(+1)).intValue());
659         checkCountConsistency(map);
660     }
661 
662     @Test
663     public void testDuplicatedAfterAfter() {
664         TimeSpanMap<Integer> map = new TimeSpanMap<>(null);
665         map.addValidAfter(+2, AbsoluteDate.ARBITRARY_EPOCH, false); // first call at ARBITRARY_EPOCH
666         map.addValidBefore(0, AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(+2), false);
667         map.addValidAfter(+1, AbsoluteDate.ARBITRARY_EPOCH, false); // second call at ARBITRARY_EPOCH
668         Assert.assertEquals(3, map.getSpansNumber());
669         Assert.assertNull(map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-1)));
670         Assert.assertEquals(+1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(+1)).intValue());
671         Assert.assertEquals(+2, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(+10)).intValue());
672         checkCountConsistency(map);
673     }
674 
675     @Test
676     public void testValidAllTime() {
677         AbsoluteDate ref = AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(1);
678         TimeSpanMap<Integer> map = new TimeSpanMap<>(0);
679 
680         // action
681         map.addValidAfter(1, ref, false);
682         map.addValidBefore(2, ref, false);
683 
684         // verify
685         Assert.assertEquals(1, (int) map.get(ref.shiftedBy(1)));
686         Assert.assertEquals(2, (int) map.get(ref.shiftedBy(-1)));
687         Assert.assertEquals(1, (int) map.get(ref));
688     }
689 
690     @Test
691     public void testBetweenPastInfinity() {
692         TimeSpanMap<Integer> map = new TimeSpanMap<>(null);
693         Assert.assertEquals(1, map.getSpansNumber());
694         map.addValidBetween(1, AbsoluteDate.PAST_INFINITY, AbsoluteDate.ARBITRARY_EPOCH);
695         Assert.assertEquals(2, map.getSpansNumber());
696         Assert.assertEquals(1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-1)).intValue());
697         Assert.assertNull(map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(+1)));
698     }
699 
700     @Test
701     public void testBetweenFutureInfinity() {
702         TimeSpanMap<Integer> map = new TimeSpanMap<>(null);
703         Assert.assertEquals(1, map.getSpansNumber());
704         map.addValidBetween(1, AbsoluteDate.ARBITRARY_EPOCH, AbsoluteDate.FUTURE_INFINITY);
705         Assert.assertEquals(2, map.getSpansNumber());
706         Assert.assertNull(map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(-1)));
707         Assert.assertEquals(1, map.get(AbsoluteDate.ARBITRARY_EPOCH.shiftedBy(+1)).intValue());
708     }
709 
710     @Test
711     public void testBetweenBothInfinity() {
712         TimeSpanMap<Integer> map = new TimeSpanMap<>(null);
713         Assert.assertEquals(1, map.getSpansNumber());
714         map.addValidBetween(1, AbsoluteDate.PAST_INFINITY, AbsoluteDate.FUTURE_INFINITY);
715         Assert.assertEquals(1, map.getSpansNumber());
716         Assert.assertEquals(1, map.get(AbsoluteDate.ARBITRARY_EPOCH).intValue());
717     }
718 
719     private <T> void checkCountConsistency(final TimeSpanMap<T> map) {
720         final int count1 = map.getSpansNumber();
721         int count2 = 0;
722         for (Span<T> span = map.getFirstSpan(); span != null; span = span.next()) {
723             ++count2;
724         }
725         Assert.assertEquals(count1, count2);
726     }
727 
728     @Before
729     public void setUp() {
730         Utils.setDataRoot("regular-data");
731     }
732 
733 }