View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF 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.apache.commons.collections4.bidimap;
18  
19  import java.util.ArrayList;
20  import java.util.Collections;
21  import java.util.Iterator;
22  import java.util.List;
23  import java.util.Map;
24  import java.util.NoSuchElementException;
25  
26  import org.apache.commons.collections4.BulkTest;
27  import org.apache.commons.collections4.MapIterator;
28  import org.apache.commons.collections4.OrderedBidiMap;
29  import org.apache.commons.collections4.iterators.AbstractMapIteratorTest;
30  
31  /**
32   * Abstract test class for {@link OrderedBidiMap} methods and contracts.
33   *
34   */
35  public abstract class AbstractOrderedBidiMapTest<K, V> extends AbstractBidiMapTest<K, V> {
36  
37      public AbstractOrderedBidiMapTest(final String testName) {
38          super(testName);
39      }
40  
41      public AbstractOrderedBidiMapTest() {
42          super();
43      }
44  
45      //-----------------------------------------------------------------------
46      public void testFirstKey() {
47          resetEmpty();
48          OrderedBidiMap<K, V> bidi = getMap();
49          try {
50              bidi.firstKey();
51              fail();
52          } catch (final NoSuchElementException ex) {}
53  
54          resetFull();
55          bidi = getMap();
56          final K confirmedFirst = confirmed.keySet().iterator().next();
57          assertEquals(confirmedFirst, bidi.firstKey());
58      }
59  
60      public void testLastKey() {
61          resetEmpty();
62          OrderedBidiMap<K, V> bidi = getMap();
63          try {
64              bidi.lastKey();
65              fail();
66          } catch (final NoSuchElementException ex) {}
67  
68          resetFull();
69          bidi = getMap();
70          K confirmedLast = null;
71          for (final Iterator<K> it = confirmed.keySet().iterator(); it.hasNext();) {
72              confirmedLast = it.next();
73          }
74          assertEquals(confirmedLast, bidi.lastKey());
75      }
76  
77      //-----------------------------------------------------------------------
78      public void testNextKey() {
79          resetEmpty();
80          OrderedBidiMap<K, V> bidi = (OrderedBidiMap<K, V>) map;
81          assertEquals(null, bidi.nextKey(getOtherKeys()[0]));
82          if (!isAllowNullKey()) {
83              try {
84                  assertEquals(null, bidi.nextKey(null)); // this is allowed too
85              } catch (final NullPointerException ex) {}
86          } else {
87              assertEquals(null, bidi.nextKey(null));
88          }
89  
90          resetFull();
91          bidi = (OrderedBidiMap<K, V>) map;
92          final Iterator<K> it = confirmed.keySet().iterator();
93          K confirmedLast = it.next();
94          while (it.hasNext()) {
95              final K confirmedObject = it.next();
96              assertEquals(confirmedObject, bidi.nextKey(confirmedLast));
97              confirmedLast = confirmedObject;
98          }
99          assertEquals(null, bidi.nextKey(confirmedLast));
100 
101         if (!isAllowNullKey()) {
102             try {
103                 bidi.nextKey(null);
104                 fail();
105             } catch (final NullPointerException ex) {}
106         } else {
107             assertEquals(null, bidi.nextKey(null));
108         }
109     }
110 
111     public void testPreviousKey() {
112         resetEmpty();
113         OrderedBidiMap<K, V> bidi = getMap();
114         assertEquals(null, bidi.previousKey(getOtherKeys()[0]));
115         if (!isAllowNullKey()) {
116             try {
117                 assertEquals(null, bidi.previousKey(null)); // this is allowed too
118             } catch (final NullPointerException ex) {}
119         } else {
120             assertEquals(null, bidi.previousKey(null));
121         }
122 
123         resetFull();
124         bidi = getMap();
125         final List<K> list = new ArrayList<>(confirmed.keySet());
126         Collections.reverse(list);
127         final Iterator<K> it = list.iterator();
128         K confirmedLast = it.next();
129         while (it.hasNext()) {
130             final K confirmedObject = it.next();
131             assertEquals(confirmedObject, bidi.previousKey(confirmedLast));
132             confirmedLast = confirmedObject;
133         }
134         assertEquals(null, bidi.previousKey(confirmedLast));
135 
136         if (!isAllowNullKey()) {
137             try {
138                 bidi.previousKey(null);
139                 fail();
140             } catch (final NullPointerException ex) {}
141         } else {
142             assertEquals(null, bidi.previousKey(null));
143         }
144     }
145 
146     //-----------------------------------------------------------------------
147     public BulkTest bulkTestOrderedMapIterator() {
148         return new TestBidiOrderedMapIterator();
149     }
150 
151     /**
152      * {@inheritDoc}
153      */
154     @Override
155     public OrderedBidiMap<K, V> getMap() {
156         return (OrderedBidiMap<K, V>) super.getMap();
157     }
158 
159     public class TestBidiOrderedMapIterator extends AbstractMapIteratorTest<K, V> {
160         public TestBidiOrderedMapIterator() {
161             super("TestBidiOrderedMapIterator");
162         }
163 
164         @Override
165         public V[] addSetValues() {
166             return AbstractOrderedBidiMapTest.this.getNewSampleValues();
167         }
168 
169         @Override
170         public boolean supportsRemove() {
171             return AbstractOrderedBidiMapTest.this.isRemoveSupported();
172         }
173 
174         @Override
175         public boolean supportsSetValue() {
176             return AbstractOrderedBidiMapTest.this.isSetValueSupported();
177         }
178 
179         @Override
180         public MapIterator<K, V> makeEmptyIterator() {
181             resetEmpty();
182             return AbstractOrderedBidiMapTest.this.getMap().mapIterator();
183         }
184 
185         @Override
186         public MapIterator<K, V> makeObject() {
187             resetFull();
188             return AbstractOrderedBidiMapTest.this.getMap().mapIterator();
189         }
190 
191         @Override
192         public Map<K, V> getMap() {
193             // assumes makeFullMapIterator() called first
194             return AbstractOrderedBidiMapTest.this.map;
195         }
196 
197         @Override
198         public Map<K, V> getConfirmedMap() {
199             // assumes makeFullMapIterator() called first
200             return AbstractOrderedBidiMapTest.this.confirmed;
201         }
202 
203         @Override
204         public void verify() {
205             super.verify();
206             AbstractOrderedBidiMapTest.this.verify();
207         }
208     }
209 
210 }