| /* |
| * 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()); |
| } |
| } |