/*
 * Copyright 2009 Google Inc.
 *
 * 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.gwt.emultest.java.util;

import java.util.Arrays;
import java.util.BitSet;
import java.util.HashSet;

/**
 * Tests BitSet class.
 */
public class BitSetTest extends EmulTestBase {

  /**
   * This class is used to describe numerical patterns.
   */
  private interface Pattern {
    boolean contains(int i);
  }

  // count used for looping tests
  private static final int TEST_SIZE = 509;

  // this number has to be bigger than 100
  private static final int BIG_NUMBER = (TEST_SIZE) * 10 + 101;

  private static void assertTrue(BitSet set, int index) {
    assertTrue("expected=true set[" + index + "]=false", set.get(index));
  }

  private static void assertFalse(BitSet set, int index) {
    assertFalse("expected=false set[" + index + "]=true", set.get(index));
  }

  private static BitSet createSetOfMultiples(int multiple) {
    BitSet set = new BitSet(TEST_SIZE);
    for (int i = 0; i < TEST_SIZE; i += multiple) {
      set.set(i);
    }
    return set;
  }

  // this checks to see the values given are true, and the others around are not
  private static void checkValues(BitSet set, int... values) {
    assertEquals(values.length, set.cardinality());

    int highestIndex = values[values.length - 1];
    boolean[] bits = new boolean[highestIndex + 1];
    for (int value : values) {
      bits[value] = true;
    }

    for (int index = 0; index < bits.length; index++) {
      assertEquals(bits[index], set.get(index));
    }
  }

  private static void checkEqualityTrue(BitSet setA, BitSet setB) {
    assertTrue(setA.equals(setB));
    assertTrue(setB.equals(setA));
    assertTrue(setA.equals(setA));
    assertTrue(setB.equals(setB));
  }

  private static void checkEqualityFalse(BitSet setA, BitSet setB) {
    assertFalse(setA.equals(setB));
    assertFalse(setB.equals(setA));
  }

  // Checks that the values in the given range are the only true values
  private static void checkRange(BitSet set, int fromIndex, int toIndex) {
    for (int i = fromIndex; i < toIndex; i++) {
      assertTrue(set, i);
    }
    assertEquals(toIndex - fromIndex, set.cardinality());
  }

  // Checks that the values in the given range are the only true values
  private static void checkRange(BitSet set, int fromIndex1, int toIndex1,
      int fromIndex2, int toIndex2) {
    for (int i = fromIndex1; i < toIndex1; i++) {
      assertTrue(set, i);
    }
    for (int i = fromIndex2; i < toIndex2; i++) {
      assertTrue(set, i);
    }
    assertEquals(toIndex1 - fromIndex1 + toIndex2 - fromIndex2,
        set.cardinality());
  }

  private static void checkPattern(BitSet set, Pattern pattern) {
    for (int i = 0; i < TEST_SIZE; i++) {
      boolean contained = pattern.contains(i);
      if (contained != set.get(i)) {
        fail("expected=" + contained + " set[" + i + "]=" + !contained);
      }
    }
  }

  public void testConstructor() {
    BitSet set = new BitSet();

    // test what we know to be true of a new BitSet
    assertTrue(set.isEmpty());
    assertEquals(0, set.length());
    assertEquals(0, set.cardinality());

    // test exceptions
    try {
      set = new BitSet(-1);
      fail("exception expected");
    } catch (NegativeArraySizeException expected) {
    }

    set = new BitSet(0);
    set = new BitSet(BIG_NUMBER);
  }

  public void testAnd() {
    Pattern multiplesOf6 = new Pattern() {
      @Override
      public boolean contains(int i) {
        return i % 6 == 0;
      }
    };

    // setA will contain all multiples of 2
    BitSet setA = createSetOfMultiples(2);

    // setB will contain all multiples of 3
    BitSet setB = createSetOfMultiples(3);

    // and()ing the sets should give multiples of 6
    setA.and(setB);

    // verify by checking multiples of 6
    checkPattern(setA, multiplesOf6);

    // and()ing a set to itself should do nothing
    setA.and(setA);

    // verify by checking multiples of 6
    checkPattern(setA, multiplesOf6);

    // and()ing with a set identical to itself should do nothing
    setA.and((BitSet) setA.clone());

    // verify by checking multiples of 6
    checkPattern(setA, multiplesOf6);

    // and()ing with all trues should do nothing
    BitSet trueSet = new BitSet(TEST_SIZE);
    trueSet.set(0, TEST_SIZE);
    setA.and(trueSet);

    // verify by checking multiples of 6
    checkPattern(setA, multiplesOf6);

    // and()ing with all trues in a larger set should do nothing
    trueSet.set(TEST_SIZE, TEST_SIZE * 2);
    setA.and(trueSet);

    // verify by checking multiples of 6
    checkPattern(setA, multiplesOf6);
    // there were "TEST_SIZE" extra trues, so lets verify those came out false
    for (int i = TEST_SIZE; i < TEST_SIZE * 2; i++) {
      assertFalse(setA.get(i));
    }

    // and()ing with an empty set should result in an empty set
    setA.and(new BitSet());
    assertEquals(0, setA.length());

    // these close bits should not intersect
    setB = new BitSet();
    setA.set(0);
    setB.set(1);
    setA.and(setB);
    assertTrue(setA.isEmpty());

    // these bits should not intersect
    setB = new BitSet();
    setA.set(0);
    setB.set(BIG_NUMBER);
    setA.and(setB);
    assertTrue(setA.isEmpty());
    setA.set(0);
    setB.and(setA);
    assertTrue(setB.isEmpty());

    setA = new BitSet();
    setA.set(1);
    setA.set(5);
    setB = new BitSet();
    setB.set(2);
    setA.and(setB);
    assertTrue(setA.isEmpty());

    setA = new BitSet();
    setA.set(1);
    setA.set(5);
    setB = new BitSet();
    setB.set(5);
    setA.and(setB);
    assertTrue(setA.get(5));
    assertEquals(1, setA.cardinality());

    setA = new BitSet();
    setA.set(2);
    setB = new BitSet();
    setB.set(1);
    setB.set(3);
    setA.and(setB);
    assertEquals(0, setA.cardinality());
  }

