Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2011 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.google;
 
 import static com.google.common.collect.BoundType.CLOSED;
 import static com.google.common.collect.BoundType.OPEN;
 import static com.google.common.collect.testing.Helpers.copyToList;
 import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_ADD;
 import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_REMOVE;
 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 java.util.List;
Tester for navigation of SortedMultisets.

Author(s):
Louis Wasserman
 
 public class MultisetNavigationTester<E> extends AbstractMultisetTester<E> {
   private SortedMultiset<E> sortedMultiset;
   private List<E> entries;
   private Entry<E> a;
   private Entry<E> b;
   private Entry<E> c;

  
Used to avoid http://bugs.sun.com/view_bug.do?bug_id=6558557
 
   static <T> SortedMultiset<T> cast(Multiset<T> iterable) {
     return (SortedMultiset<T>) iterable;
   }
 
   @Override
   public void setUp() throws Exception {
     super.setUp();
      =
             getSubjectGenerator().getCollectionSize().getNumElements()));
     Collections.sort(.comparator());
 
     // some tests assume SEVERAL == 3
     if (.size() >= 1) {
        = Multisets.immutableEntry(.get(0), .count(.get(0)));
       if (.size() >= 3) {
          = Multisets.immutableEntry(.get(1), .count(.get(1)));
          = Multisets.immutableEntry(.get(2), .count(.get(2)));
       }
     }
   }

  
Resets the contents of sortedMultiset to have entries a, c, for the navigation tests.
 
   @SuppressWarnings("unchecked")
   // Needed to stop Eclipse whining
   private void resetWithHole() {
     List<E> container = new ArrayList<E>();
     container.addAll(Collections.nCopies(.getCount(), .getElement()));
     container.addAll(Collections.nCopies(.getCount(), .getElement()));
     super.resetContainer(getSubjectGenerator().create(container.toArray()));
   }
 
   public void testEmptyMultisetFirst() {
     try {
       .elementSet().first();
       fail();
    } catch (NoSuchElementException e) {}
  }
  public void testEmptyMultisetPollFirst() {
  }
  public void testEmptyMultisetNearby() {
    for (BoundType type : BoundType.values()) {
    }
  }
  public void testEmptyMultisetLast() {
    try {
      fail();
    } catch (NoSuchElementException e) {}
  }
  public void testEmptyMultisetPollLast() {
  }
  public void testSingletonMultisetFirst() {
  }
  public void testSingletonMultisetPollFirst() {
  }
  public void testSingletonMultisetNearby() {
  }
  public void testSingletonMultisetLast() {
  }
  public void testSingletonMultisetPollLast() {
  }
  public void testFirst() {
  }
  @SuppressWarnings("unchecked")
  public void testPollFirst() {
  }
  public void testPollFirstUnsupported() {
    try {
      fail();
    } catch (UnsupportedOperationException e) {}
  }
  public void testLower() {
    resetWithHole();
  }
  public void testFloor() {
    resetWithHole();
  }
  public void testCeiling() {
    resetWithHole();
  }
  public void testHigher() {
    resetWithHole();
  }
  public void testLast() {
  }
  @SuppressWarnings("unchecked")
  public void testPollLast() {
  }
  public void testPollLastUnsupported() {
    try {
      fail();
    } catch (UnsupportedOperationException e) {}
  }
  public void testDescendingNavigation() {
    List<Entry<E>> ascending = new ArrayList<Entry<E>>();
    Iterators.addAll(ascending.entrySet().iterator());
    List<Entry<E>> descending = new ArrayList<Entry<E>>();
    Iterators.addAll(descending.descendingMultiset().entrySet().iterator());
    Collections.reverse(descending);
    assertEquals(ascendingdescending);
  }
  void expectAddFailure(SortedMultiset<E> multisetEntry<E> entry) {
    try {
      multiset.add(entry.getElement(), entry.getCount());
      fail("Expected IllegalArgumentException");
    } catch (IllegalArgumentException expected) {}
    try {
      multiset.add(entry.getElement());
      fail("Expected IllegalArgumentException");
    } catch (IllegalArgumentException expected) {}
    try {
      multiset.addAll(Collections.singletonList(entry.getElement()));
      fail("Expected IllegalArgumentException");
    } catch (IllegalArgumentException expected) {}
  }
  void expectRemoveZero(SortedMultiset<E> multisetEntry<E> entry) {
    assertEquals(0, multiset.remove(entry.getElement(), entry.getCount()));
    assertFalse(multiset.remove(entry.getElement()));
    assertFalse(multiset.elementSet().remove(entry.getElement()));
  }
  void expectSetCountFailure(SortedMultiset<E> multisetEntry<E> entry) {
    try {
      multiset.setCount(entry.getElement(), multiset.count(entry.getElement()));
    } catch (IllegalArgumentException acceptable) {}
    try {
      multiset.setCount(entry.getElement(), multiset.count(entry.getElement()) + 1);
      fail("Expected IllegalArgumentException");
    } catch (IllegalArgumentException expected) {}
  }
  public void testAddOutOfTailBoundsOne() {
  }
  public void testAddOutOfTailBoundsSeveral() {
  }
  public void testAddOutOfHeadBoundsOne() {
  }
  public void testAddOutOfHeadBoundsSeveral() {
  }
  public void testRemoveOutOfTailBoundsOne() {
  }
  }
  public void testRemoveOutOfHeadBoundsOne() {
  }
  }
  public void testSetCountOutOfTailBoundsOne() {
  }
  }
  public void testSetCountOutOfHeadBoundsOne() {
  }
  }
  public void testAddWithConflictingBounds() {
        .getElement(), ));
        .getElement(), ));
        .getElement(), ));
        .getElement(), ));
        .getElement(), ));
        .getElement(), ));
  }
  public void testConflictingBounds() {
        ));
        ));
        ));
        ));
        ));
        ));
  }
  public void testEmptyRangeSubMultiset(SortedMultiset<E> multiset) {
    assertTrue(multiset.isEmpty());
    assertEquals(0, multiset.size());
    assertEquals(0, multiset.toArray().length);
    assertTrue(multiset.entrySet().isEmpty());
    assertFalse(multiset.iterator().hasNext());
    assertEquals(0, multiset.entrySet().size());
    assertEquals(0, multiset.entrySet().toArray().length);
    assertFalse(multiset.entrySet().iterator().hasNext());
  }
  @SuppressWarnings("unchecked")
    for (Entry<E> entry : Arrays.asList()) {
      expectAddFailure(multisetentry);
    }
  }
  private int totalSize(Iterable<? extends Entry<?>> entries) {
    int sum = 0;
    for (Entry<?> entry : entries) {
      sum += entry.getCount();
    }
    return sum;
  }
  private enum SubMultisetSpec {
    TAIL_CLOSED {
      @Override
      <E> List<Entry<E>> expectedEntries(int targetEntryList<Entry<E>> entries) {
        return entries.subList(targetEntryentries.size());
      }
      @Override
      <E> SortedMultiset<E> subMultiset(SortedMultiset<E> multisetList<Entry<E>> entries,
          int targetEntry) {
        return multiset.tailMultiset(entries.get(targetEntry).getElement(), );
      }
    },
    TAIL_OPEN {
      @Override
      <E> List<Entry<E>> expectedEntries(int targetEntryList<Entry<E>> entries) {
        return entries.subList(targetEntry + 1, entries.size());
      }
      @Override
      <E> SortedMultiset<E> subMultiset(SortedMultiset<E> multisetList<Entry<E>> entries,
          int targetEntry) {
        return multiset.tailMultiset(entries.get(targetEntry).getElement(), );
      }
    },
    HEAD_CLOSED {
      @Override
      <E> List<Entry<E>> expectedEntries(int targetEntryList<Entry<E>> entries) {
        return entries.subList(0, targetEntry + 1);
      }
      @Override
      <E> SortedMultiset<E> subMultiset(SortedMultiset<E> multisetList<Entry<E>> entries,
          int targetEntry) {
        return multiset.headMultiset(entries.get(targetEntry).getElement(), );
      }
    },
    HEAD_OPEN {
      @Override
      <E> List<Entry<E>> expectedEntries(int targetEntryList<Entry<E>> entries) {
        return entries.subList(0, targetEntry);
      }
      @Override
      <E> SortedMultiset<E> subMultiset(SortedMultiset<E> multisetList<Entry<E>> entries,
          int targetEntry) {
        return multiset.headMultiset(entries.get(targetEntry).getElement(), );
      }
    };
    abstract <E> List<Entry<E>> expectedEntries(int targetEntryList<Entry<E>> entries);
    abstract <E> SortedMultiset<E> subMultiset(SortedMultiset<E> multisetList<Entry<E>> entries,
        int targetEntry);
  }
  private void testSubMultisetEntrySet(SubMultisetSpec spec) {
    List<Entry<E>> entries = copyToList(.entrySet());
    for (int i = 0; i < entries.size(); i++) {
      List<Entry<E>> expected = spec.expectedEntries(ientries);
      SortedMultiset<E> subMultiset = spec.subMultiset(entriesi);
      assertEquals(expectedcopyToList(subMultiset.entrySet()));
    }
  }
  private void testSubMultisetSize(SubMultisetSpec spec) {
    List<Entry<E>> entries = copyToList(.entrySet());
    for (int i = 0; i < entries.size(); i++) {
      List<Entry<E>> expected = spec.expectedEntries(ientries);
      SortedMultiset<E> subMultiset = spec.subMultiset(entriesi);
      assertEquals(totalSize(expected), subMultiset.size());
    }
  }
    List<Entry<E>> entries = copyToList(.entrySet());
    for (int i = 0; i < entries.size(); i++) {
      List<Entry<E>> expected = spec.expectedEntries(ientries);
      SortedMultiset<E> subMultiset = spec.subMultiset(entriesi);
      assertEquals(expected.size(), subMultiset.entrySet().size());
      assertEquals(expected.size(), subMultiset.elementSet().size());
    }
  }
  public void testTailClosedEntrySet() {
  }
  public void testTailClosedSize() {
  }
  public void testTailClosedDistinctElements() {
  }
  public void testTailOpenEntrySet() {
  }
  public void testTailOpenSize() {
  }
  public void testTailOpenDistinctElements() {
  }
  public void testHeadClosedEntrySet() {
  }
  public void testHeadClosedSize() {
  }
  public void testHeadClosedDistinctElements() {
  }
  public void testHeadOpenEntrySet() {
  }
  public void testHeadOpenSize() {
  }
  public void testHeadOpenDistinctElements() {
  }
  public void testClearTailOpen() {
    List<Entry<E>> expected =
  }
  public void testClearTailOpenEntrySet() {
    List<Entry<E>> expected =
  }
  public void testClearTailClosed() {
    List<Entry<E>> expected =
  }
  public void testClearTailClosedEntrySet() {
    List<Entry<E>> expected =
  }
  public void testClearHeadOpen() {
    List<Entry<E>> expected =
  }
  public void testClearHeadOpenEntrySet() {
    List<Entry<E>> expected =
  }
  public void testClearHeadClosed() {
    List<Entry<E>> expected =
  }
  public void testClearHeadClosedEntrySet() {
    List<Entry<E>> expected =
  }