/** Tests the method {@link ImmutableBitSet#iterator()}. */
@Test
public void testIterator() {
assertToIterBitSet("", ImmutableBitSet.of());
assertToIterBitSet("0", ImmutableBitSet.of(0));
assertToIterBitSet("0, 1", ImmutableBitSet.of(0, 1));
assertToIterBitSet("10", ImmutableBitSet.of(10));
}
/**
* Tests the method {@link
* org.apache.calcite.util.ImmutableBitSet#of(org.apache.calcite.util.ImmutableIntList)}.
*/
@Test
public void testBitSetOfImmutableIntList() {
ImmutableIntList list = ImmutableIntList.of();
assertThat(ImmutableBitSet.of(list), equalTo(ImmutableBitSet.of()));
list = ImmutableIntList.of(2, 70, 5, 0);
assertThat(ImmutableBitSet.of(list), equalTo(ImmutableBitSet.of(0, 2, 5, 70)));
}
@Test
public void testIntersect() {
assertThat(
ImmutableBitSet.of(1, 2, 3, 100, 200).intersect(ImmutableBitSet.of(2, 100)).toString(),
equalTo("{2, 100}"));
assertTrue(
ImmutableBitSet.of(1, 3, 5, 101, 20001).intersect(ImmutableBitSet.of(2, 100))
== ImmutableBitSet.of());
}
/**
* Tests the methods {@link org.apache.calcite.util.ImmutableBitSet#toList} and {@link
* org.apache.calcite.util.ImmutableBitSet#asList}.
*/
@Test
public void testAsList() {
final List<ImmutableBitSet> list = getSortedList();
for (ImmutableBitSet bitSet : list) {
final IntList list1 = bitSet.toList();
final List<Integer> listView = bitSet.asList();
assertThat(list1.size(), equalTo(bitSet.cardinality()));
assertThat(list1.toString(), equalTo(listView.toString()));
assertTrue(list1.equals(listView));
assertThat(list1.hashCode(), equalTo(listView.hashCode()));
}
}
@Test
public void testCreateLongs() {
assertThat(ImmutableBitSet.valueOf(0L), equalTo(ImmutableBitSet.of()));
assertThat(ImmutableBitSet.valueOf(0xAL), equalTo(ImmutableBitSet.of(1, 3)));
assertThat(ImmutableBitSet.valueOf(0xAL, 0, 0), equalTo(ImmutableBitSet.of(1, 3)));
assertThat(ImmutableBitSet.valueOf(0, 0, 0xAL, 0), equalTo(ImmutableBitSet.of(129, 131)));
}
@Test
public void testShift() {
final ImmutableBitSet bitSet = ImmutableBitSet.of(29, 4, 1969);
assertThat(bitSet.shift(0), is(bitSet));
assertThat(bitSet.shift(1), is(ImmutableBitSet.of(30, 5, 1970)));
assertThat(bitSet.shift(-4), is(ImmutableBitSet.of(25, 0, 1965)));
try {
final ImmutableBitSet x = bitSet.shift(-5);
fail("Expected error, got " + x);
} catch (ArrayIndexOutOfBoundsException e) {
assertThat(e.getMessage(), is("-1"));
}
final ImmutableBitSet empty = ImmutableBitSet.of();
assertThat(empty.shift(-100), is(empty));
}
/** Tests the method {@link org.apache.calcite.util.ImmutableBitSet#toArray}. */
@Test
public void testToArray() {
int[][] arrays = {{}, {0}, {0, 2}, {1, 65}, {100}};
for (int[] array : arrays) {
assertThat(ImmutableBitSet.of(array).toArray(), equalTo(array));
}
}
@Test
public void testClear() {
final ImmutableBitSet bitSet = ImmutableBitSet.of(29, 4, 1969);
final ImmutableBitSet bitSet2 = ImmutableBitSet.of(4, 1969);
assertThat(bitSet.clear(29), equalTo(bitSet2));
assertThat(bitSet.clear(29).clear(29), equalTo(bitSet2));
assertThat(bitSet.clear(29).clear(4).clear(29).clear(1969), equalTo(ImmutableBitSet.of()));
assertThat(bitSet.clearIf(29, false), equalTo(bitSet));
assertThat(bitSet.clearIf(29, true), equalTo(bitSet2));
}
@Test
public void testCompare() {
final List<ImmutableBitSet> sorted = getSortedList();
for (int i = 0; i < sorted.size(); i++) {
for (int j = 0; j < sorted.size(); j++) {
final ImmutableBitSet set0 = sorted.get(i);
final ImmutableBitSet set1 = sorted.get(j);
int c = set0.compareTo(set1);
if (c == 0) {
assertTrue(i == j || i == 3 && j == 4 || i == 4 && j == 3);
} else {
assertEquals(c, Utilities.compare(i, j));
}
assertEquals(c == 0, set0.equals(set1));
assertEquals(c == 0, set1.equals(set0));
}
}
}
/** Tests the method {@link org.apache.calcite.util.ImmutableBitSet#toList()}. */
@Test
public void testToList() {
assertThat(ImmutableBitSet.of().toList(), equalTo(Collections.<Integer>emptyList()));
assertThat(ImmutableBitSet.of(5).toList(), equalTo(Arrays.asList(5)));
assertThat(ImmutableBitSet.of(3, 5).toList(), equalTo(Arrays.asList(3, 5)));
assertThat(ImmutableBitSet.of(63).toList(), equalTo(Arrays.asList(63)));
assertThat(ImmutableBitSet.of(64).toList(), equalTo(Arrays.asList(64)));
assertThat(ImmutableBitSet.of(3, 63).toList(), equalTo(Arrays.asList(3, 63)));
assertThat(ImmutableBitSet.of(3, 64).toList(), equalTo(Arrays.asList(3, 64)));
assertThat(ImmutableBitSet.of(0, 4, 2).toList(), equalTo(Arrays.asList(0, 2, 4)));
}
/** Tests the method {@link org.apache.calcite.util.ImmutableBitSet#previousClearBit(int)}. */
@Test
public void testPreviousClearBit() {
assertThat(ImmutableBitSet.of().previousClearBit(10), equalTo(10));
assertThat(ImmutableBitSet.of().previousClearBit(0), equalTo(0));
assertThat(ImmutableBitSet.of().previousClearBit(-1), equalTo(-1));
try {
final int actual = ImmutableBitSet.of().previousClearBit(-2);
fail("expected exception, got " + actual);
} catch (IndexOutOfBoundsException e) {
// ok
}
assertThat(ImmutableBitSet.of(0, 1, 3, 4).previousClearBit(4), equalTo(2));
assertThat(ImmutableBitSet.of(0, 1, 3, 4).previousClearBit(3), equalTo(2));
assertThat(ImmutableBitSet.of(0, 1, 3, 4).previousClearBit(2), equalTo(2));
assertThat(ImmutableBitSet.of(0, 1, 3, 4).previousClearBit(1), equalTo(-1));
assertThat(ImmutableBitSet.of(1, 3, 4).previousClearBit(1), equalTo(0));
}
@Test
public void testSet() {
final ImmutableBitSet bitSet = ImmutableBitSet.of(29, 4, 1969);
final ImmutableBitSet bitSet2 = ImmutableBitSet.of(29, 4, 1969, 30);
assertThat(bitSet.set(30), equalTo(bitSet2));
assertThat(bitSet.set(30).set(30), equalTo(bitSet2));
assertThat(bitSet.set(29), equalTo(bitSet));
assertThat(bitSet.setIf(30, false), equalTo(bitSet));
assertThat(bitSet.setIf(30, true), equalTo(bitSet2));
}
private List<ImmutableBitSet> getSortedList() {
return Arrays.asList(
ImmutableBitSet.of(),
ImmutableBitSet.of(0, 1),
ImmutableBitSet.of(0, 1, 3),
ImmutableBitSet.of(1),
ImmutableBitSet.of(1),
ImmutableBitSet.of(1, 1000),
ImmutableBitSet.of(2, 3));
}
@Test
public void testBuilder() {
assertThat(
ImmutableBitSet.builder()
.set(9)
.set(100)
.set(1000)
.clear(250)
.set(88)
.clear(100)
.clear(1000)
.build()
.toString(),
equalTo("{9, 88}"));
}
/**
* Unit test for {@link org.apache.calcite.util.ImmutableBitSet.Builder#build(ImmutableBitSet)}.
*/
@Test
public void testBuilderUseOriginal() {
final ImmutableBitSet fives = ImmutableBitSet.of(5, 10, 15);
final ImmutableBitSet fives2 = ImmutableBitSet.builder(fives).clear(2).set(10).build(fives);
assertTrue(fives2 == fives);
final ImmutableBitSet fives3 = ImmutableBitSet.builder(fives).clear(2).set(10).build();
assertTrue(fives3 != fives);
assertTrue(fives3.equals(fives));
assertTrue(fives3.equals(fives2));
}
@Test
public void testCreateLongBuffer() {
assertThat(
ImmutableBitSet.valueOf(LongBuffer.wrap(new long[] {})), equalTo(ImmutableBitSet.of()));
assertThat(
ImmutableBitSet.valueOf(LongBuffer.wrap(new long[] {0xAL})),
equalTo(ImmutableBitSet.of(1, 3)));
assertThat(
ImmutableBitSet.valueOf(LongBuffer.wrap(new long[] {0, 0, 0xAL, 0})),
equalTo(ImmutableBitSet.of(129, 131)));
}
/** Tests the method {@link org.apache.calcite.util.ImmutableBitSet#union(ImmutableBitSet)}. */
@Test
public void testUnion() {
assertThat(ImmutableBitSet.of(1).union(ImmutableBitSet.of(3)).toString(), equalTo("{1, 3}"));
assertThat(
ImmutableBitSet.of(1).union(ImmutableBitSet.of(3, 100)).toString(), equalTo("{1, 3, 100}"));
ImmutableBitSet x =
ImmutableBitSet.builder(ImmutableBitSet.of(1))
.addAll(ImmutableBitSet.of(2))
.addAll(ImmutableBitSet.of())
.addAll(ImmutableBitSet.of(3))
.build();
assertThat(x.toString(), equalTo("{1, 2, 3}"));
}
/**
* Tests the method {@link
* org.apache.calcite.util.ImmutableBitSet#contains(org.apache.calcite.util.ImmutableBitSet)}.
*/
@Test
public void testBitSetsContains() {
assertTrue(ImmutableBitSet.range(0, 5).contains(ImmutableBitSet.range(2, 4)));
assertTrue(ImmutableBitSet.range(0, 5).contains(ImmutableBitSet.range(4)));
assertFalse(ImmutableBitSet.range(0, 5).contains(ImmutableBitSet.of(14)));
assertFalse(ImmutableBitSet.range(20, 25).contains(ImmutableBitSet.of(14)));
final ImmutableBitSet empty = ImmutableBitSet.of();
assertTrue(ImmutableBitSet.range(20, 25).contains(empty));
assertTrue(empty.contains(empty));
assertFalse(empty.contains(ImmutableBitSet.of(0)));
assertFalse(empty.contains(ImmutableBitSet.of(1)));
assertFalse(empty.contains(ImmutableBitSet.of(63)));
assertFalse(empty.contains(ImmutableBitSet.of(64)));
assertFalse(empty.contains(ImmutableBitSet.of(1000)));
assertTrue(ImmutableBitSet.of(1, 4, 7).contains(ImmutableBitSet.of(1, 4, 7)));
}
@Test
public void testToLongArray() {
final ImmutableBitSet bitSet = ImmutableBitSet.of(29, 4, 1969);
assertThat(ImmutableBitSet.valueOf(bitSet.toLongArray()), equalTo(bitSet));
assertThat(ImmutableBitSet.valueOf(LongBuffer.wrap(bitSet.toLongArray())), equalTo(bitSet));
}
@Override
protected void add(HierNode<T> node) {
super.add(node);
bottom.merge(node.getBitMask());
}
@Test
public void testPowerSet() {
final ImmutableBitSet empty = ImmutableBitSet.of();
assertThat(Iterables.size(empty.powerSet()), equalTo(1));
assertThat(empty.powerSet().toString(), equalTo("[{}]"));
final ImmutableBitSet single = ImmutableBitSet.of(2);
assertThat(Iterables.size(single.powerSet()), equalTo(2));
assertThat(single.powerSet().toString(), equalTo("[{}, {2}]"));
final ImmutableBitSet two = ImmutableBitSet.of(2, 10);
assertThat(Iterables.size(two.powerSet()), equalTo(4));
assertThat(two.powerSet().toString(), equalTo("[{}, {10}, {2}, {2, 10}]"));
final ImmutableBitSet seventeen = ImmutableBitSet.range(3, 20);
assertThat(Iterables.size(seventeen.powerSet()), equalTo(131072));
}
/** Tests the method {@link org.apache.calcite.util.BitSets#closure(java.util.SortedMap)}. */
@Test
public void testClosure() {
final SortedMap<Integer, ImmutableBitSet> empty = Maps.newTreeMap();
assertThat(ImmutableBitSet.closure(empty), equalTo(empty));
// Currently you need an entry for each position, otherwise you get an NPE.
// We should fix that.
final SortedMap<Integer, ImmutableBitSet> map = Maps.newTreeMap();
map.put(0, ImmutableBitSet.of(3));
map.put(1, ImmutableBitSet.of());
map.put(2, ImmutableBitSet.of(7));
map.put(3, ImmutableBitSet.of(4, 12));
map.put(4, ImmutableBitSet.of());
map.put(5, ImmutableBitSet.of());
map.put(6, ImmutableBitSet.of());
map.put(7, ImmutableBitSet.of());
map.put(8, ImmutableBitSet.of());
map.put(9, ImmutableBitSet.of());
map.put(10, ImmutableBitSet.of());
map.put(11, ImmutableBitSet.of());
map.put(12, ImmutableBitSet.of());
final String original = map.toString();
final String expected =
"{0={3, 4, 12}, 1={}, 2={7}, 3={3, 4, 12}, 4={4, 12}, 5={}, 6={}, 7={7}, 8={}, 9={}, 10={}, 11={}, 12={4, 12}}";
assertThat(ImmutableBitSet.closure(map).toString(), equalTo(expected));
assertThat("argument modified", map.toString(), equalTo(original));
// Now a similar map with missing entries. Same result.
final SortedMap<Integer, ImmutableBitSet> map2 = Maps.newTreeMap();
map2.put(0, ImmutableBitSet.of(3));
map2.put(2, ImmutableBitSet.of(7));
map2.put(3, ImmutableBitSet.of(4, 12));
map2.put(9, ImmutableBitSet.of());
final String original2 = map2.toString();
assertThat(ImmutableBitSet.closure(map2).toString(), equalTo(expected));
assertThat("argument modified", map2.toString(), equalTo(original2));
}
@Test
public void testNth() {
assertThat(ImmutableBitSet.of(0, 2, 4).nth(0), equalTo(0));
assertThat(ImmutableBitSet.of(0, 2, 4).nth(1), equalTo(2));
assertThat(ImmutableBitSet.of(0, 2, 4).nth(2), equalTo(4));
assertThat(ImmutableBitSet.of(0, 2, 63).nth(2), equalTo(63));
assertThat(ImmutableBitSet.of(0, 2, 64).nth(2), equalTo(64));
assertThat(ImmutableBitSet.of(64).nth(0), equalTo(64));
assertThat(ImmutableBitSet.of(64, 65).nth(0), equalTo(64));
assertThat(ImmutableBitSet.of(64, 65).nth(1), equalTo(65));
assertThat(ImmutableBitSet.of(64, 128).nth(1), equalTo(128));
try {
ImmutableBitSet.of().nth(0);
fail("expected throw");
} catch (IndexOutOfBoundsException e) {
// ok
}
try {
ImmutableBitSet.of().nth(1);
fail("expected throw");
} catch (IndexOutOfBoundsException e) {
// ok
}
try {
ImmutableBitSet.of(64).nth(1);
fail("expected throw");
} catch (IndexOutOfBoundsException e) {
// ok
}
try {
ImmutableBitSet.of(64).nth(-1);
fail("expected throw");
} catch (IndexOutOfBoundsException e) {
// ok
}
}
@Test
public void testGet2() {
final ImmutableBitSet bitSet = ImmutableBitSet.of(29, 4, 1969);
assertThat(bitSet.get(0, 8), is(ImmutableBitSet.of(4)));
assertThat(bitSet.get(0, 5), is(ImmutableBitSet.of(4)));
assertThat(bitSet.get(0, 4), is(ImmutableBitSet.of()));
assertThat(bitSet.get(4, 4), is(ImmutableBitSet.of()));
assertThat(bitSet.get(5, 5), is(ImmutableBitSet.of()));
assertThat(bitSet.get(4, 5), is(ImmutableBitSet.of(4)));
assertThat(bitSet.get(4, 1000), is(ImmutableBitSet.of(4, 29)));
assertThat(bitSet.get(4, 32), is(ImmutableBitSet.of(4, 29)));
assertThat(bitSet.get(2000, 10000), is(ImmutableBitSet.of()));
assertThat(bitSet.get(1000, 10000), is(ImmutableBitSet.of(1969)));
assertThat(bitSet.get(5, 10000), is(ImmutableBitSet.of(29, 1969)));
assertThat(bitSet.get(65, 10000), is(ImmutableBitSet.of(1969)));
final ImmutableBitSet emptyBitSet = ImmutableBitSet.of();
assertThat(emptyBitSet.get(0, 4), is(ImmutableBitSet.of()));
assertThat(emptyBitSet.get(0, 0), is(ImmutableBitSet.of()));
assertThat(emptyBitSet.get(0, 10000), is(ImmutableBitSet.of()));
assertThat(emptyBitSet.get(7, 10000), is(ImmutableBitSet.of()));
assertThat(emptyBitSet.get(73, 10000), is(ImmutableBitSet.of()));
}
@Test
public void testIndexOf() {
assertThat(ImmutableBitSet.of(0, 2, 4).indexOf(0), equalTo(0));
assertThat(ImmutableBitSet.of(0, 2, 4).indexOf(2), equalTo(1));
assertThat(ImmutableBitSet.of(0, 2, 4).indexOf(3), equalTo(-1));
assertThat(ImmutableBitSet.of(0, 2, 4).indexOf(4), equalTo(2));
assertThat(ImmutableBitSet.of(0, 2, 4).indexOf(5), equalTo(-1));
assertThat(ImmutableBitSet.of(0, 2, 4).indexOf(-1), equalTo(-1));
assertThat(ImmutableBitSet.of(0, 2, 4).indexOf(-2), equalTo(-1));
assertThat(ImmutableBitSet.of().indexOf(-1), equalTo(-1));
assertThat(ImmutableBitSet.of().indexOf(-2), equalTo(-1));
assertThat(ImmutableBitSet.of().indexOf(0), equalTo(-1));
assertThat(ImmutableBitSet.of().indexOf(1000), equalTo(-1));
}
/** Tests the method {@link BitSets#range(int, int)}. */
@Test
public void testRange() {
assertEquals(ImmutableBitSet.range(0, 4).toList(), Arrays.asList(0, 1, 2, 3));
assertEquals(ImmutableBitSet.range(1, 4).toList(), Arrays.asList(1, 2, 3));
assertEquals(ImmutableBitSet.range(4).toList(), Arrays.asList(0, 1, 2, 3));
assertEquals(ImmutableBitSet.range(0).toList(), Collections.<Integer>emptyList());
assertEquals(ImmutableBitSet.range(2, 2).toList(), Collections.<Integer>emptyList());
assertThat(ImmutableBitSet.range(63, 66).toString(), equalTo("{63, 64, 65}"));
assertThat(ImmutableBitSet.range(65, 68).toString(), equalTo("{65, 66, 67}"));
assertThat(ImmutableBitSet.range(65, 65).toString(), equalTo("{}"));
assertThat(ImmutableBitSet.range(65, 65).length(), equalTo(0));
assertThat(ImmutableBitSet.range(65, 165).cardinality(), equalTo(100));
// Same tests as above, using a builder.
assertThat(ImmutableBitSet.builder().set(63, 66).build().toString(), equalTo("{63, 64, 65}"));
assertThat(ImmutableBitSet.builder().set(65, 68).build().toString(), equalTo("{65, 66, 67}"));
assertThat(ImmutableBitSet.builder().set(65, 65).build().toString(), equalTo("{}"));
assertThat(ImmutableBitSet.builder().set(65, 65).build().length(), equalTo(0));
assertThat(ImmutableBitSet.builder().set(65, 165).build().cardinality(), equalTo(100));
final ImmutableBitSet e0 = ImmutableBitSet.range(0, 0);
final ImmutableBitSet e1 = ImmutableBitSet.of();
assertTrue(e0.equals(e1));
assertThat(e0.hashCode(), equalTo(e1.hashCode()));
// Empty builder returns the singleton empty set.
assertTrue(ImmutableBitSet.builder().build() == ImmutableBitSet.of());
}
protected void modify(HierNode<T> x, HierNode<T> y) {
// System.out.println( "Modifying on a inc between " + x + " and " + y );
int i = freeBit(x, y);
// System.out.println( "I " + i );
// System.out.println( "Getting parents of " + y + " >> " + y.getParents() );
Collection<HierNode<T>> py = y.getParents();
BitSet t = new BitSet(y.getBitMask().length());
for (HierNode<T> parent : py) {
t.or(parent.getBitMask());
}
BitSet d = singleBitDiff(t, y.getBitMask());
int inDex = d.nextSetBit(0);
if (inDex < 0) {
propagate(y, i);
} else {
// System.out.println( "D " + toBinaryString( d ) );
Set<HierNode<T>> ancestors = ancestorNodes(x);
Set<HierNode<T>> affectedAncestors = new HashSet<HierNode<T>>();
for (HierNode<T> anc : ancestors) {
if (anc.getBitMask().get(inDex)) {
affectedAncestors.add(anc);
}
}
// System.out.println( "Ancestors of " + x + " >> " + ancestors );
// System.out.println( "Affected " + x + " >> " + affectedAncestors );
if (affectedAncestors.size() == 0) {
return;
}
Set<HierNode<T>> gcs = gcs(affectedAncestors);
// System.out.println( "GCS of Affected " + gcs );
Set<HierNode<T>> affectedDescendants = new HashSet<HierNode<T>>();
for (HierNode<T> g : gcs) {
affectedDescendants.addAll(descendantNodes(g));
}
affectedDescendants.remove(x); // take x out it's not yet in the set
int dx = firstOne(d);
if (bottom.get(i)) {
i = freeBit(new HierNode<T>(bottom));
}
for (HierNode<T> sub : affectedDescendants) {
boolean keepsBit = false;
for (HierNode<T> sup : sub.getParents()) {
if (!keepsBit && !affectedDescendants.contains(sup) && sup.getBitMask().get(inDex)) {
keepsBit = true;
}
}
BitSet subMask = sub.getBitMask();
if (!keepsBit) {
subMask = decrement(subMask, dx);
}
subMask = increment(subMask, i);
updateMask(sub, subMask);
// System.out.println( "\tModified Desc" + sub );
}
inDex = d.nextSetBit(inDex + 1);
}
}