  public void testAndNot() {
    Pattern multiplesOf2Not3 = new Pattern() {
      @Override
      public boolean contains(int i) {
        return i % 2 == 0 && i % 3 != 0;
      }
    };

    // setA will contain all multiples of 2
    BitSet setA = createSetOfMultiples(2);

    // setB will contain all multiples of 3
    BitSet setB = createSetOfMultiples(3);

    // andNot() the sets
    setA.andNot(setB);

    // verify by checking for multiples of 2 that are not multiples of 3
    checkPattern(setA, multiplesOf2Not3);

    // andNot()ing with an empty set should do nothing
    setA.andNot(new BitSet());

    // verify by checking for multiples of 2 that are not multiples of 3
    checkPattern(setA, multiplesOf2Not3);

    // andNot()ing with all trues should result in an empty set
    BitSet trueSet = new BitSet(TEST_SIZE * 2);
    trueSet.set(0, TEST_SIZE * 2);
    setA.andNot(trueSet);
    assertTrue(setA.isEmpty());

    // save setB in setA
    setA = (BitSet) setB.clone();

    // andNot()ing a set to itself should result in an empty set
    setB.andNot(setB);
    assertTrue(setB.isEmpty());

    // andNot()ing a set identical to itself should result in an empty set
    setA.andNot((BitSet) setA.clone());
    assertTrue(setA.isEmpty());

    setA = new BitSet();
    setA.set(2);
    setB = new BitSet();
    setB.set(1);
    setB.set(3);
    setA.andNot(setB);
    assertTrue(setA.get(2));
    assertEquals(1, setA.cardinality());
  }

  public void testCardinality() {
    BitSet set = new BitSet(TEST_SIZE);

    // test the empty count
    assertEquals(0, set.cardinality());

    // test a count of 1
    set.set(0);
    assertEquals(1, set.cardinality());

    // test a count of 2
    set.set(BIG_NUMBER);
    assertEquals(2, set.cardinality());

    // clear them both and test again
    set.clear(0);
    set.clear(BIG_NUMBER);
    assertEquals(0, set.cardinality());

    // test different multiples
    for (int multiple = 1; multiple < 33; multiple++) {
      set = new BitSet();
      set.set(BIG_NUMBER + multiple);
      for (int i = 1; i < 33; i++) {
        set.set(i * multiple);
        assertEquals(i + 1, set.cardinality());
      }
    }

    // test powers of 2
    set = new BitSet();
    int count = 0;
    for (int i = 1; i < TEST_SIZE; i += i) {
      set.set(i);
      count++;
    }
    assertEquals(count, set.cardinality());

    // test a long run
    set = new BitSet();
    for (int i = 0; i < TEST_SIZE; i++) {
      set.set(i);
      assertEquals(i + 1, set.cardinality());
    }
  }

  public void testClear() {
    BitSet set = new BitSet(TEST_SIZE);
    for (int i = 0; i < TEST_SIZE; i++) {
      set.set(i);
    }

    set.clear();
    assertTrue(set.isEmpty());

    set = new BitSet();
    set.set(BIG_NUMBER);
    set.clear();
    assertFalse(set.get(BIG_NUMBER));
  }

  public void testClearInt() {
    BitSet set = new BitSet();
    set.set(0);
    set.clear(0);
    assertFalse(set.get(0));
    set.set(BIG_NUMBER);
    checkValues(set, BIG_NUMBER);
    set.clear(BIG_NUMBER);
    assertFalse(set.get(BIG_NUMBER));

    set = new BitSet();
    set.set(1);
    set.set(2);
    set.set(3);
    set.set(18);
    set.set(40);
    set.clear(2);
    checkValues(set, 1, 3, 18, 40);
    set.clear(9);
    checkValues(set, 1, 3, 18, 40);
    set.clear(18);
    checkValues(set, 1, 3, 40);
    set.clear(7);
    set.clear(6);
    checkValues(set, 1, 3, 40);
    set.clear(3);
    checkValues(set, 1, 40);
    set.clear(40);
    checkValues(set, 1);
    set.clear(1);
    assertTrue(set.isEmpty());

    // test exceptions
    try {
      set.clear(-1, 2);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }

    try {
      set.clear(3, 1);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }

    set.clear(2, 2);
  }

