alvinalexander.com | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Java example source code file (MultisetNavigationTester.java)

This example Java source code file (MultisetNavigationTester.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

arraylist, closed, entry, expected, illegalargumentexception, list, nosuchelementexception, open, override, sortedmultiset, supports_add, supports_remove, suppresswarnings, unsupportedoperationexception, util

The MultisetNavigationTester.java Java example source code

/*
 * 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 com.google.common.annotations.GwtCompatible;
import com.google.common.collect.BoundType;
import com.google.common.collect.Iterators;
import com.google.common.collect.Multiset;
import com.google.common.collect.Multiset.Entry;
import com.google.common.collect.Multisets;
import com.google.common.collect.SortedMultiset;
import com.google.common.collect.testing.features.CollectionFeature;
import com.google.common.collect.testing.features.CollectionSize;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.NoSuchElementException;

/**
 * Tester for navigation of SortedMultisets.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
public class MultisetNavigationTester<E> extends AbstractMultisetTester {
  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 cast(Multiset iterable) {
    return (SortedMultiset<T>) iterable;
  }

  @Override
  public void setUp() throws Exception {
    super.setUp();
    sortedMultiset = cast(getMultiset());
    entries =
        copyToList(
            getSubjectGenerator()
                .getSampleElements(getSubjectGenerator().getCollectionSize().getNumElements()));
    Collections.sort(entries, sortedMultiset.comparator());

    // some tests assume SEVERAL == 3
    if (entries.size() >= 1) {
      a = Multisets.immutableEntry(entries.get(0), sortedMultiset.count(entries.get(0)));
      if (entries.size() >= 3) {
        b = Multisets.immutableEntry(entries.get(1), sortedMultiset.count(entries.get(1)));
        c = Multisets.immutableEntry(entries.get(2), sortedMultiset.count(entries.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();
    container.addAll(Collections.nCopies(a.getCount(), a.getElement()));
    container.addAll(Collections.nCopies(c.getCount(), c.getElement()));
    super.resetContainer(getSubjectGenerator().create(container.toArray()));
    sortedMultiset = (SortedMultiset<E>) getMultiset();
  }

  @CollectionSize.Require(ZERO)
  public void testEmptyMultisetFirst() {
    assertNull(sortedMultiset.firstEntry());
    try {
      sortedMultiset.elementSet().first();
      fail();
    } catch (NoSuchElementException e) {
    }
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(ZERO)
  public void testEmptyMultisetPollFirst() {
    assertNull(sortedMultiset.pollFirstEntry());
  }

  @CollectionSize.Require(ZERO)
  public void testEmptyMultisetNearby() {
    for (BoundType type : BoundType.values()) {
      assertNull(sortedMultiset.headMultiset(e0(), type).lastEntry());
      assertNull(sortedMultiset.tailMultiset(e0(), type).firstEntry());
    }
  }

  @CollectionSize.Require(ZERO)
  public void testEmptyMultisetLast() {
    assertNull(sortedMultiset.lastEntry());
    try {
      assertNull(sortedMultiset.elementSet().last());
      fail();
    } catch (NoSuchElementException e) {
    }
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(ZERO)
  public void testEmptyMultisetPollLast() {
    assertNull(sortedMultiset.pollLastEntry());
  }

  @CollectionSize.Require(ONE)
  public void testSingletonMultisetFirst() {
    assertEquals(a, sortedMultiset.firstEntry());
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(ONE)
  public void testSingletonMultisetPollFirst() {
    assertEquals(a, sortedMultiset.pollFirstEntry());
    assertTrue(sortedMultiset.isEmpty());
  }

  @CollectionSize.Require(ONE)
  public void testSingletonMultisetNearby() {
    assertNull(sortedMultiset.headMultiset(e0(), OPEN).lastEntry());
    assertNull(sortedMultiset.tailMultiset(e0(), OPEN).lastEntry());

    assertEquals(a, sortedMultiset.headMultiset(e0(), CLOSED).lastEntry());
    assertEquals(a, sortedMultiset.tailMultiset(e0(), CLOSED).firstEntry());
  }

  @CollectionSize.Require(ONE)
  public void testSingletonMultisetLast() {
    assertEquals(a, sortedMultiset.lastEntry());
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(ONE)
  public void testSingletonMultisetPollLast() {
    assertEquals(a, sortedMultiset.pollLastEntry());
    assertTrue(sortedMultiset.isEmpty());
  }

  @CollectionSize.Require(SEVERAL)
  public void testFirst() {
    assertEquals(a, sortedMultiset.firstEntry());
  }

  @SuppressWarnings("unchecked")
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(SEVERAL)
  public void testPollFirst() {
    assertEquals(a, sortedMultiset.pollFirstEntry());
    assertEquals(Arrays.asList(b, c), copyToList(sortedMultiset.entrySet()));
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  public void testPollFirstUnsupported() {
    try {
      sortedMultiset.pollFirstEntry();
      fail();
    } catch (UnsupportedOperationException e) {
    }
  }

  @CollectionSize.Require(SEVERAL)
  public void testLower() {
    resetWithHole();
    assertEquals(null, sortedMultiset.headMultiset(a.getElement(), OPEN).lastEntry());
    assertEquals(a, sortedMultiset.headMultiset(b.getElement(), OPEN).lastEntry());
    assertEquals(a, sortedMultiset.headMultiset(c.getElement(), OPEN).lastEntry());
  }

  @CollectionSize.Require(SEVERAL)
  public void testFloor() {
    resetWithHole();
    assertEquals(a, sortedMultiset.headMultiset(a.getElement(), CLOSED).lastEntry());
    assertEquals(a, sortedMultiset.headMultiset(b.getElement(), CLOSED).lastEntry());
    assertEquals(c, sortedMultiset.headMultiset(c.getElement(), CLOSED).lastEntry());
  }

  @CollectionSize.Require(SEVERAL)
  public void testCeiling() {
    resetWithHole();

    assertEquals(a, sortedMultiset.tailMultiset(a.getElement(), CLOSED).firstEntry());
    assertEquals(c, sortedMultiset.tailMultiset(b.getElement(), CLOSED).firstEntry());
    assertEquals(c, sortedMultiset.tailMultiset(c.getElement(), CLOSED).firstEntry());
  }

  @CollectionSize.Require(SEVERAL)
  public void testHigher() {
    resetWithHole();
    assertEquals(c, sortedMultiset.tailMultiset(a.getElement(), OPEN).firstEntry());
    assertEquals(c, sortedMultiset.tailMultiset(b.getElement(), OPEN).firstEntry());
    assertEquals(null, sortedMultiset.tailMultiset(c.getElement(), OPEN).firstEntry());
  }

  @CollectionSize.Require(SEVERAL)
  public void testLast() {
    assertEquals(c, sortedMultiset.lastEntry());
  }

  @SuppressWarnings("unchecked")
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(SEVERAL)
  public void testPollLast() {
    assertEquals(c, sortedMultiset.pollLastEntry());
    assertEquals(Arrays.asList(a, b), copyToList(sortedMultiset.entrySet()));
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  @CollectionSize.Require(SEVERAL)
  public void testPollLastUnsupported() {
    try {
      sortedMultiset.pollLastEntry();
      fail();
    } catch (UnsupportedOperationException e) {
    }
  }

  @CollectionSize.Require(SEVERAL)
  public void testDescendingNavigation() {
    List<Entry ascending = new ArrayList>();
    Iterators.addAll(ascending, sortedMultiset.entrySet().iterator());
    List<Entry descending = new ArrayList>();
    Iterators.addAll(descending, sortedMultiset.descendingMultiset().entrySet().iterator());
    Collections.reverse(descending);
    assertEquals(ascending, descending);
  }

  void expectAddFailure(SortedMultiset<E> multiset, Entry 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> multiset, Entry entry) {
    assertEquals(0, multiset.remove(entry.getElement(), entry.getCount()));
    assertFalse(multiset.remove(entry.getElement()));
    assertFalse(multiset.elementSet().remove(entry.getElement()));
  }

  void expectSetCountFailure(SortedMultiset<E> multiset, Entry 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) {
    }
  }

  @CollectionSize.Require(ONE)
  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddOutOfTailBoundsOne() {
    expectAddFailure(sortedMultiset.tailMultiset(a.getElement(), OPEN), a);
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddOutOfTailBoundsSeveral() {
    expectAddFailure(sortedMultiset.tailMultiset(a.getElement(), OPEN), a);
    expectAddFailure(sortedMultiset.tailMultiset(b.getElement(), CLOSED), a);
    expectAddFailure(sortedMultiset.tailMultiset(b.getElement(), OPEN), a);
    expectAddFailure(sortedMultiset.tailMultiset(b.getElement(), OPEN), b);
    expectAddFailure(sortedMultiset.tailMultiset(c.getElement(), CLOSED), a);
    expectAddFailure(sortedMultiset.tailMultiset(c.getElement(), CLOSED), b);
    expectAddFailure(sortedMultiset.tailMultiset(c.getElement(), OPEN), a);
    expectAddFailure(sortedMultiset.tailMultiset(c.getElement(), OPEN), b);
    expectAddFailure(sortedMultiset.tailMultiset(c.getElement(), OPEN), c);
  }

  @CollectionSize.Require(ONE)
  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddOutOfHeadBoundsOne() {
    expectAddFailure(sortedMultiset.headMultiset(a.getElement(), OPEN), a);
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddOutOfHeadBoundsSeveral() {
    expectAddFailure(sortedMultiset.headMultiset(c.getElement(), OPEN), c);
    expectAddFailure(sortedMultiset.headMultiset(b.getElement(), CLOSED), c);
    expectAddFailure(sortedMultiset.headMultiset(b.getElement(), OPEN), c);
    expectAddFailure(sortedMultiset.headMultiset(b.getElement(), OPEN), b);
    expectAddFailure(sortedMultiset.headMultiset(a.getElement(), CLOSED), c);
    expectAddFailure(sortedMultiset.headMultiset(a.getElement(), CLOSED), b);
    expectAddFailure(sortedMultiset.headMultiset(a.getElement(), OPEN), c);
    expectAddFailure(sortedMultiset.headMultiset(a.getElement(), OPEN), b);
    expectAddFailure(sortedMultiset.headMultiset(a.getElement(), OPEN), a);
  }

  @CollectionSize.Require(ONE)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testRemoveOutOfTailBoundsOne() {
    expectRemoveZero(sortedMultiset.tailMultiset(a.getElement(), OPEN), a);
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testRemoveOutOfTailBoundsSeveral() {
    expectRemoveZero(sortedMultiset.tailMultiset(a.getElement(), OPEN), a);
    expectRemoveZero(sortedMultiset.tailMultiset(b.getElement(), CLOSED), a);
    expectRemoveZero(sortedMultiset.tailMultiset(b.getElement(), OPEN), a);
    expectRemoveZero(sortedMultiset.tailMultiset(b.getElement(), OPEN), b);
    expectRemoveZero(sortedMultiset.tailMultiset(c.getElement(), CLOSED), a);
    expectRemoveZero(sortedMultiset.tailMultiset(c.getElement(), CLOSED), b);
    expectRemoveZero(sortedMultiset.tailMultiset(c.getElement(), OPEN), a);
    expectRemoveZero(sortedMultiset.tailMultiset(c.getElement(), OPEN), b);
    expectRemoveZero(sortedMultiset.tailMultiset(c.getElement(), OPEN), c);
  }

  @CollectionSize.Require(ONE)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testRemoveOutOfHeadBoundsOne() {
    expectRemoveZero(sortedMultiset.headMultiset(a.getElement(), OPEN), a);
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testRemoveOutOfHeadBoundsSeveral() {
    expectRemoveZero(sortedMultiset.headMultiset(c.getElement(), OPEN), c);
    expectRemoveZero(sortedMultiset.headMultiset(b.getElement(), CLOSED), c);
    expectRemoveZero(sortedMultiset.headMultiset(b.getElement(), OPEN), c);
    expectRemoveZero(sortedMultiset.headMultiset(b.getElement(), OPEN), b);
    expectRemoveZero(sortedMultiset.headMultiset(a.getElement(), CLOSED), c);
    expectRemoveZero(sortedMultiset.headMultiset(a.getElement(), CLOSED), b);
    expectRemoveZero(sortedMultiset.headMultiset(a.getElement(), OPEN), c);
    expectRemoveZero(sortedMultiset.headMultiset(a.getElement(), OPEN), b);
    expectRemoveZero(sortedMultiset.headMultiset(a.getElement(), OPEN), a);
  }

  @CollectionSize.Require(ONE)
  @CollectionFeature.Require({SUPPORTS_ADD, SUPPORTS_REMOVE})
  public void testSetCountOutOfTailBoundsOne() {
    expectSetCountFailure(sortedMultiset.tailMultiset(a.getElement(), OPEN), a);
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require({SUPPORTS_ADD, SUPPORTS_REMOVE})
  public void testSetCountOutOfTailBoundsSeveral() {
    expectSetCountFailure(sortedMultiset.tailMultiset(a.getElement(), OPEN), a);
    expectSetCountFailure(sortedMultiset.tailMultiset(b.getElement(), CLOSED), a);
    expectSetCountFailure(sortedMultiset.tailMultiset(b.getElement(), OPEN), a);
    expectSetCountFailure(sortedMultiset.tailMultiset(b.getElement(), OPEN), b);
    expectSetCountFailure(sortedMultiset.tailMultiset(c.getElement(), CLOSED), a);
    expectSetCountFailure(sortedMultiset.tailMultiset(c.getElement(), CLOSED), b);
    expectSetCountFailure(sortedMultiset.tailMultiset(c.getElement(), OPEN), a);
    expectSetCountFailure(sortedMultiset.tailMultiset(c.getElement(), OPEN), b);
    expectSetCountFailure(sortedMultiset.tailMultiset(c.getElement(), OPEN), c);
  }

  @CollectionSize.Require(ONE)
  @CollectionFeature.Require({SUPPORTS_ADD, SUPPORTS_REMOVE})
  public void testSetCountOutOfHeadBoundsOne() {
    expectSetCountFailure(sortedMultiset.headMultiset(a.getElement(), OPEN), a);
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require({SUPPORTS_ADD, SUPPORTS_REMOVE})
  public void testSetCountOutOfHeadBoundsSeveral() {
    expectSetCountFailure(sortedMultiset.headMultiset(c.getElement(), OPEN), c);
    expectSetCountFailure(sortedMultiset.headMultiset(b.getElement(), CLOSED), c);
    expectSetCountFailure(sortedMultiset.headMultiset(b.getElement(), OPEN), c);
    expectSetCountFailure(sortedMultiset.headMultiset(b.getElement(), OPEN), b);
    expectSetCountFailure(sortedMultiset.headMultiset(a.getElement(), CLOSED), c);
    expectSetCountFailure(sortedMultiset.headMultiset(a.getElement(), CLOSED), b);
    expectSetCountFailure(sortedMultiset.headMultiset(a.getElement(), OPEN), c);
    expectSetCountFailure(sortedMultiset.headMultiset(a.getElement(), OPEN), b);
    expectSetCountFailure(sortedMultiset.headMultiset(a.getElement(), OPEN), a);
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddWithConflictingBounds() {
    testEmptyRangeSubMultisetSupportingAdd(
        sortedMultiset.subMultiset(a.getElement(), CLOSED, a.getElement(), OPEN));
    testEmptyRangeSubMultisetSupportingAdd(
        sortedMultiset.subMultiset(a.getElement(), OPEN, a.getElement(), OPEN));
    testEmptyRangeSubMultisetSupportingAdd(
        sortedMultiset.subMultiset(a.getElement(), OPEN, a.getElement(), CLOSED));
    testEmptyRangeSubMultisetSupportingAdd(
        sortedMultiset.subMultiset(b.getElement(), CLOSED, a.getElement(), CLOSED));
    testEmptyRangeSubMultisetSupportingAdd(
        sortedMultiset.subMultiset(b.getElement(), CLOSED, a.getElement(), OPEN));
    testEmptyRangeSubMultisetSupportingAdd(
        sortedMultiset.subMultiset(b.getElement(), OPEN, a.getElement(), OPEN));
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testConflictingBounds() {
    testEmptyRangeSubMultiset(
        sortedMultiset.subMultiset(a.getElement(), CLOSED, a.getElement(), OPEN));
    testEmptyRangeSubMultiset(
        sortedMultiset.subMultiset(a.getElement(), OPEN, a.getElement(), OPEN));
    testEmptyRangeSubMultiset(
        sortedMultiset.subMultiset(a.getElement(), OPEN, a.getElement(), CLOSED));
    testEmptyRangeSubMultiset(
        sortedMultiset.subMultiset(b.getElement(), CLOSED, a.getElement(), CLOSED));
    testEmptyRangeSubMultiset(
        sortedMultiset.subMultiset(b.getElement(), CLOSED, a.getElement(), OPEN));
    testEmptyRangeSubMultiset(
        sortedMultiset.subMultiset(b.getElement(), OPEN, a.getElement(), OPEN));
  }

  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")
  public void testEmptyRangeSubMultisetSupportingAdd(SortedMultiset<E> multiset) {
    for (Entry<E> entry : Arrays.asList(a, b, c)) {
      expectAddFailure(multiset, entry);
    }
  }

  private static 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> expectedEntries(int targetEntry, List> entries) {
        return entries.subList(targetEntry, entries.size());
      }

      @Override
      <E> SortedMultiset subMultiset(
          SortedMultiset<E> multiset, List> entries, int targetEntry) {
        return multiset.tailMultiset(entries.get(targetEntry).getElement(), CLOSED);
      }
    },
    TAIL_OPEN {
      @Override
      <E> List> expectedEntries(int targetEntry, List> entries) {
        return entries.subList(targetEntry + 1, entries.size());
      }

      @Override
      <E> SortedMultiset subMultiset(
          SortedMultiset<E> multiset, List> entries, int targetEntry) {
        return multiset.tailMultiset(entries.get(targetEntry).getElement(), OPEN);
      }
    },
    HEAD_CLOSED {
      @Override
      <E> List> expectedEntries(int targetEntry, List> entries) {
        return entries.subList(0, targetEntry + 1);
      }

      @Override
      <E> SortedMultiset subMultiset(
          SortedMultiset<E> multiset, List> entries, int targetEntry) {
        return multiset.headMultiset(entries.get(targetEntry).getElement(), CLOSED);
      }
    },
    HEAD_OPEN {
      @Override
      <E> List> expectedEntries(int targetEntry, List> entries) {
        return entries.subList(0, targetEntry);
      }

      @Override
      <E> SortedMultiset subMultiset(
          SortedMultiset<E> multiset, List> entries, int targetEntry) {
        return multiset.headMultiset(entries.get(targetEntry).getElement(), OPEN);
      }
    };

    abstract <E> List> expectedEntries(int targetEntry, List> entries);

    abstract <E> SortedMultiset subMultiset(
        SortedMultiset<E> multiset, List> entries, int targetEntry);
  }

  private void testSubMultisetEntrySet(SubMultisetSpec spec) {
    List<Entry entries = copyToList(sortedMultiset.entrySet());
    for (int i = 0; i < entries.size(); i++) {
      List<Entry expected = spec.expectedEntries(i, entries);
      SortedMultiset<E> subMultiset = spec.subMultiset(sortedMultiset, entries, i);
      assertEquals(expected, copyToList(subMultiset.entrySet()));
    }
  }

  private void testSubMultisetSize(SubMultisetSpec spec) {
    List<Entry entries = copyToList(sortedMultiset.entrySet());
    for (int i = 0; i < entries.size(); i++) {
      List<Entry expected = spec.expectedEntries(i, entries);
      SortedMultiset<E> subMultiset = spec.subMultiset(sortedMultiset, entries, i);
      assertEquals(totalSize(expected), subMultiset.size());
    }
  }

  private void testSubMultisetDistinctElements(SubMultisetSpec spec) {
    List<Entry entries = copyToList(sortedMultiset.entrySet());
    for (int i = 0; i < entries.size(); i++) {
      List<Entry expected = spec.expectedEntries(i, entries);
      SortedMultiset<E> subMultiset = spec.subMultiset(sortedMultiset, entries, i);
      assertEquals(expected.size(), subMultiset.entrySet().size());
      assertEquals(expected.size(), subMultiset.elementSet().size());
    }
  }

  public void testTailClosedEntrySet() {
    testSubMultisetEntrySet(SubMultisetSpec.TAIL_CLOSED);
  }

  public void testTailClosedSize() {
    testSubMultisetSize(SubMultisetSpec.TAIL_CLOSED);
  }

  public void testTailClosedDistinctElements() {
    testSubMultisetDistinctElements(SubMultisetSpec.TAIL_CLOSED);
  }

  public void testTailOpenEntrySet() {
    testSubMultisetEntrySet(SubMultisetSpec.TAIL_OPEN);
  }

  public void testTailOpenSize() {
    testSubMultisetSize(SubMultisetSpec.TAIL_OPEN);
  }

  public void testTailOpenDistinctElements() {
    testSubMultisetDistinctElements(SubMultisetSpec.TAIL_OPEN);
  }

  public void testHeadClosedEntrySet() {
    testSubMultisetEntrySet(SubMultisetSpec.HEAD_CLOSED);
  }

  public void testHeadClosedSize() {
    testSubMultisetSize(SubMultisetSpec.HEAD_CLOSED);
  }

  public void testHeadClosedDistinctElements() {
    testSubMultisetDistinctElements(SubMultisetSpec.HEAD_CLOSED);
  }

  public void testHeadOpenEntrySet() {
    testSubMultisetEntrySet(SubMultisetSpec.HEAD_OPEN);
  }

  public void testHeadOpenSize() {
    testSubMultisetSize(SubMultisetSpec.HEAD_OPEN);
  }

  public void testHeadOpenDistinctElements() {
    testSubMultisetDistinctElements(SubMultisetSpec.HEAD_OPEN);
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testClearTailOpen() {
    List<Entry expected =
        copyToList(sortedMultiset.headMultiset(b.getElement(), CLOSED).entrySet());
    sortedMultiset.tailMultiset(b.getElement(), OPEN).clear();
    assertEquals(expected, copyToList(sortedMultiset.entrySet()));
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testClearTailOpenEntrySet() {
    List<Entry expected =
        copyToList(sortedMultiset.headMultiset(b.getElement(), CLOSED).entrySet());
    sortedMultiset.tailMultiset(b.getElement(), OPEN).entrySet().clear();
    assertEquals(expected, copyToList(sortedMultiset.entrySet()));
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testClearTailClosed() {
    List<Entry expected =
        copyToList(sortedMultiset.headMultiset(b.getElement(), OPEN).entrySet());
    sortedMultiset.tailMultiset(b.getElement(), CLOSED).clear();
    assertEquals(expected, copyToList(sortedMultiset.entrySet()));
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testClearTailClosedEntrySet() {
    List<Entry expected =
        copyToList(sortedMultiset.headMultiset(b.getElement(), OPEN).entrySet());
    sortedMultiset.tailMultiset(b.getElement(), CLOSED).entrySet().clear();
    assertEquals(expected, copyToList(sortedMultiset.entrySet()));
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testClearHeadOpen() {
    List<Entry expected =
        copyToList(sortedMultiset.tailMultiset(b.getElement(), CLOSED).entrySet());
    sortedMultiset.headMultiset(b.getElement(), OPEN).clear();
    assertEquals(expected, copyToList(sortedMultiset.entrySet()));
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testClearHeadOpenEntrySet() {
    List<Entry expected =
        copyToList(sortedMultiset.tailMultiset(b.getElement(), CLOSED).entrySet());
    sortedMultiset.headMultiset(b.getElement(), OPEN).entrySet().clear();
    assertEquals(expected, copyToList(sortedMultiset.entrySet()));
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testClearHeadClosed() {
    List<Entry expected =
        copyToList(sortedMultiset.tailMultiset(b.getElement(), OPEN).entrySet());
    sortedMultiset.headMultiset(b.getElement(), CLOSED).clear();
    assertEquals(expected, copyToList(sortedMultiset.entrySet()));
  }

  @CollectionSize.Require(SEVERAL)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testClearHeadClosedEntrySet() {
    List<Entry expected =
        copyToList(sortedMultiset.tailMultiset(b.getElement(), OPEN).entrySet());
    sortedMultiset.headMultiset(b.getElement(), CLOSED).entrySet().clear();
    assertEquals(expected, copyToList(sortedMultiset.entrySet()));
  }
}

Other Java examples (source code examples)

Here is a short list of links related to this Java MultisetNavigationTester.java source code file:

... this post is sponsored by my books ...

#1 New Release!

FP Best Seller

 

new blog posts

 

Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.