Apache
/
lucene
mirror of https://github.com/apache/lucene.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

LUCENE-2541: Improve readability of TestNumericUtils by using autoboxing and varargs 

git-svn-id: https://svn.apache.org/repos/asf/lucene/dev/trunk@965110 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Uwe Schindler 2010-07-17 17:16:14 +00:00
parent 7902749e3e
commit 42aa9a20b3
1 changed files with 195 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

386
lucene/src/test/org/apache/lucene/util/TestNumericUtils.java
View File

@ -180,12 +180,14 @@ public class TestNumericUtils extends LuceneTestCase {
// INFO: Tests for trieCodeLong()/trieCodeInt() not needed because implicitely tested by range filter tests // INFO: Tests for trieCodeLong()/trieCodeInt() not needed because implicitely tested by range filter tests
/** Note: The neededBounds iterator must be unsigned (easier understanding what's happening) */ /** Note: The neededBounds Iterable must be unsigned (easier understanding what's happening) */
private void assertLongRangeSplit(final long lower, final long upper, int precisionStep, private void assertLongRangeSplit(final long lower, final long upper, int precisionStep,
final boolean useBitSet, final Iterator<Long> neededBounds, final Iterator<Integer> neededShifts final boolean useBitSet, final Iterable<Long> expectedBounds, final Iterable<Integer> expectedShifts
) throws Exception { ) throws Exception {
final OpenBitSet bits=useBitSet ? new OpenBitSet(upper-lower+1) : null; final OpenBitSet bits=useBitSet ? new OpenBitSet(upper-lower+1) : null;
final Iterator<Long> neededBounds = (expectedBounds == null) ? null : expectedBounds.iterator();
final Iterator<Integer> neededShifts = (expectedShifts == null) ? null : expectedShifts.iterator();
NumericUtils.splitLongRange(new NumericUtils.LongRangeBuilder() { NumericUtils.splitLongRange(new NumericUtils.LongRangeBuilder() {
@Override @Override
public void addRange(long min, long max, int shift) { public void addRange(long min, long max, int shift) {
@ -200,7 +202,7 @@ public class TestNumericUtils extends LuceneTestCase {
// make unsigned longs for easier display and understanding // make unsigned longs for easier display and understanding
min ^= 0x8000000000000000L; min ^= 0x8000000000000000L;
max ^= 0x8000000000000000L; max ^= 0x8000000000000000L;
//System.out.println("Long.valueOf(0x"+Long.toHexString(min>>>shift)+"L),Long.valueOf(0x"+Long.toHexString(max>>>shift)+"L)/*shift="+shift+"*/,"); //System.out.println("0x"+Long.toHexString(min>>>shift)+"L,0x"+Long.toHexString(max>>>shift)+"L)/*shift="+shift+"*/,");
assertEquals( "shift", neededShifts.next().intValue(), shift); assertEquals( "shift", neededShifts.next().intValue(), shift);
assertEquals( "inner min bound", neededBounds.next().longValue(), min>>>shift); assertEquals( "inner min bound", neededBounds.next().longValue(), min>>>shift);
assertEquals( "inner max bound", neededBounds.next().longValue(), max>>>shift); assertEquals( "inner max bound", neededBounds.next().longValue(), max>>>shift);
@ -217,92 +219,92 @@ public class TestNumericUtils extends LuceneTestCase {
/** LUCENE-2541: NumericRangeQuery errors with endpoints near long min and max values */ /** LUCENE-2541: NumericRangeQuery errors with endpoints near long min and max values */
public void testLongExtremeValues() throws Exception { public void testLongExtremeValues() throws Exception {
// upper end extremes // upper end extremes
assertLongRangeSplit(Long.MAX_VALUE, Long.MAX_VALUE, 1, true, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MAX_VALUE, Long.MAX_VALUE, 1, true, Arrays.asList(
Long.valueOf(0xffffffffffffffffL),Long.valueOf(0xffffffffffffffffL) 0xffffffffffffffffL,0xffffffffffffffffL
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0) 0
}).iterator()); ));
assertLongRangeSplit(Long.MAX_VALUE, Long.MAX_VALUE, 2, true, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MAX_VALUE, Long.MAX_VALUE, 2, true, Arrays.asList(
Long.valueOf(0xffffffffffffffffL),Long.valueOf(0xffffffffffffffffL) 0xffffffffffffffffL,0xffffffffffffffffL
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0) 0
}).iterator()); ));
assertLongRangeSplit(Long.MAX_VALUE, Long.MAX_VALUE, 4, true, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MAX_VALUE, Long.MAX_VALUE, 4, true, Arrays.asList(
Long.valueOf(0xffffffffffffffffL),Long.valueOf(0xffffffffffffffffL) 0xffffffffffffffffL,0xffffffffffffffffL
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0) 0
}).iterator()); ));
assertLongRangeSplit(Long.MAX_VALUE, Long.MAX_VALUE, 6, true, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MAX_VALUE, Long.MAX_VALUE, 6, true, Arrays.asList(
Long.valueOf(0xffffffffffffffffL),Long.valueOf(0xffffffffffffffffL) 0xffffffffffffffffL,0xffffffffffffffffL
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0) 0
}).iterator()); ));
assertLongRangeSplit(Long.MAX_VALUE, Long.MAX_VALUE, 8, true, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MAX_VALUE, Long.MAX_VALUE, 8, true, Arrays.asList(
Long.valueOf(0xffffffffffffffffL),Long.valueOf(0xffffffffffffffffL) 0xffffffffffffffffL,0xffffffffffffffffL
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0) 0
}).iterator()); ));
assertLongRangeSplit(Long.MAX_VALUE, Long.MAX_VALUE, 64, true, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MAX_VALUE, Long.MAX_VALUE, 64, true, Arrays.asList(
Long.valueOf(0xffffffffffffffffL),Long.valueOf(0xffffffffffffffffL) 0xffffffffffffffffL,0xffffffffffffffffL
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0) 0
}).iterator()); ));
assertLongRangeSplit(Long.MAX_VALUE-0xfL, Long.MAX_VALUE, 4, true, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MAX_VALUE-0xfL, Long.MAX_VALUE, 4, true, Arrays.asList(
Long.valueOf(0xfffffffffffffffL),Long.valueOf(0xfffffffffffffffL) 0xfffffffffffffffL,0xfffffffffffffffL
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(4) 4
}).iterator()); ));
assertLongRangeSplit(Long.MAX_VALUE-0x10L, Long.MAX_VALUE, 4, true, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MAX_VALUE-0x10L, Long.MAX_VALUE, 4, true, Arrays.asList(
Long.valueOf(0xffffffffffffffefL),Long.valueOf(0xffffffffffffffefL), 0xffffffffffffffefL,0xffffffffffffffefL,
Long.valueOf(0xfffffffffffffffL),Long.valueOf(0xfffffffffffffffL) 0xfffffffffffffffL,0xfffffffffffffffL
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0), Integer.valueOf(4), 0, 4
}).iterator()); ));
// lower end extremes // lower end extremes
assertLongRangeSplit(Long.MIN_VALUE, Long.MIN_VALUE, 1, true, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MIN_VALUE, Long.MIN_VALUE, 1, true, Arrays.asList(
Long.valueOf(0x0000000000000000L),Long.valueOf(0x0000000000000000L) 0x0000000000000000L,0x0000000000000000L
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0) 0
}).iterator()); ));
assertLongRangeSplit(Long.MIN_VALUE, Long.MIN_VALUE, 2, true, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MIN_VALUE, Long.MIN_VALUE, 2, true, Arrays.asList(
Long.valueOf(0x0000000000000000L),Long.valueOf(0x0000000000000000L) 0x0000000000000000L,0x0000000000000000L
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0) 0
}).iterator()); ));
assertLongRangeSplit(Long.MIN_VALUE, Long.MIN_VALUE, 4, true, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MIN_VALUE, Long.MIN_VALUE, 4, true, Arrays.asList(
Long.valueOf(0x0000000000000000L),Long.valueOf(0x0000000000000000L) 0x0000000000000000L,0x0000000000000000L
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0) 0
}).iterator()); ));
assertLongRangeSplit(Long.MIN_VALUE, Long.MIN_VALUE, 6, true, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MIN_VALUE, Long.MIN_VALUE, 6, true, Arrays.asList(
Long.valueOf(0x0000000000000000L),Long.valueOf(0x0000000000000000L) 0x0000000000000000L,0x0000000000000000L
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0) 0
}).iterator()); ));
assertLongRangeSplit(Long.MIN_VALUE, Long.MIN_VALUE, 8, true, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MIN_VALUE, Long.MIN_VALUE, 8, true, Arrays.asList(
Long.valueOf(0x0000000000000000L),Long.valueOf(0x0000000000000000L) 0x0000000000000000L,0x0000000000000000L
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0) 0
}).iterator()); ));
assertLongRangeSplit(Long.MIN_VALUE, Long.MIN_VALUE, 64, true, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MIN_VALUE, Long.MIN_VALUE, 64, true, Arrays.asList(
Long.valueOf(0x0000000000000000L),Long.valueOf(0x0000000000000000L) 0x0000000000000000L,0x0000000000000000L
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0) 0
}).iterator()); ));
assertLongRangeSplit(Long.MIN_VALUE, Long.MIN_VALUE+0xfL, 4, true, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MIN_VALUE, Long.MIN_VALUE+0xfL, 4, true, Arrays.asList(
Long.valueOf(0x000000000000000L),Long.valueOf(0x000000000000000L) 0x000000000000000L,0x000000000000000L
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(4) 4
}).iterator()); ));
assertLongRangeSplit(Long.MIN_VALUE, Long.MIN_VALUE+0x10L, 4, true, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MIN_VALUE, Long.MIN_VALUE+0x10L, 4, true, Arrays.asList(
Long.valueOf(0x0000000000000010L),Long.valueOf(0x0000000000000010L), 0x0000000000000010L,0x0000000000000010L,
Long.valueOf(0x000000000000000L),Long.valueOf(0x000000000000000L) 0x000000000000000L,0x000000000000000L
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0), Integer.valueOf(4), 0, 4
}).iterator()); ));
} }
public void testRandomSplit() throws Exception { public void testRandomSplit() throws Exception {
@ -349,81 +351,83 @@ public class TestNumericUtils extends LuceneTestCase {
public void testSplitLongRange() throws Exception { public void testSplitLongRange() throws Exception {
// a hard-coded "standard" range // a hard-coded "standard" range
assertLongRangeSplit(-5000L, 9500L, 4, true, Arrays.asList(new Long[]{ assertLongRangeSplit(-5000L, 9500L, 4, true, Arrays.asList(
Long.valueOf(0x7fffffffffffec78L),Long.valueOf(0x7fffffffffffec7fL), 0x7fffffffffffec78L,0x7fffffffffffec7fL,
Long.valueOf(0x8000000000002510L),Long.valueOf(0x800000000000251cL), 0x8000000000002510L,0x800000000000251cL,
Long.valueOf(0x7fffffffffffec8L), Long.valueOf(0x7fffffffffffecfL), 0x7fffffffffffec8L, 0x7fffffffffffecfL,
Long.valueOf(0x800000000000250L), Long.valueOf(0x800000000000250L), 0x800000000000250L, 0x800000000000250L,
Long.valueOf(0x7fffffffffffedL), Long.valueOf(0x7fffffffffffefL), 0x7fffffffffffedL, 0x7fffffffffffefL,
Long.valueOf(0x80000000000020L), Long.valueOf(0x80000000000024L), 0x80000000000020L, 0x80000000000024L,
Long.valueOf(0x7ffffffffffffL), Long.valueOf(0x8000000000001L) 0x7ffffffffffffL, 0x8000000000001L
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0), Integer.valueOf(0), 0, 0,
Integer.valueOf(4), Integer.valueOf(4), 4, 4,
Integer.valueOf(8), Integer.valueOf(8), 8, 8,
Integer.valueOf(12) 12
}).iterator()); ));
// the same with no range splitting // the same with no range splitting
assertLongRangeSplit(-5000L, 9500L, 64, true, Arrays.asList(new Long[]{ assertLongRangeSplit(-5000L, 9500L, 64, true, Arrays.asList(
Long.valueOf(0x7fffffffffffec78L),Long.valueOf(0x800000000000251cL) 0x7fffffffffffec78L,0x800000000000251cL
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0) 0
}).iterator()); ));
// this tests optimized range splitting, if one of the inner bounds // this tests optimized range splitting, if one of the inner bounds
// is also the bound of the next lower precision, it should be used completely // is also the bound of the next lower precision, it should be used completely
assertLongRangeSplit(0L, 1024L+63L, 4, true, Arrays.asList(new Long[]{ assertLongRangeSplit(0L, 1024L+63L, 4, true, Arrays.asList(
Long.valueOf(0x800000000000040L), Long.valueOf(0x800000000000043L), 0x800000000000040L, 0x800000000000043L,
Long.valueOf(0x80000000000000L), Long.valueOf(0x80000000000003L) 0x80000000000000L, 0x80000000000003L
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(4), Integer.valueOf(8) 4, 8
}).iterator()); ));
// the full long range should only consist of a lowest precision range; no bitset testing here, as too much memory needed :-) // the full long range should only consist of a lowest precision range; no bitset testing here, as too much memory needed :-)
assertLongRangeSplit(Long.MIN_VALUE, Long.MAX_VALUE, 8, false, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MIN_VALUE, Long.MAX_VALUE, 8, false, Arrays.asList(
Long.valueOf(0x00L),Long.valueOf(0xffL) 0x00L,0xffL
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(56) 56
}).iterator()); ));
// the same with precisionStep=4 // the same with precisionStep=4
assertLongRangeSplit(Long.MIN_VALUE, Long.MAX_VALUE, 4, false, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MIN_VALUE, Long.MAX_VALUE, 4, false, Arrays.asList(
Long.valueOf(0x0L),Long.valueOf(0xfL) 0x0L,0xfL
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(60) 60
}).iterator()); ));
// the same with precisionStep=2 // the same with precisionStep=2
assertLongRangeSplit(Long.MIN_VALUE, Long.MAX_VALUE, 2, false, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MIN_VALUE, Long.MAX_VALUE, 2, false, Arrays.asList(
Long.valueOf(0x0L),Long.valueOf(0x3L) 0x0L,0x3L
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(62) 62
}).iterator()); ));
// the same with precisionStep=1 // the same with precisionStep=1
assertLongRangeSplit(Long.MIN_VALUE, Long.MAX_VALUE, 1, false, Arrays.asList(new Long[]{ assertLongRangeSplit(Long.MIN_VALUE, Long.MAX_VALUE, 1, false, Arrays.asList(
Long.valueOf(0x0L),Long.valueOf(0x1L) 0x0L,0x1L
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(63) 63
}).iterator()); ));
// a inverse range should produce no sub-ranges // a inverse range should produce no sub-ranges
assertLongRangeSplit(9500L, -5000L, 4, false, Collections.<Long>emptyList().iterator(), Collections.<Integer>emptyList().iterator()); assertLongRangeSplit(9500L, -5000L, 4, false, Collections.<Long>emptyList(), Collections.<Integer>emptyList());
// a 0-length range should reproduce the range itsself // a 0-length range should reproduce the range itsself
assertLongRangeSplit(9500L, 9500L, 4, false, Arrays.asList(new Long[]{ assertLongRangeSplit(9500L, 9500L, 4, false, Arrays.asList(
Long.valueOf(0x800000000000251cL),Long.valueOf(0x800000000000251cL) 0x800000000000251cL,0x800000000000251cL
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0) 0
}).iterator()); ));
} }
/** Note: The neededBounds iterator must be unsigned (easier understanding what's happening) */ /** Note: The neededBounds Iterable must be unsigned (easier understanding what's happening) */
private void assertIntRangeSplit(final int lower, final int upper, int precisionStep, private void assertIntRangeSplit(final int lower, final int upper, int precisionStep,
final boolean useBitSet, final Iterator<Integer> neededBounds, final Iterator<Integer> neededShifts final boolean useBitSet, final Iterable<Integer> expectedBounds, final Iterable<Integer> expectedShifts
) throws Exception { ) throws Exception {
final OpenBitSet bits=useBitSet ? new OpenBitSet(upper-lower+1) : null; final OpenBitSet bits=useBitSet ? new OpenBitSet(upper-lower+1) : null;
final Iterator<Integer> neededBounds = (expectedBounds == null) ? null : expectedBounds.iterator();
final Iterator<Integer> neededShifts = (expectedShifts == null) ? null : expectedShifts.iterator();
NumericUtils.splitIntRange(new NumericUtils.IntRangeBuilder() { NumericUtils.splitIntRange(new NumericUtils.IntRangeBuilder() {
@Override @Override
@ -439,7 +443,7 @@ public class TestNumericUtils extends LuceneTestCase {
// make unsigned ints for easier display and understanding // make unsigned ints for easier display and understanding
min ^= 0x80000000; min ^= 0x80000000;
max ^= 0x80000000; max ^= 0x80000000;
//System.out.println("Integer.valueOf(0x"+Integer.toHexString(min>>>shift)+"),Integer.valueOf(0x"+Integer.toHexString(max>>>shift)+")/*shift="+shift+"*/,"); //System.out.println("0x"+Integer.toHexString(min>>>shift)+",0x"+Integer.toHexString(max>>>shift)+")/*shift="+shift+"*/,");
assertEquals( "shift", neededShifts.next().intValue(), shift); assertEquals( "shift", neededShifts.next().intValue(), shift);
assertEquals( "inner min bound", neededBounds.next().intValue(), min>>>shift); assertEquals( "inner min bound", neededBounds.next().intValue(), min>>>shift);
assertEquals( "inner max bound", neededBounds.next().intValue(), max>>>shift); assertEquals( "inner max bound", neededBounds.next().intValue(), max>>>shift);
@ -455,74 +459,74 @@ public class TestNumericUtils extends LuceneTestCase {
public void testSplitIntRange() throws Exception { public void testSplitIntRange() throws Exception {
// a hard-coded "standard" range // a hard-coded "standard" range
assertIntRangeSplit(-5000, 9500, 4, true, Arrays.asList(new Integer[]{ assertIntRangeSplit(-5000, 9500, 4, true, Arrays.asList(
Integer.valueOf(0x7fffec78),Integer.valueOf(0x7fffec7f), 0x7fffec78,0x7fffec7f,
Integer.valueOf(0x80002510),Integer.valueOf(0x8000251c), 0x80002510,0x8000251c,
Integer.valueOf(0x7fffec8), Integer.valueOf(0x7fffecf), 0x7fffec8, 0x7fffecf,
Integer.valueOf(0x8000250), Integer.valueOf(0x8000250), 0x8000250, 0x8000250,
Integer.valueOf(0x7fffed), Integer.valueOf(0x7fffef), 0x7fffed, 0x7fffef,
Integer.valueOf(0x800020), Integer.valueOf(0x800024), 0x800020, 0x800024,
Integer.valueOf(0x7ffff), Integer.valueOf(0x80001) 0x7ffff, 0x80001
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0), Integer.valueOf(0), 0, 0,
Integer.valueOf(4), Integer.valueOf(4), 4, 4,
Integer.valueOf(8), Integer.valueOf(8), 8, 8,
Integer.valueOf(12) 12
}).iterator()); ));
// the same with no range splitting // the same with no range splitting
assertIntRangeSplit(-5000, 9500, 32, true, Arrays.asList(new Integer[]{ assertIntRangeSplit(-5000, 9500, 32, true, Arrays.asList(
Integer.valueOf(0x7fffec78),Integer.valueOf(0x8000251c) 0x7fffec78,0x8000251c
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0) 0
}).iterator()); ));
// this tests optimized range splitting, if one of the inner bounds // this tests optimized range splitting, if one of the inner bounds
// is also the bound of the next lower precision, it should be used completely // is also the bound of the next lower precision, it should be used completely
assertIntRangeSplit(0, 1024+63, 4, true, Arrays.asList(new Integer[]{ assertIntRangeSplit(0, 1024+63, 4, true, Arrays.asList(
Integer.valueOf(0x8000040), Integer.valueOf(0x8000043), 0x8000040, 0x8000043,
Integer.valueOf(0x800000), Integer.valueOf(0x800003) 0x800000, 0x800003
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(4), Integer.valueOf(8) 4, 8
}).iterator()); ));
// the full int range should only consist of a lowest precision range; no bitset testing here, as too much memory needed :-) // the full int range should only consist of a lowest precision range; no bitset testing here, as too much memory needed :-)
assertIntRangeSplit(Integer.MIN_VALUE, Integer.MAX_VALUE, 8, false, Arrays.asList(new Integer[]{ assertIntRangeSplit(Integer.MIN_VALUE, Integer.MAX_VALUE, 8, false, Arrays.asList(
Integer.valueOf(0x00),Integer.valueOf(0xff) 0x00,0xff
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(24) 24
}).iterator()); ));
// the same with precisionStep=4 // the same with precisionStep=4
assertIntRangeSplit(Integer.MIN_VALUE, Integer.MAX_VALUE, 4, false, Arrays.asList(new Integer[]{ assertIntRangeSplit(Integer.MIN_VALUE, Integer.MAX_VALUE, 4, false, Arrays.asList(
Integer.valueOf(0x0),Integer.valueOf(0xf) 0x0,0xf
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(28) 28
}).iterator()); ));
// the same with precisionStep=2 // the same with precisionStep=2
assertIntRangeSplit(Integer.MIN_VALUE, Integer.MAX_VALUE, 2, false, Arrays.asList(new Integer[]{ assertIntRangeSplit(Integer.MIN_VALUE, Integer.MAX_VALUE, 2, false, Arrays.asList(
Integer.valueOf(0x0),Integer.valueOf(0x3) 0x0,0x3
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(30) 30
}).iterator()); ));
// the same with precisionStep=1 // the same with precisionStep=1
assertIntRangeSplit(Integer.MIN_VALUE, Integer.MAX_VALUE, 1, false, Arrays.asList(new Integer[]{ assertIntRangeSplit(Integer.MIN_VALUE, Integer.MAX_VALUE, 1, false, Arrays.asList(
Integer.valueOf(0x0),Integer.valueOf(0x1) 0x0,0x1
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(31) 31
}).iterator()); ));
// a inverse range should produce no sub-ranges // a inverse range should produce no sub-ranges
assertIntRangeSplit(9500, -5000, 4, false, Collections.<Integer>emptyList().iterator(), Collections.<Integer>emptyList().iterator()); assertIntRangeSplit(9500, -5000, 4, false, Collections.<Integer>emptyList(), Collections.<Integer>emptyList());
// a 0-length range should reproduce the range itsself // a 0-length range should reproduce the range itsself
assertIntRangeSplit(9500, 9500, 4, false, Arrays.asList(new Integer[]{ assertIntRangeSplit(9500, 9500, 4, false, Arrays.asList(
Integer.valueOf(0x8000251c),Integer.valueOf(0x8000251c) 0x8000251c,0x8000251c
}).iterator(), Arrays.asList(new Integer[]{ ), Arrays.asList(
Integer.valueOf(0) 0
}).iterator()); ));
} }
} }