  public void testClearIntIntAndSetIntInt() {
    BitSet set = new BitSet();

    set.set(7);
    set.set(50);
    set.set(BIG_NUMBER);
    set.clear(0, BIG_NUMBER);
    checkValues(set, BIG_NUMBER);
    set.clear(0, BIG_NUMBER + 1);
    assertTrue(set.isEmpty());

    set.set(0, 65);
    checkRange(set, 0, 65);
    set.clear(0, 63);
    checkRange(set, 63, 65);
    set.clear(63, 65);
    assertTrue(set.isEmpty());

    set.set(0, 128);
    set.clear(0, 64);
    checkRange(set, 64, 128);
    set.clear(0, 129);
    assertTrue(set.isEmpty());

    set.set(0, 65);
    checkRange(set, 0, 65);

    set.clear(0, 16);
    checkRange(set, 16, 65);

    set.set(0, 16);
    checkRange(set, 0, 65);
    set.clear(5, 5);
    set.clear(7, 14);
    set.clear(15, 42);
    set.clear(43, 55);
    set.clear(58, 62);
    set.clear(BIG_NUMBER, BIG_NUMBER);
    set.clear(BIG_NUMBER, BIG_NUMBER + 1);
    checkValues(set, 0, 1, 2, 3, 4, 5, 6, 14, 42, 55, 56, 57, 62, 63, 64);
    set.clear(0, 65);
    assertTrue(set.isEmpty());

    set.set(0, 33);
    checkRange(set, 0, 33);
    set.clear(0, 8);
    checkRange(set, 8, 33);

    for (int i = 0; i < 33; i++) {
      // this shouldn't change anything
      set.clear(i, i);
      assertEquals(25, set.cardinality());
      // nor should this
      set.set(i, i);
      assertEquals(25, set.cardinality());
    }

    for (int i = 0; i < 65; i++) {
      set.set(0, 128);
      set.clear(i, 128 - i);
      checkRange(set, 0, i, 128 - i, 128);
    }
    set.clear(0, 128);
    assertTrue(set.isEmpty());

    set.set(7, 100);
    checkRange(set, 7, 100);

    set = new BitSet();
    set.set(BIG_NUMBER, BIG_NUMBER);
    assertEquals(0, set.cardinality());
    set.set(BIG_NUMBER, BIG_NUMBER + 1);
    checkRange(set, BIG_NUMBER, BIG_NUMBER + 1);
    set.clear(BIG_NUMBER, BIG_NUMBER);
    checkValues(set, BIG_NUMBER);
    set.clear(BIG_NUMBER, BIG_NUMBER + 1);
    assertEquals(0, set.cardinality());

    set = new BitSet();
    set.set(10, 12);
    set.clear(11, 1000);
    checkValues(set, 10);

    set = new BitSet();
    set.set(10, 12);
    set.clear(0, 10);
    set.set(BIG_NUMBER, BIG_NUMBER);
    checkValues(set, 10, 11);
    set.clear(10, 12);
    assertTrue(set.isEmpty());

    set = new BitSet();
    set.set(1, 20);
    set.clear(5, 10);
    checkRange(set, 1, 5, 10, 20);

    set = new BitSet();
    set.set(1, 10);
    set.clear(5, 15);
    checkRange(set, 1, 5);

    // test clear(int, int) exceptions
    try {
      set.clear(-1, 2);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }

    try {
      set.clear(3, 1);
      fail("expected exception");
    } catch (IndexOutOfBoundsException expected) {
    }

    set.clear(2, 2);

    // test set(int, int) exceptions
    try {
      set.set(-1, 2);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }

    try {
      set.set(3, 1);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }

    set.set(2, 2);
  }

  public void testClone() {
    BitSet set = new BitSet();
    set.set(2);
    set.set(4);
    set.set(32);
    set.set(BIG_NUMBER);
    BitSet clone = (BitSet) set.clone();
    checkValues(clone, 2, 4, 32, BIG_NUMBER);
    assertTrue(set.equals(clone));
    assertEquals(4, clone.cardinality());
  }

