IntervalTest


1   /* This file is part of SableCC ( http://sablecc.org ).
2    *
3    * Copyright 2007 Raymond Audet <raymond.audet@gmail.com>
4    * Copyright 2007 Etienne M. Gagnon <egagnon@j-meg.com>
5    *
6    * Licensed under the Apache License, Version 2.0 (the "License");
7    * you may not use this file except in compliance with the License.
8    * You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
17   */
18  
19  package org.sablecc.sablecc.alphabet;
20  
21  import static org.junit.Assert.assertEquals;
22  import static org.junit.Assert.assertFalse;
23  import static org.junit.Assert.assertNull;
24  import static org.junit.Assert.assertTrue;
25  import static org.junit.Assert.fail;
26  
27  import java.math.BigInteger  ;
28  import java.util.Random  ;
29  
30  import org.junit.Before;
31  import org.junit.Test;
32  import org.sablecc.sablecc.exception.InternalException;
33  
34  public class IntervalTest {
35  
36      private Interval<Integer  > intervalInt;
37  
38      private Interval<BigInteger  > intervalBig;
39  
40      @Before
41      public void setUp()
42              throws Exception   {
43  
44          this.intervalInt = Realms.getInteger().createInterval(10, 20);
45          this.intervalBig = Realms.getBigInteger().createInterval(
46                  new BigInteger  ("100"), new BigInteger  ("200"));
47      }
48  
49      @Test
50      @SuppressWarnings  ("unused")
51      public void testIntervalTTAdjacencyRealmOfT() {
52  
53          assertEquals(10, this.intervalInt.getLowerBound());
54          assertEquals(20, this.intervalInt.getUpperBound());
55  
56          // Case with null bounds
57          try {
58  
59              Interval<Integer  > nullBoundInterval = new Interval<Integer  >(null,
60                      null);
61              fail("An InternalException should be thrown.");
62          }
63          catch (InternalException e) {
64              // expected
65          }
66  
67          // Case with incorrect bounds with Integer
68          try {
69              Interval<Integer  > wrongBoundInterval = new Interval<Integer  >(20,
70                      10, Realms.getInteger());
71              fail("An InternalException should be thrown.");
72          }
73          catch (InternalException e) {
74              // expected
75          }
76  
77          // Case with incorrect bounds with BigInteger
78          try {
79              Interval<BigInteger  > wrongBoundIntervalBig = new Interval<BigInteger  >(
80                      new BigInteger  ("9999"), BigInteger.ZERO, Realms
81                              .getBigInteger());
82              fail("An InternalException should be thrown.");
83          }
84          catch (InternalException e) {
85              // expected
86          }
87      }
88  
89      @Test
90      public void testIntervalTAdjacencyRealmOfT() {
91  
92          // With Integer
93          Interval<Integer  > oneBoundInterval = new Interval<Integer  >(10, Realms
94                  .getInteger());
95          assertTrue("The lower and upper bounds aren't and should be the same.",
96                  oneBoundInterval.getUpperBound() == oneBoundInterval
97                          .getLowerBound());
98  
99          // With BigInteger
100         Interval<BigInteger  > oneBoundIntervalBig = new Interval<BigInteger  >(
101                 new BigInteger  (1000, new Random  ()), Realms.getBigInteger());
102         assertTrue("The lower and upper bounds aren't and should be the same.",
103                 oneBoundIntervalBig.getUpperBound() == oneBoundIntervalBig
104                         .getLowerBound());
105     }
106 
107     @Test
108     public void testEqualsObject() {
109 
110         // Case when two interval are not of the same instance
111         assertFalse("The objects should not be comparable.", this.intervalInt
112                 .equals(new String  ()));
113 
114         // With Integer
115         Interval<Integer  > differentInterval = Realms.getInteger()
116                 .createInterval(10, 50);
117         Interval<Integer  > sameInterval = Realms.getInteger().createInterval(10,
118                 20);
119         assertFalse("The two intervals should not be equals.", this.intervalInt
120                 .equals(differentInterval));
121         assertTrue("The two intervals should be equals.", this.intervalInt
122                 .equals(sameInterval));
123 
124         // With BigInteger
125         Interval<BigInteger  > differentIntervalBig = Realms.getBigInteger()
126                 .createInterval(BigInteger.ONE,
127                         new BigInteger  (1000, new Random  ()));
128         Interval<BigInteger  > sameIntervalBig = Realms.getBigInteger()
129                 .createInterval(new BigInteger  ("100"), new BigInteger  ("200"));
130         assertFalse("The two intervals should not be equals.", this.intervalBig
131                 .equals(differentIntervalBig));
132         assertTrue("The two intervals should be equals.", this.intervalBig
133                 .equals(sameIntervalBig));
134     }
135 
136     @Test
137     public void testHashCode() {
138 
139         // With Integer
140         Interval<Integer  > sameIntervalInt = Realms.getInteger().createInterval(
141                 10, 20);
142         assertEquals(
143                 "Two instance of the same symbol should have the same hashcode",
144                 this.intervalInt.hashCode(), sameIntervalInt.hashCode());
145 
146         // With BigInteger
147         Interval<BigInteger  > sameIntervalBig = Realms.getBigInteger()
148                 .createInterval(new BigInteger  ("100"), new BigInteger  ("200"));
149         assertEquals(
150                 "Two instance of the same symbol should have the same hashcode",
151                 this.intervalBig.hashCode(), sameIntervalBig.hashCode());
152 
153     }
154 
155     @Test
156     public void testCompareTo() {
157 
158         // With Integer
159         Interval<Integer  > lowerInterval = Realms.getInteger().createInterval(0,
160                 10);
161         Interval<Integer  > greaterInterval = Realms.getInteger().createInterval(
162                 10, 50);
163 
164         assertTrue("intervalInt should be greater than lowerInterval.",
165                 this.intervalInt.compareTo(lowerInterval) > 0);
166         assertTrue("intervalInt should be lower than greaterInterval.",
167                 this.intervalInt.compareTo(greaterInterval) < 0);
168         assertTrue("The two intervals should be equals.", this.intervalInt
169                 .compareTo(this.intervalInt) == 0);
170 
171         // With BigInteger
172         Interval<BigInteger  > lowerIntervalBig = Realms.getBigInteger()
173                 .createInterval(BigInteger.ZERO, new BigInteger  ("400"));
174         Interval<BigInteger  > greaterIntervalBig = Realms
175                 .getBigInteger()
176                 .createInterval(new BigInteger  ("999"), new BigInteger  ("999999"));
177 
178         assertTrue("intervalBig should be greater than lowerIntervalBig.",
179                 this.intervalBig.compareTo(lowerIntervalBig) > 0);
180         assertTrue("intervalBig should be lower than greaterIntervalBig.",
181                 this.intervalBig.compareTo(greaterIntervalBig) < 0);
182         assertTrue("The two intervals should be equals.", this.intervalBig
183                 .compareTo(this.intervalBig) == 0);
184     }
185 
186     @Test
187     public void testIsAdjacentTo() {
188 
189         // Test with Integer
190         Interval<Integer  > adjacentInterval = Realms.getInteger()
191                 .createInterval(21, 40);
192         assertTrue("The two intervals should be adjacent.", this.intervalInt
193                 .isAdjacentTo(adjacentInterval));
194         assertFalse("The two intervals should not be adjacent.",
195                 this.intervalInt.isAdjacentTo(Realms.getInteger()
196                         .createInterval(200, 400)));
197 
198         // Implementation of AdjacencyRealm<BigInteger>
199 
200         // Test with BigInteger
201         Interval<BigInteger  > adjacentIntervalBig = Realms.getBigInteger()
202                 .createInterval(new BigInteger  ("201"), new BigInteger  ("999"));
203         assertTrue("The two intervals should be adjacent.", this.intervalBig
204                 .isAdjacentTo(adjacentIntervalBig));
205         assertFalse("The two intervals should not be adjacent.",
206                 this.intervalBig.isAdjacentTo(Realms.getBigInteger()
207                         .createInterval(BigInteger.ONE)));
208 
209     }
210 
211     @Test
212     public void testIntersects() {
213 
214         // With Integer
215         Interval<Integer  > intersectingInterval = Realms.getInteger()
216                 .createInterval(15, 50);
217         assertTrue("The two intervals should intersect.", this.intervalInt
218                 .intersects(intersectingInterval));
219         assertFalse("They should not intersect.", this.intervalInt
220                 .intersects(Realms.getInteger().createInterval(200)));
221 
222         // With BigInteger
223         Interval<BigInteger  > intersectingIntervalBig = Realms.getBigInteger()
224                 .createInterval(new BigInteger  ("150"));
225         assertTrue("The two intervals should intersect.", this.intervalBig
226                 .intersects(intersectingIntervalBig));
227         assertFalse("They should not intersect.", this.intervalBig
228                 .intersects(Realms.getBigInteger().createInterval(
229                         BigInteger.ZERO, BigInteger.TEN)));
230     }
231 
232     @Test
233     public void testIntersection() {
234 
235         // With Integer
236         Interval<Integer  > intersectingInterval = Realms.getInteger()
237                 .createInterval(15, 50);
238         Interval<Integer  > resultInterval = this.intervalInt
239                 .intersection(intersectingInterval);
240 
241         assertEquals("The lowerBound of the intersection should be 15.", 15,
242                 resultInterval.getLowerBound());
243         assertEquals("The upperBound of the intersection should be 20.", 20,
244                 resultInterval.getUpperBound());
245 
246         assertNull("No intersection expected.", this.intervalInt
247                 .intersection(Realms.getInteger().createInterval(40, 60)));
248 
249         // With BigInteger
250         Interval<BigInteger  > intersectingIntervalBig = Realms.getBigInteger()
251                 .createInterval(new BigInteger  ("150"), new BigInteger  ("9999"));
252         Interval<BigInteger  > resultIntervalBig = this.intervalBig
253                 .intersection(intersectingIntervalBig);
254 
255         assertEquals("The lowerBound of the intersection should be 150.",
256                 "150", resultIntervalBig.getLowerBound().toString());
257         assertEquals("The upperBound of the intersection should be 200.",
258                 "200", resultIntervalBig.getUpperBound().toString());
259 
260         assertNull("No intersection expected.", this.intervalBig
261                 .intersection(Realms.getBigInteger().createInterval(
262                         new BigInteger  (1000, new Random  ()))));
263     }
264 
265     @Test
266     public void testMergeWith() {
267 
268         // Test with Integer
269         Interval<Integer  > adjacentInterval = Realms.getInteger()
270                 .createInterval(21, 40);
271         Interval<Integer  > resultMerge = this.intervalInt
272                 .mergeWith(adjacentInterval);
273 
274         assertEquals(
275                 "The lower bound of the merging should be the lower bound of intervalInt.",
276                 this.intervalInt.getLowerBound(), resultMerge.getLowerBound());
277         assertEquals(
278                 "The upper bound of the merging should be the upper bound of adjacentInterval.",
279                 adjacentInterval.getUpperBound(), resultMerge.getUpperBound());
280 
281         try {
282             resultMerge = this.intervalInt.mergeWith(Realms.getInteger()
283                     .createInterval(999, 9999));
284             fail("An InternalException should be thrown because the two intervals are not adjacent.");
285         }
286         catch (InternalException e) {
287             // expected
288         }
289 
290         // With BigInteger
291         Interval<BigInteger  > adjacentIntervalBig = Realms.getBigInteger()
292                 .createInterval(new BigInteger  ("201"), new BigInteger  ("999"));
293         Interval<BigInteger  > resultMergeBig = this.intervalBig
294                 .mergeWith(adjacentIntervalBig);
295 
296         assertEquals(
297                 "The lower bound of the merging should be the lower bound of intervalBig.",
298                 this.intervalBig.getLowerBound(), resultMergeBig
299                         .getLowerBound());
300         assertEquals(
301                 "The upper bound of the merging should be the upper bound of adjacentIntervalBig.",
302                 adjacentIntervalBig.getUpperBound(), resultMergeBig
303                         .getUpperBound());
304 
305         try {
306             resultMergeBig = this.intervalBig.mergeWith(Realms.getBigInteger()
307                     .createInterval(BigInteger.ONE, BigInteger.TEN));
308             fail("An InternalException should be thrown because the two intervals are not adjacent.");
309         }
310         catch (InternalException e) {
311             // expected
312         }
313 
314     }
315 
316     @Test
317     public void testMin() {
318 
319         // With Integer
320         Interval<Integer  > lowerInterval = Realms.getInteger().createInterval(0,
321                 5);
322         Interval<Integer  > greaterInterval = Realms.getInteger().createInterval(
323                 50, 200);
324         Interval<Integer  > resultInterval = Interval.min(this.intervalInt,
325                 lowerInterval);
326 
327         assertTrue("The minimum should be lowerInterval.", lowerInterval
328                 .equals(resultInterval));
329 
330         resultInterval = Interval.min(this.intervalInt, greaterInterval);
331         assertTrue("The minimum should be intervalInt.", resultInterval
332                 .equals(this.intervalInt));
333 
334         // With BigInteger
335         Interval<BigInteger  > lowerIntervalBig = Realms.getBigInteger()
336                 .createInterval(BigInteger.ZERO, BigInteger.TEN);
337         Interval<BigInteger  > greaterIntervalBig = Realms.getBigInteger()
338                 .createInterval(new BigInteger  ("999"), new BigInteger  ("99999"));
339         Interval<BigInteger  > resultIntervalBig = Interval.min(this.intervalBig,
340                 lowerIntervalBig);
341 
342         assertTrue("The minimum should be lowerIntervalBig.", lowerIntervalBig
343                 .equals(resultIntervalBig));
344 
345         resultIntervalBig = Interval.min(this.intervalBig, greaterIntervalBig);
346         assertTrue("The minimum should be intervalBig.", this.intervalBig
347                 .equals(resultIntervalBig));
348     }
349 
350     @Test
351     public void testMax() {
352 
353         // With Integer
354         Interval<Integer  > lowerInterval = Realms.getInteger().createInterval(0,
355                 5);
356         Interval<Integer  > greaterInterval = Realms.getInteger().createInterval(
357                 50, 200);
358         Interval<Integer  > resultInterval = Interval.max(this.intervalInt,
359                 lowerInterval);
360 
361         assertTrue("The maximum should be intervalInt.", this.intervalInt
362                 .equals(resultInterval));
363 
364         resultInterval = Interval.max(this.intervalInt, greaterInterval);
365         assertTrue("The maximum should be greaterInterval.", greaterInterval
366                 .equals(resultInterval));
367 
368         // With BigInteger
369         Interval<BigInteger  > lowerIntervalBig = Realms.getBigInteger()
370                 .createInterval(BigInteger.ZERO, BigInteger.TEN);
371         Interval<BigInteger  > greaterIntervalBig = Realms.getBigInteger()
372                 .createInterval(new BigInteger  ("999"), new BigInteger  ("99999"));
373         Interval<BigInteger  > resultIntervalBig = Interval.max(this.intervalBig,
374                 lowerIntervalBig);
375 
376         assertTrue("The maximum should be intervalBig.", this.intervalBig
377                 .equals(resultIntervalBig));
378 
379         resultIntervalBig = Interval.max(this.intervalBig, greaterIntervalBig);
380         assertTrue("The maximum should be greaterIntervalBig.",
381                 greaterIntervalBig.equals(resultIntervalBig));
382     }
383 
384 }
385
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags