Java VisibleForTesting类代码示例

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
static List<Range> reduce(List<Range> ranges) {
    List<Range> list = Lists.newArrayList();
    Range previous = null;
    for (Range r : ranges) {
        if (previous != null) {
            if (previous.high() >= r.low() - 1) {
                // combine with previous because overlapping or contiguous
                previous = new Range(previous.low(), Math.max(previous.high(), r.high()));
            } else {
                list.add(previous);
                previous = r;
            }
        } else {
            previous = r;
        }
    }
    if (previous != null) {
        list.add(previous);
    }
    return list;
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
Range toRange(Box box, BoxMinMaxIndexEstimationStrategy strategy) {
    Preconditions.checkNotNull(strategy, "strategy cannot be null");
    Visitor visitor = new Visitor();
    if (strategy == BoxMinMaxIndexEstimationStrategy.SCAN_ENTIRE_PERIMETER) {
        // brute force method of finding min and max values within box
        // min and max values must be on the perimeter of the box
        visitPerimeter(box, visitor);
    } else {
        // TODO ideally don't use brute force but this method not working yet
        // not a problem with visitVertices I don't think but perhaps the choice of
        // split indices
        // visitVertices(box, visitor);
        throw new RuntimeException("Unsupported strategy: " + strategy);
    }
    return visitor.getRange();
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
BigInteger toIndex(long... transposedIndex) {
    byte[] b = new byte[length];
    int bIndex = length - 1;
    long mask = 1L << (bits - 1);
    for (int i = 0; i < bits; i++) {
        for (int j = 0; j < transposedIndex.length; j++) {
            if ((transposedIndex[j] & mask) != 0) {
                b[length - 1 - bIndex / 8] |= 1 << (bIndex % 8);
            }
            bIndex--;
        }
        mask >>= 1;
    }
    // b is expected to be BigEndian
    return new BigInteger(1, b);
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
void visitBox(Box box, Consumer<long[]> visitor) {
    int dimensions = box.a.length;
    long[] p = new long[dimensions];
    for (int i = 0; i < dimensions; i++) {
        p[i] = Math.min(box.a[i], box.b[i]);
    }
    visitBox(box, p, 0, visitor);
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
void visitVertices(Box box, Consumer<long[]> visitor) {
    for (long i = 0; i < (1L << dimensions); i++) {
        long[] x = new long[box.a.length];
        for (int j = 0; j < box.dimensions(); j++) {
            if ((i & (1L << j)) != 0) {
                // if jth bit set
                x[j] = box.b[j];
            } else {
                x[j] = box.a[j];
            }
        }
        visitor.accept(x);
    }
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
/**
 * <p>
 * Given the axes (coordinates) of a point in N-Dimensional space, find the
 * distance to that point along the Hilbert curve. That distance will be
 * transposed; broken into pieces and distributed into an array.
 *
 * <p>
 * The number of dimensions is the length of the hilbertAxes array.
 *
 * <p>
 * Note: In Skilling's paper, this function is called AxestoTranspose.
 * 
 * @param mutate
 * 
 * @param point
 *            Point in N-space
 * @return The Hilbert distance (or index) as a transposed Hilbert index
 */
@VisibleForTesting
static long[] transposedIndex(int bits, long... point) {
    final long M = 1L << (bits - 1);
    final int n = point.length; // n: Number of dimensions
    final long[] x = Arrays.copyOf(point, n);
    long p, q, t;
    int i;
    // Inverse undo
    for (q = M; q > 1; q >>= 1) {
        p = q - 1;
        for (i = 0; i < n; i++)
            if ((x[i] & q) != 0)
                x[0] ^= p; // invert
            else {
                t = (x[0] ^ x[i]) & p;
                x[0] ^= t;
                x[i] ^= t;
            }
    } // exchange
      // Gray encode
    for (i = 1; i < n; i++)
        x[i] ^= x[i - 1];
    t = 0;
    for (q = M; q > 1; q >>= 1)
        if ((x[n - 1] & q) != 0)
            t ^= q - 1;
    for (i = 0; i < n; i++)
        x[i] ^= t;

    return x;
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
Options(Callable<File> filefactory, int pageSizeBytes, Scheduler scheduler) {
    Preconditions.checkNotNull(filefactory);
    Preconditions.checkArgument(pageSizeBytes > 0, "bufferSizeBytes must be greater than 0");
    Preconditions.checkNotNull(scheduler);
    this.fileFactory = filefactory;
    this.pageSizeBytes = pageSizeBytes;
    this.scheduler = scheduler;
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
static void closeQuietly(Socket socket) {
    try {
        socket.close();
    } catch (IOException e) {
        // ignore exception
    }
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
public static void close(PagedQueue queue) {
    try {
        queue.close();
    } catch (Throwable err) {
        Exceptions.throwIfFatal(err);
        RxJavaPlugins.onError(err);
    }
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
static Method getMethod(Class<?> cls, String name, Class<?>... params) {
    Method m;
    try {
        m = cls.getDeclaredMethod(name, params);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    m.setAccessible(true);
    return m;
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
/**
 * Returns a capacity that is sufficient to keep the map from being resized
 * as long as it grows no larger than expectedSize and the load factor is >=
 * its default (0.75).
 */
@VisibleForTesting
static int capacity(int expectedSize) {
    if (expectedSize < 3) {
        checkNonnegative(expectedSize, "expectedSize");
        return expectedSize + 1;
    }
    if (expectedSize < MAX_POWER_OF_TWO) {
        return expectedSize + expectedSize / 3;
    }
    return Integer.MAX_VALUE; // any large value
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
static int checkNonnegative(int value, String name) {
    if (value < 0) {
        throw new IllegalArgumentException(name + " cannot be negative but was: " + value);
    }
    return value;
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
static int computeArrayListCapacity(int arraySize) {
    Preconditions.checkArgument(arraySize >= 0, "arraySize must be non-negative");

    // TODO(kevinb): Figure out the right behavior, and document it
    return saturatedCast(5L + arraySize + (arraySize / 10));
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
/**
 * Returns the {@code int} nearest in value to {@code value}.
 *
 * @param value
 *            any {@code long} value
 * @return the same value cast to {@code int} if it is in the range of the
 *         {@code int} type, {@link Integer#MAX_VALUE} if it is too large,
 *         or {@link Integer#MIN_VALUE} if it is too small
 */
@VisibleForTesting
static int saturatedCast(long value) {
    if (value > Integer.MAX_VALUE) {
        return Integer.MAX_VALUE;
    }
    if (value < Integer.MIN_VALUE) {
        return Integer.MIN_VALUE;
    }
    return (int) value;
}
 

import com.github.davidmoten.guavamini.annotations.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
int height() {
    return height;
}