  public void testEquals() {
    BitSet setA = new BitSet();
    BitSet setB = new BitSet();
    checkEqualityTrue(setA, setB);

    setA.set(0);
    setB.set(0);
    checkEqualityTrue(setA, setB);

    setA.set(BIG_NUMBER);
    setB.set(BIG_NUMBER);
    checkEqualityTrue(setA, setB);

    setA.clear(0);
    setB.clear(0);
    checkEqualityTrue(setA, setB);

    setA.clear(BIG_NUMBER);
    setB.clear(BIG_NUMBER);
    checkEqualityTrue(setA, setB);

    setA.set(0);
    setB.set(1);
    checkEqualityFalse(setA, setB);

    setA.set(2);
    setB.set(2);
    checkEqualityFalse(setA, setB);

    setA = new BitSet();
    setB = new BitSet();
    setA.set(Math.max(0, BIG_NUMBER - 8));
    setB.set(BIG_NUMBER + 1);
    checkEqualityFalse(setA, setB);

    BitSet set1 = new BitSet();
    set1.set(40);
    BitSet set2 = new BitSet();
    set2.set(1);
    set2.set(40);
    assertFalse(set1.equals(set2));

    setA = new BitSet();
    setA.set(2);
    setB = new BitSet();
    setB.set(1);
    setB.set(3);
    checkEqualityFalse(setA, setB);
  }

  public void testFlipInt() {
    BitSet set = new BitSet();
    set.flip(0);
    assertTrue(set.get(0));
    set.flip(0);
    assertFalse(set.get(0));
    set.flip(BIG_NUMBER);
    assertTrue(set.get(BIG_NUMBER));
    set.flip(BIG_NUMBER);
    assertFalse(set.get(BIG_NUMBER));

    set = new BitSet();
    set.flip(1);
    set.flip(2);
    set.flip(3);
    set.flip(4);
    set.flip(6);
    set.flip(4);
    set.flip(6);
    set.flip(6);
    set.flip(6);
    set.flip(8);
    set.flip(10);
    set.flip(8);
    set.flip(2);
    set.flip(8);
    checkValues(set, 1, 3, 8, 10);
    set.flip(8);
    checkValues(set, 1, 3, 10);
    set.flip(3);
    checkValues(set, 1, 10);
    set.flip(10);
    set.flip(11);
    checkValues(set, 1, 11);
    set.flip(1);
    checkValues(set, 11);
    set.flip(11);
    assertTrue(set.isEmpty());

    // test exceptions
    try {
      set.flip(-1);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }

    set.flip(BIG_NUMBER);
    set.flip(BIG_NUMBER);
  }

  public void testFlipIntInt() {
    BitSet set = new BitSet();
    set.flip(0, BIG_NUMBER);
    checkRange(set, 0, BIG_NUMBER);
    set.flip(0, BIG_NUMBER - 1);
    checkValues(set, BIG_NUMBER - 1);
    set.clear(0, BIG_NUMBER);
    assertTrue(set.isEmpty());

    set.flip(0, 33);
    set.flip(0, 8);
    checkRange(set, 8, 33);

    // current state is set.set(8,33)
    for (int i = 0; i < 33; i++) {
      // this shouldn't change anything
      set.flip(i, i);
      assertEquals(25, set.cardinality());
    }

    // current state is set.set(8,33)
    set.flip(0, 8);
    set.flip(7, 21);
    set.flip(22, 27);
    checkValues(set, 0, 1, 2, 3, 4, 5, 6, 21, 27, 28, 29, 30, 31, 32);

    set = new BitSet();
    set.flip(10, 12);
    set.flip(11, 1000);
    checkRange(set, 10, 11, 12, 1000);

    set = new BitSet();
    set.flip(10, 12);
    set.flip(0, 10);
    checkRange(set, 0, 12);
    set.flip(0, 12);
    assertTrue(set.isEmpty());

    set.flip(0, 64);
    set.flip(0, 63);
    checkValues(set, 63);
    set.flip(63, 64);
    assertTrue(set.isEmpty());

    set.flip(0, 130);
    checkRange(set, 0, 130);
    set.flip(0, 66);
    checkRange(set, 66, 130);
    set.flip(65, 131);
    checkRange(set, 65, 66, 130, 131);

    set = new BitSet();
    set.flip(1, 20);
    set.flip(5, 10);
    checkRange(set, 1, 5, 10, 20);

    set = new BitSet();
    set.flip(1, 10);
    set.flip(5, 15);
    checkRange(set, 1, 5, 10, 15);

    // test exceptions
    try {
      set.flip(-1, 2);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }

    try {
      set.flip(3, 1);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }

    set.flip(2, 2);
  }

  public void testGetIntAndSetInt() {
    BitSet set = new BitSet();
    set.set(0);
    assertTrue(set.get(0));
    assertFalse(set.get(1));
    assertFalse(set.get(2));
    assertFalse(set.get(100));

    set.set(BIG_NUMBER);
    assertFalse(set.get(BIG_NUMBER - 1));
    assertTrue(set.get(BIG_NUMBER));
    assertFalse(set.get(BIG_NUMBER + 1));

    set = new BitSet();
    set.set(0);
    set.set(4);
    set.set(7);
    set.set(10);
    set.set(31);
    set.set(32);
    set.set(33);
    set.set(69);
    checkValues(set, 0, 4, 7, 10, 31, 32, 33, 69);

    // test get() exceptions
    try {
      set.get(-1);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }

    set.get(BIG_NUMBER);

    // test set() exceptions
    try {
      set.set(-1);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }

    set.set(BIG_NUMBER);
  }

