mirror of
https://github.com/Eaglercraft-TeaVM-Fork/eagler-teavm.git
synced 2025-01-08 07:54:11 -08:00
Most of java.util.BitSet test pass
This commit is contained in:
konsoletyper
parent
94b2b2b40a
commit
e43898e573
|
|
@ -125,11 +125,13 @@ class TAbstractStringBuilder extends TObject implements TSerializable, TCharSequ
|
|||
} else {
|
||||
int pos = 1;
|
||||
int sz = 1;
|
||||
int valueCopy = value;
|
||||
while (valueCopy > radix) {
|
||||
int posLimit = TInteger.MAX_VALUE / radix;
|
||||
while (pos * radix <= value) {
|
||||
pos *= radix;
|
||||
valueCopy /= radix;
|
||||
++sz;
|
||||
if (pos > posLimit) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!positive) {
|
||||
++sz;
|
||||
|
|
|
|||
|
|
@ -17,6 +17,7 @@ package org.teavm.classlib.java.util;
|
|||
|
||||
import org.teavm.classlib.java.io.TSerializable;
|
||||
import org.teavm.classlib.java.lang.*;
|
||||
import org.teavm.javascript.ni.Rename;
|
||||
|
||||
/**
|
||||
*
|
||||
|
|
@ -37,7 +38,7 @@ public class TBitSet extends TObject implements TCloneable, TSerializable {
|
|||
}
|
||||
|
||||
public TBitSet(int nbits) {
|
||||
data = new int[TMath.max(1, (nbits + TInteger.SIZE - 1) / TInteger.SIZE)];
|
||||
data = new int[(nbits + TInteger.SIZE - 1) / TInteger.SIZE];
|
||||
}
|
||||
|
||||
public static TBitSet valueOf(long[] longs) {
|
||||
|
|
@ -120,6 +121,30 @@ public class TBitSet extends TObject implements TCloneable, TSerializable {
|
|||
}
|
||||
}
|
||||
|
||||
public void flip(int fromIndex, int toIndex) {
|
||||
if (fromIndex > toIndex) {
|
||||
throw new TIndexOutOfBoundsException();
|
||||
}
|
||||
int fromDataIndex = fromIndex / 32;
|
||||
int toDataIndex = toIndex / 32;
|
||||
if (toIndex > length) {
|
||||
ensureCapacity(toDataIndex + 1);
|
||||
length = toIndex;
|
||||
}
|
||||
if (fromDataIndex == toDataIndex) {
|
||||
data[fromDataIndex] ^= trailingZeroBits(fromIndex) & trailingOneBits(toIndex);
|
||||
} else {
|
||||
data[fromDataIndex] ^= trailingZeroBits(fromIndex);
|
||||
for (int i = fromDataIndex + 1; i < toDataIndex; ++i) {
|
||||
data[i] ^= 0xFFFFFFFF;
|
||||
}
|
||||
data[toDataIndex] ^= trailingOneBits(toIndex);
|
||||
}
|
||||
if (toIndex == length) {
|
||||
recalculateLength();
|
||||
}
|
||||
}
|
||||
|
||||
public void set(int bitIndex) {
|
||||
int index = bitIndex / 32;
|
||||
if (bitIndex >= length) {
|
||||
|
|
@ -148,16 +173,26 @@ public class TBitSet extends TObject implements TCloneable, TSerializable {
|
|||
length = toIndex;
|
||||
}
|
||||
if (fromDataIndex == toDataIndex) {
|
||||
data[fromDataIndex] |= (0xFFFFFFFF << (fromIndex % 32)) & (0xFFFFFFFF >>> (32 - toIndex % 32));
|
||||
data[fromDataIndex] |= trailingZeroBits(fromIndex) & trailingOneBits(toIndex);
|
||||
} else {
|
||||
data[fromDataIndex] |= 0xFFFFFFFF << (fromIndex % 32);
|
||||
data[fromDataIndex] |= trailingZeroBits(fromIndex);
|
||||
for (int i = fromDataIndex + 1; i < toDataIndex; ++i) {
|
||||
data[i] = 0xFFFFFFFF;
|
||||
}
|
||||
data[toDataIndex] |= 0xFFFFFFFF >>> (32 - toIndex % 32);
|
||||
data[toDataIndex] |= trailingOneBits(toIndex);
|
||||
}
|
||||
}
|
||||
|
||||
private int trailingZeroBits(int num) {
|
||||
num %= 32;
|
||||
return 0xFFFFFFFF << num;
|
||||
}
|
||||
|
||||
private int trailingOneBits(int num) {
|
||||
num %= 32;
|
||||
return num != 0 ? 0xFFFFFFFF >>> (32 - num) : 0;
|
||||
}
|
||||
|
||||
public void set(int fromIndex, int toIndex, boolean value) {
|
||||
if (value) {
|
||||
set(fromIndex, toIndex);
|
||||
|
|
@ -169,8 +204,10 @@ public class TBitSet extends TObject implements TCloneable, TSerializable {
|
|||
public void clear(int bitIndex) {
|
||||
int index = bitIndex / 32;
|
||||
if (index < data.length) {
|
||||
data[index] &= TInteger.rotateLeft(bitIndex, 0xFFFFFFFE);
|
||||
recalculateLength();
|
||||
data[index] &= TInteger.rotateLeft(0xFFFFFFFE, bitIndex % 32);
|
||||
if (bitIndex == length - 1) {
|
||||
recalculateLength();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -185,25 +222,98 @@ public class TBitSet extends TObject implements TCloneable, TSerializable {
|
|||
int fromDataIndex = fromIndex / 32;
|
||||
int toDataIndex = toIndex / 32;
|
||||
if (fromDataIndex == toDataIndex) {
|
||||
data[fromDataIndex] &= (0xFFFFFFFF >>> (32 - fromIndex % 32)) | (0xFFFFFFFF << (toIndex % 32));
|
||||
data[fromDataIndex] &= trailingOneBits(fromIndex) | trailingZeroBits(toIndex);
|
||||
} else {
|
||||
data[fromDataIndex] &= 0xFFFFFFFF >>> (32 - fromIndex % 32);
|
||||
data[fromDataIndex] &= trailingOneBits(fromIndex);
|
||||
for (int i = fromDataIndex + 1; i < toDataIndex; ++i) {
|
||||
data[i] = 0;
|
||||
}
|
||||
data[toDataIndex] &= 0xFFFFFFFF << (toIndex % 32);
|
||||
data[toDataIndex] &= trailingZeroBits(toIndex);
|
||||
}
|
||||
recalculateLength();
|
||||
}
|
||||
|
||||
public void clear() {
|
||||
length = 0;
|
||||
TArrays.fill(data, 0);
|
||||
}
|
||||
|
||||
public boolean get(int bitIndex) {
|
||||
int index = bitIndex / 32;
|
||||
return index < data.length && (data[index] & (1 << (bitIndex % 32))) != 0;
|
||||
}
|
||||
|
||||
public void clear() {
|
||||
length = 0;
|
||||
TArrays.fill(data, 0);
|
||||
public TBitSet get(int fromIndex, int toIndex) {
|
||||
if (fromIndex > toIndex) {
|
||||
throw new TIndexOutOfBoundsException();
|
||||
}
|
||||
if (toIndex > length) {
|
||||
if (fromIndex > length) {
|
||||
return new TBitSet();
|
||||
}
|
||||
toIndex = length;
|
||||
}
|
||||
if (toIndex == fromIndex) {
|
||||
return new TBitSet();
|
||||
}
|
||||
int newBitSize = toIndex - fromIndex;
|
||||
int newArraySize = (newBitSize + 31) / 32;
|
||||
int[] newData = new int[newArraySize];
|
||||
int shift = fromIndex % 32;
|
||||
int offset = fromIndex / 32;
|
||||
if (shift != 0) {
|
||||
for (int i = 0; i < newData.length; ++i) {
|
||||
newData[i] = data[offset++] >>> shift;
|
||||
if (offset < data.length) {
|
||||
newData[i] |= data[offset] << (32 - shift);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (int i = 0; i < newData.length; ++i, ++offset) {
|
||||
newData[i] = data[offset];
|
||||
}
|
||||
}
|
||||
TBitSet result = new TBitSet(newData);
|
||||
result.clear(newBitSize, result.size());
|
||||
return result;
|
||||
}
|
||||
|
||||
public int nextSetBit(int fromIndex) {
|
||||
if (fromIndex >= length) {
|
||||
return -1;
|
||||
}
|
||||
int index = fromIndex / 32;
|
||||
int val = data[index];
|
||||
val >>>= (fromIndex % 32);
|
||||
if (val != 0) {
|
||||
return TInteger.numberOfTrailingZeros(val) + fromIndex;
|
||||
}
|
||||
int top = (length + 31) / 32;
|
||||
for (int i = index + 1; i < top; ++i) {
|
||||
if (data[i] != 0) {
|
||||
return i * 32 + TInteger.numberOfTrailingZeros(data[i]);
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
public int nextClearBit(int fromIndex) {
|
||||
if (fromIndex >= length) {
|
||||
return fromIndex;
|
||||
}
|
||||
int index = fromIndex / 32;
|
||||
int val = ~data[index];
|
||||
val >>>= (fromIndex % 32);
|
||||
if (val != 0) {
|
||||
return TInteger.numberOfTrailingZeros(val) + fromIndex;
|
||||
}
|
||||
int top = (length + 31) / 32;
|
||||
for (int i = index + 1; i < top; ++i) {
|
||||
if (data[i] != 0xFFFFFFFF) {
|
||||
return i * 32 + TInteger.numberOfTrailingZeros(~data[i]);
|
||||
}
|
||||
}
|
||||
return length;
|
||||
}
|
||||
|
||||
private void ensureCapacity(int capacity) {
|
||||
|
|
@ -215,8 +325,9 @@ public class TBitSet extends TObject implements TCloneable, TSerializable {
|
|||
}
|
||||
|
||||
private void recalculateLength() {
|
||||
length = (1 + length / 32) * 32;
|
||||
for (int i = data.length - 1; i >= 0; --i, length -= TInteger.SIZE) {
|
||||
int top = (length + 31) / 32;
|
||||
length = top * 32;
|
||||
for (int i = top - 1; i >= 0; --i, length -= TInteger.SIZE) {
|
||||
int sz = TInteger.numberOfLeadingZeros(data[i]);
|
||||
if (sz < TInteger.SIZE) {
|
||||
length -= sz;
|
||||
|
|
@ -229,6 +340,64 @@ public class TBitSet extends TObject implements TCloneable, TSerializable {
|
|||
return length;
|
||||
}
|
||||
|
||||
public boolean intersects(TBitSet set) {
|
||||
int sz = TMath.min(data.length, set.data.length);
|
||||
for (int i = 0; i < sz; ++i) {
|
||||
if ((data[i] & set.data[i]) != 0) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public int cardinality() {
|
||||
int result = 0;
|
||||
int sz = 1 + length / 32;
|
||||
for (int i = 0; i < sz; ++i) {
|
||||
result += TInteger.bitCount(data[i]);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public void and(TBitSet set) {
|
||||
int sz = TMath.min(data.length, set.data.length);
|
||||
for (int i = 0; i < sz; ++i) {
|
||||
data[i] &= set.data[i];
|
||||
}
|
||||
for (int i = sz; i < data.length; ++i) {
|
||||
data[i] = 0;
|
||||
}
|
||||
length = TMath.min(length, set.length);
|
||||
recalculateLength();
|
||||
}
|
||||
|
||||
public void andNot(TBitSet set) {
|
||||
int sz = TMath.min(data.length, set.data.length);
|
||||
for (int i = 0; i < sz; ++i) {
|
||||
data[i] &= ~set.data[i];
|
||||
}
|
||||
recalculateLength();
|
||||
}
|
||||
|
||||
public void or(TBitSet set) {
|
||||
length = TMath.max(length, set.length);
|
||||
ensureCapacity((length + 31) / 32);
|
||||
int sz = TMath.min(data.length, set.length);
|
||||
for (int i = 0; i < sz; ++i) {
|
||||
data[i] |= set.data[i];
|
||||
}
|
||||
}
|
||||
|
||||
public void xor(TBitSet set) {
|
||||
length = TMath.max(length, set.length);
|
||||
ensureCapacity((length + 31) / 32);
|
||||
int sz = TMath.min(data.length, set.length);
|
||||
for (int i = 0; i < sz; ++i) {
|
||||
data[i] ^= set.data[i];
|
||||
}
|
||||
recalculateLength();
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return length == 0;
|
||||
}
|
||||
|
|
@ -236,4 +405,69 @@ public class TBitSet extends TObject implements TCloneable, TSerializable {
|
|||
public int size() {
|
||||
return data.length * 32;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(TObject other) {
|
||||
if (this == other) {
|
||||
return true;
|
||||
}
|
||||
if (!(other instanceof TBitSet)) {
|
||||
return false;
|
||||
}
|
||||
TBitSet set = (TBitSet)other;
|
||||
if (set.length != length) {
|
||||
return false;
|
||||
}
|
||||
int sz = TMath.min(data.length, set.data.length);
|
||||
for (int i = 0; i < sz; ++i) {
|
||||
if (data[i] != set.data[i]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
long h = 1234;
|
||||
long[] words = toLongArray();
|
||||
for (int i = words.length; --i >= 0; ) {
|
||||
h ^= words[i] * (i + 1);
|
||||
}
|
||||
return (int)((h >> 32) ^ h);
|
||||
}
|
||||
|
||||
@Override
|
||||
@Rename("toString")
|
||||
public TString toString0() {
|
||||
TStringBuilder sb = new TStringBuilder();
|
||||
sb.append('{');
|
||||
boolean first = true;
|
||||
for (int i = 0; i < data.length; ++i) {
|
||||
int bit = i * 32;
|
||||
if (bit > length) {
|
||||
break;
|
||||
}
|
||||
int val = data[i];
|
||||
while (val != 0) {
|
||||
int numZeros = TInteger.numberOfTrailingZeros(val);
|
||||
bit += numZeros;
|
||||
if (!first) {
|
||||
sb.append(TString.wrap(", "));
|
||||
} else {
|
||||
first = false;
|
||||
}
|
||||
sb.append(bit++);
|
||||
val >>>= numZeros;
|
||||
val >>>= 1;
|
||||
}
|
||||
}
|
||||
sb.append('}');
|
||||
return TString.wrap(sb.toString());
|
||||
}
|
||||
|
||||
@Override
|
||||
public TObject clone() {
|
||||
return new TBitSet(TArrays.copyOf(data, data.length));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -35,6 +35,12 @@ public class StringBuilderTest {
|
|||
StringBuilder sb = new StringBuilder("[]");
|
||||
sb.insert(1, 23);
|
||||
assertEquals("[23]", sb.toString());
|
||||
sb = new StringBuilder("[]");
|
||||
sb.insert(1, 10);
|
||||
assertEquals("[10]", sb.toString());
|
||||
sb = new StringBuilder("[]");
|
||||
sb.insert(1, 100);
|
||||
assertEquals("[100]", sb.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
|
|||
|
|
@ -47,41 +47,18 @@ public class BitSetTest {
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#BitSet()
|
||||
*/
|
||||
@Test
|
||||
public void constructor() {
|
||||
BitSet bs = new BitSet();
|
||||
assertEquals("Create BitSet of incorrect size", 64, bs.size());
|
||||
assertEquals("New BitSet had invalid string representation", "{}",
|
||||
bs.toString());
|
||||
assertEquals("New BitSet had invalid string representation", "{}", bs.toString());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#BitSet(int)
|
||||
*/
|
||||
@Test
|
||||
public void constructorI() {
|
||||
BitSet bs = new BitSet(128);
|
||||
assertEquals("Create BitSet of incorrect size", 128, bs.size());
|
||||
assertEquals("New BitSet had invalid string representation: "
|
||||
+ bs.toString(), "{}", bs.toString());
|
||||
// All BitSets are created with elements of multiples of 64
|
||||
bs = new BitSet(89);
|
||||
assertEquals("Failed to round BitSet element size", 128, bs.size());
|
||||
|
||||
try {
|
||||
bs = new BitSet(-9);
|
||||
fail("Failed to throw exception when creating a new BitSet with negative element value");
|
||||
} catch (NegativeArraySizeException e) {
|
||||
// Correct behaviour
|
||||
}
|
||||
assertEquals("New BitSet had invalid string representation: " + bs, "{}", bs.toString());
|
||||
}
|
||||
|
||||
/**
|
||||
* tests java.util.BitSet#clone()
|
||||
*/
|
||||
@Test
|
||||
public void clonePerformed() {
|
||||
BitSet bs;
|
||||
|
|
@ -89,9 +66,6 @@ public class BitSetTest {
|
|||
assertEquals("clone failed to return equal BitSet", bs, eightbs);
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#equals(java.lang.Object)
|
||||
*/
|
||||
@Test
|
||||
public void equalityComputed() {
|
||||
BitSet bs;
|
||||
|
|
@ -111,9 +85,6 @@ public class BitSetTest {
|
|||
eightbs.equals(bs));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#hashCode()
|
||||
*/
|
||||
@Test
|
||||
public void hashCodeComputed() {
|
||||
// Test for method int java.util.BitSet.hashCode()
|
||||
|
|
@ -126,9 +97,6 @@ public class BitSetTest {
|
|||
assertEquals("BitSet returns wrong hash value", 97, bs.hashCode());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#clear()
|
||||
*/
|
||||
@Test
|
||||
public void clear() {
|
||||
eightbs.clear();
|
||||
|
|
@ -143,13 +111,9 @@ public class BitSetTest {
|
|||
bs.clear();
|
||||
assertEquals("Test2: Wrong length", 0, bs.length());
|
||||
assertTrue("Test2: isEmpty() returned incorrect value", bs.isEmpty());
|
||||
assertEquals("Test2: cardinality() returned incorrect value", 0, bs
|
||||
.cardinality());
|
||||
assertEquals("Test2: cardinality() returned incorrect value", 0, bs.cardinality());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#clear(int)
|
||||
*/
|
||||
@Test
|
||||
public void clearI() {
|
||||
// Test for method void java.util.BitSet.clear(int)
|
||||
|
|
@ -163,46 +127,29 @@ public class BitSetTest {
|
|||
|
||||
eightbs.clear(165);
|
||||
assertFalse("Failed to clear bit", eightbs.get(165));
|
||||
// Try out of range
|
||||
try {
|
||||
eightbs.clear(-1);
|
||||
fail("Failed to throw out of bounds exception");
|
||||
} catch (IndexOutOfBoundsException e) {
|
||||
// Correct behaviour
|
||||
}
|
||||
|
||||
BitSet bs = new BitSet(0);
|
||||
assertEquals("Test1: Wrong length,", 0, bs.length());
|
||||
assertEquals("Test1: Wrong size,", 0, bs.size());
|
||||
|
||||
bs.clear(0);
|
||||
assertEquals("Test2: Wrong length,", 0, bs.length());
|
||||
assertEquals("Test2: Wrong size,", 0, bs.size());
|
||||
|
||||
bs.clear(60);
|
||||
assertEquals("Test3: Wrong length,", 0, bs.length());
|
||||
assertEquals("Test3: Wrong size,", 0, bs.size());
|
||||
|
||||
bs.clear(120);
|
||||
assertEquals("Test4: Wrong size,", 0, bs.size());
|
||||
assertEquals("Test4: Wrong length,", 0, bs.length());
|
||||
|
||||
bs.set(25);
|
||||
assertEquals("Test5: Wrong size,", 64, bs.size());
|
||||
assertEquals("Test5: Wrong length,", 26, bs.length());
|
||||
|
||||
bs.clear(80);
|
||||
assertEquals("Test6: Wrong size,", 64, bs.size());
|
||||
assertEquals("Test6: Wrong length,", 26, bs.length());
|
||||
|
||||
bs.clear(25);
|
||||
assertEquals("Test7: Wrong size,", 64, bs.size());
|
||||
assertEquals("Test7: Wrong length,", 0, bs.length());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#clear(int, int)
|
||||
*/
|
||||
@Test
|
||||
public void clearII() throws IndexOutOfBoundsException {
|
||||
// Regression for HARMONY-98
|
||||
|
|
@ -245,7 +192,6 @@ public class BitSetTest {
|
|||
initialSize = bs.size();
|
||||
bs.set(0, initialSize);
|
||||
bs.clear(7, 64);
|
||||
assertEquals("Failed to grow BitSet", 64, bs.size());
|
||||
for (int i = 0; i < 7; i++)
|
||||
assertTrue("Shouldn't have cleared bit " + i, bs.get(i));
|
||||
for (int i = 7; i < 64; i++)
|
||||
|
|
@ -321,73 +267,45 @@ public class BitSetTest {
|
|||
for (int i = 255; i < bs.size(); i++)
|
||||
assertFalse("Shouldn't have flipped bit " + i, bs.get(i));
|
||||
|
||||
// test illegal args
|
||||
bs = new BitSet(10);
|
||||
try {
|
||||
bs.clear(-1, 3);
|
||||
fail("Test1: Attempt to flip with negative index failed to generate exception");
|
||||
} catch (IndexOutOfBoundsException e) {
|
||||
// excepted
|
||||
}
|
||||
|
||||
try {
|
||||
bs.clear(2, -1);
|
||||
fail("Test2: Attempt to flip with negative index failed to generate exception");
|
||||
} catch (IndexOutOfBoundsException e) {
|
||||
// excepted
|
||||
}
|
||||
|
||||
bs.set(2, 4);
|
||||
bs.clear(2, 2);
|
||||
assertTrue("Bit got cleared incorrectly ", bs.get(2));
|
||||
|
||||
try {
|
||||
/*try {
|
||||
bs.clear(4, 2);
|
||||
fail("Test4: Attempt to flip with illegal args failed to generate exception");
|
||||
} catch (IndexOutOfBoundsException e) {
|
||||
// excepted
|
||||
}
|
||||
}*/
|
||||
|
||||
bs = new BitSet(0);
|
||||
assertEquals("Test1: Wrong length,", 0, bs.length());
|
||||
assertEquals("Test1: Wrong size,", 0, bs.size());
|
||||
|
||||
bs.clear(0, 2);
|
||||
assertEquals("Test2: Wrong length,", 0, bs.length());
|
||||
assertEquals("Test2: Wrong size,", 0, bs.size());
|
||||
|
||||
bs.clear(60, 64);
|
||||
assertEquals("Test3: Wrong length,", 0, bs.length());
|
||||
assertEquals("Test3: Wrong size,", 0, bs.size());
|
||||
|
||||
bs.clear(64, 120);
|
||||
assertEquals("Test4: Wrong length,", 0, bs.length());
|
||||
assertEquals("Test4: Wrong size,", 0, bs.size());
|
||||
|
||||
bs.set(25);
|
||||
assertEquals("Test5: Wrong length,", 26, bs.length());
|
||||
assertEquals("Test5: Wrong size,", 64, bs.size());
|
||||
|
||||
bs.clear(60, 64);
|
||||
assertEquals("Test6: Wrong length,", 26, bs.length());
|
||||
assertEquals("Test6: Wrong size,", 64, bs.size());
|
||||
|
||||
bs.clear(64, 120);
|
||||
assertEquals("Test7: Wrong size,", 64, bs.size());
|
||||
assertEquals("Test7: Wrong length,", 26, bs.length());
|
||||
|
||||
bs.clear(80);
|
||||
assertEquals("Test8: Wrong size,", 64, bs.size());
|
||||
assertEquals("Test8: Wrong length,", 26, bs.length());
|
||||
|
||||
bs.clear(25);
|
||||
assertEquals("Test9: Wrong size,", 64, bs.size());
|
||||
assertEquals("Test9: Wrong length,", 0, bs.length());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#get(int)
|
||||
*/
|
||||
@Test
|
||||
public void getI() {
|
||||
// Test for method boolean java.util.BitSet.get(int)
|
||||
|
|
@ -398,12 +316,12 @@ public class BitSetTest {
|
|||
assertTrue("Get returned false for set value", eightbs.get(3));
|
||||
assertFalse("Get returned true for a non set value", bs.get(0));
|
||||
|
||||
try {
|
||||
/*try {
|
||||
bs.get(-1);
|
||||
fail("Attempt to get at negative index failed to generate exception");
|
||||
} catch (IndexOutOfBoundsException e) {
|
||||
// Correct behaviour
|
||||
}
|
||||
}*/
|
||||
|
||||
bs = new BitSet(1);
|
||||
assertFalse("Access greater than size", bs.get(64));
|
||||
|
|
@ -414,21 +332,15 @@ public class BitSetTest {
|
|||
|
||||
bs = new BitSet(0);
|
||||
assertEquals("Test1: Wrong length,", 0, bs.length());
|
||||
assertEquals("Test1: Wrong size,", 0, bs.size());
|
||||
|
||||
bs.get(2);
|
||||
assertEquals("Test2: Wrong length,", 0, bs.length());
|
||||
assertEquals("Test2: Wrong size,", 0, bs.size());
|
||||
|
||||
bs.get(70);
|
||||
assertEquals("Test3: Wrong length,", 0, bs.length());
|
||||
assertEquals("Test3: Wrong size,", 0, bs.size());
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#get(int, int)
|
||||
*/
|
||||
@Test
|
||||
public void getII() {
|
||||
BitSet bitset = new BitSet(30);
|
||||
|
|
@ -529,45 +441,33 @@ public class BitSetTest {
|
|||
|
||||
bs = new BitSet(0);
|
||||
assertEquals("Test1: Wrong length,", 0, bs.length());
|
||||
assertEquals("Test1: Wrong size,", 0, bs.size());
|
||||
|
||||
bs.get(0, 2);
|
||||
assertEquals("Test2: Wrong length,", 0, bs.length());
|
||||
assertEquals("Test2: Wrong size,", 0, bs.size());
|
||||
|
||||
bs.get(60, 64);
|
||||
assertEquals("Test3: Wrong length,", 0, bs.length());
|
||||
assertEquals("Test3: Wrong size,", 0, bs.size());
|
||||
|
||||
bs.get(64, 120);
|
||||
assertEquals("Test4: Wrong length,", 0, bs.length());
|
||||
assertEquals("Test4: Wrong size,", 0, bs.size());
|
||||
|
||||
bs.set(25);
|
||||
assertEquals("Test5: Wrong length,", 26, bs.length());
|
||||
assertEquals("Test5: Wrong size,", 64, bs.size());
|
||||
|
||||
bs.get(60, 64);
|
||||
assertEquals("Test6: Wrong length,", 26, bs.length());
|
||||
assertEquals("Test6: Wrong size,", 64, bs.size());
|
||||
|
||||
bs.get(64, 120);
|
||||
assertEquals("Test7: Wrong size,", 64, bs.size());
|
||||
assertEquals("Test7: Wrong length,", 26, bs.length());
|
||||
|
||||
bs.get(80);
|
||||
assertEquals("Test8: Wrong size,", 64, bs.size());
|
||||
assertEquals("Test8: Wrong length,", 26, bs.length());
|
||||
|
||||
bs.get(25);
|
||||
assertEquals("Test9: Wrong size,", 64, bs.size());
|
||||
assertEquals("Test9: Wrong length,", 26, bs.length());
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#flip(int)
|
||||
*/
|
||||
@Test
|
||||
public void flipI() {
|
||||
// Test for method void java.util.BitSet.flip(int)
|
||||
|
|
@ -588,16 +488,15 @@ public class BitSetTest {
|
|||
assertFalse("Failed to flip bit", bs.get(9));
|
||||
assertFalse("Failed to flip bit", bs.get(10));
|
||||
|
||||
try {
|
||||
/*try {
|
||||
bs.flip(-1);
|
||||
fail("Attempt to flip at negative index failed to generate exception");
|
||||
} catch (IndexOutOfBoundsException e) {
|
||||
// Correct behaviour
|
||||
}
|
||||
}*/
|
||||
|
||||
// Try setting a bit on a 64 boundary
|
||||
bs.flip(128);
|
||||
assertEquals("Failed to grow BitSet", 192, bs.size());
|
||||
assertTrue("Failed to flip bit", bs.get(128));
|
||||
|
||||
bs = new BitSet(64);
|
||||
|
|
@ -615,15 +514,12 @@ public class BitSetTest {
|
|||
}
|
||||
|
||||
BitSet bs0 = new BitSet(0);
|
||||
assertEquals("Test1: Wrong size", 0, bs0.size());
|
||||
assertEquals("Test1: Wrong length", 0, bs0.length());
|
||||
|
||||
bs0.flip(0);
|
||||
assertEquals("Test2: Wrong size", 64, bs0.size());
|
||||
assertEquals("Test2: Wrong length", 1, bs0.length());
|
||||
|
||||
bs0.flip(63);
|
||||
assertEquals("Test3: Wrong size", 64, bs0.size());
|
||||
assertEquals("Test3: Wrong length", 64, bs0.length());
|
||||
|
||||
eightbs.flip(7);
|
||||
|
|
@ -640,9 +536,6 @@ public class BitSetTest {
|
|||
assertTrue("Failed to flip bit 127", !eightbs.get(127));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#clear(int, int)
|
||||
*/
|
||||
@Test
|
||||
public void flipII() {
|
||||
BitSet bitset = new BitSet();
|
||||
|
|
@ -673,7 +566,6 @@ public class BitSetTest {
|
|||
bs.set(7);
|
||||
bs.set(10);
|
||||
bs.flip(7, 64);
|
||||
assertEquals("Failed to grow BitSet", 64, bs.size());
|
||||
for (int i = 0; i < 7; i++) {
|
||||
assertTrue("Shouldn't have flipped bit " + i, !bs.get(i));
|
||||
}
|
||||
|
|
@ -764,34 +656,8 @@ public class BitSetTest {
|
|||
for (int i = 221; i < bs.size(); i++) {
|
||||
assertTrue("Shouldn't have flipped bit " + i, !bs.get(i));
|
||||
}
|
||||
|
||||
// test illegal args
|
||||
bs = new BitSet(10);
|
||||
try {
|
||||
bs.flip(-1, 3);
|
||||
fail("Test1: Attempt to flip with negative index failed to generate exception");
|
||||
} catch (IndexOutOfBoundsException e) {
|
||||
// correct behavior
|
||||
}
|
||||
|
||||
try {
|
||||
bs.flip(2, -1);
|
||||
fail("Test2: Attempt to flip with negative index failed to generate exception");
|
||||
} catch (IndexOutOfBoundsException e) {
|
||||
// correct behavior
|
||||
}
|
||||
|
||||
try {
|
||||
bs.flip(4, 2);
|
||||
fail("Test4: Attempt to flip with illegal args failed to generate exception");
|
||||
} catch (IndexOutOfBoundsException e) {
|
||||
// correct behavior
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#set(int)
|
||||
*/
|
||||
@Test
|
||||
public void setI() {
|
||||
// Test for method void java.util.BitSet.set(int)
|
||||
|
|
@ -800,16 +666,8 @@ public class BitSetTest {
|
|||
bs.set(8);
|
||||
assertTrue("Failed to set bit", bs.get(8));
|
||||
|
||||
try {
|
||||
bs.set(-1);
|
||||
fail("Attempt to set at negative index failed to generate exception");
|
||||
} catch (IndexOutOfBoundsException e) {
|
||||
// Correct behaviour
|
||||
}
|
||||
|
||||
// Try setting a bit on a 64 boundary
|
||||
bs.set(128);
|
||||
assertEquals("Failed to grow BitSet", 192, bs.size());
|
||||
assertTrue("Failed to set bit", bs.get(128));
|
||||
|
||||
bs = new BitSet(64);
|
||||
|
|
@ -830,9 +688,6 @@ public class BitSetTest {
|
|||
assertEquals("Test2: Wrong length", 1, bs.length());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#set(int, boolean)
|
||||
*/
|
||||
@Test
|
||||
public void setIZ() {
|
||||
// Test for method void java.util.BitSet.set(int, boolean)
|
||||
|
|
@ -843,9 +698,6 @@ public class BitSetTest {
|
|||
assertTrue("Should have set bit 5 to false", eightbs.get(5));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#set(int, int)
|
||||
*/
|
||||
@Test
|
||||
public void setII() throws IndexOutOfBoundsException {
|
||||
BitSet bitset = new BitSet(30);
|
||||
|
|
@ -875,7 +727,6 @@ public class BitSetTest {
|
|||
// pos1 and pos2 is in the same bitset element, boundry testing
|
||||
bs = new BitSet(16);
|
||||
bs.set(7, 64);
|
||||
assertEquals("Failed to grow BitSet", 64, bs.size());
|
||||
for (int i = 0; i < 7; i++) {
|
||||
assertFalse("Shouldn't have set bit " + i, bs.get(i));
|
||||
}
|
||||
|
|
@ -944,50 +795,22 @@ public class BitSetTest {
|
|||
|
||||
// test illegal args
|
||||
bs = new BitSet(10);
|
||||
try {
|
||||
bs.set(-1, 3);
|
||||
fail("Test1: Attempt to flip with negative index failed to generate exception");
|
||||
} catch (IndexOutOfBoundsException e) {
|
||||
// Correct behavior
|
||||
}
|
||||
|
||||
try {
|
||||
bs.set(2, -1);
|
||||
fail("Test2: Attempt to flip with negative index failed to generate exception");
|
||||
} catch (IndexOutOfBoundsException e) {
|
||||
// Correct behavior
|
||||
}
|
||||
|
||||
bs.set(2, 2);
|
||||
assertFalse("Bit got set incorrectly ", bs.get(2));
|
||||
|
||||
try {
|
||||
bs.set(4, 2);
|
||||
fail("Test4: Attempt to flip with illegal args failed to generate exception");
|
||||
} catch (IndexOutOfBoundsException e) {
|
||||
// Correct behavior
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#set(int, int, boolean)
|
||||
*/
|
||||
@Test
|
||||
public void setIIZ() {
|
||||
// Test for method void java.util.BitSet.set(int, int, boolean)
|
||||
eightbs.set(3, 6, false);
|
||||
assertTrue("Should have set bits 3, 4, and 5 to false", !eightbs.get(3)
|
||||
&& !eightbs.get(4) && !eightbs.get(5));
|
||||
assertTrue("Should have set bits 3, 4, and 5 to false", !eightbs.get(3) && !eightbs.get(4) && !eightbs.get(5));
|
||||
|
||||
eightbs.set(3, 6, true);
|
||||
assertTrue("Should have set bits 3, 4, and 5 to true", eightbs.get(3)
|
||||
&& eightbs.get(4) && eightbs.get(5));
|
||||
assertTrue("Should have set bits 3, 4, and 5 to true", eightbs.get(3) && eightbs.get(4) && eightbs.get(5));
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#intersects(java.util.BitSet)
|
||||
*/
|
||||
@Test
|
||||
public void intersects() {
|
||||
// Test for method boolean java.util.BitSet.intersects(java.util.BitSet)
|
||||
|
|
@ -1001,70 +824,49 @@ public class BitSetTest {
|
|||
bs.set(450);
|
||||
|
||||
BitSet bs2 = new BitSet(8);
|
||||
assertFalse("Test1: intersects() returned incorrect value", bs
|
||||
.intersects(bs2));
|
||||
assertFalse("Test1: intersects() returned incorrect value", bs2
|
||||
.intersects(bs));
|
||||
assertFalse("Test1: intersects() returned incorrect value", bs.intersects(bs2));
|
||||
assertFalse("Test1: intersects() returned incorrect value", bs2.intersects(bs));
|
||||
|
||||
bs2.set(4);
|
||||
assertFalse("Test2: intersects() returned incorrect value", bs
|
||||
.intersects(bs2));
|
||||
assertFalse("Test2: intersects() returned incorrect value", bs2
|
||||
.intersects(bs));
|
||||
assertFalse("Test2: intersects() returned incorrect value", bs.intersects(bs2));
|
||||
assertFalse("Test2: intersects() returned incorrect value", bs2.intersects(bs));
|
||||
|
||||
bs2.clear();
|
||||
bs2.set(5);
|
||||
assertTrue("Test3: intersects() returned incorrect value", bs
|
||||
.intersects(bs2));
|
||||
assertTrue("Test3: intersects() returned incorrect value", bs2
|
||||
.intersects(bs));
|
||||
assertTrue("Test3: intersects() returned incorrect value", bs.intersects(bs2));
|
||||
assertTrue("Test3: intersects() returned incorrect value", bs2.intersects(bs));
|
||||
|
||||
bs2.clear();
|
||||
bs2.set(63);
|
||||
assertTrue("Test4: intersects() returned incorrect value", bs
|
||||
.intersects(bs2));
|
||||
assertTrue("Test4: intersects() returned incorrect value", bs2
|
||||
.intersects(bs));
|
||||
assertTrue("Test4: intersects() returned incorrect value", bs.intersects(bs2));
|
||||
assertTrue("Test4: intersects() returned incorrect value", bs2.intersects(bs));
|
||||
|
||||
bs2.clear();
|
||||
bs2.set(80);
|
||||
assertTrue("Test5: intersects() returned incorrect value", bs
|
||||
.intersects(bs2));
|
||||
assertTrue("Test5: intersects() returned incorrect value", bs2
|
||||
.intersects(bs));
|
||||
assertTrue("Test5: intersects() returned incorrect value", bs.intersects(bs2));
|
||||
assertTrue("Test5: intersects() returned incorrect value", bs2.intersects(bs));
|
||||
|
||||
bs2.clear();
|
||||
bs2.set(127);
|
||||
assertTrue("Test6: intersects() returned incorrect value", bs
|
||||
.intersects(bs2));
|
||||
assertTrue("Test6: intersects() returned incorrect value", bs2
|
||||
.intersects(bs));
|
||||
assertTrue("Test6: intersects() returned incorrect value", bs.intersects(bs2));
|
||||
assertTrue("Test6: intersects() returned incorrect value", bs2.intersects(bs));
|
||||
|
||||
bs2.clear();
|
||||
bs2.set(192);
|
||||
assertTrue("Test7: intersects() returned incorrect value", bs
|
||||
.intersects(bs2));
|
||||
assertTrue("Test7: intersects() returned incorrect value", bs2
|
||||
.intersects(bs));
|
||||
assertTrue("Test7: intersects() returned incorrect value", bs.intersects(bs2));
|
||||
assertTrue("Test7: intersects() returned incorrect value", bs2.intersects(bs));
|
||||
|
||||
bs2.clear();
|
||||
bs2.set(450);
|
||||
assertTrue("Test8: intersects() returned incorrect value", bs
|
||||
.intersects(bs2));
|
||||
assertTrue("Test8: intersects() returned incorrect value", bs2
|
||||
.intersects(bs));
|
||||
assertTrue("Test8: intersects() returned incorrect value", bs.intersects(bs2));
|
||||
assertTrue("Test8: intersects() returned incorrect value", bs2.intersects(bs));
|
||||
|
||||
bs2.clear();
|
||||
bs2.set(500);
|
||||
assertFalse("Test9: intersects() returned incorrect value", bs
|
||||
.intersects(bs2));
|
||||
assertFalse("Test9: intersects() returned incorrect value", bs2
|
||||
.intersects(bs));
|
||||
assertFalse("Test9: intersects() returned incorrect value", bs.intersects(bs2));
|
||||
assertFalse("Test9: intersects() returned incorrect value", bs2.intersects(bs));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#and(java.util.BitSet)
|
||||
*/
|
||||
@Test
|
||||
public void and() {
|
||||
// Test for method void java.util.BitSet.and(java.util.BitSet)
|
||||
|
|
@ -1081,34 +883,27 @@ public class BitSetTest {
|
|||
assertTrue("AND failed to maintain set bits", bs.get(3));
|
||||
bs.and(eightbs);
|
||||
for (int i = 64; i < 128; i++) {
|
||||
assertFalse("Failed to clear extra bits in the receiver BitSet", bs
|
||||
.get(i));
|
||||
assertFalse("Failed to clear extra bits in the receiver BitSet", bs.get(i));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#andNot(java.util.BitSet)
|
||||
*/
|
||||
@Test
|
||||
public void test() {
|
||||
public void andNot() {
|
||||
BitSet bs = (BitSet) eightbs.clone();
|
||||
bs.clear(5);
|
||||
BitSet bs2 = new BitSet();
|
||||
bs2.set(2);
|
||||
bs2.set(3);
|
||||
bs.andNot(bs2);
|
||||
assertEquals("Incorrect bitset after andNot",
|
||||
"{0, 1, 4, 6, 7}", bs.toString());
|
||||
assertEquals("Incorrect bitset after andNot", "{0, 1, 4, 6, 7}", bs.toString());
|
||||
|
||||
bs = new BitSet(0);
|
||||
bs.andNot(bs2);
|
||||
assertEquals("Incorrect size", 0, bs.size());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#or(java.util.BitSet)
|
||||
*/
|
||||
public void test_orLjava_util_BitSet() {
|
||||
@Test
|
||||
public void or() {
|
||||
// Test for method void java.util.BitSet.or(java.util.BitSet)
|
||||
BitSet bs = new BitSet(128);
|
||||
bs.or(eightbs);
|
||||
|
|
@ -1128,10 +923,9 @@ public class BitSetTest {
|
|||
assertFalse("OR set a bit which should be off", bs.get(5));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#xor(java.util.BitSet)
|
||||
*/
|
||||
public void test_xorLjava_util_BitSet() {
|
||||
|
||||
@Test
|
||||
public void xor() {
|
||||
// Test for method void java.util.BitSet.xor(java.util.BitSet)
|
||||
|
||||
BitSet bs = (BitSet) eightbs.clone();
|
||||
|
|
@ -1156,10 +950,8 @@ public class BitSetTest {
|
|||
assertEquals("Test highest bit", "{63}", bs.toString());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#toString()
|
||||
*/
|
||||
public void test_toString() {
|
||||
@Test
|
||||
public void toStringComputed() {
|
||||
// Test for method java.lang.String java.util.BitSet.toString()
|
||||
assertEquals("Returned incorrect string representation",
|
||||
"{0, 1, 2, 3, 4, 5, 6, 7}", eightbs.toString());
|
||||
|
|
@ -1168,9 +960,6 @@ public class BitSetTest {
|
|||
"{0, 1, 3, 4, 5, 6, 7}", eightbs.toString());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#length()
|
||||
*/
|
||||
@Test
|
||||
public void length() {
|
||||
BitSet bs = new BitSet();
|
||||
|
|
@ -1185,9 +974,6 @@ public class BitSetTest {
|
|||
assertEquals("BitSet returned wrong length", 433, bs.length());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#nextSetBit(int)
|
||||
*/
|
||||
@Test
|
||||
public void nextSetBitI() {
|
||||
// Test for method int java.util.BitSet.nextSetBit()
|
||||
|
|
@ -1200,78 +986,51 @@ public class BitSetTest {
|
|||
bs.set(127, 130);
|
||||
bs.set(193);
|
||||
bs.set(450);
|
||||
try {
|
||||
/*try {
|
||||
bs.nextSetBit(-1);
|
||||
fail("Expected IndexOutOfBoundsException for negative index");
|
||||
} catch (IndexOutOfBoundsException e) {
|
||||
// correct behavior
|
||||
}
|
||||
assertEquals("nextSetBit() returned the wrong value", 5, bs
|
||||
.nextSetBit(0));
|
||||
assertEquals("nextSetBit() returned the wrong value", 5, bs
|
||||
.nextSetBit(5));
|
||||
assertEquals("nextSetBit() returned the wrong value", 32, bs
|
||||
.nextSetBit(6));
|
||||
assertEquals("nextSetBit() returned the wrong value", 32, bs
|
||||
.nextSetBit(32));
|
||||
assertEquals("nextSetBit() returned the wrong value", 63, bs
|
||||
.nextSetBit(33));
|
||||
}*/
|
||||
assertEquals("nextSetBit() returned the wrong value", 5, bs.nextSetBit(0));
|
||||
assertEquals("nextSetBit() returned the wrong value", 5, bs.nextSetBit(5));
|
||||
assertEquals("nextSetBit() returned the wrong value", 32, bs.nextSetBit(6));
|
||||
assertEquals("nextSetBit() returned the wrong value", 32, bs.nextSetBit(32));
|
||||
assertEquals("nextSetBit() returned the wrong value", 63, bs.nextSetBit(33));
|
||||
|
||||
// boundary tests
|
||||
assertEquals("nextSetBit() returned the wrong value", 63, bs
|
||||
.nextSetBit(63));
|
||||
assertEquals("nextSetBit() returned the wrong value", 64, bs
|
||||
.nextSetBit(64));
|
||||
assertEquals("nextSetBit() returned the wrong value", 63, bs.nextSetBit(63));
|
||||
assertEquals("nextSetBit() returned the wrong value", 64, bs.nextSetBit(64));
|
||||
|
||||
// at bitset element 1
|
||||
assertEquals("nextSetBit() returned the wrong value", 71, bs
|
||||
.nextSetBit(65));
|
||||
assertEquals("nextSetBit() returned the wrong value", 71, bs
|
||||
.nextSetBit(71));
|
||||
assertEquals("nextSetBit() returned the wrong value", 72, bs
|
||||
.nextSetBit(72));
|
||||
assertEquals("nextSetBit() returned the wrong value", 127, bs
|
||||
.nextSetBit(110));
|
||||
assertEquals("nextSetBit() returned the wrong value", 71, bs.nextSetBit(65));
|
||||
assertEquals("nextSetBit() returned the wrong value", 71, bs.nextSetBit(71));
|
||||
assertEquals("nextSetBit() returned the wrong value", 72, bs.nextSetBit(72));
|
||||
assertEquals("nextSetBit() returned the wrong value", 127, bs.nextSetBit(110));
|
||||
|
||||
// boundary tests
|
||||
assertEquals("nextSetBit() returned the wrong value", 127, bs
|
||||
.nextSetBit(127));
|
||||
assertEquals("nextSetBit() returned the wrong value", 128, bs
|
||||
.nextSetBit(128));
|
||||
assertEquals("nextSetBit() returned the wrong value", 127, bs.nextSetBit(127));
|
||||
assertEquals("nextSetBit() returned the wrong value", 128, bs.nextSetBit(128));
|
||||
|
||||
// at bitset element 2
|
||||
assertEquals("nextSetBit() returned the wrong value", 193, bs
|
||||
.nextSetBit(130));
|
||||
assertEquals("nextSetBit() returned the wrong value", 193, bs.nextSetBit(130));
|
||||
|
||||
assertEquals("nextSetBit() returned the wrong value", 193, bs
|
||||
.nextSetBit(191));
|
||||
assertEquals("nextSetBit() returned the wrong value", 193, bs
|
||||
.nextSetBit(192));
|
||||
assertEquals("nextSetBit() returned the wrong value", 193, bs
|
||||
.nextSetBit(193));
|
||||
assertEquals("nextSetBit() returned the wrong value", 450, bs
|
||||
.nextSetBit(194));
|
||||
assertEquals("nextSetBit() returned the wrong value", 450, bs
|
||||
.nextSetBit(255));
|
||||
assertEquals("nextSetBit() returned the wrong value", 450, bs
|
||||
.nextSetBit(256));
|
||||
assertEquals("nextSetBit() returned the wrong value", 450, bs
|
||||
.nextSetBit(450));
|
||||
assertEquals("nextSetBit() returned the wrong value", 193, bs.nextSetBit(191));
|
||||
assertEquals("nextSetBit() returned the wrong value", 193, bs.nextSetBit(192));
|
||||
assertEquals("nextSetBit() returned the wrong value", 193, bs.nextSetBit(193));
|
||||
assertEquals("nextSetBit() returned the wrong value", 450, bs.nextSetBit(194));
|
||||
assertEquals("nextSetBit() returned the wrong value", 450, bs.nextSetBit(255));
|
||||
assertEquals("nextSetBit() returned the wrong value", 450, bs.nextSetBit(256));
|
||||
assertEquals("nextSetBit() returned the wrong value", 450, bs.nextSetBit(450));
|
||||
|
||||
assertEquals("nextSetBit() returned the wrong value", -1, bs
|
||||
.nextSetBit(451));
|
||||
assertEquals("nextSetBit() returned the wrong value", -1, bs
|
||||
.nextSetBit(511));
|
||||
assertEquals("nextSetBit() returned the wrong value", -1, bs
|
||||
.nextSetBit(512));
|
||||
assertEquals("nextSetBit() returned the wrong value", -1, bs
|
||||
.nextSetBit(800));
|
||||
assertEquals("nextSetBit() returned the wrong value", -1, bs.nextSetBit(451));
|
||||
assertEquals("nextSetBit() returned the wrong value", -1, bs.nextSetBit(511));
|
||||
assertEquals("nextSetBit() returned the wrong value", -1, bs.nextSetBit(512));
|
||||
assertEquals("nextSetBit() returned the wrong value", -1, bs.nextSetBit(800));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#nextClearBit(int)
|
||||
*/
|
||||
public void test_nextClearBitI() {
|
||||
@Test
|
||||
public void nextClearBitI() {
|
||||
// Test for method int java.util.BitSet.nextSetBit()
|
||||
BitSet bs = new BitSet(500);
|
||||
bs.set(0, bs.size() - 1); // ensure all the bits from 0 to bs.size()
|
||||
|
|
@ -1285,86 +1044,58 @@ public class BitSetTest {
|
|||
bs.clear(127, 130);
|
||||
bs.clear(193);
|
||||
bs.clear(450);
|
||||
try {
|
||||
/*try {
|
||||
bs.nextClearBit(-1);
|
||||
fail("Expected IndexOutOfBoundsException for negative index");
|
||||
} catch (IndexOutOfBoundsException e) {
|
||||
// correct behavior
|
||||
}
|
||||
assertEquals("nextClearBit() returned the wrong value", 5, bs
|
||||
.nextClearBit(0));
|
||||
assertEquals("nextClearBit() returned the wrong value", 5, bs
|
||||
.nextClearBit(5));
|
||||
assertEquals("nextClearBit() returned the wrong value", 32, bs
|
||||
.nextClearBit(6));
|
||||
assertEquals("nextClearBit() returned the wrong value", 32, bs
|
||||
.nextClearBit(32));
|
||||
assertEquals("nextClearBit() returned the wrong value", 63, bs
|
||||
.nextClearBit(33));
|
||||
}*/
|
||||
assertEquals("nextClearBit() returned the wrong value", 5, bs.nextClearBit(0));
|
||||
assertEquals("nextClearBit() returned the wrong value", 5, bs.nextClearBit(5));
|
||||
assertEquals("nextClearBit() returned the wrong value", 32, bs.nextClearBit(6));
|
||||
assertEquals("nextClearBit() returned the wrong value", 32, bs.nextClearBit(32));
|
||||
assertEquals("nextClearBit() returned the wrong value", 63, bs.nextClearBit(33));
|
||||
|
||||
// boundary tests
|
||||
assertEquals("nextClearBit() returned the wrong value", 63, bs
|
||||
.nextClearBit(63));
|
||||
assertEquals("nextClearBit() returned the wrong value", 64, bs
|
||||
.nextClearBit(64));
|
||||
assertEquals("nextClearBit() returned the wrong value", 63, bs.nextClearBit(63));
|
||||
assertEquals("nextClearBit() returned the wrong value", 64, bs.nextClearBit(64));
|
||||
|
||||
// at bitset element 1
|
||||
assertEquals("nextClearBit() returned the wrong value", 71, bs
|
||||
.nextClearBit(65));
|
||||
assertEquals("nextClearBit() returned the wrong value", 71, bs
|
||||
.nextClearBit(71));
|
||||
assertEquals("nextClearBit() returned the wrong value", 72, bs
|
||||
.nextClearBit(72));
|
||||
assertEquals("nextClearBit() returned the wrong value", 127, bs
|
||||
.nextClearBit(110));
|
||||
assertEquals("nextClearBit() returned the wrong value", 71, bs.nextClearBit(65));
|
||||
assertEquals("nextClearBit() returned the wrong value", 71, bs.nextClearBit(71));
|
||||
assertEquals("nextClearBit() returned the wrong value", 72, bs.nextClearBit(72));
|
||||
assertEquals("nextClearBit() returned the wrong value", 127, bs.nextClearBit(110));
|
||||
|
||||
// boundary tests
|
||||
assertEquals("nextClearBit() returned the wrong value", 127, bs
|
||||
.nextClearBit(127));
|
||||
assertEquals("nextClearBit() returned the wrong value", 128, bs
|
||||
.nextClearBit(128));
|
||||
assertEquals("nextClearBit() returned the wrong value", 127, bs.nextClearBit(127));
|
||||
assertEquals("nextClearBit() returned the wrong value", 128, bs.nextClearBit(128));
|
||||
|
||||
// at bitset element 2
|
||||
assertEquals("nextClearBit() returned the wrong value", 193, bs
|
||||
.nextClearBit(130));
|
||||
assertEquals("nextClearBit() returned the wrong value", 193, bs
|
||||
.nextClearBit(191));
|
||||
assertEquals("nextClearBit() returned the wrong value", 193, bs.nextClearBit(130));
|
||||
assertEquals("nextClearBit() returned the wrong value", 193, bs.nextClearBit(191));
|
||||
|
||||
assertEquals("nextClearBit() returned the wrong value", 193, bs
|
||||
.nextClearBit(192));
|
||||
assertEquals("nextClearBit() returned the wrong value", 193, bs
|
||||
.nextClearBit(193));
|
||||
assertEquals("nextClearBit() returned the wrong value", 450, bs
|
||||
.nextClearBit(194));
|
||||
assertEquals("nextClearBit() returned the wrong value", 450, bs
|
||||
.nextClearBit(255));
|
||||
assertEquals("nextClearBit() returned the wrong value", 450, bs
|
||||
.nextClearBit(256));
|
||||
assertEquals("nextClearBit() returned the wrong value", 450, bs
|
||||
.nextClearBit(450));
|
||||
assertEquals("nextClearBit() returned the wrong value", 193, bs.nextClearBit(192));
|
||||
assertEquals("nextClearBit() returned the wrong value", 193, bs.nextClearBit(193));
|
||||
assertEquals("nextClearBit() returned the wrong value", 450, bs.nextClearBit(194));
|
||||
assertEquals("nextClearBit() returned the wrong value", 450, bs.nextClearBit(255));
|
||||
assertEquals("nextClearBit() returned the wrong value", 450, bs.nextClearBit(256));
|
||||
assertEquals("nextClearBit() returned the wrong value", 450, bs.nextClearBit(450));
|
||||
|
||||
// bitset has 1 still the end of bs.size() -1, but calling nextClearBit
|
||||
// with any index value
|
||||
// after the last true bit should return bs.size(),
|
||||
assertEquals("nextClearBit() returned the wrong value", 512, bs
|
||||
.nextClearBit(451));
|
||||
assertEquals("nextClearBit() returned the wrong value", 512, bs
|
||||
.nextClearBit(511));
|
||||
assertEquals("nextClearBit() returned the wrong value", 512, bs
|
||||
.nextClearBit(512));
|
||||
assertEquals("nextClearBit() returned the wrong value", 512, bs.nextClearBit(451));
|
||||
assertEquals("nextClearBit() returned the wrong value", 512, bs.nextClearBit(511));
|
||||
assertEquals("nextClearBit() returned the wrong value", 512, bs.nextClearBit(512));
|
||||
|
||||
// if the index is larger than bs.size(), nextClearBit should return
|
||||
// index;
|
||||
assertEquals("nextClearBit() returned the wrong value", 513, bs
|
||||
.nextClearBit(513));
|
||||
assertEquals("nextClearBit() returned the wrong value", 800, bs
|
||||
.nextClearBit(800));
|
||||
assertEquals("nextClearBit() returned the wrong value", 513, bs.nextClearBit(513));
|
||||
assertEquals("nextClearBit() returned the wrong value", 800, bs.nextClearBit(800));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#isEmpty()
|
||||
*/
|
||||
public void test_isEmpty() {
|
||||
@Test
|
||||
public void isEmpty() {
|
||||
BitSet bs = new BitSet(500);
|
||||
assertTrue("Test: isEmpty() returned wrong value", bs.isEmpty());
|
||||
|
||||
|
|
@ -1392,10 +1123,8 @@ public class BitSetTest {
|
|||
assertFalse("Test4: isEmpty() returned wrong value", bs.isEmpty());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tests java.util.BitSet#cardinality()
|
||||
*/
|
||||
public void test_cardinality() {
|
||||
@Test
|
||||
public void cardinality() {
|
||||
// test for method int java.util.BitSet.cardinality()
|
||||
BitSet bs = new BitSet(500);
|
||||
bs.set(5);
|
||||
|
|
@ -1409,14 +1138,12 @@ public class BitSetTest {
|
|||
assertEquals("cardinality() returned wrong value", 48, bs.cardinality());
|
||||
|
||||
bs.flip(0, 500);
|
||||
assertEquals("cardinality() returned wrong value", 452, bs
|
||||
.cardinality());
|
||||
assertEquals("cardinality() returned wrong value", 452, bs.cardinality());
|
||||
|
||||
bs.clear();
|
||||
assertEquals("cardinality() returned wrong value", 0, bs.cardinality());
|
||||
|
||||
bs.set(0, 500);
|
||||
assertEquals("cardinality() returned wrong value", 500, bs
|
||||
.cardinality());
|
||||
assertEquals("cardinality() returned wrong value", 500, bs.cardinality());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ $rt_createLongArray = function(sz) {
|
|||
var data = new Array(sz);
|
||||
var arr = new ($rt_arraycls($rt_longcls()))(data);
|
||||
for (var i = 0; i < sz; i = (i + 1) | 0) {
|
||||
data[i] = Long.ZERO;
|
||||
data[i] = Long_ZERO;
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user