Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2010 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.google.common.collect.testing.testers;
 
 import static com.google.common.collect.testing.features.CollectionSize.ONE;
 import static com.google.common.collect.testing.features.CollectionSize.SEVERAL;
 import static com.google.common.collect.testing.features.CollectionSize.ZERO;
 import static org.truth0.Truth.ASSERT;
 
 
 import java.util.List;
A generic JUnit test which tests operations on a SortedMap. Can't be invoked directly; please see SortedMapTestSuiteBuilder.

Author(s):
Jesse Wilson
Louis Wasserman
 
 public class SortedMapNavigationTester<K, V> extends AbstractMapTester<K, V> {
 
   private SortedMap<K, V> navigableMap;
   private Entry<K, V> a;
   private Entry<K, V> c;
 
   @Override public void setUp() throws Exception {
     super.setUp();
      = (SortedMap<K, V>) getMap();
     List<Entry<K, V>> entries = Helpers.copyToList(getSubjectGenerator().getSampleElements(
     Collections.sort(entries, Helpers.<K, V>entryComparator(.comparator()));
 
     // some tests assume SEVERAL == 3
     if (entries.size() >= 1) {
        = entries.get(0);
       if (entries.size() >= 3) {
          = entries.get(2);
       }
     }
   }
 
   public void testEmptyMapFirst() {
     try {
       .firstKey();
       fail();
     } catch (NoSuchElementException e) {
     }
   }
 
   public void testEmptyMapLast() {
     try {
       fail();
     } catch (NoSuchElementException e) {
     }
   }
 
   public void testSingletonMapFirst() {
   }
 
   public void testSingletonMapLast() {
   }
 
   public void testFirst() {
   }
 
  public void testLast() {
  }
  
  @CollectionSize.Require(absent = )
  public void testHeadMapExclusive() {
  }
  
  @CollectionSize.Require(absent = )
  public void testTailMapInclusive() {
  }
  
  public void testHeadMap() {
    List<Entry<K, V>> entries = Helpers.copyToList(getSubjectGenerator().getSampleElements(
    Collections.sort(entries, Helpers.<K, V>entryComparator(.comparator()));
    for (int i = 0; i < entries.size(); i++) {
      .that(.headMap(entries.get(i).getKey()).entrySet())
          .iteratesAs(entries.subList(0, i));
    }
  }
  
  public void testTailMap() {
    List<Entry<K, V>> entries = Helpers.copyToList(getSubjectGenerator().getSampleElements(
    Collections.sort(entries, Helpers.<K, V>entryComparator(.comparator()));
    for (int i = 0; i < entries.size(); i++) {
      .that(.tailMap(entries.get(i).getKey()).entrySet())
          .iteratesAs(entries.subList(ientries.size()));
    }
  }
  
  public void testSubMap() {
    List<Entry<K, V>> entries = Helpers.copyToList(getSubjectGenerator().getSampleElements(
    Collections.sort(entries, Helpers.<K, V>entryComparator(.comparator()));
    for (int i = 0; i < entries.size(); i++) {
      for (int j = i + 1; j < entries.size(); j++) {
        .that(
                 .subMap(entries.get(i).getKey(), entries.get(j).getKey())
                 .entrySet())
            .iteratesAs(entries.subList(ij)); 
      }
    }
  }
  
  public void testSubMapIllegal() {
    try {
      .subMap(.getKey(), .getKey());
      fail("Expected IllegalArgumentException");
    } catch (IllegalArgumentException expected) {}
  }
  
  @CollectionSize.Require(absent = )
  public void testOrderedByComparator() {
    @SuppressWarnings("unchecked")
    Comparator<? super K> comparator = .comparator();
    if (comparator == null) {
      comparator = new Comparator<K>() {
        @SuppressWarnings("unchecked")
        @Override
        public int compare(K o1, K o2) {
          return ((Comparableo1).compareTo(o2);
        }
      };
    }
    Iterator<Entry<K, V>> entryItr = .entrySet().iterator();
    Entry<K, V> prevEntry = entryItr.next();
    while (entryItr.hasNext()) {
      Entry<K, V> nextEntry = entryItr.next();
      assertTrue(comparator.compare(prevEntry.getKey(), nextEntry.getKey()) < 0);
      prevEntry = nextEntry;
    }
  }
New to GrepCode? Check out our FAQ X