  public void testGetIntInt() {
    BitSet set = new BitSet();

    set.set(1);
    assertFalse(set.get(1, 1).get(0));
    assertTrue(set.get(1, 2).get(0));
    assertTrue(set.get(0, 2).get(1));

    set.set(32);
    set.set(50);
    set.set(BIG_NUMBER);

    BitSet subSet = set.get(0, BIG_NUMBER);
    checkValues(subSet, 1, 32, 50);

    subSet = set.get(1, BIG_NUMBER);
    checkValues(subSet, 0, 31, 49);

    subSet = set.get(2, BIG_NUMBER + 1);
    checkValues(subSet, 30, 48, BIG_NUMBER - 2);

    subSet = set.get(32, BIG_NUMBER * 2);
    checkValues(subSet, 0, 18, BIG_NUMBER - 32);
    assertEquals(3, subSet.cardinality());

    subSet = set.get(0, BIG_NUMBER + 1);
    assertEquals(set, subSet);

    set = new BitSet();
    for (int i = 8; i < 33; i++) {
      set.set(i);
    }
    for (int i = 0; i < 33; i++) {
      assertTrue(set.get(i, i).isEmpty());
    }

    // test exceptions
    try {
      set.get(-1, 2);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }

    try {
      set.get(3, 1);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }

    set.get(2, 2);
  }

  public void testHashCode() {
    // Note: Oracle's hashCode() implementation creates many collisions when
    // testSize is big, causing this test to fail in development mode.
    // Since this is an "unimportant test" as suggested by the original author,
    // we can just test with a small number.
    int testSize = 25;

    HashSet<Integer> hashValues = new HashSet<>();

    // count the collisions
    int collisions = 0;

    // hash an empty set
    hashValues.add(new BitSet().hashCode());

    // hash the set of {TEST_SIZE + 1}
    BitSet set = new BitSet();
    set.set(testSize + 1);
    assertTrue(hashValues.add(set.hashCode()));

    // hash the set of {0, TEST_SIZE + 1}
    set.set(0);
    assertTrue(hashValues.add(set.hashCode()));

    // hash the set of {0}
    set = new BitSet();
    set.set(0);
    assertTrue(hashValues.add(set.hashCode()));

    for (int multiple = 1; multiple < 33; multiple++) {
      set = new BitSet();
      set.set(0);

      // fill a set with multiples
      for (int i = multiple; i < testSize; i += multiple) {
        set.set(i);
        // hash the current set, except in the case of {0}
        if (i != 0) {
          if (hashValues.add(set.hashCode()) == false) {
            collisions++;
          }
          set.set(testSize + 1);
          if (hashValues.add(set.hashCode()) == false) {
            collisions++;
          }
          set.clear(testSize + 1);
        }
      }
    }

    assertEquals(0, collisions);
  }

  public void testIntersects() {
    final int prime = 37;
    for (int multiple = 1; multiple < prime; multiple++) {
      int size = prime * multiple + 1;

      // setA will contain all multiples of "multiple" up to "size"
      BitSet setA = new BitSet(size);
      for (int i = multiple; i < size; i += multiple) {
        setA.set(i);
      }

      // setB will contain all multiples of "prime" up to "size"
      BitSet setB = new BitSet();
      for (int i = prime; i < size; i += prime) {
        setB.set(i);
      }

      // the two sets should only intersect on the very last bit
      assertTrue(setA.intersects(setB));
      setA.clear(size - 1);
      assertFalse(setA.intersects(setB));

      // the inverse of a set should not intersect itself
      setB = new BitSet();
      for (int i = 0; i < prime; i++) {
        setB.set(i, !setA.get(i));
      }
      assertFalse(setA.intersects(setB));

      // a set intersects itself if it has any bits set
      assertTrue(setA.intersects(setA));
      setA = new BitSet();
      assertFalse(setA.intersects(setA));

      // an empty set doesn't intersect itself
      assertFalse(new BitSet().intersects(new BitSet()));
    }

    BitSet setA = new BitSet();
    setA.set(2);
    BitSet setB = new BitSet();
    setB.set(1);
    setB.set(3);
    assertFalse(setA.intersects(setB));
  }

  public void testIsEmpty() {
    BitSet set = new BitSet();
    assertTrue(set.isEmpty());
    set.set(0);
    assertFalse(set.isEmpty());
    set = new BitSet();
    set.set(BIG_NUMBER);
    assertFalse(set.isEmpty());
  }

  public void testLength() {
    BitSet set = new BitSet();
    assertEquals(0, set.length());

    set.set(30);
    assertEquals(31, set.length());
    set.clear(30);
    set.set(31);
    assertEquals(32, set.length());
    set.clear(31);
    set.set(100);
    set.set(BIG_NUMBER);
    assertEquals(BIG_NUMBER + 1, set.length());
    set.clear(BIG_NUMBER);
    assertEquals(101, set.length());
    set.clear(100);
    assertEquals(0, set.length());
    set.set(0);
    assertEquals(1, set.length());

    set = new BitSet();
    for (int i = 0; i < 640; i++) {
      set.set(i);
      assertEquals(i + 1, set.length());
    }
    for (int i = 0; i < 639; i++) {
      set.clear(i);
      assertEquals(640, set.length());
    }
    set.clear(639);
    assertEquals(0, set.length());
  }

  public void testNextClearBit() {
    BitSet set = new BitSet(10);

    assertEquals(BIG_NUMBER, set.nextClearBit(BIG_NUMBER));

    for (int i = 0; i < 10; i++) {
      assertEquals(i, set.nextClearBit(i));
    }
    for (int i = 10; i < 100; i++) {
      assertEquals(i, set.nextClearBit(i));
    }

    set.set(0, 9);
    set.set(10, 50);
    for (int i = 0; i <= 9; i++) {
      assertEquals(9, set.nextClearBit(i));
    }
    for (int i = 10; i < 50; i++) {
      assertEquals(50, set.nextClearBit(i));
    }
    for (int i = 50; i < 100; i++) {
      assertEquals(i, set.nextClearBit(i));
    }

    set = new BitSet();
    set.set(61);
    for (int i = 0; i < 60; i++) {
      set.set(i);
      assertEquals(i + 1, set.nextClearBit(0));
    }
    set.clear(61);
    for (int i = 60; i < 100; i++) {
      set.set(i);
      assertEquals(i + 1, set.nextClearBit(0));
    }
    assertEquals(BIG_NUMBER, set.nextClearBit(BIG_NUMBER));

    try {
      set.nextClearBit(-1);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }
  }

  public void testNextSetBit() {
    BitSet set = new BitSet();

    assertEquals(-1, set.nextSetBit(0));
    assertEquals(-1, set.nextSetBit(BIG_NUMBER));

    set.set(0);
    set.set(1);
    set.set(3);
    set.set(31);
    set.set(32);
    set.set(33);
    assertEquals(0, set.nextSetBit(0));
    assertEquals(1, set.nextSetBit(1));
    assertEquals(3, set.nextSetBit(2));
    assertEquals(3, set.nextSetBit(3));
    assertEquals(31, set.nextSetBit(4));
    assertEquals(31, set.nextSetBit(31));
    assertEquals(32, set.nextSetBit(32));
    assertEquals(33, set.nextSetBit(33));
    assertEquals(-1, set.nextSetBit(34));

    set = new BitSet();
    set.set(BIG_NUMBER);
    assertEquals(BIG_NUMBER, set.nextSetBit(0));
    assertEquals(BIG_NUMBER, set.nextSetBit(BIG_NUMBER));
    assertEquals(-1, set.nextSetBit(BIG_NUMBER + 1));

    for (int i = 0; i < TEST_SIZE; i++) {
      set.set(BIG_NUMBER + i);
    }
    set.set(TEST_SIZE / 2);
    assertEquals(TEST_SIZE / 2, set.nextSetBit(0));

    try {
      set.nextSetBit(-1);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }
  }

  public void testPreviousClearBit() {
    BitSet set = new BitSet();

    assertEquals(-1, set.previousClearBit(-1));
    assertEquals(0, set.previousClearBit(0));
    assertEquals(100, set.previousClearBit(100));

    set.set(0, 9);
    set.set(10, 50);
    for (int i = 100; i >= 50; i--) {
      assertEquals(i, set.previousClearBit(i));
    }
    for (int i = 49; i >= 9; i--) {
      assertEquals(9, set.previousClearBit(i));
    }
    for (int i = 8; i >= 0; i--) {
      assertEquals(-1, set.previousClearBit(i));
    }

    try {
      set.previousClearBit(-100);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }
  }

  public void testPreviousSetBit() {
    BitSet set = new BitSet();

    assertEquals(-1, set.previousSetBit(-1));
    assertEquals(-1, set.previousSetBit(0));
    assertEquals(-1, set.previousSetBit(100));

    set.set(0, 9);
    set.set(10, 50);
    for (int i = 100; i >= 50; i--) {
      assertEquals(49, set.previousSetBit(i));
    }
    for (int i = 49; i >= 10; i--) {
      assertEquals(i, set.previousSetBit(i));
    }
    assertEquals(8, set.previousSetBit(9));
    for (int i = 8; i >= 0; i--) {
      assertEquals(i, set.previousSetBit(i));
    }

    try {
      set.previousSetBit(-100);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }
  }

  public void testOr() {
    Pattern multiplesOf2And5 = new Pattern() {
      @Override
      public boolean contains(int i) {
        return i % 2 == 0 || i % 5 == 0;
      }
    };

    // setA will contain all multiples of 2
    BitSet setA = createSetOfMultiples(2);

    // setB will contain all multiples of 5
    BitSet setB = createSetOfMultiples(5);

    // or() the two sets to get both multiples of 2 and 5
    setA.or(setB);

    // verify multiples of 2 and 5
    checkPattern(setA, multiplesOf2And5);

    // or()ing a set to itself should do nothing
    setA.or(setA);

    // verify multiples of 2 and 5
    checkPattern(setA, multiplesOf2And5);

    // or()ing with set identical to itself should do nothing
    setA.or((BitSet) setA.clone());

    // verify multiples of 2 and 5
    checkPattern(setA, multiplesOf2And5);

    // or()ing with an empty set (all falses) should do nothing
    setA.or(new BitSet());

    // verify multiples of 2 and 5
    checkPattern(setA, multiplesOf2And5);

    // or()ing with all trues should result in all trues
    BitSet trueSet = new BitSet(TEST_SIZE * 2);
    trueSet.set(0, TEST_SIZE * 2);
    setA.or(trueSet);
    assertEquals(TEST_SIZE * 2, setA.cardinality());

    setA = new BitSet();
    setA.set(2);
    setB = new BitSet();
    setB.set(1);
    setB.set(3);
    setA.or(setB);
    checkRange(setA, 1, 4);
  }

  public void testSetIntBoolean() {
    BitSet set = new BitSet();
    set.set(0, true);
    assertTrue(set.get(0));
    set.set(0, false);
    assertFalse(set.get(0));
    set.set(BIG_NUMBER, true);
    assertTrue(set.get(BIG_NUMBER));
    set.set(BIG_NUMBER, false);
    assertFalse(set.get(BIG_NUMBER));

    set = new BitSet();
    set.set(1, true);
    set.set(2, true);
    set.set(3, true);
    set.set(4, true);
    set.set(6, true);
    set.set(4, false);
    set.set(6, true);
    set.set(6, false);
    set.set(6, false);
    set.set(8, true);
    set.set(10, true);
    set.set(8, false);
    set.set(2, false);
    set.set(8, true);
    checkValues(set, 1, 3, 8, 10);
    set.set(8, false);
    checkValues(set, 1, 3, 10);
    set.set(3, false);
    checkValues(set, 1, 10);
    set.set(10, false);
    set.set(11, true);
    checkValues(set, 1, 11);
    set.set(1, false);
    checkValues(set, 11);
    set.set(11, false);
    assertTrue(set.isEmpty());
  }

  public void testSetIntIntBoolean() {
    BitSet set = new BitSet();
    set.set(0, BIG_NUMBER, true);
    assertEquals(BIG_NUMBER, set.cardinality());
    set.set(0, BIG_NUMBER - 1, false);
    assertEquals(1, set.cardinality());
    set.set(0, BIG_NUMBER, false);
    assertTrue(set.isEmpty());

    set.set(0, 32, true);
    checkRange(set, 0, 32);
    set.set(0, 8, false);
    checkRange(set, 8, 32);
    set.set(0, 8, true);
    checkRange(set, 0, 32);
    set.set(7, 21, false);
    checkValues(set, 0, 1, 2, 3, 4, 5, 6, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
    set.set(22, 27, false);
    checkValues(set, 0, 1, 2, 3, 4, 5, 6, 21, 27, 28, 29, 30, 31);

    set = new BitSet();
    set.set(11, 1000, true);
    set.set(10, 12, false);
    checkRange(set, 12, 1000);
    assertEquals(988, set.cardinality());

    set = new BitSet();
    set.set(10, 12, true);
    set.set(0, 10, true);
    checkRange(set, 0, 12);
    set.set(0, 12, false);
    assertTrue(set.isEmpty());

    set = new BitSet();
    set.set(1, 20, true);
    set.set(5, 10, false);
    checkRange(set, 1, 5, 10, 20);

    set = new BitSet();
    set.set(1, 10, true);
    set.set(5, 10, false);
    set.set(10, 15, true);
    checkRange(set, 1, 5, 10, 15);

    // test exceptions
    try {
      set.set(-1, 2, true);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }

    try {
      set.set(3, 1, true);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }

    set.set(2, 2, true);

    try {
      set.set(-1, 2, false);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }

    try {
      set.set(3, 1, false);
      fail("exception expected");
    } catch (IndexOutOfBoundsException expected) {
    }

    set.set(2, 2, false);
  }

  public void testSize() {
    // this is an unimportant test

    BitSet set = new BitSet(7);
    assertTrue(set.size() >= 7);
    set = new BitSet(BIG_NUMBER);
    assertTrue(set.size() >= BIG_NUMBER);
  }

  public void testToString() {
    BitSet set = new BitSet();
    assertEquals("{}", set.toString());

    set.set(32);
    assertEquals("{32}", set.toString());

    set.set(BIG_NUMBER);
    assertEquals("{32, " + BIG_NUMBER + "}", set.toString());

    set.set(1);
    assertEquals("{1, 32, " + BIG_NUMBER + "}", set.toString());

    set.set(2);
    assertEquals("{1, 2, 32, " + BIG_NUMBER + "}", set.toString());
  }

  public void testXor() {
    Pattern exclusiveMultiples = new Pattern() {
      @Override
      public boolean contains(int i) {
        return (i % 2 == 0) ^ (i % 3 == 0);
      }
    };

    // setA will contain all multiples of 2
    BitSet setA = createSetOfMultiples(2);

    // setB will contain all multiples of 3
    BitSet setB = createSetOfMultiples(3);

    // xor()ing the sets should give exclusive multiples of 2 and 3
    setA.xor(setB);

    // verify by checking for exclusive multiples of 2 and 3
    checkPattern(setA, exclusiveMultiples);

    // xor()ing a set to an empty set should do nothing
    setA.xor(new BitSet());

    // verify by checking for exclusive multiples of 2 and 3
    checkPattern(setA, exclusiveMultiples);

    // xor()ing a set with all trues should flip each bit
    BitSet trueSet = new BitSet(TEST_SIZE * 2);
    trueSet.set(0, TEST_SIZE * 2);
    setA.xor(trueSet);

    // verify by checking for !(exclusive multiples of 2 and 3)
    checkPattern(setA, new Pattern() {
      @Override
      public boolean contains(int i) {
        return !((i % 2 == 0) ^ (i % 3 == 0));
      }
    });
    // there were "TEST_SIZE" extra trues, so verify those came out as true
    for (int i = TEST_SIZE; i < TEST_SIZE * 2; i++) {
      assertTrue(setA.get(i));
    }

    // xor()ing a set to itself should result in an empty set
    setA.xor(setA);
    assertTrue(setA.isEmpty());

    // xor()ing a set identical to itself should result in an empty set
    setB.xor((BitSet) setB.clone());
    assertTrue(setB.isEmpty());

    setA = new BitSet();
    setA.set(2);
    setB = new BitSet();
    setB.set(1);
    setB.set(3);
    setA.xor(setB);
    checkRange(setA, 1, 4);
  }

  public void testToByteArray() {
    BitSet set = new BitSet();
    assertEquals(0, set.toByteArray().length);

    int[] bits = {7, 8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 32, 33, 34, 35, 36, 37, 38,
        47, 49, 51, 52, 53, 54, 55};
    for (int bit : bits) {
      set.set(bit);
    }
    byte[] expected = {(byte) -128, (byte) -1, (byte) 0, (byte) 31,
        (byte) 127, (byte) 128, (byte) 250};
    assertTrue(Arrays.equals(expected, set.toByteArray()));

    set.clear();
    assertEquals(0, set.toByteArray().length);
  }

  public void testToLongArray() {
    BitSet set = new BitSet();
    assertEquals(0, set.toLongArray().length);

    int[] bits = {63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
        83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
        104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
        122, 123, 124, 125, 126, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140,
        141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
        159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176,
        177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 287, 288, 289,
        290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
        308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325,
        326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343,
        344, 345, 346, 347, 348, 349, 350, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
        395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412,
        413, 414, 450, 453, 454, 514, 515, 516, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528,
        529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546,
        547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564,
        565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 584, 640, 641, 642, 643, 644, 645,
        646, 711};
    for (int bit : bits) {
      set.set(bit);
    }
    long[] expected = {Long.MIN_VALUE, Long.MAX_VALUE, -1, 0, Integer.MIN_VALUE,
        Integer.MAX_VALUE, 0x7fffffff, 100, -100, 256, 127, 128};
    assertTrue(Arrays.equals(expected, set.toLongArray()));

    set.clear();
    assertEquals(0, set.toLongArray().length);
  }

  public void testValueOfBytes() {
    BitSet set = BitSet.valueOf(new byte[0]);
    assertTrue(set.isEmpty());

    set = BitSet.valueOf(new byte[]{(byte) -128, (byte) -1, (byte) 0, (byte) 31,
        (byte) 127, (byte) 128, (byte) 250});
    assertEquals("{7, 8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 32, 33, 34, 35, 36, 37, 38, " +
        "47, 49, 51, 52, 53, 54, 55}", set.toString());
  }

  public void testValueOfLongs() {
    BitSet set = BitSet.valueOf(new long[0]);
    assertTrue(set.isEmpty());

    set = BitSet.valueOf(new long[]{Long.MIN_VALUE, Long.MAX_VALUE, -1, 0, Integer.MIN_VALUE,
        Integer.MAX_VALUE, 0x7fffffff, 100, -100, 256, 127, 128});
    assertEquals("{63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, " +
        "83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, " +
        "104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, " +
        "122, 123, 124, 125, 126, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, " +
        "141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, " +
        "159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, " +
        "177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 287, 288, 289, " +
        "290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, " +
        "308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, " +
        "326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, " +
        "344, 345, 346, 347, 348, 349, 350, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, " +
        "395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, " +
        "413, 414, 450, 453, 454, 514, 515, 516, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, " +
        "529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, " +
        "547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, " +
        "565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 584, 640, 641, 642, 643, 644, 645, " +
        "646, 711}", set.toString());
  }

  public void testStream() {
    BitSet bitSet = new BitSet();
    assertEquals(new int[]{}, bitSet.stream().toArray());
    bitSet.set(2);
    assertEquals(new int[]{2}, bitSet.stream().toArray());
    bitSet.set(5);
    assertEquals(new int[]{2, 5}, bitSet.stream().toArray());
    bitSet.set(100);
    assertEquals(new int[]{2, 5, 100}, bitSet.stream().toArray());
  }
}
