method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void flip(final long x) { byte[] high = LongUtils.highPart(x); ContainerWithIndex containerWithIndex = highLowContainer.searchContainer(high); if (containerWithIndex == null) { addLong(x); } else { char low = LongUtils.lowPart(x); Container freshOne = containerWithIndex.getContainer().flip(low); highLowContainer.replaceContainer(containerWithIndex.getContainerIdx(), freshOne); } } Roaring64Bitmap(); void addInt(int x); @Override void addLong(long x); @Override long getLongCardinality(); int getIntCardinality(); @Override long select(final long j); Iterator<Long> iterator(); @Override void forEach(final LongConsumer lc); @Override long rankLong(long id); void or(final Roaring64Bitmap x2); void xor(final Roaring64Bitmap x2); void and(final Roaring64Bitmap x2); void andNot(final Roaring64Bitmap x2); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); @Override String toString(); @Override LongIterator getLongIterator(); @Override boolean contains(long x); @Override int getSizeInBytes(); @Override long getLongSizeInBytes(); @Override boolean isEmpty(); @Override ImmutableLongBitmapDataProvider limit(long x); boolean runOptimize(); @Override void serialize(DataOutput out); void serialize(ByteBuffer byteBuffer); void deserialize(DataInput in); void deserialize(ByteBuffer in); @Override long serializedSizeInBytes(); void clear(); @Override long[] toArray(); static Roaring64Bitmap bitmapOf(final long... dat); void add(long... dat); void add(final long rangeStart, final long rangeEnd); @Override LongIterator getReverseLongIterator(); @Override void removeLong(long x); @Override void trim(); @Override int hashCode(); @Override boolean equals(Object obj); void flip(final long x); @Override Roaring64Bitmap clone(); }### Answer:
@Test public void testFlip() { Roaring64Bitmap map = newDefaultCtor(); map.addLong(0); map.flip(0); assertFalse(map.contains(0)); assertTrue(map.getLongCardinality() == 0); } |
### Question:
Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { public void addInt(int x) { addLong(Util.toUnsignedLong(x)); } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities); Roaring64NavigableMap(BitmapDataProviderSupplier supplier); Roaring64NavigableMap(boolean signedLongs, BitmapDataProviderSupplier supplier); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities,
BitmapDataProviderSupplier supplier); @Override void addLong(long x); void addInt(int x); @Override long getLongCardinality(); int getIntCardinality(); @Override long select(final long j); Iterator<Long> iterator(); @Override void forEach(final LongConsumer lc); @Override long rankLong(long id); void or(final Roaring64NavigableMap x2); void xor(final Roaring64NavigableMap x2); void and(final Roaring64NavigableMap x2); void andNot(final Roaring64NavigableMap x2); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); @Override String toString(); @Override LongIterator getLongIterator(); @Override boolean contains(long x); @Override int getSizeInBytes(); @Override long getLongSizeInBytes(); @Override boolean isEmpty(); @Override ImmutableLongBitmapDataProvider limit(long x); boolean runOptimize(); @Override void serialize(DataOutput out); void deserialize(DataInput in); @Override long serializedSizeInBytes(); void clear(); @Override long[] toArray(); static Roaring64NavigableMap bitmapOf(final long... dat); void add(long... dat); void add(final long rangeStart, final long rangeEnd); @Override LongIterator getReverseLongIterator(); @Override void removeLong(long x); @Override void trim(); @Override int hashCode(); @Override boolean equals(Object obj); void flip(final long x); }### Answer:
@Test public void testAddInt() { Roaring64NavigableMap map = newDefaultCtor(); map.addInt(-1); assertEquals(Util.toUnsignedLong(-1), map.select(0)); } |
### Question:
Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public LongIterator getLongIterator() { final Iterator<Map.Entry<Integer, BitmapDataProvider>> it = highToBitmap.entrySet().iterator(); return toIterator(it, false); } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities); Roaring64NavigableMap(BitmapDataProviderSupplier supplier); Roaring64NavigableMap(boolean signedLongs, BitmapDataProviderSupplier supplier); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities,
BitmapDataProviderSupplier supplier); @Override void addLong(long x); void addInt(int x); @Override long getLongCardinality(); int getIntCardinality(); @Override long select(final long j); Iterator<Long> iterator(); @Override void forEach(final LongConsumer lc); @Override long rankLong(long id); void or(final Roaring64NavigableMap x2); void xor(final Roaring64NavigableMap x2); void and(final Roaring64NavigableMap x2); void andNot(final Roaring64NavigableMap x2); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); @Override String toString(); @Override LongIterator getLongIterator(); @Override boolean contains(long x); @Override int getSizeInBytes(); @Override long getLongSizeInBytes(); @Override boolean isEmpty(); @Override ImmutableLongBitmapDataProvider limit(long x); boolean runOptimize(); @Override void serialize(DataOutput out); void deserialize(DataInput in); @Override long serializedSizeInBytes(); void clear(); @Override long[] toArray(); static Roaring64NavigableMap bitmapOf(final long... dat); void add(long... dat); void add(final long rangeStart, final long rangeEnd); @Override LongIterator getReverseLongIterator(); @Override void removeLong(long x); @Override void trim(); @Override int hashCode(); @Override boolean equals(Object obj); void flip(final long x); }### Answer:
@Test public void testIterator_NextWithoutHasNext_Empty() { assertThrows(IllegalStateException.class, () -> { Roaring64NavigableMap map = newDefaultCtor(); map.getLongIterator().next(); }); } |
### Question:
Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { private int compare(int x, int y) { if (signedLongs) { return Integer.compare(x, y); } else { return RoaringIntPacking.compareUnsigned(x, y); } } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities); Roaring64NavigableMap(BitmapDataProviderSupplier supplier); Roaring64NavigableMap(boolean signedLongs, BitmapDataProviderSupplier supplier); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities,
BitmapDataProviderSupplier supplier); @Override void addLong(long x); void addInt(int x); @Override long getLongCardinality(); int getIntCardinality(); @Override long select(final long j); Iterator<Long> iterator(); @Override void forEach(final LongConsumer lc); @Override long rankLong(long id); void or(final Roaring64NavigableMap x2); void xor(final Roaring64NavigableMap x2); void and(final Roaring64NavigableMap x2); void andNot(final Roaring64NavigableMap x2); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); @Override String toString(); @Override LongIterator getLongIterator(); @Override boolean contains(long x); @Override int getSizeInBytes(); @Override long getLongSizeInBytes(); @Override boolean isEmpty(); @Override ImmutableLongBitmapDataProvider limit(long x); boolean runOptimize(); @Override void serialize(DataOutput out); void deserialize(DataInput in); @Override long serializedSizeInBytes(); void clear(); @Override long[] toArray(); static Roaring64NavigableMap bitmapOf(final long... dat); void add(long... dat); void add(final long rangeStart, final long rangeEnd); @Override LongIterator getReverseLongIterator(); @Override void removeLong(long x); @Override void trim(); @Override int hashCode(); @Override boolean equals(Object obj); void flip(final long x); }### Answer:
@Test public void testComparator() { Comparator<Integer> natural = new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return Integer.compare(o1, o2); } }; Comparator<Integer> unsigned = RoaringIntPacking.unsignedComparator(); assertTrue(natural.compare(-1, 1) < 0); assertFalse(unsigned.compare(-1, 1) < 0); assertTrue(natural.compare(Integer.MAX_VALUE, Integer.MAX_VALUE + 1) > 0); assertFalse(unsigned.compare(Integer.MAX_VALUE, Integer.MAX_VALUE + 1) > 0); assertTrue(unsigned.compare(Integer.MAX_VALUE + 1, Integer.MAX_VALUE + 2) < 0); } |
### Question:
Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public long getLongCardinality() { if (doCacheCardinalities) { if (highToBitmap.isEmpty()) { return 0L; } int indexOk = ensureCumulatives(highestHigh()); if (highToBitmap.isEmpty()) { return 0L; } return sortedCumulatedCardinality[indexOk - 1]; } else { long cardinality = 0L; for (BitmapDataProvider bitmap : highToBitmap.values()) { cardinality += bitmap.getLongCardinality(); } return cardinality; } } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities); Roaring64NavigableMap(BitmapDataProviderSupplier supplier); Roaring64NavigableMap(boolean signedLongs, BitmapDataProviderSupplier supplier); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities,
BitmapDataProviderSupplier supplier); @Override void addLong(long x); void addInt(int x); @Override long getLongCardinality(); int getIntCardinality(); @Override long select(final long j); Iterator<Long> iterator(); @Override void forEach(final LongConsumer lc); @Override long rankLong(long id); void or(final Roaring64NavigableMap x2); void xor(final Roaring64NavigableMap x2); void and(final Roaring64NavigableMap x2); void andNot(final Roaring64NavigableMap x2); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); @Override String toString(); @Override LongIterator getLongIterator(); @Override boolean contains(long x); @Override int getSizeInBytes(); @Override long getLongSizeInBytes(); @Override boolean isEmpty(); @Override ImmutableLongBitmapDataProvider limit(long x); boolean runOptimize(); @Override void serialize(DataOutput out); void deserialize(DataInput in); @Override long serializedSizeInBytes(); void clear(); @Override long[] toArray(); static Roaring64NavigableMap bitmapOf(final long... dat); void add(long... dat); void add(final long rangeStart, final long rangeEnd); @Override LongIterator getReverseLongIterator(); @Override void removeLong(long x); @Override void trim(); @Override int hashCode(); @Override boolean equals(Object obj); void flip(final long x); }### Answer:
@Test public void testSerialization_Empty() throws IOException, ClassNotFoundException { final Roaring64NavigableMap map = newDefaultCtor(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); try (ObjectOutputStream oos = new ObjectOutputStream(baos)) { oos.writeObject(map); } final Roaring64NavigableMap clone; try (ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()))) { clone = (Roaring64NavigableMap) ois.readObject(); } assertNotSame(map, clone); assertEquals(0, clone.getLongCardinality()); } |
### Question:
Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { public void add(long... dat) { for (long oneLong : dat) { addLong(oneLong); } } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities); Roaring64NavigableMap(BitmapDataProviderSupplier supplier); Roaring64NavigableMap(boolean signedLongs, BitmapDataProviderSupplier supplier); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities,
BitmapDataProviderSupplier supplier); @Override void addLong(long x); void addInt(int x); @Override long getLongCardinality(); int getIntCardinality(); @Override long select(final long j); Iterator<Long> iterator(); @Override void forEach(final LongConsumer lc); @Override long rankLong(long id); void or(final Roaring64NavigableMap x2); void xor(final Roaring64NavigableMap x2); void and(final Roaring64NavigableMap x2); void andNot(final Roaring64NavigableMap x2); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); @Override String toString(); @Override LongIterator getLongIterator(); @Override boolean contains(long x); @Override int getSizeInBytes(); @Override long getLongSizeInBytes(); @Override boolean isEmpty(); @Override ImmutableLongBitmapDataProvider limit(long x); boolean runOptimize(); @Override void serialize(DataOutput out); void deserialize(DataInput in); @Override long serializedSizeInBytes(); void clear(); @Override long[] toArray(); static Roaring64NavigableMap bitmapOf(final long... dat); void add(long... dat); void add(final long rangeStart, final long rangeEnd); @Override LongIterator getReverseLongIterator(); @Override void removeLong(long x); @Override void trim(); @Override int hashCode(); @Override boolean equals(Object obj); void flip(final long x); }### Answer:
@Test public void testCardinalityAboveIntegerMaxValue_RoaringBitmap() { assertThrows(IllegalArgumentException.class, () -> { RoaringBitmap map = new RoaringBitmap(); map.add(0L, outOfRoaringBitmapRange); }); } |
### Question:
Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public void trim() { for (BitmapDataProvider bitmap : highToBitmap.values()) { bitmap.trim(); } } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities); Roaring64NavigableMap(BitmapDataProviderSupplier supplier); Roaring64NavigableMap(boolean signedLongs, BitmapDataProviderSupplier supplier); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities,
BitmapDataProviderSupplier supplier); @Override void addLong(long x); void addInt(int x); @Override long getLongCardinality(); int getIntCardinality(); @Override long select(final long j); Iterator<Long> iterator(); @Override void forEach(final LongConsumer lc); @Override long rankLong(long id); void or(final Roaring64NavigableMap x2); void xor(final Roaring64NavigableMap x2); void and(final Roaring64NavigableMap x2); void andNot(final Roaring64NavigableMap x2); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); @Override String toString(); @Override LongIterator getLongIterator(); @Override boolean contains(long x); @Override int getSizeInBytes(); @Override long getLongSizeInBytes(); @Override boolean isEmpty(); @Override ImmutableLongBitmapDataProvider limit(long x); boolean runOptimize(); @Override void serialize(DataOutput out); void deserialize(DataInput in); @Override long serializedSizeInBytes(); void clear(); @Override long[] toArray(); static Roaring64NavigableMap bitmapOf(final long... dat); void add(long... dat); void add(final long rangeStart, final long rangeEnd); @Override LongIterator getReverseLongIterator(); @Override void removeLong(long x); @Override void trim(); @Override int hashCode(); @Override boolean equals(Object obj); void flip(final long x); }### Answer:
@Test public void testTrim() { Roaring64NavigableMap map = new Roaring64NavigableMap(true); int enableTrim = 100; long from = RoaringIntPacking.pack(0, -1 - enableTrim); long to = from + 2 * enableTrim; assertNotEquals(RoaringIntPacking.high(to), RoaringIntPacking.high(from)); for (long i = from; i <= to; i++) { map.addLong(i); } map.trim(); } |
### Question:
Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public long select(final long j) throws IllegalArgumentException { if (!doCacheCardinalities) { return selectNoCache(j); } int indexOk = ensureCumulatives(highestHigh()); if (highToBitmap.isEmpty()) { return throwSelectInvalidIndex(j); } int position = Arrays.binarySearch(sortedCumulatedCardinality, 0, indexOk, j); if (position >= 0) { if (position == indexOk - 1) { return throwSelectInvalidIndex(j); } int high = sortedHighs[position + 1]; BitmapDataProvider nextBitmap = highToBitmap.get(high); return RoaringIntPacking.pack(high, nextBitmap.select(0)); } else { int insertionPoint = -position - 1; final long previousBucketCardinality; if (insertionPoint == 0) { previousBucketCardinality = 0L; } else if (insertionPoint >= indexOk) { return throwSelectInvalidIndex(j); } else { previousBucketCardinality = sortedCumulatedCardinality[insertionPoint - 1]; } final int givenBitmapSelect = (int) (j - previousBucketCardinality); int high = sortedHighs[insertionPoint]; BitmapDataProvider lowBitmap = highToBitmap.get(high); int low = lowBitmap.select(givenBitmapSelect); return RoaringIntPacking.pack(high, low); } } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities); Roaring64NavigableMap(BitmapDataProviderSupplier supplier); Roaring64NavigableMap(boolean signedLongs, BitmapDataProviderSupplier supplier); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities,
BitmapDataProviderSupplier supplier); @Override void addLong(long x); void addInt(int x); @Override long getLongCardinality(); int getIntCardinality(); @Override long select(final long j); Iterator<Long> iterator(); @Override void forEach(final LongConsumer lc); @Override long rankLong(long id); void or(final Roaring64NavigableMap x2); void xor(final Roaring64NavigableMap x2); void and(final Roaring64NavigableMap x2); void andNot(final Roaring64NavigableMap x2); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); @Override String toString(); @Override LongIterator getLongIterator(); @Override boolean contains(long x); @Override int getSizeInBytes(); @Override long getLongSizeInBytes(); @Override boolean isEmpty(); @Override ImmutableLongBitmapDataProvider limit(long x); boolean runOptimize(); @Override void serialize(DataOutput out); void deserialize(DataInput in); @Override long serializedSizeInBytes(); void clear(); @Override long[] toArray(); static Roaring64NavigableMap bitmapOf(final long... dat); void add(long... dat); void add(final long rangeStart, final long rangeEnd); @Override LongIterator getReverseLongIterator(); @Override void removeLong(long x); @Override void trim(); @Override int hashCode(); @Override boolean equals(Object obj); void flip(final long x); }### Answer:
@Test public void testSelect_Empty() { assertThrows(IllegalArgumentException.class, () -> { Roaring64NavigableMap map = newUnsignedHeap(); map.select(0); }); } |
### Question:
Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public String getContainerName() { if (this instanceof BitmapContainer) { return ContainerNames[0]; } else if (this instanceof ArrayContainer) { return ContainerNames[1]; } else { return ContainerNames[2]; } } static Container rangeOfOnes(final int start, final int last); abstract Container add(int begin, int end); abstract Container add(char x); abstract Container and(ArrayContainer x); abstract Container and(BitmapContainer x); Container and(Container x); abstract Container and(RunContainer x); int andCardinality(Container x); int xorCardinality(Container other); abstract Container andNot(ArrayContainer x); abstract Container andNot(BitmapContainer x); Container andNot(Container x); abstract Container andNot(RunContainer x); Container orNot(Container x, int endOfRange); abstract void clear(); @Override abstract Container clone(); abstract boolean isEmpty(); abstract boolean isFull(); abstract boolean contains(char x); abstract boolean contains(int minimum, int supremum); boolean contains(Container subset); abstract void deserialize(DataInput in); abstract void fillLeastSignificant16bits(int[] x, int i, int mask); abstract Container flip(char x); abstract int getArraySizeInBytes(); abstract int getCardinality(); String getContainerName(); abstract void forEach(char msb, IntConsumer ic); abstract CharIterator getReverseCharIterator(); abstract PeekableCharIterator getCharIterator(); abstract PeekableCharRankIterator getCharRankIterator(); abstract ContainerBatchIterator getBatchIterator(); abstract int getSizeInBytes(); abstract Container iadd(int begin, int end); abstract Container iand(ArrayContainer x); abstract Container iand(BitmapContainer x); Container iand(Container x); abstract Container iand(RunContainer x); abstract Container iandNot(ArrayContainer x); abstract Container iandNot(BitmapContainer x); Container iandNot(Container x); abstract Container iandNot(RunContainer x); Container iorNot(Container x, int endOfRange); abstract Container inot(int rangeStart, int rangeEnd); abstract boolean intersects(ArrayContainer x); abstract boolean intersects(BitmapContainer x); boolean intersects(Container x); abstract boolean intersects(RunContainer x); abstract boolean intersects(int minimum, int supremum); abstract Container ior(ArrayContainer x); abstract Container ior(BitmapContainer x); Container ior(Container x); abstract Container ior(RunContainer x); abstract Container iremove(int begin, int end); abstract Container ixor(ArrayContainer x); abstract Container ixor(BitmapContainer x); Container ixor(Container x); abstract Container ixor(RunContainer x); Container lazyIOR(Container x); Container lazyOR(Container x); abstract Container limit(int maxcardinality); abstract Container not(int rangeStart, int rangeEnd); abstract Container or(ArrayContainer x); abstract Container or(BitmapContainer x); Container or(Container x); abstract Container or(RunContainer x); abstract int rank(char lowbits); abstract Container remove(int begin, int end); abstract Container remove(char x); abstract Container repairAfterLazy(); abstract Container runOptimize(); abstract char select(int j); abstract void serialize(DataOutput out); abstract int serializedSizeInBytes(); abstract MappeableContainer toMappeableContainer(); abstract void trim(); abstract void writeArray(DataOutput out); abstract void writeArray(ByteBuffer buffer); abstract Container xor(ArrayContainer x); abstract Container xor(BitmapContainer x); Container xor(Container x); abstract Container xor(RunContainer x); abstract BitmapContainer toBitmapContainer(); abstract int nextValue(char fromValue); abstract int previousValue(char fromValue); abstract int nextAbsentValue(char fromValue); abstract int previousAbsentValue(char fromValue); abstract int first(); abstract int last(); static final String[] ContainerNames; }### Answer:
@Test public void testNames() { assertEquals(new BitmapContainer().getContainerName(), Container.ContainerNames[0]); assertEquals(new ArrayContainer().getContainerName(), Container.ContainerNames[1]); assertEquals(new RunContainer().getContainerName(), Container.ContainerNames[2]); } |
### Question:
Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { abstract int numberOfRuns(); static Container rangeOfOnes(final int start, final int last); abstract Container add(int begin, int end); abstract Container add(char x); abstract Container and(ArrayContainer x); abstract Container and(BitmapContainer x); Container and(Container x); abstract Container and(RunContainer x); int andCardinality(Container x); int xorCardinality(Container other); abstract Container andNot(ArrayContainer x); abstract Container andNot(BitmapContainer x); Container andNot(Container x); abstract Container andNot(RunContainer x); Container orNot(Container x, int endOfRange); abstract void clear(); @Override abstract Container clone(); abstract boolean isEmpty(); abstract boolean isFull(); abstract boolean contains(char x); abstract boolean contains(int minimum, int supremum); boolean contains(Container subset); abstract void deserialize(DataInput in); abstract void fillLeastSignificant16bits(int[] x, int i, int mask); abstract Container flip(char x); abstract int getArraySizeInBytes(); abstract int getCardinality(); String getContainerName(); abstract void forEach(char msb, IntConsumer ic); abstract CharIterator getReverseCharIterator(); abstract PeekableCharIterator getCharIterator(); abstract PeekableCharRankIterator getCharRankIterator(); abstract ContainerBatchIterator getBatchIterator(); abstract int getSizeInBytes(); abstract Container iadd(int begin, int end); abstract Container iand(ArrayContainer x); abstract Container iand(BitmapContainer x); Container iand(Container x); abstract Container iand(RunContainer x); abstract Container iandNot(ArrayContainer x); abstract Container iandNot(BitmapContainer x); Container iandNot(Container x); abstract Container iandNot(RunContainer x); Container iorNot(Container x, int endOfRange); abstract Container inot(int rangeStart, int rangeEnd); abstract boolean intersects(ArrayContainer x); abstract boolean intersects(BitmapContainer x); boolean intersects(Container x); abstract boolean intersects(RunContainer x); abstract boolean intersects(int minimum, int supremum); abstract Container ior(ArrayContainer x); abstract Container ior(BitmapContainer x); Container ior(Container x); abstract Container ior(RunContainer x); abstract Container iremove(int begin, int end); abstract Container ixor(ArrayContainer x); abstract Container ixor(BitmapContainer x); Container ixor(Container x); abstract Container ixor(RunContainer x); Container lazyIOR(Container x); Container lazyOR(Container x); abstract Container limit(int maxcardinality); abstract Container not(int rangeStart, int rangeEnd); abstract Container or(ArrayContainer x); abstract Container or(BitmapContainer x); Container or(Container x); abstract Container or(RunContainer x); abstract int rank(char lowbits); abstract Container remove(int begin, int end); abstract Container remove(char x); abstract Container repairAfterLazy(); abstract Container runOptimize(); abstract char select(int j); abstract void serialize(DataOutput out); abstract int serializedSizeInBytes(); abstract MappeableContainer toMappeableContainer(); abstract void trim(); abstract void writeArray(DataOutput out); abstract void writeArray(ByteBuffer buffer); abstract Container xor(ArrayContainer x); abstract Container xor(BitmapContainer x); Container xor(Container x); abstract Container xor(RunContainer x); abstract BitmapContainer toBitmapContainer(); abstract int nextValue(char fromValue); abstract int previousValue(char fromValue); abstract int nextAbsentValue(char fromValue); abstract int previousAbsentValue(char fromValue); abstract int first(); abstract int last(); static final String[] ContainerNames; }### Answer:
@Test public void numberOfRuns() { char[] positions = {3, 4, 5, 10, 11, 13, 15, 62, 63, 64, 65}; Container ac = new ArrayContainer(); Container bc = new BitmapContainer(); Container rc = new RunContainer(); for (char position : positions) { ac.add(position); bc.add(position); rc.add(position); } assertEquals(rc.numberOfRuns(), ac.numberOfRuns()); assertEquals(rc.numberOfRuns(), bc.numberOfRuns()); } |
### Question:
Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container add(int begin, int end); static Container rangeOfOnes(final int start, final int last); abstract Container add(int begin, int end); abstract Container add(char x); abstract Container and(ArrayContainer x); abstract Container and(BitmapContainer x); Container and(Container x); abstract Container and(RunContainer x); int andCardinality(Container x); int xorCardinality(Container other); abstract Container andNot(ArrayContainer x); abstract Container andNot(BitmapContainer x); Container andNot(Container x); abstract Container andNot(RunContainer x); Container orNot(Container x, int endOfRange); abstract void clear(); @Override abstract Container clone(); abstract boolean isEmpty(); abstract boolean isFull(); abstract boolean contains(char x); abstract boolean contains(int minimum, int supremum); boolean contains(Container subset); abstract void deserialize(DataInput in); abstract void fillLeastSignificant16bits(int[] x, int i, int mask); abstract Container flip(char x); abstract int getArraySizeInBytes(); abstract int getCardinality(); String getContainerName(); abstract void forEach(char msb, IntConsumer ic); abstract CharIterator getReverseCharIterator(); abstract PeekableCharIterator getCharIterator(); abstract PeekableCharRankIterator getCharRankIterator(); abstract ContainerBatchIterator getBatchIterator(); abstract int getSizeInBytes(); abstract Container iadd(int begin, int end); abstract Container iand(ArrayContainer x); abstract Container iand(BitmapContainer x); Container iand(Container x); abstract Container iand(RunContainer x); abstract Container iandNot(ArrayContainer x); abstract Container iandNot(BitmapContainer x); Container iandNot(Container x); abstract Container iandNot(RunContainer x); Container iorNot(Container x, int endOfRange); abstract Container inot(int rangeStart, int rangeEnd); abstract boolean intersects(ArrayContainer x); abstract boolean intersects(BitmapContainer x); boolean intersects(Container x); abstract boolean intersects(RunContainer x); abstract boolean intersects(int minimum, int supremum); abstract Container ior(ArrayContainer x); abstract Container ior(BitmapContainer x); Container ior(Container x); abstract Container ior(RunContainer x); abstract Container iremove(int begin, int end); abstract Container ixor(ArrayContainer x); abstract Container ixor(BitmapContainer x); Container ixor(Container x); abstract Container ixor(RunContainer x); Container lazyIOR(Container x); Container lazyOR(Container x); abstract Container limit(int maxcardinality); abstract Container not(int rangeStart, int rangeEnd); abstract Container or(ArrayContainer x); abstract Container or(BitmapContainer x); Container or(Container x); abstract Container or(RunContainer x); abstract int rank(char lowbits); abstract Container remove(int begin, int end); abstract Container remove(char x); abstract Container repairAfterLazy(); abstract Container runOptimize(); abstract char select(int j); abstract void serialize(DataOutput out); abstract int serializedSizeInBytes(); abstract MappeableContainer toMappeableContainer(); abstract void trim(); abstract void writeArray(DataOutput out); abstract void writeArray(ByteBuffer buffer); abstract Container xor(ArrayContainer x); abstract Container xor(BitmapContainer x); Container xor(Container x); abstract Container xor(RunContainer x); abstract BitmapContainer toBitmapContainer(); abstract int nextValue(char fromValue); abstract int previousValue(char fromValue); abstract int nextAbsentValue(char fromValue); abstract int previousAbsentValue(char fromValue); abstract int first(); abstract int last(); static final String[] ContainerNames; }### Answer:
@Test public void testConsistentToString() { ArrayContainer ac = new ArrayContainer(); BitmapContainer bc = new BitmapContainer(); RunContainer rc = new RunContainer(); for (char i : new char[]{0, 2, 17, Short.MAX_VALUE, (char)-3, (char)-1}) { ac.add(i); bc.add(i); rc.add(i); } String expected = "{0,2,17,32767,65533,65535}"; assertEquals(expected, ac.toString()); assertEquals(expected, bc.toString()); String normalizedRCstr = rc.toString() .replaceAll("\\d+\\]\\[", "") .replace('[', '{') .replaceFirst(",\\d+\\]", "}"); assertEquals(expected, normalizedRCstr); } |
### Question:
BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); }### Answer:
@Test public void testEmptyBitSet() { final BitSet bitset = new BitSet(); final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBitsets(bitset, bitmap); }
@Test public void testFlipFlapBetweenRandomFullAndEmptyBitSet() { final Random random = new Random(); final int nbitsPerBlock = 1024 * Long.SIZE; final int blocks = 50; final BitSet bitset = new BitSet(nbitsPerBlock * blocks); for (int block = 0; block < blocks * nbitsPerBlock; block += nbitsPerBlock) { int type = random.nextInt(3); switch (type) { case 0: appendRandomBitset(random, block, bitset, nbitsPerBlock); break; case 1: bitset.set(block, block + nbitsPerBlock); break; default: break; } } final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBitsets(bitset, bitmap); }
@Test public void testFullBitSet() { final BitSet bitset = new BitSet(); final int nbits = 1024 * Long.SIZE * 50; bitset.set(0, nbits); final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBitsets(bitset, bitmap); }
@Test public void testGapBitmap() { for (int gap = 1; gap <= 4096; gap *= 2) { for (int offset = 300; offset < 3000; offset += 10) { BitSet bitset = new BitSet(); for (int k = 0; k < 100000; k += gap) { bitset.set(k + offset); } final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBitsets(bitset, bitmap); } } }
@Test public void testRandomBitmap() { final Random random = new Random(1235); final int runs = 50; final int maxNbits = 500000; for (int i = 0; i < runs; i++) { final BitSet bitset = randomBitset(random, 0, random.nextInt(maxNbits)); final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBitsets(bitset, bitmap); } }
@Test public void testRandomBitmap_extended() { final Random random = new Random(1245); final int runs = 50; final int maxNbits = 500000; for (int i = 0; i < runs; i++) { final BitSet bitset = randomBitset(random, 100000, random.nextInt(maxNbits)); final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBitsets(bitset, bitmap); } }
@Test public void testSmallBitSet1() { final BitSet bitset = new BitSet(); bitset.set(1); final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBitsets(bitset, bitmap); }
@Test public void testSmallBitSet1_10000000() { final BitSet bitset = new BitSet(); bitset.set(1); bitset.set(10000000); final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBitsets(bitset, bitmap); }
@Test public void testSmallBitSet10000000() { final BitSet bitset = new BitSet(); bitset.set(10000000); final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBitsets(bitset, bitmap); } |
### Question:
RunContainer extends Container implements Cloneable { @Override public int first() { assertNonEmpty(numberOfRuns() == 0); return (valueslength[0]); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected RunContainer(BitmapContainer bc, int nbrRuns); RunContainer(final int capacity); private RunContainer(int nbrruns, char[] valueslength); RunContainer(MappeableRunContainer bc); RunContainer(final char[] array, final int numRuns); @Override Container add(int begin, int end); @Override Container add(char k); @Override Container and(ArrayContainer x); @Override Container and(BitmapContainer x); @Override Container and(RunContainer x); @Override int andCardinality(ArrayContainer x); @Override int andCardinality(BitmapContainer x); @Override int andCardinality(RunContainer x); @Override Container andNot(ArrayContainer x); @Override Container andNot(BitmapContainer x); @Override Container andNot(RunContainer x); @Override void clear(); @Override Container clone(); @Override boolean isEmpty(); @Override boolean contains(char x); @Override boolean contains(int minimum, int supremum); @Override void deserialize(DataInput in); @Override boolean equals(Object o); @Override void fillLeastSignificant16bits(int[] x, int i, int mask); @Override Container flip(char x); @Override int getArraySizeInBytes(); @Override int getCardinality(); char getLength(int index); @Override CharIterator getReverseCharIterator(); @Override PeekableCharIterator getCharIterator(); @Override PeekableCharRankIterator getCharRankIterator(); @Override ContainerBatchIterator getBatchIterator(); @Override int getSizeInBytes(); char getValue(int index); @Override int hashCode(); @Override Container iadd(int begin, int end); @Override Container iand(ArrayContainer x); @Override Container iand(BitmapContainer x); @Override Container iand(RunContainer x); @Override Container iandNot(ArrayContainer x); @Override Container iandNot(BitmapContainer x); @Override Container iandNot(RunContainer x); @Override Container inot(int rangeStart, int rangeEnd); @Override boolean intersects(ArrayContainer x); @Override boolean intersects(BitmapContainer x); @Override boolean intersects(RunContainer x); @Override boolean intersects(int minimum, int supremum); @Override Container ior(ArrayContainer x); @Override Container ior(BitmapContainer x); @Override Container ior(RunContainer x); @Override Container iremove(int begin, int end); @Override boolean isFull(); static RunContainer full(); @Override Iterator<Character> iterator(); @Override Container ixor(ArrayContainer x); @Override Container ixor(BitmapContainer x); @Override Container ixor(RunContainer x); @Override Container limit(int maxcardinality); @Override Container not(int rangeStart, int rangeEnd); @Override int numberOfRuns(); @Override Container or(ArrayContainer x); @Override Container or(BitmapContainer x); @Override Container or(RunContainer x); @Override int rank(char lowbits); @Override void readExternal(ObjectInput in); @Override Container remove(int begin, int end); @Override Container remove(char x); @Override Container repairAfterLazy(); @Override Container runOptimize(); @Override char select(int j); @Override void serialize(DataOutput out); @Override int serializedSizeInBytes(); @Override MappeableContainer toMappeableContainer(); CharBuffer toCharBuffer(); @Override String toString(); @Override void trim(); @Override void writeArray(DataOutput out); @Override void writeArray(ByteBuffer buffer); @Override void writeExternal(ObjectOutput out); @Override Container xor(ArrayContainer x); @Override Container xor(BitmapContainer x); @Override Container xor(RunContainer x); @Override void forEach(char msb, IntConsumer ic); @Override BitmapContainer toBitmapContainer(); @Override int nextValue(char fromValue); @Override int previousValue(char fromValue); @Override int nextAbsentValue(char fromValue); @Override int previousAbsentValue(char fromValue); @Override int first(); @Override int last(); }### Answer:
@Test public void testFirst_Empty() { assertThrows(NoSuchElementException.class, () -> new RunContainer().first()); } |
### Question:
FastAggregation { @Deprecated public static RoaringBitmap horizontal_or(Iterator<? extends RoaringBitmap> bitmaps) { return naive_or(bitmaps); } private FastAggregation(); static RoaringBitmap and(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap and(RoaringBitmap... bitmaps); static RoaringBitmap and(long[] aggregationBuffer, RoaringBitmap... bitmaps); @Deprecated static RoaringBitmap horizontal_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap horizontal_or(List<? extends RoaringBitmap> bitmaps); static RoaringBitmap horizontal_or(RoaringBitmap... bitmaps); static RoaringBitmap horizontal_xor(RoaringBitmap... bitmaps); static RoaringBitmap naive_and(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_and(RoaringBitmap... bitmaps); static RoaringBitmap workShyAnd(long[] buffer, RoaringBitmap... bitmaps); static RoaringBitmap workAndMemoryShyAnd(long[] buffer, RoaringBitmap... bitmaps); static RoaringBitmap naive_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_or(RoaringBitmap... bitmaps); static RoaringBitmap naive_xor(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_xor(RoaringBitmap... bitmaps); static RoaringBitmap or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap or(RoaringBitmap... bitmaps); static RoaringBitmap priorityqueue_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap priorityqueue_or(RoaringBitmap... bitmaps); static RoaringBitmap priorityqueue_xor(RoaringBitmap... bitmaps); static RoaringBitmap xor(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap xor(RoaringBitmap... bitmaps); }### Answer:
@Test public void horizontal_or() { RoaringBitmap rb1 = RoaringBitmap.bitmapOf(0, 1, 2); RoaringBitmap rb2 = RoaringBitmap.bitmapOf(0, 5, 6); RoaringBitmap rb3 = RoaringBitmap.bitmapOf(1<<16, 2<<16); RoaringBitmap result = FastAggregation.horizontal_or(Arrays.asList(rb1, rb2, rb3)); RoaringBitmap expected = RoaringBitmap.bitmapOf(0, 1, 2, 5, 6, 1<<16, 2<<16); assertEquals(expected, result); }
@Test public void horizontal_or2() { RoaringBitmap rb1 = RoaringBitmap.bitmapOf(0, 1, 2); RoaringBitmap rb2 = RoaringBitmap.bitmapOf(0, 5, 6); RoaringBitmap rb3 = RoaringBitmap.bitmapOf(1<<16, 2<<16); RoaringBitmap result = FastAggregation.horizontal_or(rb1, rb2, rb3); RoaringBitmap expected = RoaringBitmap.bitmapOf(0, 1, 2, 5, 6, 1<<16, 2<<16); assertEquals(expected, result); } |
### Question:
FastAggregation { public static RoaringBitmap or(Iterator<? extends RoaringBitmap> bitmaps) { return naive_or(bitmaps); } private FastAggregation(); static RoaringBitmap and(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap and(RoaringBitmap... bitmaps); static RoaringBitmap and(long[] aggregationBuffer, RoaringBitmap... bitmaps); @Deprecated static RoaringBitmap horizontal_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap horizontal_or(List<? extends RoaringBitmap> bitmaps); static RoaringBitmap horizontal_or(RoaringBitmap... bitmaps); static RoaringBitmap horizontal_xor(RoaringBitmap... bitmaps); static RoaringBitmap naive_and(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_and(RoaringBitmap... bitmaps); static RoaringBitmap workShyAnd(long[] buffer, RoaringBitmap... bitmaps); static RoaringBitmap workAndMemoryShyAnd(long[] buffer, RoaringBitmap... bitmaps); static RoaringBitmap naive_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_or(RoaringBitmap... bitmaps); static RoaringBitmap naive_xor(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_xor(RoaringBitmap... bitmaps); static RoaringBitmap or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap or(RoaringBitmap... bitmaps); static RoaringBitmap priorityqueue_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap priorityqueue_or(RoaringBitmap... bitmaps); static RoaringBitmap priorityqueue_xor(RoaringBitmap... bitmaps); static RoaringBitmap xor(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap xor(RoaringBitmap... bitmaps); }### Answer:
@Test public void or() { RoaringBitmap rb1 = RoaringBitmap.bitmapOf(0, 1, 2); RoaringBitmap rb2 = RoaringBitmap.bitmapOf(0, 5, 6); RoaringBitmap rb3 = RoaringBitmap.bitmapOf(1<<16, 2<<16); RoaringBitmap result = FastAggregation.or(rb1, rb2, rb3); RoaringBitmap expected = RoaringBitmap.bitmapOf(0, 1, 2, 5, 6, 1<<16, 2<<16); assertEquals(expected, result); }
@Test public void testOrWithIterator() { final RoaringBitmap b1 = RoaringBitmap.bitmapOf(1, 2); final RoaringBitmap b2 = RoaringBitmap.bitmapOf(2, 3); final RoaringBitmap bItResult = FastAggregation.or(Arrays.asList(b1, b2).iterator()); assertTrue(bItResult.contains(1)); assertTrue(bItResult.contains(2)); assertTrue(bItResult.contains(3)); final ExtendedRoaringBitmap eb1 = new ExtendedRoaringBitmap(); eb1.add(1); eb1.add(2); final ExtendedRoaringBitmap eb2 = new ExtendedRoaringBitmap(); eb2.add(2); eb2.add(3); final RoaringBitmap ebItResult = FastAggregation.or(Arrays.asList(b1, b2).iterator()); assertTrue(ebItResult.contains(1)); assertTrue(ebItResult.contains(2)); assertTrue(ebItResult.contains(3)); } |
### Question:
Util { public static int iterateUntil(char[] array, int pos, int length, int min) { while (pos < length && (array[pos]) < min) { pos++; } return pos; } private Util(); static Container[] addOffset(Container source, char offsets); static int advanceUntil(char[] array, int pos, int length, char min); static int iterateUntil(char[] array, int pos, int length, int min); static void fillArrayAND(final char[] container, final long[] bitmap1,
final long[] bitmap2); static void fillArrayANDNOT(final char[] container, final long[] bitmap1,
final long[] bitmap2); static void fillArrayXOR(final char[] container, final long[] bitmap1,
final long[] bitmap2); static void flipBitmapRange(long[] bitmap, int start, int end); @Deprecated static int cardinalityInBitmapWordRange(long[] bitmap, int start, int end); static int cardinalityInBitmapRange(long[] bitmap, int start, int end); static int maxLowBitAsInteger(); static void resetBitmapRange(long[] bitmap, int start, int end); static int intersectArrayIntoBitmap(long[] bitmap, char[] array, int length); static int select(long w, int j); static void setBitmapRange(long[] bitmap, int start, int end); @Deprecated static int setBitmapRangeAndCardinalityChange(long[] bitmap, int start, int end); @Deprecated static int flipBitmapRangeAndCardinalityChange(long[] bitmap, int start, int end); @Deprecated static int resetBitmapRangeAndCardinalityChange(long[] bitmap, int start, int end); static int unsignedBinarySearch(final char[] array, final int begin, final int end,
final char k); static int unsignedDifference(final char[] set1, final int length1, final char[] set2,
final int length2, final char[] buffer); static int unsignedDifference(CharIterator set1, CharIterator set2,
final char[] buffer); static int unsignedExclusiveUnion2by2(final char[] set1, final int length1,
final char[] set2, final int length2, final char[] buffer); static int unsignedIntersect2by2(final char[] set1, final int length1, final char[] set2,
final int length2, final char[] buffer); static boolean unsignedIntersects(char[] set1, int length1, char[] set2, int length2); static int unsignedLocalIntersect2by2Cardinality(final char[] set1, final int length1,
final char[] set2, final int length2); static int unsignedUnion2by2(
final char[] set1, final int offset1, final int length1,
final char[] set2, final int offset2, final int length2,
final char[] buffer); static long toUnsignedLong(int x); static void partialRadixSort(int[] data); static final boolean USE_HYBRID_BINSEARCH; }### Answer:
@Test public void testIterateUntil() { char[] data = fromShorts(new short[]{0, 3, 16, 18, 21, 29, 30,-342}); assertEquals(1, Util.iterateUntil(data, 0, data.length, ((char) 3))); assertEquals(5, Util.iterateUntil(data, 0, data.length, ((char) 28))); assertEquals(5, Util.iterateUntil(data, 0, data.length, ((char) 29))); assertEquals(7, Util.iterateUntil(data, 0, data.length, ((char) -342))); } |
### Question:
FastAggregation { public static RoaringBitmap and(Iterator<? extends RoaringBitmap> bitmaps) { return naive_and(bitmaps); } private FastAggregation(); static RoaringBitmap and(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap and(RoaringBitmap... bitmaps); static RoaringBitmap and(long[] aggregationBuffer, RoaringBitmap... bitmaps); @Deprecated static RoaringBitmap horizontal_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap horizontal_or(List<? extends RoaringBitmap> bitmaps); static RoaringBitmap horizontal_or(RoaringBitmap... bitmaps); static RoaringBitmap horizontal_xor(RoaringBitmap... bitmaps); static RoaringBitmap naive_and(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_and(RoaringBitmap... bitmaps); static RoaringBitmap workShyAnd(long[] buffer, RoaringBitmap... bitmaps); static RoaringBitmap workAndMemoryShyAnd(long[] buffer, RoaringBitmap... bitmaps); static RoaringBitmap naive_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_or(RoaringBitmap... bitmaps); static RoaringBitmap naive_xor(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_xor(RoaringBitmap... bitmaps); static RoaringBitmap or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap or(RoaringBitmap... bitmaps); static RoaringBitmap priorityqueue_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap priorityqueue_or(RoaringBitmap... bitmaps); static RoaringBitmap priorityqueue_xor(RoaringBitmap... bitmaps); static RoaringBitmap xor(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap xor(RoaringBitmap... bitmaps); }### Answer:
@Test public void testAndWithIterator() { final RoaringBitmap b1 = RoaringBitmap.bitmapOf(1, 2); final RoaringBitmap b2 = RoaringBitmap.bitmapOf(2, 3); final RoaringBitmap bResult = FastAggregation.and(Arrays.asList(b1, b2).iterator()); assertFalse(bResult.contains(1)); assertTrue(bResult.contains(2)); assertFalse(bResult.contains(3)); final ExtendedRoaringBitmap eb1 = new ExtendedRoaringBitmap(); eb1.add(1); eb1.add(2); final ExtendedRoaringBitmap eb2 = new ExtendedRoaringBitmap(); eb2.add(2); eb2.add(3); final RoaringBitmap ebResult = FastAggregation.and(Arrays.asList(b1, b2).iterator()); assertFalse(ebResult.contains(1)); assertTrue(ebResult.contains(2)); assertFalse(ebResult.contains(3)); } |
### Question:
FastAggregation { public static RoaringBitmap naive_and(Iterator<? extends RoaringBitmap> bitmaps) { if (!bitmaps.hasNext()) { return new RoaringBitmap(); } RoaringBitmap answer = bitmaps.next().clone(); while (bitmaps.hasNext() && !answer.isEmpty()) { answer.and(bitmaps.next()); } return answer; } private FastAggregation(); static RoaringBitmap and(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap and(RoaringBitmap... bitmaps); static RoaringBitmap and(long[] aggregationBuffer, RoaringBitmap... bitmaps); @Deprecated static RoaringBitmap horizontal_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap horizontal_or(List<? extends RoaringBitmap> bitmaps); static RoaringBitmap horizontal_or(RoaringBitmap... bitmaps); static RoaringBitmap horizontal_xor(RoaringBitmap... bitmaps); static RoaringBitmap naive_and(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_and(RoaringBitmap... bitmaps); static RoaringBitmap workShyAnd(long[] buffer, RoaringBitmap... bitmaps); static RoaringBitmap workAndMemoryShyAnd(long[] buffer, RoaringBitmap... bitmaps); static RoaringBitmap naive_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_or(RoaringBitmap... bitmaps); static RoaringBitmap naive_xor(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_xor(RoaringBitmap... bitmaps); static RoaringBitmap or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap or(RoaringBitmap... bitmaps); static RoaringBitmap priorityqueue_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap priorityqueue_or(RoaringBitmap... bitmaps); static RoaringBitmap priorityqueue_xor(RoaringBitmap... bitmaps); static RoaringBitmap xor(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap xor(RoaringBitmap... bitmaps); }### Answer:
@Test public void testNaiveAndWithIterator() { final RoaringBitmap b1 = RoaringBitmap.bitmapOf(1, 2); final RoaringBitmap b2 = RoaringBitmap.bitmapOf(2, 3); final RoaringBitmap bResult = FastAggregation.naive_and(Arrays.asList(b1, b2).iterator()); assertFalse(bResult.contains(1)); assertTrue(bResult.contains(2)); assertFalse(bResult.contains(3)); final ExtendedRoaringBitmap eb1 = new ExtendedRoaringBitmap(); eb1.add(1); eb1.add(2); final ExtendedRoaringBitmap eb2 = new ExtendedRoaringBitmap(); eb2.add(2); eb2.add(3); final RoaringBitmap ebResult = FastAggregation.naive_and(Arrays.asList(b1, b2).iterator()); assertFalse(ebResult.contains(1)); assertTrue(ebResult.contains(2)); assertFalse(ebResult.contains(3)); } |
### Question:
FastAggregation { public static RoaringBitmap naive_or(Iterator<? extends RoaringBitmap> bitmaps) { RoaringBitmap answer = new RoaringBitmap(); while (bitmaps.hasNext()) { answer.naivelazyor(bitmaps.next()); } answer.repairAfterLazy(); return answer; } private FastAggregation(); static RoaringBitmap and(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap and(RoaringBitmap... bitmaps); static RoaringBitmap and(long[] aggregationBuffer, RoaringBitmap... bitmaps); @Deprecated static RoaringBitmap horizontal_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap horizontal_or(List<? extends RoaringBitmap> bitmaps); static RoaringBitmap horizontal_or(RoaringBitmap... bitmaps); static RoaringBitmap horizontal_xor(RoaringBitmap... bitmaps); static RoaringBitmap naive_and(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_and(RoaringBitmap... bitmaps); static RoaringBitmap workShyAnd(long[] buffer, RoaringBitmap... bitmaps); static RoaringBitmap workAndMemoryShyAnd(long[] buffer, RoaringBitmap... bitmaps); static RoaringBitmap naive_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_or(RoaringBitmap... bitmaps); static RoaringBitmap naive_xor(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_xor(RoaringBitmap... bitmaps); static RoaringBitmap or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap or(RoaringBitmap... bitmaps); static RoaringBitmap priorityqueue_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap priorityqueue_or(RoaringBitmap... bitmaps); static RoaringBitmap priorityqueue_xor(RoaringBitmap... bitmaps); static RoaringBitmap xor(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap xor(RoaringBitmap... bitmaps); }### Answer:
@Test public void testNaiveOrWithIterator() { final RoaringBitmap b1 = RoaringBitmap.bitmapOf(1, 2); final RoaringBitmap b2 = RoaringBitmap.bitmapOf(2, 3); final RoaringBitmap bResult = FastAggregation.naive_or(Arrays.asList(b1, b2).iterator()); assertTrue(bResult.contains(1)); assertTrue(bResult.contains(2)); assertTrue(bResult.contains(3)); final ExtendedRoaringBitmap eb1 = new ExtendedRoaringBitmap(); eb1.add(1); eb1.add(2); final ExtendedRoaringBitmap eb2 = new ExtendedRoaringBitmap(); eb2.add(2); eb2.add(3); final RoaringBitmap ebResult = FastAggregation.naive_or(Arrays.asList(b1, b2).iterator()); assertTrue(ebResult.contains(1)); assertTrue(ebResult.contains(2)); assertTrue(ebResult.contains(3)); } |
### Question:
FastAggregation { public static RoaringBitmap naive_xor(Iterator<? extends RoaringBitmap> bitmaps) { RoaringBitmap answer = new RoaringBitmap(); while (bitmaps.hasNext()) { answer.xor(bitmaps.next()); } return answer; } private FastAggregation(); static RoaringBitmap and(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap and(RoaringBitmap... bitmaps); static RoaringBitmap and(long[] aggregationBuffer, RoaringBitmap... bitmaps); @Deprecated static RoaringBitmap horizontal_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap horizontal_or(List<? extends RoaringBitmap> bitmaps); static RoaringBitmap horizontal_or(RoaringBitmap... bitmaps); static RoaringBitmap horizontal_xor(RoaringBitmap... bitmaps); static RoaringBitmap naive_and(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_and(RoaringBitmap... bitmaps); static RoaringBitmap workShyAnd(long[] buffer, RoaringBitmap... bitmaps); static RoaringBitmap workAndMemoryShyAnd(long[] buffer, RoaringBitmap... bitmaps); static RoaringBitmap naive_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_or(RoaringBitmap... bitmaps); static RoaringBitmap naive_xor(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap naive_xor(RoaringBitmap... bitmaps); static RoaringBitmap or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap or(RoaringBitmap... bitmaps); static RoaringBitmap priorityqueue_or(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap priorityqueue_or(RoaringBitmap... bitmaps); static RoaringBitmap priorityqueue_xor(RoaringBitmap... bitmaps); static RoaringBitmap xor(Iterator<? extends RoaringBitmap> bitmaps); static RoaringBitmap xor(RoaringBitmap... bitmaps); }### Answer:
@Test public void testNaiveXorWithIterator() { final RoaringBitmap b1 = RoaringBitmap.bitmapOf(1, 2); final RoaringBitmap b2 = RoaringBitmap.bitmapOf(2, 3); final RoaringBitmap bResult = FastAggregation.naive_xor(Arrays.asList(b1, b2).iterator()); assertTrue(bResult.contains(1)); assertFalse(bResult.contains(2)); assertTrue(bResult.contains(3)); final ExtendedRoaringBitmap eb1 = new ExtendedRoaringBitmap(); eb1.add(1); eb1.add(2); final ExtendedRoaringBitmap eb2 = new ExtendedRoaringBitmap(); eb2.add(2); eb2.add(3); final RoaringBitmap ebResult = FastAggregation.naive_xor(Arrays.asList(b1, b2).iterator()); assertTrue(ebResult.contains(1)); assertFalse(ebResult.contains(2)); assertTrue(ebResult.contains(3)); } |
### Question:
RunContainer extends Container implements Cloneable { @Override public void clear() { nbrruns = 0; } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected RunContainer(BitmapContainer bc, int nbrRuns); RunContainer(final int capacity); private RunContainer(int nbrruns, char[] valueslength); RunContainer(MappeableRunContainer bc); RunContainer(final char[] array, final int numRuns); @Override Container add(int begin, int end); @Override Container add(char k); @Override Container and(ArrayContainer x); @Override Container and(BitmapContainer x); @Override Container and(RunContainer x); @Override int andCardinality(ArrayContainer x); @Override int andCardinality(BitmapContainer x); @Override int andCardinality(RunContainer x); @Override Container andNot(ArrayContainer x); @Override Container andNot(BitmapContainer x); @Override Container andNot(RunContainer x); @Override void clear(); @Override Container clone(); @Override boolean isEmpty(); @Override boolean contains(char x); @Override boolean contains(int minimum, int supremum); @Override void deserialize(DataInput in); @Override boolean equals(Object o); @Override void fillLeastSignificant16bits(int[] x, int i, int mask); @Override Container flip(char x); @Override int getArraySizeInBytes(); @Override int getCardinality(); char getLength(int index); @Override CharIterator getReverseCharIterator(); @Override PeekableCharIterator getCharIterator(); @Override PeekableCharRankIterator getCharRankIterator(); @Override ContainerBatchIterator getBatchIterator(); @Override int getSizeInBytes(); char getValue(int index); @Override int hashCode(); @Override Container iadd(int begin, int end); @Override Container iand(ArrayContainer x); @Override Container iand(BitmapContainer x); @Override Container iand(RunContainer x); @Override Container iandNot(ArrayContainer x); @Override Container iandNot(BitmapContainer x); @Override Container iandNot(RunContainer x); @Override Container inot(int rangeStart, int rangeEnd); @Override boolean intersects(ArrayContainer x); @Override boolean intersects(BitmapContainer x); @Override boolean intersects(RunContainer x); @Override boolean intersects(int minimum, int supremum); @Override Container ior(ArrayContainer x); @Override Container ior(BitmapContainer x); @Override Container ior(RunContainer x); @Override Container iremove(int begin, int end); @Override boolean isFull(); static RunContainer full(); @Override Iterator<Character> iterator(); @Override Container ixor(ArrayContainer x); @Override Container ixor(BitmapContainer x); @Override Container ixor(RunContainer x); @Override Container limit(int maxcardinality); @Override Container not(int rangeStart, int rangeEnd); @Override int numberOfRuns(); @Override Container or(ArrayContainer x); @Override Container or(BitmapContainer x); @Override Container or(RunContainer x); @Override int rank(char lowbits); @Override void readExternal(ObjectInput in); @Override Container remove(int begin, int end); @Override Container remove(char x); @Override Container repairAfterLazy(); @Override Container runOptimize(); @Override char select(int j); @Override void serialize(DataOutput out); @Override int serializedSizeInBytes(); @Override MappeableContainer toMappeableContainer(); CharBuffer toCharBuffer(); @Override String toString(); @Override void trim(); @Override void writeArray(DataOutput out); @Override void writeArray(ByteBuffer buffer); @Override void writeExternal(ObjectOutput out); @Override Container xor(ArrayContainer x); @Override Container xor(BitmapContainer x); @Override Container xor(RunContainer x); @Override void forEach(char msb, IntConsumer ic); @Override BitmapContainer toBitmapContainer(); @Override int nextValue(char fromValue); @Override int previousValue(char fromValue); @Override int nextAbsentValue(char fromValue); @Override int previousAbsentValue(char fromValue); @Override int first(); @Override int last(); }### Answer:
@Test public void clear() { Container rc = new RunContainer(); rc.add((char) 1); assertEquals(1, rc.getCardinality()); rc.clear(); assertEquals(0, rc.getCardinality()); } |
### Question:
ThreadContextImpl implements ThreadContextPlus { @Override public TraceEntry startTransaction(String transactionType, String transactionName, MessageSupplier messageSupplier, TimerName timerName) { return startTransaction(transactionType, transactionName, messageSupplier, timerName, AlreadyInTransactionBehavior.CAPTURE_TRACE_ENTRY); } ThreadContextImpl(Transaction transaction, @Nullable TraceEntryImpl parentTraceEntry,
@Nullable TraceEntryImpl parentThreadContextPriorEntry, MessageSupplier messageSupplier,
TimerName rootTimerName, long startTick, boolean captureThreadStats,
int maxQueryAggregates, int maxServiceCallAggregates,
@Nullable ThreadAllocatedBytes threadAllocatedBytes,
boolean limitExceededAuxThreadContext, Ticker ticker,
ThreadContextThreadLocal.Holder threadContextHolder,
@Nullable ServletRequestInfo servletRequestInfo); Transaction getTransaction(); long getThreadId(); boolean isActive(); @Nullable TimerImpl getCurrentTimer(); @Override int getCurrentNestingGroupId(); @Override void setCurrentNestingGroupId(int nestingGroupId); @Override int getCurrentSuppressionKeyId(); @Override void setCurrentSuppressionKeyId(int suppressionKeyId); @Override AuxThreadContext createAuxThreadContext(); @Override boolean isInTransaction(); @Override TraceEntry startTransaction(String transactionType, String transactionName,
MessageSupplier messageSupplier, TimerName timerName); @Override TraceEntry startTransaction(String transactionType, String transactionName,
MessageSupplier messageSupplier, TimerName timerName,
AlreadyInTransactionBehavior alreadyInTransactionBehavior); @Override TraceEntry startTraceEntry(MessageSupplier messageSupplier, TimerName timerName); @Override AsyncTraceEntry startAsyncTraceEntry(MessageSupplier messageSupplier,
TimerName timerName); @Override QueryEntry startQueryEntry(String queryType, String queryText,
QueryMessageSupplier queryMessageSupplier, TimerName timerName); @Override QueryEntry startQueryEntry(String queryType, String queryText, long queryExecutionCount,
QueryMessageSupplier queryMessageSupplier, TimerName timerName); @Override AsyncQueryEntry startAsyncQueryEntry(String queryType, String queryText,
QueryMessageSupplier queryMessageSupplier, TimerName timerName); @Override TraceEntry startServiceCallEntry(String serviceCallType, String serviceCallText,
MessageSupplier messageSupplier, TimerName timerName); @Override AsyncTraceEntry startAsyncServiceCallEntry(String serviceCallType,
String serviceCallText, MessageSupplier messageSupplier, TimerName timerName); @Override Timer startTimer(TimerName timerName); @Override void setTransactionAsync(); @Override void setTransactionAsyncComplete(); @Override void setTransactionOuter(); @Override void setTransactionType(@Nullable String transactionType, int priority); @Override void setTransactionName(@Nullable String transactionName, int priority); @Override void setTransactionUser(@Nullable String user, int priority); @Override void addTransactionAttribute(String name, @Nullable String value); @Override void setTransactionSlowThreshold(long threshold, TimeUnit unit, int priority); @Override void setTransactionError(Throwable t); @Override void setTransactionError(@Nullable String message); @Override void setTransactionError(@Nullable String message, @Nullable Throwable t); @Override void addErrorEntry(Throwable t); @Override void addErrorEntry(@Nullable String message); @Override void addErrorEntry(@Nullable String message, Throwable t); @Override @Nullable ServletRequestInfo getServletRequestInfo(); @Override void setServletRequestInfo(@Nullable ServletRequestInfo servletRequestInfo); @Override @Deprecated @Nullable MessageSupplier getServletMessageSupplier(); @Override @Deprecated void setServletMessageSupplier(@Nullable MessageSupplier messageSupplier); }### Answer:
@Test public void testStartTransaction() { assertThat(threadContext.startTransaction(null, "text", messageSupplier, timerName)) .isEqualTo(NopTransactionService.TRACE_ENTRY); assertThat(threadContext.startTransaction("type", null, messageSupplier, timerName)) .isEqualTo(NopTransactionService.TRACE_ENTRY); assertThat(threadContext.startTransaction("type", "text", null, timerName)) .isEqualTo(NopTransactionService.TRACE_ENTRY); assertThat(threadContext.startTransaction("type", "text", messageSupplier, null)) .isEqualTo(NopTransactionService.TRACE_ENTRY); } |
### Question:
ThreadContextImpl implements ThreadContextPlus { private TraceEntryImpl startAsyncTraceEntry(long startTick, MessageSupplier messageSupplier, TimerImpl syncTimer, AsyncTimerImpl asyncTimer) { TraceEntryImpl entry = traceEntryComponent.pushEntry(startTick, messageSupplier, syncTimer, asyncTimer, null, 0); transaction.memoryBarrierReadWrite(); return entry; } ThreadContextImpl(Transaction transaction, @Nullable TraceEntryImpl parentTraceEntry,
@Nullable TraceEntryImpl parentThreadContextPriorEntry, MessageSupplier messageSupplier,
TimerName rootTimerName, long startTick, boolean captureThreadStats,
int maxQueryAggregates, int maxServiceCallAggregates,
@Nullable ThreadAllocatedBytes threadAllocatedBytes,
boolean limitExceededAuxThreadContext, Ticker ticker,
ThreadContextThreadLocal.Holder threadContextHolder,
@Nullable ServletRequestInfo servletRequestInfo); Transaction getTransaction(); long getThreadId(); boolean isActive(); @Nullable TimerImpl getCurrentTimer(); @Override int getCurrentNestingGroupId(); @Override void setCurrentNestingGroupId(int nestingGroupId); @Override int getCurrentSuppressionKeyId(); @Override void setCurrentSuppressionKeyId(int suppressionKeyId); @Override AuxThreadContext createAuxThreadContext(); @Override boolean isInTransaction(); @Override TraceEntry startTransaction(String transactionType, String transactionName,
MessageSupplier messageSupplier, TimerName timerName); @Override TraceEntry startTransaction(String transactionType, String transactionName,
MessageSupplier messageSupplier, TimerName timerName,
AlreadyInTransactionBehavior alreadyInTransactionBehavior); @Override TraceEntry startTraceEntry(MessageSupplier messageSupplier, TimerName timerName); @Override AsyncTraceEntry startAsyncTraceEntry(MessageSupplier messageSupplier,
TimerName timerName); @Override QueryEntry startQueryEntry(String queryType, String queryText,
QueryMessageSupplier queryMessageSupplier, TimerName timerName); @Override QueryEntry startQueryEntry(String queryType, String queryText, long queryExecutionCount,
QueryMessageSupplier queryMessageSupplier, TimerName timerName); @Override AsyncQueryEntry startAsyncQueryEntry(String queryType, String queryText,
QueryMessageSupplier queryMessageSupplier, TimerName timerName); @Override TraceEntry startServiceCallEntry(String serviceCallType, String serviceCallText,
MessageSupplier messageSupplier, TimerName timerName); @Override AsyncTraceEntry startAsyncServiceCallEntry(String serviceCallType,
String serviceCallText, MessageSupplier messageSupplier, TimerName timerName); @Override Timer startTimer(TimerName timerName); @Override void setTransactionAsync(); @Override void setTransactionAsyncComplete(); @Override void setTransactionOuter(); @Override void setTransactionType(@Nullable String transactionType, int priority); @Override void setTransactionName(@Nullable String transactionName, int priority); @Override void setTransactionUser(@Nullable String user, int priority); @Override void addTransactionAttribute(String name, @Nullable String value); @Override void setTransactionSlowThreshold(long threshold, TimeUnit unit, int priority); @Override void setTransactionError(Throwable t); @Override void setTransactionError(@Nullable String message); @Override void setTransactionError(@Nullable String message, @Nullable Throwable t); @Override void addErrorEntry(Throwable t); @Override void addErrorEntry(@Nullable String message); @Override void addErrorEntry(@Nullable String message, Throwable t); @Override @Nullable ServletRequestInfo getServletRequestInfo(); @Override void setServletRequestInfo(@Nullable ServletRequestInfo servletRequestInfo); @Override @Deprecated @Nullable MessageSupplier getServletMessageSupplier(); @Override @Deprecated void setServletMessageSupplier(@Nullable MessageSupplier messageSupplier); }### Answer:
@Test public void testStartAsyncTraceEntry() { assertThat(threadContext.startAsyncTraceEntry(null, timerName)) .isEqualTo(NopTransactionService.ASYNC_TRACE_ENTRY); assertThat(threadContext.startAsyncTraceEntry(messageSupplier, null)) .isEqualTo(NopTransactionService.ASYNC_TRACE_ENTRY); assertThat(threadContext.startAsyncTraceEntry(messageSupplier, timerName) .getClass().getName()).endsWith("$DummyTraceEntryOrQuery"); } |
### Question:
ThreadContextImpl implements ThreadContextPlus { @Override public Timer startTimer(TimerName timerName) { if (timerName == null) { logger.error("startTimer(): argument 'timerName' must be non-null"); return NopTimer.INSTANCE; } if (currentTimer == null) { logger.warn("startTimer(): called on completed thread context"); return NopTimer.INSTANCE; } return currentTimer.startNestedTimer(timerName); } ThreadContextImpl(Transaction transaction, @Nullable TraceEntryImpl parentTraceEntry,
@Nullable TraceEntryImpl parentThreadContextPriorEntry, MessageSupplier messageSupplier,
TimerName rootTimerName, long startTick, boolean captureThreadStats,
int maxQueryAggregates, int maxServiceCallAggregates,
@Nullable ThreadAllocatedBytes threadAllocatedBytes,
boolean limitExceededAuxThreadContext, Ticker ticker,
ThreadContextThreadLocal.Holder threadContextHolder,
@Nullable ServletRequestInfo servletRequestInfo); Transaction getTransaction(); long getThreadId(); boolean isActive(); @Nullable TimerImpl getCurrentTimer(); @Override int getCurrentNestingGroupId(); @Override void setCurrentNestingGroupId(int nestingGroupId); @Override int getCurrentSuppressionKeyId(); @Override void setCurrentSuppressionKeyId(int suppressionKeyId); @Override AuxThreadContext createAuxThreadContext(); @Override boolean isInTransaction(); @Override TraceEntry startTransaction(String transactionType, String transactionName,
MessageSupplier messageSupplier, TimerName timerName); @Override TraceEntry startTransaction(String transactionType, String transactionName,
MessageSupplier messageSupplier, TimerName timerName,
AlreadyInTransactionBehavior alreadyInTransactionBehavior); @Override TraceEntry startTraceEntry(MessageSupplier messageSupplier, TimerName timerName); @Override AsyncTraceEntry startAsyncTraceEntry(MessageSupplier messageSupplier,
TimerName timerName); @Override QueryEntry startQueryEntry(String queryType, String queryText,
QueryMessageSupplier queryMessageSupplier, TimerName timerName); @Override QueryEntry startQueryEntry(String queryType, String queryText, long queryExecutionCount,
QueryMessageSupplier queryMessageSupplier, TimerName timerName); @Override AsyncQueryEntry startAsyncQueryEntry(String queryType, String queryText,
QueryMessageSupplier queryMessageSupplier, TimerName timerName); @Override TraceEntry startServiceCallEntry(String serviceCallType, String serviceCallText,
MessageSupplier messageSupplier, TimerName timerName); @Override AsyncTraceEntry startAsyncServiceCallEntry(String serviceCallType,
String serviceCallText, MessageSupplier messageSupplier, TimerName timerName); @Override Timer startTimer(TimerName timerName); @Override void setTransactionAsync(); @Override void setTransactionAsyncComplete(); @Override void setTransactionOuter(); @Override void setTransactionType(@Nullable String transactionType, int priority); @Override void setTransactionName(@Nullable String transactionName, int priority); @Override void setTransactionUser(@Nullable String user, int priority); @Override void addTransactionAttribute(String name, @Nullable String value); @Override void setTransactionSlowThreshold(long threshold, TimeUnit unit, int priority); @Override void setTransactionError(Throwable t); @Override void setTransactionError(@Nullable String message); @Override void setTransactionError(@Nullable String message, @Nullable Throwable t); @Override void addErrorEntry(Throwable t); @Override void addErrorEntry(@Nullable String message); @Override void addErrorEntry(@Nullable String message, Throwable t); @Override @Nullable ServletRequestInfo getServletRequestInfo(); @Override void setServletRequestInfo(@Nullable ServletRequestInfo servletRequestInfo); @Override @Deprecated @Nullable MessageSupplier getServletMessageSupplier(); @Override @Deprecated void setServletMessageSupplier(@Nullable MessageSupplier messageSupplier); }### Answer:
@Test public void testStartTimer() { assertThat(threadContext.startTimer(null)).isEqualTo(NopTimer.INSTANCE); threadContext.setCurrentTimer(null); assertThat(threadContext.startTimer(timerName)).isEqualTo(NopTimer.INSTANCE); } |
### Question:
Reflection { @SuppressWarnings("unchecked") public static <T> T invokeWithDefault(@Nullable Method method, Object obj, T defaultValue) { if (method == null) { return defaultValue; } try { Object value = method.invoke(obj); if (value == null) { return defaultValue; } return (T) value; } catch (Throwable t) { logger.warn("error calling {}.{}()", method.getDeclaringClass().getName(), method.getName(), t); return defaultValue; } } private Reflection(); static @Nullable Method getMethod(@Nullable Class<?> clazz, String methodName); static @Nullable Field getDeclaredField(@Nullable Class<?> clazz, String fieldName); @SuppressWarnings("unchecked") static T invoke(@Nullable Method method, Object obj); @SuppressWarnings("unchecked") static T invokeWithDefault(@Nullable Method method, Object obj, T defaultValue); static @Nullable Object getFieldValue(@Nullable Field field, Object obj); }### Answer:
@Test public void shouldReturnDefaultValueWhenMethodIsNull() { assertThat(Reflection.invokeWithDefault(null, null, "the default")) .isEqualTo("the default"); } |
### Question:
Transaction { @VisibleForTesting static String buildTraceId(long startTime) { byte[] bytes = new byte[10]; random.nextBytes(bytes); return lowerSixBytesHex(startTime) + BaseEncoding.base16().lowerCase().encode(bytes); } Transaction(long startTime, long startTick, String transactionType, String transactionName,
MessageSupplier messageSupplier, TimerName timerName, boolean captureThreadStats,
int maxTraceEntries, int maxQueryAggregates, int maxServiceCallAggregates,
int maxProfileSamples, @Nullable ThreadAllocatedBytes threadAllocatedBytes,
CompletionCallback completionCallback, Ticker ticker,
TransactionRegistry transactionRegistry, TransactionService transactionService,
ConfigService configService, UserProfileScheduler userProfileScheduler,
ThreadContextThreadLocal.Holder threadContextHolder); String getTraceId(); long getStartTick(); boolean isCompleted(); long getDurationNanos(); String getTransactionType(); String getTransactionName(); String getHeadline(); String getUser(); SetMultimap<String, String> getAttributes(); @Nullable ErrorMessage getErrorMessage(); long getTotalCpuNanos(); List<Aggregate.Query> getQueries(); List<String> getSharedQueryTexts(); void visitEntries(long captureTick, EntryVisitor entryVisitor); @Nullable Profile getMainThreadProfileProtobuf(); @Nullable Profile getAuxThreadProfileProtobuf(); @Nullable Cancellable getImmedateTraceStoreRunnable(); boolean isPartiallyStored(); ThreadContextImpl getMainThreadContext(); List<ThreadContextImpl> getActiveAuxThreadContexts(); void setImmediateTraceStoreRunnable(Cancellable immedateTraceStoreRunnable); }### Answer:
@Test public void traceIdShouldBeThirtyTwoCharactersAndLowerCase() { String traceId = Transaction.buildTraceId(System.currentTimeMillis()); assertThat(traceId).hasSize(32); assertThat(traceId.toLowerCase()).isEqualTo(traceId); } |
### Question:
Transaction { @VisibleForTesting static String lowerSixBytesHex(long startTime) { long mask = 1L << 48; return Long.toHexString(mask | (startTime & (mask - 1))).substring(1); } Transaction(long startTime, long startTick, String transactionType, String transactionName,
MessageSupplier messageSupplier, TimerName timerName, boolean captureThreadStats,
int maxTraceEntries, int maxQueryAggregates, int maxServiceCallAggregates,
int maxProfileSamples, @Nullable ThreadAllocatedBytes threadAllocatedBytes,
CompletionCallback completionCallback, Ticker ticker,
TransactionRegistry transactionRegistry, TransactionService transactionService,
ConfigService configService, UserProfileScheduler userProfileScheduler,
ThreadContextThreadLocal.Holder threadContextHolder); String getTraceId(); long getStartTick(); boolean isCompleted(); long getDurationNanos(); String getTransactionType(); String getTransactionName(); String getHeadline(); String getUser(); SetMultimap<String, String> getAttributes(); @Nullable ErrorMessage getErrorMessage(); long getTotalCpuNanos(); List<Aggregate.Query> getQueries(); List<String> getSharedQueryTexts(); void visitEntries(long captureTick, EntryVisitor entryVisitor); @Nullable Profile getMainThreadProfileProtobuf(); @Nullable Profile getAuxThreadProfileProtobuf(); @Nullable Cancellable getImmedateTraceStoreRunnable(); boolean isPartiallyStored(); ThreadContextImpl getMainThreadContext(); List<ThreadContextImpl> getActiveAuxThreadContexts(); void setImmediateTraceStoreRunnable(Cancellable immedateTraceStoreRunnable); }### Answer:
@Test public void shouldLowerSixBytesWithPadding() { long startTime = 123456; String lowerSixBytes = Transaction.lowerSixBytesHex(startTime); assertThat(lowerSixBytes).isEqualTo("00000001e240"); }
@Test public void shouldLowerSixBytesWithNoPaddingOrTruncation() { long startTime = 123456123456789L; String lowerSixBytes = Transaction.lowerSixBytesHex(startTime); assertThat(lowerSixBytes).isEqualTo("70485e624d15"); }
@Test public void shouldLowerSixBytesWithTruncation() { long startTime = 123456123456789123L; String lowerSixBytes = Transaction.lowerSixBytesHex(startTime); assertThat(lowerSixBytes).isEqualTo("9ab0affd1a83"); } |
### Question:
TimerNameCache { public TimerName getTimerName(Class<?> adviceClass) { if (adviceClass == null) { logger.error("getTimerName(): argument 'adviceClass' must be non-null"); return unknownTimerName; } Pointcut pointcut = adviceClass.getAnnotation(Pointcut.class); if (pointcut == null) { logger.warn("advice has no @Pointcut: {}", adviceClass.getName()); return unknownTimerName; } else if (pointcut.timerName().isEmpty()) { logger.warn("advice @Pointcut has no timerName() attribute: {}", adviceClass.getName()); return unknownTimerName; } else { return getName(pointcut.timerName()); } } TimerName getTimerName(Class<?> adviceClass); }### Answer:
@Test public void testNullClass() { TimerNameCache timerNameCache = new TimerNameCache(); TimerName timerName = timerNameCache.getTimerName((Class<?>) null); assertThat(((TimerNameImpl) timerName).name()).isEqualTo("unknown"); }
@Test public void testClassWithoutPointcutAnnotation() { TimerNameCache timerNameCache = new TimerNameCache(); TimerName timerName = timerNameCache.getTimerName(A.class); assertThat(((TimerNameImpl) timerName).name()).isEqualTo("unknown"); }
@Test public void testClassWithEmptyTimerName() { TimerNameCache timerNameCache = new TimerNameCache(); TimerName timerName = timerNameCache.getTimerName(B.class); assertThat(((TimerNameImpl) timerName).name()).isEqualTo("unknown"); }
@Test public void testNormal() { TimerNameCache timerNameCache = new TimerNameCache(); TimerName timerName = timerNameCache.getTimerName(C.class); assertThat(((TimerNameImpl) timerName).name()).isEqualTo("z"); } |
### Question:
Strings { public static List<String> split(String string) { List<String> list = new ArrayList<String>(); int lastFoundIndex = -1; int nextFoundIndex; while ((nextFoundIndex = string.indexOf(',', lastFoundIndex + 1)) != -1) { String value = string.substring(lastFoundIndex + 1, nextFoundIndex).trim(); if (!value.isEmpty()) { list.add(value); } lastFoundIndex = nextFoundIndex; } String value = string.substring(lastFoundIndex + 1).trim(); if (!value.isEmpty()) { list.add(value); } return list; } private Strings(); static String nullToEmpty(@Nullable String string); static List<String> split(String string); }### Answer:
@Test public void shouldSplit() { assertThat(Strings.split("c,s,v")).contains("c", "s", "v"); assertThat(Strings.split("c,s,v,")).contains("c", "s", "v"); assertThat(Strings.split(" , csv , x, y ")).contains("csv", "x", "y"); assertThat(Strings.split(",,,")).isEmpty(); } |
### Question:
ToolMain { @VisibleForTesting static @Nullable File getGlowrootJarFile(@Nullable CodeSource codeSource) throws URISyntaxException { if (codeSource == null) { return null; } File codeSourceFile = new File(codeSource.getLocation().toURI()); if (codeSourceFile.getName().endsWith(".jar")) { return codeSourceFile; } return null; } private ToolMain(); static void main(String[] args, @Nullable File glowrootJarFile); }### Answer:
@Test public void testNullCodeSource() throws URISyntaxException { assertThat(ToolMain.getGlowrootJarFile(null)).isNull(); }
@Test public void testWithGlowrootJar() throws Exception { File glowrootJar = new File("x/glowroot.jar").getAbsoluteFile(); CodeSource codeSource = new CodeSource(glowrootJar.toURI().toURL(), new Certificate[0]); assertThat(ToolMain.getGlowrootJarFile(codeSource)).isEqualTo(glowrootJar); }
@Test public void testWithNotGlowrootJar() throws Exception { File glowrootJar = new File("x/classes"); CodeSource codeSource = new CodeSource(glowrootJar.toURI().toURL(), new Certificate[0]); assertThat(ToolMain.getGlowrootJarFile(codeSource)).isNull(); } |
### Question:
ServletMessageSupplier extends MessageSupplier implements ServletRequestInfo { static @Nullable String maskRequestQueryString(@Nullable String requestQueryString, List<Pattern> maskPatterns) { if (requestQueryString == null) { return null; } if (maskPatterns.isEmpty()) { return requestQueryString; } StringBuilder sb = new StringBuilder(requestQueryString.length()); boolean existMaskedParameters = false; int keyStartIndex = 0; boolean inMaskedValue = false; for (int i = 0; i < requestQueryString.length(); i++) { char c = requestQueryString.charAt(i); switch (c) { case '&': sb.append('&'); keyStartIndex = sb.length(); inMaskedValue = false; break; case '=': if (keyStartIndex == -1) { if (!inMaskedValue) { sb.append(c); } } else { String key = sb.substring(keyStartIndex, sb.length()); sb.append('='); String keyLowerCase = key.toLowerCase(Locale.ENGLISH); if (DetailCapture.matchesOneOf(keyLowerCase, maskPatterns)) { inMaskedValue = true; sb.append(MASK_TEXT); existMaskedParameters = true; } keyStartIndex = -1; } break; default: if (!inMaskedValue) { sb.append(c); } } } if (existMaskedParameters) { return sb.toString(); } else { return requestQueryString; } } ServletMessageSupplier(String requestMethod, String requestContextPath,
String requestServletPath, @Nullable String requestPathInfo, String requestUri,
@Nullable String requestQueryString, Map<String, Object> requestHeaders,
@Nullable String requestRemoteAddr, @Nullable String requestRemoteHost,
Map<String, String> sessionAttributeMap); @Override Message get(); @Override String getMethod(); @Override String getContextPath(); @Override String getServletPath(); @Override @Nullable String getPathInfo(); @Override String getUri(); }### Answer:
@Test public void shouldMask() { List<Pattern> maskPatterns = ImmutableList.of(Pattern.compile(".*password.*")); String requestQueryString = "test=one&xpasswordy=maskme&test=two"; String maskRequestQueryString = ServletMessageSupplier.maskRequestQueryString(requestQueryString, maskPatterns); assertThat(maskRequestQueryString).isEqualTo("test=one&xpasswordy=****&test=two"); }
@Test public void shouldNotMask() { List<Pattern> maskPatterns = ImmutableList.of(Pattern.compile(".*password.*")); String requestQueryString = "test=one&xpassworry=nomask&test=two"; String maskRequestQueryString = ServletMessageSupplier.maskRequestQueryString(requestQueryString, maskPatterns); assertThat(maskRequestQueryString).isEqualTo("test=one&xpassworry=nomask&test=two"); }
@Test public void shouldMaskStrange() { List<Pattern> maskPatterns = ImmutableList.of(Pattern.compile(".*password.*")); String requestQueryString = "test=one&&&===&=&xpasswordy=mask=me&&&==&test=two"; String maskRequestQueryString = ServletMessageSupplier.maskRequestQueryString(requestQueryString, maskPatterns); assertThat(maskRequestQueryString) .isEqualTo("test=one&&&===&=&xpasswordy=****&&&==&test=two"); }
@Test public void shouldNotMaskStrange() { List<Pattern> maskPatterns = ImmutableList.of(Pattern.compile(".*password.*")); String requestQueryString = "test=one&&&===&=&xpassworry=no=mask&&&==&test=two"; String maskRequestQueryString = ServletMessageSupplier.maskRequestQueryString(requestQueryString, maskPatterns); assertThat(maskRequestQueryString) .isEqualTo("test=one&&&===&=&xpassworry=no=mask&&&==&test=two"); } |
### Question:
LazySecretKeyImpl implements LazySecretKey { @Override public SecretKey getOrCreate() throws Exception { synchronized (secretFile) { if (secretKey == null) { if (secretFile.exists()) { secretKey = loadKey(secretFile); } else { secretKey = Encryption.generateNewKey(); Files.write(secretKey.getEncoded(), secretFile); } } return secretKey; } } LazySecretKeyImpl(File secretFile); @Override @Nullable SecretKey getExisting(); @Override SecretKey getOrCreate(); }### Answer:
@Test public void testLoadSecretKey() throws Exception { SecretKey secretKey = Encryption.generateNewKey(); File secretKeyFile = File.createTempFile("glowroot-unit-test-", ""); byte[] encodedKey = secretKey.getEncoded(); Files.write(encodedKey, secretKeyFile); LazySecretKey lazySecretKey = new LazySecretKeyImpl(secretKeyFile); assertThat(lazySecretKey.getOrCreate().getEncoded()).isEqualTo(encodedKey); secretKeyFile.delete(); } |
### Question:
LazySecretKeyImpl implements LazySecretKey { @Override public @Nullable SecretKey getExisting() throws Exception { synchronized (secretFile) { if (secretKey == null && secretFile.exists()) { secretKey = loadKey(secretFile); } return secretKey; } } LazySecretKeyImpl(File secretFile); @Override @Nullable SecretKey getExisting(); @Override SecretKey getOrCreate(); }### Answer:
@Test public void testLoadSecretKey2() throws Exception { SecretKey secretKey = Encryption.generateNewKey(); File secretKeyFile = File.createTempFile("glowroot-unit-test-", ""); byte[] encodedKey = secretKey.getEncoded(); Files.write(encodedKey, secretKeyFile); LazySecretKey lazySecretKey = new LazySecretKeyImpl(secretKeyFile); assertThat(lazySecretKey.getExisting().getEncoded()).isEqualTo(encodedKey); secretKeyFile.delete(); } |
### Question:
ScheduledRunnable implements Runnable, Cancellable { public void scheduleWithFixedDelay(ScheduledExecutorService scheduledExecutor, long period, TimeUnit unit) { scheduleWithFixedDelay(scheduledExecutor, 0, period, unit); } void scheduleWithFixedDelay(ScheduledExecutorService scheduledExecutor, long period,
TimeUnit unit); void scheduleWithFixedDelay(ScheduledExecutorService scheduledExecutor,
long initialDelay, long period, TimeUnit unit); @Override void run(); @Override void cancel(); }### Answer:
@Test public void testScheduleWithFixedDelay() { TestScheduledRunnable testScheduledRunnable = new TestScheduledRunnable(); testScheduledRunnable.scheduleWithFixedDelay(scheduledExecutorService, 1, SECONDS); verify(scheduledExecutorService).scheduleWithFixedDelay(testScheduledRunnable, 0, 1, SECONDS); verifyNoMoreInteractions(scheduledExecutorService); }
@Test public void testScheduleWithFixedDelayCalledTwice() { TestScheduledRunnable testScheduledRunnable = new TestScheduledRunnable(); testScheduledRunnable.scheduleWithFixedDelay(scheduledExecutorService, 1, SECONDS); testScheduledRunnable.scheduleWithFixedDelay(scheduledExecutorService, 1, SECONDS); verify(scheduledExecutorService).scheduleWithFixedDelay(testScheduledRunnable, 0, 1, SECONDS); verifyNoMoreInteractions(scheduledExecutorService); } |
### Question:
ScheduledRunnable implements Runnable, Cancellable { @Override public void cancel() { if (future != null) { future.cancel(false); } } void scheduleWithFixedDelay(ScheduledExecutorService scheduledExecutor, long period,
TimeUnit unit); void scheduleWithFixedDelay(ScheduledExecutorService scheduledExecutor,
long initialDelay, long period, TimeUnit unit); @Override void run(); @Override void cancel(); }### Answer:
@Test public void testCancelWithNoFuture() { TestScheduledRunnable testScheduledRunnable = new TestScheduledRunnable(); testScheduledRunnable.cancel(); } |
### Question:
ScheduledRunnable implements Runnable, Cancellable { @Override public void run() { try { runInternal(); } catch (TerminateSubsequentExecutionsException e) { logger.debug(e.getMessage(), e); throw e; } catch (Throwable t) { logger.error(t.getMessage(), t); } } void scheduleWithFixedDelay(ScheduledExecutorService scheduledExecutor, long period,
TimeUnit unit); void scheduleWithFixedDelay(ScheduledExecutorService scheduledExecutor,
long initialDelay, long period, TimeUnit unit); @Override void run(); @Override void cancel(); }### Answer:
@Test public void testExceptionalScheduledRunnable() { ExceptionalScheduledRunnable testScheduledRunnable = new ExceptionalScheduledRunnable(); testScheduledRunnable.run(); } |
### Question:
SystemProperties { public static List<String> maskJvmArgs(List<String> jvmArgs, List<String> maskSystemProperties) { if (maskSystemProperties.isEmpty()) { return jvmArgs; } List<Pattern> maskSystemPropertyPatterns = buildPatternList(maskSystemProperties); List<String> maskedJvmArgs = Lists.newArrayList(); for (String arg : jvmArgs) { maskedJvmArgs.add(maskSystemProperty(arg, maskSystemPropertyPatterns)); } return maskedJvmArgs; } private SystemProperties(); static List<String> maskJvmArgs(List<String> jvmArgs,
List<String> maskSystemProperties); static Map<String, String> maskSystemProperties(Map<String, String> systemProperties,
List<String> maskSystemProperties); }### Answer:
@Test public void shouldMaskJvmArgs() { assertThat(SystemProperties.maskJvmArgs(ImmutableList.of("-Xmx1g", "-Dtest=one"), ImmutableList.<String>of())).containsExactly("-Xmx1g", "-Dtest=one"); assertThat(SystemProperties.maskJvmArgs(ImmutableList.of("-Xmx1g", "-Dtest=one"), ImmutableList.<String>of("test"))).containsExactly("-Xmx1g", "-Dtest=****"); assertThat(SystemProperties.maskJvmArgs(ImmutableList.of("-Xmx1g", "-Dtest=one"), ImmutableList.<String>of("t"))).containsExactly("-Xmx1g", "-Dtest=one"); assertThat(SystemProperties.maskJvmArgs(ImmutableList.of("-Xmx1g", "-Dtest=one"), ImmutableList.<String>of("t*"))).containsExactly("-Xmx1g", "-Dtest=****"); assertThat(SystemProperties.maskJvmArgs(ImmutableList.of("-Xmx1g", "-Dtest=one"), ImmutableList.<String>of("e*"))).containsExactly("-Xmx1g", "-Dtest=one"); assertThat(SystemProperties.maskJvmArgs(ImmutableList.of("-Xmx1g", "-Dtest=one"), ImmutableList.<String>of("*t*"))).containsExactly("-Xmx1g", "-Dtest=****"); assertThat(SystemProperties.maskJvmArgs(ImmutableList.of("-Xmx1g", "-Dtest=one"), ImmutableList.<String>of("*x*"))).containsExactly("-Xmx1g", "-Dtest=one"); assertThat(SystemProperties.maskJvmArgs(ImmutableList.of("-Xmx1g", "-DtEst=one"), ImmutableList.<String>of("teSt"))).containsExactly("-Xmx1g", "-DtEst=****"); } |
### Question:
SystemProperties { public static Map<String, String> maskSystemProperties(Map<String, String> systemProperties, List<String> maskSystemProperties) { if (maskSystemProperties.isEmpty()) { return systemProperties; } List<Pattern> maskPatterns = buildPatternList(maskSystemProperties); Map<String, String> maskedSystemProperties = Maps.newHashMap(); for (Map.Entry<String, String> entry : systemProperties.entrySet()) { String name = entry.getKey(); if (matchesAny(name, maskPatterns)) { maskedSystemProperties.put(name, "****"); } else { maskedSystemProperties.put(name, entry.getValue()); } } return maskedSystemProperties; } private SystemProperties(); static List<String> maskJvmArgs(List<String> jvmArgs,
List<String> maskSystemProperties); static Map<String, String> maskSystemProperties(Map<String, String> systemProperties,
List<String> maskSystemProperties); }### Answer:
@Test public void shouldMaskSystemProperties() { assertThat(SystemProperties .maskSystemProperties(ImmutableMap.of("test", "one"), ImmutableList.<String>of()) .get("test")).isEqualTo("one"); assertThat(SystemProperties.maskSystemProperties(ImmutableMap.of("test", "one"), ImmutableList.<String>of("test")).get("test")).isEqualTo("****"); assertThat(SystemProperties .maskSystemProperties(ImmutableMap.of("test", "one"), ImmutableList.<String>of("t")) .get("test")).isEqualTo("one"); assertThat(SystemProperties.maskSystemProperties(ImmutableMap.of("test", "one"), ImmutableList.<String>of("t*")).get("test")).isEqualTo("****"); assertThat(SystemProperties.maskSystemProperties(ImmutableMap.of("test", "one"), ImmutableList.<String>of("e*")).get("test")).isEqualTo("one"); assertThat(SystemProperties.maskSystemProperties(ImmutableMap.of("test", "one"), ImmutableList.<String>of("*t*")).get("test")).isEqualTo("****"); assertThat(SystemProperties.maskSystemProperties(ImmutableMap.of("test", "one"), ImmutableList.<String>of("*x*")).get("test")).isEqualTo("one"); assertThat(SystemProperties.maskSystemProperties(ImmutableMap.of("tEst", "one"), ImmutableList.<String>of("teSt")).get("tEst")).isEqualTo("****"); } |
### Question:
Version { public static String getVersion(Class<?> baseClass) { Manifest manifest; try { manifest = getManifest(baseClass); } catch (IOException e) { logger.error(e.getMessage(), e); return UNKNOWN_VERSION; } return getVersion(manifest); } private Version(); static String getVersion(Class<?> baseClass); static final String UNKNOWN_VERSION; }### Answer:
@Test public void testWithNullManifest() { String version = Version.getVersion((Manifest) null); assertThat(version).isEqualTo("unknown"); }
@Test public void testWithNoImplementationVersion() { Manifest manifest = mock(Manifest.class); Attributes attributes = mock(Attributes.class); when(manifest.getMainAttributes()).thenReturn(attributes); String version = Version.getVersion(manifest); assertThat(version).isEqualTo("unknown"); }
@Test public void testWithNonSnapshotVersion() { Manifest manifest = mock(Manifest.class); Attributes attributes = mock(Attributes.class); when(manifest.getMainAttributes()).thenReturn(attributes); when(attributes.getValue("Implementation-Version")).thenReturn("0.1.2"); String version = Version.getVersion(manifest); assertThat(version).isEqualTo("0.1.2"); }
@Test public void testWithSnapshotVersion() { Manifest manifest = mock(Manifest.class); Attributes attributes = mock(Attributes.class); when(manifest.getMainAttributes()).thenReturn(attributes); when(attributes.getValue("Implementation-Version")).thenReturn("0.1.2-SNAPSHOT"); when(attributes.getValue("Build-Commit")) .thenReturn("0123456789abcdeabcde0123456789abcdeabcde"); when(attributes.getValue("Build-Time")).thenReturn("xyz"); String version = Version.getVersion(manifest); assertThat(version).isEqualTo("0.1.2-SNAPSHOT, commit 0123456789, built xyz"); }
@Test public void testWithNoneBuildCommit() { Manifest manifest = mock(Manifest.class); Attributes attributes = mock(Attributes.class); when(manifest.getMainAttributes()).thenReturn(attributes); when(attributes.getValue("Implementation-Version")).thenReturn("0.1.2-SNAPSHOT"); when(attributes.getValue("Build-Commit")).thenReturn("[none]"); when(attributes.getValue("Build-Time")).thenReturn("xyz"); String version = Version.getVersion(manifest); assertThat(version).isEqualTo("0.1.2-SNAPSHOT, built xyz"); }
@Test public void testWithInvalidBuildCommit() { Manifest manifest = mock(Manifest.class); Attributes attributes = mock(Attributes.class); when(manifest.getMainAttributes()).thenReturn(attributes); when(attributes.getValue("Implementation-Version")).thenReturn("0.1.2-SNAPSHOT"); when(attributes.getValue("Build-Commit")).thenReturn("tooshort"); when(attributes.getValue("Build-Time")).thenReturn("xyz"); String version = Version.getVersion(manifest); assertThat(version).isEqualTo("0.1.2-SNAPSHOT, built xyz"); }
@Test public void testWithMissingBuildTime() { Manifest manifest = mock(Manifest.class); Attributes attributes = mock(Attributes.class); when(manifest.getMainAttributes()).thenReturn(attributes); when(attributes.getValue("Implementation-Version")).thenReturn("0.1.2-SNAPSHOT"); when(attributes.getValue("Build-Commit")).thenReturn("tooshort"); String version = Version.getVersion(manifest); assertThat(version).isEqualTo("0.1.2-SNAPSHOT"); }
@Test public void testWithInvalidBuildCommitAndMissingBuildTime() { Manifest manifest = mock(Manifest.class); Attributes attributes = mock(Attributes.class); when(manifest.getMainAttributes()).thenReturn(attributes); when(attributes.getValue("Implementation-Version")).thenReturn("0.1.2-SNAPSHOT"); when(attributes.getValue("Build-Commit")).thenReturn("tooshort"); String version = Version.getVersion(manifest); assertThat(version).isEqualTo("0.1.2-SNAPSHOT"); } |
### Question:
Version { @VisibleForTesting static @Nullable Manifest getManifest(Class<?> clazz) throws IOException { URL classURL = clazz.getResource(clazz.getSimpleName() + ".class"); if (classURL == null) { logger.warn("url for class is unexpectedly null: {}", clazz); return null; } String externalForm = classURL.toExternalForm(); if (!externalForm.startsWith("jar:")) { return null; } URL manifestURL = new URL(externalForm.substring(0, externalForm.lastIndexOf('!')) + "!/META-INF/MANIFEST.MF"); Closer closer = Closer.create(); try { InputStream manifestIn = closer.register(manifestURL.openStream()); return new Manifest(manifestIn); } catch (Throwable t) { throw closer.rethrow(t); } finally { closer.close(); } } private Version(); static String getVersion(Class<?> baseClass); static final String UNKNOWN_VERSION; }### Answer:
@Test public void testClassWithNoClassFile() throws IOException { assertThat(Version.getManifest(long.class)).isNull(); } |
### Question:
GrpcCommon { static String convertFromV09AgentRollupId(String v09AgentRollupId) { return v09AgentRollupId.replaceAll(" */ *", "::").trim() + "::"; } GrpcCommon(AgentConfigDao agentConfigDao, V09AgentRollupDao v09AgentRollupDao); }### Answer:
@Test public void test() { assertThat(GrpcCommon.convertFromV09AgentRollupId("a/b/c")).isEqualTo("a::b::c::"); assertThat(GrpcCommon.convertFromV09AgentRollupId(" a/b/c ")).isEqualTo("a::b::c::"); assertThat(GrpcCommon.convertFromV09AgentRollupId("a / b/c")).isEqualTo("a::b::c::"); assertThat(GrpcCommon.convertFromV09AgentRollupId("a/ b /c")).isEqualTo("a::b::c::"); } |
### Question:
TraceCommonService { @VisibleForTesting static @Nullable String entriesToJson(List<Trace.Entry> entries) throws IOException { if (entries.isEmpty()) { return null; } StringBuilder sb = new StringBuilder(); JsonGenerator jg = jsonFactory.createGenerator(CharStreams.asWriter(sb)); try { writeEntries(jg, entries); } finally { jg.close(); } return sb.toString(); } TraceCommonService(TraceRepository traceRepository, LiveTraceRepository liveTraceRepository,
ConfigRepository configRepository); }### Answer:
@Test public void test() throws Exception { List<Trace.Entry> entries = Lists.newArrayList(); entries.add(Trace.Entry.newBuilder().setDepth(0).build()); entries.add(Trace.Entry.newBuilder().setDepth(1).build()); String json = TraceCommonService.entriesToJson(entries); assertThat(json).isEqualTo("[{\"startOffsetNanos\":0,\"durationNanos\":0,\"message\":\"\"," + "\"childEntries\":[{\"startOffsetNanos\":0,\"durationNanos\":0,\"message\":\"\"}]" + "}]"); } |
### Question:
ResponseInvoker { static @Nullable Class<?> getServletResponseClass(Class<?> clazz) { try { return Class.forName("javax.servlet.ServletResponse", false, clazz.getClassLoader()); } catch (ClassNotFoundException e) { logger.warn(e.getMessage(), e); } return null; } ResponseInvoker(Class<?> clazz); }### Answer:
@Test public void shouldNotFindServletResponseClass() { assertThat(ResponseInvoker.getServletResponseClass(Object.class)).isNull(); } |
### Question:
ResponseInvoker { boolean hasGetContentTypeMethod() { return getContentTypeMethod != null; } ResponseInvoker(Class<?> clazz); }### Answer:
@Test public void shouldNotFindGetContentTypeMethod() { assertThat(new ResponseInvoker(Object.class).hasGetContentTypeMethod()).isFalse(); } |
### Question:
ResourceMethodMeta { static String combine(@Nullable String classPath, @Nullable String methodPath) { if (classPath == null || classPath.isEmpty() || classPath.equals("/")) { return normalize(methodPath); } if (methodPath == null || methodPath.isEmpty() || methodPath.equals("/")) { return normalize(classPath); } return normalize(classPath) + normalize(methodPath); } ResourceMethodMeta(Method method); }### Answer:
@Test public void should() { assertThat(ResourceMethodMeta.combine(null, null)).isEqualTo("/"); assertThat(ResourceMethodMeta.combine("", null)).isEqualTo("/"); assertThat(ResourceMethodMeta.combine(null, "")).isEqualTo("/"); assertThat(ResourceMethodMeta.combine("", "")).isEqualTo("/"); assertThat(ResourceMethodMeta.combine("/abc", "/xyz")).isEqualTo("/abc/xyz"); assertThat(ResourceMethodMeta.combine("/abc", "xyz")).isEqualTo("/abc/xyz"); assertThat(ResourceMethodMeta.combine("abc", "/xyz")).isEqualTo("/abc/xyz"); assertThat(ResourceMethodMeta.combine("abc", "xyz")).isEqualTo("/abc/xyz"); assertThat(ResourceMethodMeta.combine("abc", null)).isEqualTo("/abc"); assertThat(ResourceMethodMeta.combine(null, "xyz")).isEqualTo("/xyz"); assertThat(ResourceMethodMeta.combine("abc", "")).isEqualTo("/abc"); assertThat(ResourceMethodMeta.combine("", "xyz")).isEqualTo("/xyz"); assertThat(ResourceMethodMeta.combine("/abc", "")).isEqualTo("/abc"); assertThat(ResourceMethodMeta.combine("", "/xyz")).isEqualTo("/xyz"); } |
### Question:
RateLimitedLogger { @VisibleForTesting static @Nullable Object[] newArgsWithCountSinceLastWarning( Object[] args, int countSinceLastWarning) { if (args.length == 0) { return new Object[] {countSinceLastWarning}; } @Nullable Object[] argsPlus = new Object[args.length + 1]; if (args[args.length - 1] instanceof Throwable) { System.arraycopy(args, 0, argsPlus, 0, args.length - 1); argsPlus[args.length - 1] = countSinceLastWarning; argsPlus[args.length] = args[args.length - 1]; return argsPlus; } else { System.arraycopy(args, 0, argsPlus, 0, args.length); argsPlus[args.length] = countSinceLastWarning; return argsPlus; } } RateLimitedLogger(Class<?> clazz); RateLimitedLogger(Class<?> clazz, boolean willKeepTrying); void warn(String format, /*@Nullable*/ Object... args); }### Answer:
@Test public void testEmpty() { Object[] args = RateLimitedLogger.newArgsWithCountSinceLastWarning(new Object[] {}, 0); assertThat(args).containsExactly(0); }
@Test public void testSingle() { Object[] args = RateLimitedLogger.newArgsWithCountSinceLastWarning(new Object[] {1}, 0); assertThat(args).containsExactly(1, 0); }
@Test public void testSingleException() { Exception exception = new Exception(); Object[] args = RateLimitedLogger.newArgsWithCountSinceLastWarning(new Object[] {exception}, 0); assertThat(args).containsExactly(0, exception); }
@Test public void testMultiple() { Object[] args = RateLimitedLogger.newArgsWithCountSinceLastWarning(new Object[] {1, 2}, 0); assertThat(args).containsExactly(1, 2, 0); }
@Test public void testMultipleException() { Exception exception = new Exception(); Object[] args = RateLimitedLogger.newArgsWithCountSinceLastWarning(new Object[] {1, exception}, 0); assertThat(args).containsExactly(1, 0, exception); } |
### Question:
JavaVersion { @VisibleForTesting static boolean parseIsJava6(@Nullable String javaVersion) { return javaVersion != null && javaVersion.startsWith("1.6"); } private JavaVersion(); static boolean isJava6(); static boolean isGreaterThanOrEqualToJava9(); static boolean isIbmJvm(); static boolean isJRockitJvm(); }### Answer:
@Test public void testNullVersion() { assertThat(JavaVersion.parseIsJava6(null)).isFalse(); }
@Test public void testCorrectVersion() { assertThat(JavaVersion.parseIsJava6("1.6")).isTrue(); assertThat(JavaVersion.parseIsJava6("1.6.0")).isTrue(); assertThat(JavaVersion.parseIsJava6("1.6.0_45")).isTrue(); }
@Test public void testIncorrectVersion() { assertThat(JavaVersion.parseIsJava6("1.5")).isFalse(); assertThat(JavaVersion.parseIsJava6("1.7")).isFalse(); assertThat(JavaVersion.parseIsJava6("1.7.0")).isFalse(); assertThat(JavaVersion.parseIsJava6("1.8.0")).isFalse(); } |
### Question:
CollectorProxy implements Collector { @Override public void collectAggregates(AggregateReader aggregateReader) throws Exception { if (instance == null) { earlyAggregateReaders.offer(aggregateReader); if (instance != null) { earlyAggregateReaders.remove(aggregateReader); instance.collectAggregates(aggregateReader); } } else { instance.collectAggregates(aggregateReader); } } @Override void init(File confDir, @Nullable File sharedConfDir, Environment environment,
AgentConfig agentConfig, AgentConfigUpdater agentConfigUpdater); @Override void collectAggregates(AggregateReader aggregateReader); @Override void collectGaugeValues(List<GaugeValue> gaugeValues); @Override void collectTrace(TraceReader traceReader); @Override void log(LogEvent logEvent); @VisibleForTesting void setInstance(Collector instance); }### Answer:
@Test public void testCollectAggregates() throws Exception { CollectorProxy collectorProxy = new CollectorProxy(); AggregateReader aggregateReader1 = mock(AggregateReader.class); AggregateReader aggregateReader2 = mock(AggregateReader.class); AggregateReader aggregateReader3 = mock(AggregateReader.class); collectorProxy.collectAggregates(aggregateReader1); collectorProxy.collectAggregates(aggregateReader2); Collector collector = mock(Collector.class); collectorProxy.setInstance(collector); collectorProxy.collectAggregates(aggregateReader3); InOrder inOrder = Mockito.inOrder(collector); inOrder.verify(collector).collectAggregates(aggregateReader1); inOrder.verify(collector).collectAggregates(aggregateReader2); inOrder.verify(collector).collectAggregates(aggregateReader3); } |
### Question:
CollectorProxy implements Collector { @Override public void collectGaugeValues(List<GaugeValue> gaugeValues) throws Exception { if (instance == null) { earlyGaugeValues.offer(gaugeValues); if (instance != null) { earlyGaugeValues.remove(gaugeValues); instance.collectGaugeValues(gaugeValues); } } else { instance.collectGaugeValues(gaugeValues); } } @Override void init(File confDir, @Nullable File sharedConfDir, Environment environment,
AgentConfig agentConfig, AgentConfigUpdater agentConfigUpdater); @Override void collectAggregates(AggregateReader aggregateReader); @Override void collectGaugeValues(List<GaugeValue> gaugeValues); @Override void collectTrace(TraceReader traceReader); @Override void log(LogEvent logEvent); @VisibleForTesting void setInstance(Collector instance); }### Answer:
@Test public void testCollectGaugeValues() throws Exception { CollectorProxy collectorProxy = new CollectorProxy(); @SuppressWarnings("unchecked") List<GaugeValue> gaugeValues1 = mock(List.class); @SuppressWarnings("unchecked") List<GaugeValue> gaugeValues2 = mock(List.class); @SuppressWarnings("unchecked") List<GaugeValue> gaugeValues3 = mock(List.class); collectorProxy.collectGaugeValues(gaugeValues1); collectorProxy.collectGaugeValues(gaugeValues2); Collector collector = mock(Collector.class); collectorProxy.setInstance(collector); collectorProxy.collectGaugeValues(gaugeValues3); InOrder inOrder = Mockito.inOrder(collector); inOrder.verify(collector).collectGaugeValues(gaugeValues1); inOrder.verify(collector).collectGaugeValues(gaugeValues2); inOrder.verify(collector).collectGaugeValues(gaugeValues3); } |
### Question:
CollectorProxy implements Collector { @Override public void collectTrace(TraceReader traceReader) throws Exception { if (instance == null) { earlyTraceReaders.offer(traceReader); if (instance != null) { earlyTraceReaders.remove(traceReader); instance.collectTrace(traceReader); } } else { instance.collectTrace(traceReader); } } @Override void init(File confDir, @Nullable File sharedConfDir, Environment environment,
AgentConfig agentConfig, AgentConfigUpdater agentConfigUpdater); @Override void collectAggregates(AggregateReader aggregateReader); @Override void collectGaugeValues(List<GaugeValue> gaugeValues); @Override void collectTrace(TraceReader traceReader); @Override void log(LogEvent logEvent); @VisibleForTesting void setInstance(Collector instance); }### Answer:
@Test public void testCollectTrace() throws Exception { CollectorProxy collectorProxy = new CollectorProxy(); TraceReader traceReader1 = mock(TraceReader.class); TraceReader traceReader2 = mock(TraceReader.class); TraceReader traceReader3 = mock(TraceReader.class); collectorProxy.collectTrace(traceReader1); collectorProxy.collectTrace(traceReader2); Collector collector = mock(Collector.class); collectorProxy.setInstance(collector); collectorProxy.collectTrace(traceReader3); InOrder inOrder = Mockito.inOrder(collector); inOrder.verify(collector).collectTrace(traceReader1); inOrder.verify(collector).collectTrace(traceReader2); inOrder.verify(collector).collectTrace(traceReader3); } |
### Question:
CollectorProxy implements Collector { @Override public void log(LogEvent logEvent) throws Exception { if (instance == null) { earlyLogEvents.offer(logEvent); if (instance != null) { earlyLogEvents.remove(logEvent); instance.log(logEvent); } } else { instance.log(logEvent); } } @Override void init(File confDir, @Nullable File sharedConfDir, Environment environment,
AgentConfig agentConfig, AgentConfigUpdater agentConfigUpdater); @Override void collectAggregates(AggregateReader aggregateReader); @Override void collectGaugeValues(List<GaugeValue> gaugeValues); @Override void collectTrace(TraceReader traceReader); @Override void log(LogEvent logEvent); @VisibleForTesting void setInstance(Collector instance); }### Answer:
@Test public void testLog() throws Exception { CollectorProxy collectorProxy = new CollectorProxy(); LogEvent logEvent1 = LogEvent.newBuilder() .setMessage("one") .build(); LogEvent logEvent2 = LogEvent.newBuilder() .setMessage("two") .build(); LogEvent logEvent3 = LogEvent.newBuilder() .setMessage("three") .build(); collectorProxy.log(logEvent1); collectorProxy.log(logEvent2); Collector collector = mock(Collector.class); collectorProxy.setInstance(collector); collectorProxy.log(logEvent3); InOrder inOrder = Mockito.inOrder(collector); inOrder.verify(collector).log(logEvent1); inOrder.verify(collector).log(logEvent2); inOrder.verify(collector).log(logEvent3); } |
### Question:
MainEntryPoint { private static void upgradeToCollectorAddressIfNeeded(File propFile) throws IOException { List<String> lines = readPropertiesFile(propFile); List<String> newLines = upgradeToCollectorAddressIfNeeded(lines); if (!newLines.equals(lines)) { writePropertiesFile(propFile, newLines); } } private MainEntryPoint(); static void premain(Instrumentation instrumentation, Class<?>[] allPriorLoadedClasses,
@Nullable File glowrootJarFile); static void runOfflineViewer(Directories directories,
GlowrootAgentInitFactory glowrootAgentInitFactory); @EnsuresNonNull("startupLogger") static void initLogging(File confDir, @Nullable File sharedConfDir, File logDir,
@Nullable Instrumentation instrumentation); @OnlyUsedByTests static void start(Map<String, String> properties); @OnlyUsedByTests static @Nullable GlowrootAgentInit getGlowrootAgentInit(); static final boolean PRINT_CLASS_LOADING; }### Answer:
@Test public void testUpgradeToCollectorAddress() { List<String> lines = ImmutableList.of("before=test", "collector.host=localhost", "collector.port=8181", "after=test"); List<String> newLines = MainEntryPoint.upgradeToCollectorAddressIfNeeded(lines); assertThat(newLines).containsExactly("before=test", "collector.address=localhost:8181", "after=test"); }
@Test public void testUpgradeToCollectorAddressBothEmpty() { List<String> lines = ImmutableList.of("before=test", "collector.host=", "collector.port=", "after=test"); List<String> newLines = MainEntryPoint.upgradeToCollectorAddressIfNeeded(lines); assertThat(newLines).containsExactly("before=test", "collector.address=", "after=test"); }
@Test public void testUpgradeToCollectorAddressBothMissing() { List<String> lines = ImmutableList.of("before=test", "after=test"); List<String> newLines = MainEntryPoint.upgradeToCollectorAddressIfNeeded(lines); assertThat(newLines).containsExactly("before=test", "after=test"); }
@Test public void testUpgradeToCollectorAddressOnlyHostEmpty() { List<String> lines = ImmutableList.of("before=test", "collector.host=", "collector.port=8181", "after=test"); List<String> newLines = MainEntryPoint.upgradeToCollectorAddressIfNeeded(lines); assertThat(newLines).containsExactly("before=test", "collector.address=", "after=test"); }
@Test public void testUpgradeToCollectorAddressOnlyPortEmpty() { List<String> lines = ImmutableList.of("before=test", "collector.host=localhost", "collector.port=", "after=test"); List<String> newLines = MainEntryPoint.upgradeToCollectorAddressIfNeeded(lines); assertThat(newLines).containsExactly("before=test", "collector.address=localhost:8181", "after=test"); }
@Test public void testUpgradeToCollectorAddressOnlyHostMissing() { List<String> lines = ImmutableList.of("before=test", "collector.port=8181", "after=test"); List<String> newLines = MainEntryPoint.upgradeToCollectorAddressIfNeeded(lines); assertThat(newLines).containsExactly("before=test", "after=test"); }
@Test public void testUpgradeToCollectorAddressOnlyPortMissing() { List<String> lines = ImmutableList.of("before=test", "collector.host=localhost", "after=test"); List<String> newLines = MainEntryPoint.upgradeToCollectorAddressIfNeeded(lines); assertThat(newLines).containsExactly("before=test", "collector.address=localhost:8181", "after=test"); }
@Test public void testUpgradeToCollectorAddressNotNeeded() { List<String> lines = ImmutableList.of("before=test", "collector.address=xyz:1234", "after=test"); List<String> newLines = MainEntryPoint.upgradeToCollectorAddressIfNeeded(lines); assertThat(newLines).isEqualTo(lines); } |
### Question:
PluginDescriptor { public abstract String name(); abstract String id(); abstract String name(); abstract ImmutableList<PropertyDescriptor> properties(); @JsonProperty("instrumentation") abstract ImmutableList<InstrumentationConfig> instrumentationConfigs(); abstract ImmutableList<String> aspects(); static PluginDescriptor readValue(String content); static String writeValue(List<PluginDescriptor> pluginDescriptors); }### Answer:
@Test public void testSorting() { List<PluginDescriptor> pluginDescriptors = Lists.newArrayList(); pluginDescriptors.add(pluginDescriptorWithName("Zzz")); pluginDescriptors.add(pluginDescriptorWithName("Yyy Plugin")); pluginDescriptors.add(pluginDescriptorWithName("Xxx plugin")); pluginDescriptors.add(pluginDescriptorWithName("Aaa Plugin")); pluginDescriptors.add(pluginDescriptorWithName("Bbb")); List<PluginDescriptor> sortedPluginDescriptors = new PluginDescriptorOrdering().sortedCopy(pluginDescriptors); assertThat(sortedPluginDescriptors.get(0).name()).isEqualTo("Aaa Plugin"); assertThat(sortedPluginDescriptors.get(1).name()).isEqualTo("Bbb"); assertThat(sortedPluginDescriptors.get(2).name()).isEqualTo("Xxx plugin"); assertThat(sortedPluginDescriptors.get(3).name()).isEqualTo("Yyy Plugin"); assertThat(sortedPluginDescriptors.get(4).name()).isEqualTo("Zzz"); } |
### Question:
CentralCollector implements Collector { @VisibleForTesting static String escapeHostName(String hostName) { hostName = hostName.replace("\\", "\\\\"); if (hostName.startsWith(":")) { hostName = "\\" + hostName; } while (hostName.contains("::")) { hostName = hostName.replace("::", ":\\:"); } return hostName; } CentralCollector(Map<String, String> properties, String collectorAddress,
@Nullable String collectorAuthority, File confDir, @Nullable File sharedConfDir,
LiveJvmServiceImpl liveJvmService, LiveWeavingServiceImpl liveWeavingService,
LiveTraceRepositoryImpl liveTraceRepository, AgentConfigUpdater agentConfigUpdater,
ConfigService configService); @Override void init(File confDir, @Nullable File sharedConfDir, final Environment environment,
AgentConfig agentConfig, final AgentConfigUpdater agentConfigUpdater); @Override void collectAggregates(AggregateReader aggregateReader); @Override void collectGaugeValues(List<GaugeValue> gaugeValues); @Override void collectTrace(TraceReader traceReader); @Override void log(LogEvent logEvent); @OnlyUsedByTests void close(); @OnlyUsedByTests void awaitClose(); }### Answer:
@Test public void shouldEscape() { assertThat(CentralCollector.escapeHostName("")).isEqualTo(""); assertThat(CentralCollector.escapeHostName("abc")).isEqualTo("abc"); assertThat(CentralCollector.escapeHostName("a:b:c")).isEqualTo("a:b:c"); assertThat(CentralCollector.escapeHostName(":a:b:c:")).isEqualTo("\\:a:b:c:"); assertThat(CentralCollector.escapeHostName("::a::b::c::")) .isEqualTo("\\:\\:a:\\:b:\\:c:\\:"); assertThat(CentralCollector.escapeHostName(":::a:::b:::c:::")) .isEqualTo("\\:\\:\\:a:\\:\\:b:\\:\\:c:\\:\\:"); assertThat(CentralCollector.escapeHostName("::::")).isEqualTo("\\:\\:\\:\\:"); assertThat(CentralCollector.escapeHostName("a\\b\\c")).isEqualTo("a\\\\b\\\\c"); } |
### Question:
LiveJvmServiceImpl implements LiveJvmService { @VisibleForTesting static @Nullable Long parseProcessId(String runtimeName) { int index = runtimeName.indexOf('@'); if (index > 0) { String pid = runtimeName.substring(0, index); try { return Long.parseLong(pid); } catch (NumberFormatException e) { logger.debug(e.getMessage(), e); return null; } } else { return null; } } LiveJvmServiceImpl(LazyPlatformMBeanServer lazyPlatformMBeanServer,
TransactionRegistry transactionRegistry, TransactionCollector transactionCollector,
Availability threadAllocatedBytesAvailability, ConfigService configService,
@Nullable File glowrootJarFile); @Override boolean isAvailable(String agentId); @Override ThreadDump getThreadDump(String agentId); @Override String getJstack(String agentId); @Override long getAvailableDiskSpace(String agentId, String directory); @Override HeapDumpFileInfo heapDump(String agentId, String directory); @Override HeapHistogram heapHistogram(String agentId); @Override boolean isExplicitGcDisabled(String agentId); @Override void forceGC(String agentId); @Override MBeanDump getMBeanDump(String agentId, MBeanDumpKind mbeanDumpKind,
List<String> objectNames); @Override List<String> getMatchingMBeanObjectNames(String agentId, String partialObjectName,
int limit); @Override MBeanMeta getMBeanMeta(String agentId, String mbeanObjectName); @Override Map<String, String> getSystemProperties(String agentId); @Override Capabilities getCapabilities(String agentId); static @Nullable Long getProcessId(); }### Answer:
@Test public void testNonParseable() { assertThat(LiveJvmServiceImpl.parseProcessId("")).isNull(); assertThat(LiveJvmServiceImpl.parseProcessId("x")).isNull(); assertThat(LiveJvmServiceImpl.parseProcessId("x:y")).isNull(); assertThat(LiveJvmServiceImpl.parseProcessId("@y")).isNull(); assertThat(LiveJvmServiceImpl.parseProcessId("x@y")).isNull(); }
@Test public void testParseable() { assertThat(LiveJvmServiceImpl.parseProcessId("123456@host")).isEqualTo(123456); } |
### Question:
Reflection { public static @Nullable Method getMethod(@Nullable Class<?> clazz, String methodName) { if (clazz == null) { return null; } try { return clazz.getMethod(methodName); } catch (Exception e) { logger.debug(e.getMessage(), e); return null; } } private Reflection(); static @Nullable Method getMethod(@Nullable Class<?> clazz, String methodName); static @Nullable Field getDeclaredField(@Nullable Class<?> clazz, String fieldName); @SuppressWarnings("unchecked") static T invoke(@Nullable Method method, Object obj); @SuppressWarnings("unchecked") static T invokeWithDefault(@Nullable Method method, Object obj, T defaultValue); static @Nullable Object getFieldValue(@Nullable Field field, Object obj); }### Answer:
@Test public void shouldReturnNullMethodWhenClassIsNull() { assertThat(Reflection.getMethod(null, null)).isNull(); }
@Test public void shouldReturnNullMethodWhenMethodNotFound() { assertThat(Reflection.getMethod(String.class, "thereWillNeverBeMethodWithThisName")) .isNull(); } |
### Question:
InternationalizationServiceFactory { public <T> T create(final Class<T> api, final ClassLoader loader) { if (Mode.mode != Mode.UNSAFE) { if (!api.isInterface()) { throw new IllegalArgumentException(api + " is not an interface"); } if (Stream .of(api.getMethods()) .filter(m -> m.getDeclaringClass() != Object.class) .anyMatch(m -> m.getReturnType() != String.class)) { throw new IllegalArgumentException(api + " methods must return a String"); } if (Stream .of(api.getMethods()) .flatMap(m -> Stream.of(m.getParameters())) .anyMatch(p -> p.isAnnotationPresent(Language.class) && p.getType() != Locale.class)) { throw new IllegalArgumentException("@Language can only be used with Locales"); } } final String pck = api.getPackage().getName(); return api .cast(Proxy .newProxyInstance(loader, new Class<?>[] { api }, new InternationalizedHandler(api.getName() + '.', api.getSimpleName() + '.', (pck == null || pck.isEmpty() ? "" : (pck + '.')) + "Messages", localeSupplier))); } T create(final Class<T> api, final ClassLoader loader); }### Answer:
@Test void objectMethods() { assertEquals(translate, translate); assertEquals(translate.hashCode(), translate.hashCode()); final Translate other = new InternationalizationServiceFactory(Locale::getDefault) .create(Translate.class, Translate.class.getClassLoader()); assertNotSame(translate, other); } |
### Question:
InjectorImpl implements Serializable, Injector { @Override public <T> T inject(final T instance) { if (instance == null) { return null; } doInject(instance.getClass(), unwrap(instance)); return instance; } @Override T inject(final T instance); }### Answer:
@Test void configurationInjection() { final Supplier<MyConfig> config = injector.inject(new InjectedConfig()).config; assertNotNull(config); final MyConfig configuration = config.get(); assertEquals("ok", configuration.getValue()); }
@Test void inject() { final Injected instance = new Injected(); injector.inject(instance); assertNotNull(instance.cache); assertNotNull(instance.caches); assertEquals(2, instance.caches.size()); }
@Test void injectWithProxy() throws Exception { final Map<Class<?>, Object> services = new HashMap<>(1); LocalCache localCache = new LocalCacheService("LocalCacheServiceTest", System::currentTimeMillis, this.executor); services.put(LocalCache.class, localCache); final InjectedCache instance = new InjectedCache(); ProxyGenerator proxyGenerator = new ProxyGenerator(); final Class<?> proxyClass = proxyGenerator .generateProxy(Thread.currentThread().getContextClassLoader(), InjectedCache.class, "injector", InjectedCache.class.getName()); final InjectedCache proxy = InjectedCache.class.cast(proxyClass.getConstructor().newInstance()); proxyGenerator.initialize(proxy, new InterceptorHandlerFacade(instance, services)); injector.inject(proxy); assertEquals("false", proxy.getString()); assertTrue(proxy.getClass().getName().endsWith("$TalendServiceProxy")); }
@Test void invalidConfigurationInjectionSupplier() { assertThrows(IllegalArgumentException.class, () -> injector.inject(new InvalidInjectedConfig1())); }
@Test void invalidConfigurationInjectionDirectConfig() { assertThrows(IllegalArgumentException.class, () -> injector.inject(new InvalidInjectedConfig2())); } |
### Question:
LocalConfigurationService implements LocalConfiguration, Serializable { @Override public String get(final String key) { return rawDelegates .stream() .map(d -> read(d, plugin + "." + key)) .filter(Objects::nonNull) .findFirst() .orElseGet(() -> rawDelegates .stream() .map(d -> read(d, key)) .filter(Objects::nonNull) .findFirst() .orElse(null)); } @Override String get(final String key); @Override Set<String> keys(); }### Answer:
@Test void nullDoesntFail() { assertNull(new LocalConfigurationService(singletonList(systemProperties), "LocalConfigurationServiceTest") .get("test.foo.missing")); }
@Test void readGlobal() { System.setProperty("test.foo.LocalConfigurationServiceTest", "1"); try { assertEquals("1", new LocalConfigurationService(singletonList(systemProperties), "LocalConfigurationServiceTest") .get("test.foo.LocalConfigurationServiceTest")); } finally { System.clearProperty("test.foo.LocalConfigurationServiceTest"); } } |
### Question:
LocalConfigurationService implements LocalConfiguration, Serializable { private String read(final LocalConfiguration d, final String entryKey) { return ofNullable(d.get(entryKey)).orElseGet(() -> d.get(entryKey.replace('.', '_'))); } @Override String get(final String key); @Override Set<String> keys(); }### Answer:
@Test void read() { System.setProperty("LocalConfigurationServiceTest.test.foo", "1"); try { assertEquals("1", new LocalConfigurationService(singletonList(systemProperties), "LocalConfigurationServiceTest") .get("test.foo")); } finally { System.clearProperty("LocalConfigurationServiceTest.test.foo"); } } |
### Question:
LocalConfigurationService implements LocalConfiguration, Serializable { @Override public Set<String> keys() { return rawDelegates .stream() .flatMap(d -> d.keys().stream()) .flatMap(k -> !k.startsWith(plugin + '.') ? Stream.of(k) : Stream.of(k, k.substring(plugin.length() + 1))) .collect(toSet()); } @Override String get(final String key); @Override Set<String> keys(); }### Answer:
@Test void keys() { System.setProperty("LocalConfigurationServiceTest.test.foo", "1"); System.setProperty("LocalConfigurationServiceTest.test.bar", "1"); try { assertEquals(Stream.of("test.foo", "test.bar").collect(toSet()), new LocalConfigurationService(singletonList(systemProperties), "LocalConfigurationServiceTest") .keys() .stream() .filter(it -> it.startsWith("test")) .collect(toSet())); } finally { System.clearProperty("LocalConfigurationServiceTest.test.foo"); System.clearProperty("LocalConfigurationServiceTest.test.bar"); } } |
### Question:
RecordServiceImpl implements RecordService, Serializable { @Override public Record create(final Schema schema, final Record fallbackRecord, final BiFunction<Schema.Entry, Record.Builder, Boolean> customHandler, final BiConsumer<Record.Builder, Boolean> beforeFinish) { return fallbackRecord .getSchema() .getEntries() .stream() .collect(toRecord(schema, fallbackRecord, customHandler, beforeFinish)); } @Override Collector<Schema.Entry, Record.Builder, Record> toRecord(final Schema schema, final Record fallbackRecord,
final BiFunction<Schema.Entry, Record.Builder, Boolean> customHandler,
final BiConsumer<Record.Builder, Boolean> beforeFinish); @Override Record create(final Schema schema, final Record fallbackRecord,
final BiFunction<Schema.Entry, Record.Builder, Boolean> customHandler,
final BiConsumer<Record.Builder, Boolean> beforeFinish); @Override T visit(final RecordVisitor<T> visitor, final Record record); @Override T toObject(final Record data, final Class<T> expected); @Override Record toRecord(final T data); @Override boolean forwardEntry(final Record source, final Record.Builder builder, final String sourceColumn,
final Schema.Entry entry); }### Answer:
@Test void buildRecord() { final Schema customSchema = factory .newSchemaBuilder(baseSchema) .withEntry(factory.newEntryBuilder().withName("custom").withType(STRING).withNullable(true).build()) .build(); final List<Collection<String>> spy = asList(new LinkedList<>(), new LinkedList<>()); final Record noCustomRecord = service.create(customSchema, baseRecord, (entry, builder) -> { spy.get(0).add("visited=" + entry.getName()); if (entry.getName().equals("custom")) { builder.withString("custom", "yes"); return true; } return false; }, (builder, done) -> { spy.get(0).add("done=" + done); if (!done) { builder.withString("custom", "yes"); } }); final Record customRecord = service.create(customSchema, noCustomRecord, (entry, builder) -> { spy.get(1).add("visited=" + entry.getName()); if ("custom".equals(entry.getName())) { builder.withString("custom", "yes"); return true; } return false; }, (builder, done) -> spy.get(1).add("done=" + done)); Stream .of(noCustomRecord, customRecord) .forEach(record -> assertEquals( "name=Test,age=33,address={\"street\":\"here\",\"number\":1},custom=yes", toString(record))); assertEquals(asList("visited=name", "visited=age", "visited=address", "done=false"), spy.get(0)); assertEquals(asList("visited=name", "visited=age", "visited=address", "visited=custom", "done=true"), spy.get(1)); } |
### Question:
DSLParser { private static Map<String, String> parseQuery(final String query) { final Map<String, String> parameters = new HashMap<>(); if (query == null || query.trim().isEmpty()) { return parameters; } final byte[] bytes = query.getBytes(StandardCharsets.UTF_8); int pos = 0; int end = bytes.length; String name; String value; while (pos < end) { int nameStart = pos; int nameEnd = -1; int valueStart = -1; int valueEnd = -1; boolean parsingName = true; boolean decodeName = false; boolean decodeValue = false; boolean parameterComplete = false; do { switch (bytes[pos]) { case '=': if (parsingName) { nameEnd = pos; parsingName = false; valueStart = ++pos; } else { pos++; } break; case '&': if (parsingName) { nameEnd = pos; } else { valueEnd = pos; } parameterComplete = true; pos++; break; case '%': case '+': if (parsingName) { decodeName = true; } else { decodeValue = true; } pos++; break; default: pos++; break; } } while (!parameterComplete && pos < end); if (pos == end) { if (nameEnd == -1) { nameEnd = pos; } else if (valueStart > -1 && valueEnd == -1) { valueEnd = pos; } } if (nameEnd <= nameStart) { continue; } name = new String(bytes, nameStart, nameEnd - nameStart); if (decodeName) { name = decode(name); } if (valueStart >= 0) { value = new String(bytes, valueStart, valueEnd - valueStart); if (decodeValue) { value = decode(value); } } else { value = "true"; } parameters.put(name, value); } return parameters; } static Step parse(final String rawUri); }### Answer:
@Test void parseQuery() throws UnsupportedEncodingException { assertEquals(emptyMap(), DSLParser.parse("foo: assertEquals(singletonMap("a", "b"), DSLParser.parse("foo: final String url = "jdbc: assertEquals(singletonMap("configuration.url", url), DSLParser.parse("foo: assertEquals(new HashMap<String, String>() { { put("configuration.url", url); put("configuration.password", "vault:v1:something"); } }, DSLParser .parse("foo: + "&configuration.password=vault:v1:something") .getConfiguration()); } |
### Question:
RepositoryModelBuilder { private ConfigKey getKey(final String family, final Map<String, String> meta) { final String configName = meta.get("tcomp::configurationtype::name"); final String configType = meta.get("tcomp::configurationtype::type"); return new ConfigKey(family, configName, configType); } RepositoryModel create(final ComponentManager.AllServices services,
final Collection<ComponentFamilyMeta> familyMetas, final MigrationHandlerFactory migrationHandlerFactory); }### Answer:
@Test void complexTree() { try (final ComponentManager manager = new ComponentManager(new File("target/foo"), "deps.txt", null)) { final String plugin = manager.addPlugin(jarLocation(RepositoryModelBuilderTest.class).getAbsolutePath()); final RepositoryModel model = manager.findPlugin(plugin).orElseThrow(IllegalArgumentException::new).get(RepositoryModel.class); final Family theTestFamily = model .getFamilies() .stream() .filter(f -> f.getMeta().getName().equals("TheTestFamily")) .findFirst() .orElseThrow(IllegalArgumentException::new); assertEquals(3, theTestFamily.getConfigs().get().size(), theTestFamily .getConfigs() .get() .stream() .map(c -> c.getKey().getConfigName()) .collect(joining(", "))); theTestFamily .getConfigs() .get() .forEach(it -> assertTrue(it.getKey().getConfigName().startsWith("Connection-"), it.getKey().getConfigName())); } } |
### Question:
RepositoryModelBuilder { public RepositoryModel create(final ComponentManager.AllServices services, final Collection<ComponentFamilyMeta> familyMetas, final MigrationHandlerFactory migrationHandlerFactory) { final List<Family> families = familyMetas .stream() .map(familyMeta -> createConfigForFamily(services, migrationHandlerFactory, familyMeta)) .collect(toList()); return new RepositoryModel(families); } RepositoryModel create(final ComponentManager.AllServices services,
final Collection<ComponentFamilyMeta> familyMetas, final MigrationHandlerFactory migrationHandlerFactory); }### Answer:
@Test void notRootConfig() { final PropertyEditorRegistry registry = new PropertyEditorRegistry(); final RepositoryModel model = new RepositoryModelBuilder() .create(new ComponentManager.AllServices(emptyMap()), singleton(new ComponentFamilyMeta("test", emptyList(), "noicon", "test", "test") { { final ParameterMeta store = new ParameterMeta(null, DataStore1.class, ParameterMeta.Type.OBJECT, "config.store", "store", new String[0], emptyList(), emptyList(), new HashMap<String, String>() { { put("tcomp::configurationtype::type", "datastore"); put("tcomp::configurationtype::name", "testDatastore"); } }, false); final ParameterMeta wrapper = new ParameterMeta(null, WrappingStore.class, ParameterMeta.Type.OBJECT, "config", "config", new String[0], singletonList(store), emptyList(), emptyMap(), false); getPartitionMappers() .put("test", new PartitionMapperMeta(this, "mapper", "noicon", 1, PartitionMapper1.class, () -> singletonList(wrapper), m -> null, () -> (a, b) -> null, true, false) { }); } }), new MigrationHandlerFactory( new ReflectionService(new ParameterModelService(registry), registry))); final List<Config> configs = model.getFamilies().stream().flatMap(f -> f.getConfigs().get().stream()).collect(toList()); assertEquals(1, configs.size()); } |
### Question:
PartitionMapperFlowsFactory implements FlowsFactory { @Override public Collection<String> getInputFlows() { return Collections.emptySet(); } @Override Collection<String> getInputFlows(); @Override Collection<String> getOutputFlows(); }### Answer:
@Test void testGetInputFlows() { PartitionMapperFlowsFactory factory = new PartitionMapperFlowsFactory(); Assertions.assertTrue(factory.getInputFlows().isEmpty()); } |
### Question:
PartitionMapperFlowsFactory implements FlowsFactory { @Override public Collection<String> getOutputFlows() { return Collections.singleton(Branches.DEFAULT_BRANCH); } @Override Collection<String> getInputFlows(); @Override Collection<String> getOutputFlows(); }### Answer:
@Test void testGetOutputFlows() { PartitionMapperFlowsFactory factory = new PartitionMapperFlowsFactory(); Collection<String> outputs = factory.getOutputFlows(); Assertions.assertEquals(1, outputs.size()); Assertions.assertTrue(outputs.contains("__default__")); } |
### Question:
ProcessorFlowsFactory implements FlowsFactory { @Override public Collection<String> getInputFlows() { return getListener() .map(m -> Stream.of(m.getParameters())) .orElseGet(() -> getAfterGroup().map(it -> Stream.of(it.getParameters())).orElseGet(Stream::empty)) .filter(this::isInput) .map(this::mapInputName) .collect(toList()); } @Override Collection<String> getInputFlows(); @Override Collection<String> getOutputFlows(); }### Answer:
@Test void testGetInputFlows() { final ProcessorFlowsFactory factory = new ProcessorFlowsFactory(TestProcessor.class); final Collection<String> inputs = factory.getInputFlows(); assertEquals(2, inputs.size()); assertTrue(inputs.contains("__default__")); assertTrue(inputs.contains("REJECT")); } |
### Question:
ProcessorFlowsFactory implements FlowsFactory { @Override public Collection<String> getOutputFlows() { return concat( getListener() .map(listener -> concat(getReturnedBranches(listener), getOutputParameters(listener))) .orElseGet(Stream::empty), getAfterGroup().map(this::getOutputParameters).orElseGet(Stream::empty)).distinct().collect(toList()); } @Override Collection<String> getInputFlows(); @Override Collection<String> getOutputFlows(); }### Answer:
@Test void testGetOutputFlows() { final ProcessorFlowsFactory factory = new ProcessorFlowsFactory(TestProcessor.class); final Collection<String> outputs = factory.getOutputFlows(); assertEquals(2, outputs.size()); assertTrue(outputs.contains("__default__")); assertTrue(outputs.contains("OUTPUT")); }
@Test void testGetMergeOutputFlows() { final ProcessorFlowsFactory factory = new ProcessorFlowsFactory(TestProcessorMergeOutputs.class); final Collection<String> outputs = factory.getOutputFlows(); assertEquals(2, outputs.size()); assertTrue(outputs.contains("__default__")); assertTrue(outputs.contains("OUTPUT")); } |
### Question:
QueueMapper implements Mapper, JobStateAware, Supplier<DIPipeline>, Delegated { @Override public List<Mapper> split(final long desiredSize) { return singletonList(this); } QueueMapper(final String plugin, final String family, final String name,
final PTransform<PBegin, PCollection<Record>> transform); String getStateId(); @Override long assess(); @Override List<Mapper> split(final long desiredSize); @Override Input create(); @Override boolean isStream(); @Override String plugin(); @Override String rootName(); @Override String name(); @Override void start(); @Override void stop(); @Override void setState(final State state); @Override DIPipeline get(); @Override Object getDelegate(); }### Answer:
@Test void split() { final QueueMapper mapper = new QueueMapper("test", "test", "test", null); try { mapper.setState(new JobStateAware.State()); } catch (final NullPointerException npe) { } final List<Mapper> split = mapper.split(mapper.assess()); assertEquals(1, split.size()); assertEquals(mapper, split.iterator().next()); } |
### Question:
InMemoryQueueIO { public static PTransform<PBegin, PCollection<Record>> from(final LoopState state) { return Read.from(new UnboundedQueuedInput(state.id)); } static PTransform<PBegin, PCollection<Record>> from(final LoopState state); static PTransform<PCollection<Record>, PCollection<Void>> to(final LoopState state); }### Answer:
@Test(timeout = 60000) public void input() { INPUT_OUTPUTS.clear(); final PipelineResult result; try (final LoopState state = LoopState.newTracker(null)) { IntStream.range(0, 2).forEach(i -> state.push(new RowStruct(i))); pipeline.apply(InMemoryQueueIO.from(state)).apply(ParDo.of(new DoFn<Record, Void>() { @ProcessElement public void onElement(@Element final Record record) { INPUT_OUTPUTS.add(record); } })); result = pipeline.run(); IntStream.range(2, 5).forEach(i -> state.push(new RowStruct(i))); state.end(); final long end = System.currentTimeMillis() + TimeUnit.MINUTES.toMillis(2); long lastLog = System.currentTimeMillis(); while (INPUT_OUTPUTS.size() < 5 && end - System.currentTimeMillis() >= 0) { try { if (lastLog - System.currentTimeMillis() > TimeUnit.SECONDS.toMillis(10)) { log.info("Not yet 5 records: {}, waiting", INPUT_OUTPUTS.size()); } sleep(150); } catch (final InterruptedException e) { Thread.currentThread().interrupt(); } } } result.waitUntilFinish(); assertEquals(5, INPUT_OUTPUTS.size()); assertEquals(IntStream.range(0, 5).boxed().collect(toSet()), INPUT_OUTPUTS.stream().mapToInt(o -> o.getInt("id")).boxed().collect(toSet())); } |
### Question:
InMemoryQueueIO { public static PTransform<PCollection<Record>, PCollection<Void>> to(final LoopState state) { return new QueuedOutputTransform(state.id); } static PTransform<PBegin, PCollection<Record>> from(final LoopState state); static PTransform<PCollection<Record>, PCollection<Void>> to(final LoopState state); }### Answer:
@Test(timeout = 60000) public void output() { final Collection<Record> objects = new ArrayList<>(); try (final LoopState state = LoopState.newTracker(null)) { pipeline .apply(Create.of(IntStream.range(0, 5).mapToObj(RowStruct::new).collect(toList()))) .setCoder(SerializableCoder.of(RowStruct.class)) .apply(ParDo.of(new DoFn<RowStruct, Record>() { @ProcessElement public void onElement(final ProcessContext context) { final Record record = ComponentManager .instance() .getRecordBuilderFactoryProvider() .apply(null) .newRecordBuilder() .withInt("id", context.element().id) .build(); context.output(record); } })) .setCoder(SchemaRegistryCoder.of()) .apply(InMemoryQueueIO.to(state)); pipeline.run().waitUntilFinish(); Record next; do { next = state.next(); if (next != null) { objects.add(next); } } while (next != null); } assertEquals(5, objects.size()); assertEquals(IntStream.range(0, 5).boxed().collect(toSet()), objects.stream().mapToInt(o -> o.getInt("id")).boxed().collect(toSet())); } |
### Question:
PartitionMapperImpl extends LifecycleImpl implements Mapper, Delegated { @Override public List<Mapper> split(final long desiredSize) { lazyInit(); return ((Collection<?>) doInvoke(split, splitArgSupplier.apply(desiredSize))) .stream() .map(Serializable.class::cast) .map(mapper -> new PartitionMapperImpl(rootName(), name(), inputName, plugin(), stream, mapper)) .collect(toList()); } PartitionMapperImpl(final String rootName, final String name, final String inputName, final String plugin,
final boolean stream, final Serializable instance); protected PartitionMapperImpl(); @Override long assess(); @Override List<Mapper> split(final long desiredSize); @Override Input create(); @Override boolean isStream(); @Override Object getDelegate(); }### Answer:
@Test void split() { final Mapper mapper = new PartitionMapperImpl("Root", "Test", null, "Plugin", false, new SampleMapper()); assertEquals(10, mapper.assess()); final List<Mapper> split = mapper.split(3); assertEquals(3, split.stream().distinct().count()); split.forEach(s -> { assertTrue(PartitionMapperImpl.class.isInstance(s)); assertNotSame(mapper, s); assertInput(s); }); } |
### Question:
MvnDependencyListLocalRepositoryResolver implements Resolver { @Override public Stream<Artifact> resolve(final ClassLoader rootLoader, final String artifact) { return Stream .of(readDependencies(ofNullable(getJar(artifact)) .filter(Files::exists) .map(this::findDependenciesFile) .orElseGet(() -> { final boolean isNested; try (final InputStream stream = rootLoader .getResourceAsStream(ConfigurableClassLoader.NESTED_MAVEN_REPOSITORY + artifact)) { isNested = stream != null; } catch (final IOException e) { log.debug(e.getMessage(), e); return ""; } if (isNested) { try (final ConfigurableClassLoader configurableClassLoader = new ConfigurableClassLoader("", new URL[0], rootLoader, name -> true, name -> true, new String[] { artifact }, new String[0])) { try (final InputStream deps = configurableClassLoader.getResourceAsStream(dependenciesListFile)) { return ofNullable(deps).map(s -> { try { return slurp(s); } catch (final IOException e) { log.debug(e.getMessage(), e); return ""; } }).orElse(""); } } catch (final IOException e) { log.debug(e.getMessage(), e); return ""; } } return ""; }))); } @Override Stream<Artifact> resolve(final ClassLoader rootLoader, final String artifact); Stream<Artifact> resolveFromDescriptor(final InputStream descriptor); }### Answer:
@Test void nestedDependency(@TempDir final File temporaryFolder) throws IOException { final File file = new File(temporaryFolder, UUID.randomUUID().toString() + ".jar"); file.getParentFile().mkdirs(); try (final JarOutputStream enclosing = new JarOutputStream(new FileOutputStream(file))) { enclosing.putNextEntry(new ZipEntry("MAVEN-INF/repository/foo/bar/dummy/1.0.0/dummy-1.0.0.jar")); try (final JarOutputStream nested = new JarOutputStream(enclosing)) { nested.putNextEntry(new ZipEntry("TALEND-INF/dependencies.txt")); nested .write(new DependenciesTxtBuilder() .withDependency("org.apache.tomee:ziplock:jar:7.0.5:runtime") .withDependency("org.apache.tomee:javaee-api:jar:7.0-1:compile") .build() .getBytes(StandardCharsets.UTF_8)); } } try (final URLClassLoader tempLoader = new URLClassLoader(new URL[] { file.toURI().toURL() }, getSystemClassLoader())) { final List<String> toResolve = new MvnDependencyListLocalRepositoryResolver("TALEND-INF/dependencies.txt", d -> null) .resolve(tempLoader, "foo/bar/dummy/1.0.0/dummy-1.0.0.jar") .map(Artifact::toPath) .collect(toList()); assertEquals(asList("org/apache/tomee/ziplock/7.0.5/ziplock-7.0.5.jar", "org/apache/tomee/javaee-api/7.0-1/javaee-api-7.0-1.jar"), toResolve); } } |
### Question:
PartitionMapperImpl extends LifecycleImpl implements Mapper, Delegated { @Override public Input create() { lazyInit(); final Serializable input = Serializable.class.cast(doInvoke(inputFactory)); if (isStream()) { return new StreamingInputImpl(rootName(), inputName, plugin(), input, loadRetryConfiguration()); } return new InputImpl(rootName(), inputName, plugin(), input); } PartitionMapperImpl(final String rootName, final String name, final String inputName, final String plugin,
final boolean stream, final Serializable instance); protected PartitionMapperImpl(); @Override long assess(); @Override List<Mapper> split(final long desiredSize); @Override Input create(); @Override boolean isStream(); @Override Object getDelegate(); }### Answer:
@Test void create() { assertInput(new PartitionMapperImpl("Root", "Test", null, "Plugin", false, new SampleMapper())); }
@Test void createStreaming() { final PartitionMapperImpl mapper = new PartitionMapperImpl("Root", "Test", null, "Plugin", true, new SampleMapper()); final Input input = mapper.create(); assertTrue(StreamingInputImpl.class.isInstance(input)); } |
### Question:
ConfigurableClassLoader extends URLClassLoader { public List<InputStream> findContainedResources(final String name) { try { return Stream.concat(ofNullable(super.findResources(name)).map(urls -> list(urls).stream().map(url -> { try { return url.openStream(); } catch (final IOException e) { throw new IllegalStateException(e); } })).orElseGet(Stream::empty), ofNullable(resources.get(name)) .map(s -> s .stream() .map(it -> it.resource) .map(ByteArrayInputStream::new) .map(InputStream.class::cast)) .orElseGet(Stream::empty)) .collect(toList()); } catch (final IOException e) { throw new IllegalStateException(e); } } ConfigurableClassLoader(final String id, final URL[] urls, final ClassLoader parent,
final Predicate<String> parentFilter, final Predicate<String> childFirstFilter,
final String[] nestedDependencies, final String[] jvmPrefixes); private ConfigurableClassLoader(final String id, final URL[] urls, final ClassLoader parent,
final Predicate<String> parentFilter, final Predicate<String> childFirstFilter,
final Map<String, Collection<Resource>> resources, final String[] jvmPrefixes); Class<?> registerBytecode(final String name, final byte[] bytes); String[] getJvmMarkers(); void registerTransformer(final ClassFileTransformer transformer); synchronized URLClassLoader createTemporaryCopy(); @Override synchronized void close(); @Override Class<?> loadClass(final String name, final boolean resolve); @Override URL findResource(final String name); @Override Enumeration<URL> getResources(final String name); @Override URL getResource(final String name); @Override InputStream getResourceAsStream(final String name); @Override Enumeration<URL> findResources(final String name); List<InputStream> findContainedResources(final String name); static final String NESTED_MAVEN_REPOSITORY; }### Answer:
@Test void findContainedResources(@TempDir final File temporaryFolder) throws Exception { final File nestedJar = createNestedJar(temporaryFolder, "org.apache.tomee:ziplock:jar:7.0.5"); try (final URLClassLoader parent = new URLClassLoader(new URL[] { nestedJar.toURI().toURL() }, Thread.currentThread().getContextClassLoader()); final ConfigurableClassLoader loader = new ConfigurableClassLoader("", new URL[0], parent, name -> true, name -> true, new String[] { "org/apache/tomee/ziplock/7.0.5/ziplock-7.0.5.jar" }, new String[0])) { final List<InputStream> containedResources = loader.findContainedResources("org/apache/ziplock/ClassLoaders.class"); containedResources.forEach(it -> { try { it.close(); } catch (final IOException e) { fail(e.getMessage()); } }); assertEquals(1, containedResources.size()); } finally { if (!nestedJar.delete()) { nestedJar.deleteOnExit(); } } } |
### Question:
ConfigurableClassLoader extends URLClassLoader { @Override public InputStream getResourceAsStream(final String name) { return ofNullable(doGetResourceAsStream(name)) .orElseGet(() -> ofNullable(resources.get(name)) .filter(s -> s.size() > 0) .map(s -> s.iterator().next().resource) .map(ByteArrayInputStream::new) .orElse(null)); } ConfigurableClassLoader(final String id, final URL[] urls, final ClassLoader parent,
final Predicate<String> parentFilter, final Predicate<String> childFirstFilter,
final String[] nestedDependencies, final String[] jvmPrefixes); private ConfigurableClassLoader(final String id, final URL[] urls, final ClassLoader parent,
final Predicate<String> parentFilter, final Predicate<String> childFirstFilter,
final Map<String, Collection<Resource>> resources, final String[] jvmPrefixes); Class<?> registerBytecode(final String name, final byte[] bytes); String[] getJvmMarkers(); void registerTransformer(final ClassFileTransformer transformer); synchronized URLClassLoader createTemporaryCopy(); @Override synchronized void close(); @Override Class<?> loadClass(final String name, final boolean resolve); @Override URL findResource(final String name); @Override Enumeration<URL> getResources(final String name); @Override URL getResource(final String name); @Override InputStream getResourceAsStream(final String name); @Override Enumeration<URL> findResources(final String name); List<InputStream> findContainedResources(final String name); static final String NESTED_MAVEN_REPOSITORY; }### Answer:
@Test void getResourceAsStreamChildFirst(@TempDir final File temporaryFolder) throws IOException { final File jar = new File(temporaryFolder, "getResourceAsStreamChildFirst.jar"); temporaryFolder.mkdirs(); try (final JarOutputStream outputStream = new JarOutputStream(new FileOutputStream(jar))) { outputStream.putNextEntry(new JarEntry("found.in.child.and.parent")); outputStream.write("child".getBytes(StandardCharsets.UTF_8)); outputStream.closeEntry(); } try (final URLClassLoader parent = new URLClassLoader(new URL[0], Thread.currentThread().getContextClassLoader()); final ConfigurableClassLoader loader = new ConfigurableClassLoader("", new URL[] { jar.toURI().toURL() }, parent, name -> true, name -> true, new String[0], new String[0])) { try (final BufferedReader reader = new BufferedReader( new InputStreamReader(loader.getResourceAsStream("found.in.child.and.parent")))) { assertEquals("child", reader.lines().collect(joining()).trim()); } } } |
### Question:
BufferizedProducerSupport { public T next() { if (current == null || !current.hasNext()) { current = supplier.get(); } return current != null && current.hasNext() ? current.next() : null; } T next(); }### Answer:
@Test void iterate() { final Iterator<List<String>> strings = asList(asList("a", "b"), asList("c"), asList("d", "e", "f")).iterator(); final BufferizedProducerSupport<String> support = new BufferizedProducerSupport<>(() -> strings.hasNext() ? strings.next().iterator() : null); assertEquals("a", support.next()); assertEquals("b", support.next()); assertEquals("c", support.next()); assertEquals("d", support.next()); assertEquals("e", support.next()); assertEquals("f", support.next()); assertNull(support.next()); } |
### Question:
SvgValidator { private String pathsAreClosed(final SVGOMSVGElement icon) { return browseDom(icon, node -> { if ("path".equals(node.getNodeName())) { final Node d = node.getAttributes() == null ? null : node.getAttributes().getNamedItem("d"); if (d == null || d.getNodeValue() == null) { return "Missing 'd' in a path"; } if (!d.getNodeValue().toLowerCase(Locale.ROOT).endsWith("z")) { return "All path must be closed so end with 'z', found value: '" + d.getNodeValue() + '\''; } } return null; }); } Stream<String> validate(final Path path); }### Answer:
@Test void pathsAreClosed() { final String error = doValidate("closedpath", 1).iterator().next(); assertTrue(error.startsWith("[closedpath.svg] All path must be closed so end with 'z', found value:"), error); } |
### Question:
SvgValidator { private String noEmbedStyle(final SVGOMSVGElement icon) { return browseDom(icon, node -> node.getNodeName().equals("style") ? "Forbidden <style> in icon" : null); } Stream<String> validate(final Path path); }### Answer:
@Test void noEmbedStyle() { final String error = doValidate("embeddedstyle", 1).iterator().next(); assertTrue(error.startsWith("[embeddedstyle.svg] Forbidden <style> in icon"), error); } |
### Question:
SvgValidator { private String noDisplayNone(final SVGOMSVGElement icon) { return browseDom(icon, node -> { final Node display = node.getAttributes() == null ? null : node.getAttributes().getNamedItem("display"); if (display != null && display.getNodeValue() != null) { return display.getNodeValue().replaceAll(" +", "").equalsIgnoreCase("none") ? "'display:none' is forbidden in SVG icons" : null; } return null; }); } Stream<String> validate(final Path path); }### Answer:
@Test void noDisplayNone() { final String error = doValidate("displaynone", 1).iterator().next(); assertTrue(error.startsWith("[displaynone.svg] 'display:none' is forbidden in SVG icons"), error); } |
### Question:
SVG2Png implements Runnable { @Override public void run() { try { Files.walkFileTree(iconsFolder, new SimpleFileVisitor<Path>() { @Override public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) throws IOException { final String fileName = file.getFileName().toString(); if (fileName.endsWith(".svg")) { final Path svg = file .getParent() .resolve(fileName.substring(0, fileName.length() - ".svg".length()) + "_icon32.png"); if (!Files.exists(svg)) { createPng(file, svg); log.info("Created " + svg); } } return super.visitFile(file, attrs); } }); } catch (final IOException e) { throw new IllegalStateException(e); } } SVG2Png(final Path iconsFolder, final boolean activeWorkarounds, final Object log); @Override void run(); }### Answer:
@Test void convert() throws IOException { final Path resolved = jarLocation(SVG2PngTest.class).toPath().resolve("test/icons"); final Path expected = resolved.resolve("logo_icon32.png"); if (Files.exists(expected)) { Files.delete(expected); } new SVG2Png(resolved, true, log).run(); assertTrue(Files.exists(expected)); } |
### Question:
ScanTask implements Runnable { @Override public void run() { output.getParentFile().mkdirs(); try (final OutputStream stream = new FileOutputStream(output)) { final Properties properties = new Properties(); properties.setProperty("classes.list", scanList().collect(joining(","))); properties.store(stream, "generated by " + getClass() + " at " + new Date()); } catch (final IOException e) { throw new IllegalStateException(e.getMessage(), e); } } @Override void run(); }### Answer:
@Test void run(@TempDir final File output) throws Exception { final File out = new File(output, "my.props"); new ScanTask(singletonList(new File("target/test-classes")), singletonList("org.talend.test.valid.update.UpdateService"), singletonList("org.talend.test.valid.*"), "include-exclude", out).run(); final Properties properties = new Properties(); try (final InputStream stream = new FileInputStream(out)) { properties.load(stream); } assertEquals(1, properties.size()); assertEquals("org.talend.test.valid.MyComponent," + "org.talend.test.valid.MyInternalization,org.talend.test.valid.MySource," + "org.talend.test.valid.customicon.MyComponent," + "org.talend.test.valid.customiconapi.MyComponent," + "org.talend.test.valid.datasetassourceconfig.MyComponent," + "org.talend.test.valid.datasetintwosourceswithonewithadditionalrequired.MyComponent," + "org.talend.test.valid.datasetintwosourceswithonewithadditionalrequired.MyComponent2," + "org.talend.test.valid.datastore.MyService," + "org.talend.test.valid.localconfiguration.MyComponent," + "org.talend.test.valid.nestedconfigtypes.WithNestedConfigTypes," + "org.talend.test.valid.nesteddataset.MyComponent," + "org.talend.test.valid.update.Comp,org.talend.test.valid.wording.MyComponent", properties.getProperty("classes.list")); } |
### Question:
IO { public void set() { System.setIn(stdin); System.setOut(stdout); System.setErr(stderr); } IO(); void set(); }### Answer:
@Test void stashIo() throws UnsupportedEncodingException { final IO testIO = new IO(); final ByteArrayOutputStream stdout = new ByteArrayOutputStream(); final PrintStream stdoutPs = new PrintStream(stdout); final ByteArrayOutputStream stderr = new ByteArrayOutputStream(); final PrintStream stderrPs = new PrintStream(stderr); final IO overridenIO = new IO(new InputStream() { @Override public int read() { return -1; } }, stdoutPs, stderrPs); overridenIO.set(); try { System.out.println("test out stash"); stdoutPs.flush(); System.err.println("test err stash"); stderrPs.flush(); assertEquals("test out stash\n", stdout.toString("UTF-8")); assertEquals("test err stash\n", stderr.toString("UTF-8")); } finally { testIO.set(); } } |
### Question:
Singer { public synchronized void writeRecord(final String stream, final JsonObject record) { final JsonObject json = builderFactory .createObjectBuilder() .add("type", "RECORD") .add("stream", requireNonNull(stream, "stream can't be null")) .add("time_extracted", formatDate(dateTimeSupplier.get())) .add("record", record) .build(); runIo.getStdout().println(json); } Singer(); String formatDate(final ZonedDateTime dateTime); synchronized void writeState(final JsonObject state); synchronized void writeSchema(final String stream, final JsonObject schema, final JsonArray keys,
final JsonArray bookmarks); synchronized void writeRecord(final String stream, final JsonObject record); synchronized void stdout(final String message); synchronized void stderr(final String message); }### Answer:
@Test void writeRecord() throws UnsupportedEncodingException { write(s -> s.writeRecord("test_stream", Json.createObjectBuilder().add("id", 1).add("name", "Test").build()), "{\"type\":\"RECORD\",\"stream\":\"test_stream\",\"time_extracted\":\"2019-08-23T11:26:00.000Z\",\"record\":{\"id\":1,\"name\":\"Test\"}}"); } |
### Question:
Singer { public synchronized void writeSchema(final String stream, final JsonObject schema, final JsonArray keys, final JsonArray bookmarks) { final JsonObject json = builderFactory .createObjectBuilder() .add("type", "SCHEMA") .add("stream", requireNonNull(stream, "stream can't be null")) .add("schema", schema) .add("key_properties", keys) .add("bookmark_properties", bookmarks) .build(); runIo.getStdout().println(json); } Singer(); String formatDate(final ZonedDateTime dateTime); synchronized void writeState(final JsonObject state); synchronized void writeSchema(final String stream, final JsonObject schema, final JsonArray keys,
final JsonArray bookmarks); synchronized void writeRecord(final String stream, final JsonObject record); synchronized void stdout(final String message); synchronized void stderr(final String message); }### Answer:
@Test void writeShema() throws UnsupportedEncodingException { write(s -> s .writeSchema("test_stream", Json.createObjectBuilder().add("id", 1).add("name", "Test").build(), Json.createArrayBuilder().add("foo").build(), Json.createArrayBuilder().add("bar").build()), "{\"type\":\"SCHEMA\",\"stream\":\"test_stream\",\"schema\":{\"id\":1,\"name\":\"Test\"},\"key_properties\":[\"foo\"],\"bookmark_properties\":[\"bar\"]}"); } |
### Question:
Singer { public synchronized void writeState(final JsonObject state) { final JsonObject json = builderFactory.createObjectBuilder().add("type", "STATE").add("value", state).build(); runIo.getStdout().println(json); } Singer(); String formatDate(final ZonedDateTime dateTime); synchronized void writeState(final JsonObject state); synchronized void writeSchema(final String stream, final JsonObject schema, final JsonArray keys,
final JsonArray bookmarks); synchronized void writeRecord(final String stream, final JsonObject record); synchronized void stdout(final String message); synchronized void stderr(final String message); }### Answer:
@Test void writeState() throws UnsupportedEncodingException { write(s -> s.writeState(Json.createObjectBuilder().add("offset", 1).build()), "{\"type\":\"STATE\",\"value\":{\"offset\":1}}"); } |
### Question:
Kitap implements Runnable { private void discover(final Mapper mapper) { final JsonObject schema = records(mapper) .findFirst() .map(record -> new JsonSchemaGenerator(record.getSchema().getEntries(), jsonBuilderFactory).get()) .orElseThrow(() -> new IllegalArgumentException( "No record found for " + mapper.rootName() + '#' + mapper.name())); final JsonArray metadata = schema .getJsonObject("properties") .entrySet() .stream() .collect(jsonBuilderFactory::createArrayBuilder, (a, p) -> { a .add(jsonBuilderFactory .createObjectBuilder() .add("metadata", jsonBuilderFactory .createObjectBuilder() .add("inclusion", "automatic") .add("selected-by-default", true)) .add("breadcrumb", jsonBuilderFactory.createArrayBuilder().add("properties").add(p.getKey()))); }, JsonArrayBuilder::addAll) .build(); final String streams = jsonBuilderFactory .createObjectBuilder() .add("streams", jsonBuilderFactory .createArrayBuilder() .add(jsonBuilderFactory .createObjectBuilder() .add("tap_stream_id", "default") .add("stream", "default") .add("schema", schema) .add("metadata", metadata))) .build() .toString(); singer.stdout(streams); } Kitap(final String... args); Kitap(final SingerArgs args, final Singer singer); @Override void run(); static void main(final String... args); }### Answer:
@Test void discover() throws IOException { final Kitap kitap = new Kitap(new SingerArgs("--config", config.toAbsolutePath().toString(), "--discover"), new Singer(new IO(), () -> CONSTANT_DATE)); kitap.run(); flushIO.run(); assertEquals("{\"streams\":[" + "{\"tap_stream_id\":\"default\",\"stream\":\"default\"," + "\"schema\":{\"type\":[\"null\",\"object\"],\"additionalProperties\":false,\"properties\":{\"record_number\":{\"type\":[\"integer\"]}}}," + "\"metadata\":[{\"metadata\":{\"inclusion\":\"automatic\",\"selected-by-default\":true},\"breadcrumb\":[\"properties\",\"record_number\"]}]}]}\n", stdout.toString("UTF-8")); } |
### Question:
LocalPartitionMapper extends Named implements Mapper, Delegated { @Override public List<Mapper> split(final long desiredSize) { return new ArrayList<>(singletonList(this)); } protected LocalPartitionMapper(); LocalPartitionMapper(final String rootName, final String name, final String plugin,
final Serializable instance); @Override long assess(); @Override List<Mapper> split(final long desiredSize); @Override Input create(); @Override boolean isStream(); @Override void start(); @Override void stop(); @Override Object getDelegate(); }### Answer:
@Test void split() { final Mapper mapper = new LocalPartitionMapper("Root", "Test", "Plugin", null); assertEquals(1, mapper.assess()); assertEquals(singletonList(mapper), mapper.split(1)); assertEquals(singletonList(mapper), mapper.split(10)); assertEquals(singletonList(mapper), mapper.split(-159)); } |
### Question:
JsonSchemaGenerator implements Supplier<JsonObject> { @Override public JsonObject get() { final JsonObjectBuilder json = jsonBuilderFactory.createObjectBuilder(); json.add("type", jsonBuilderFactory.createArrayBuilder().add("null").add("object").build()); json.add("additionalProperties", false); json.add("properties", properties.stream().map(this::toJson).collect(toJsonObject())); return json.build(); } @Override JsonObject get(); }### Answer:
@Test void generateSchema() { final Schema schema = factory .newSchemaBuilder(Schema.Type.RECORD) .withEntry(factory.newEntryBuilder().withType(Schema.Type.STRING).withName("name").build()) .withEntry(factory.newEntryBuilder().withType(Schema.Type.INT).withName("id").build()) .withEntry(factory .newEntryBuilder() .withType(Schema.Type.RECORD) .withName("nested") .withElementSchema(factory .newSchemaBuilder(Schema.Type.RECORD) .withEntry(factory .newEntryBuilder() .withType(Schema.Type.LONG) .withName("counter") .build()) .build()) .build()) .build(); final JsonObject object = new JsonSchemaGenerator(schema.getEntries(), Json.createBuilderFactory(emptyMap())).get(); assertEquals( "{\"type\":[\"null\",\"object\"],\"additionalProperties\":false,\"properties\":{\"name\":{\"type\":[\"string\"]},\"id\":{\"type\":[\"integer\"]},\"nested\":{\"type\":[\"null\",\"object\"],\"additionalProperties\":false,\"properties\":{\"counter\":{\"type\":[\"integer\"]}}}}}", object.toString()); } |
### Question:
RecordJsonMapper implements Function<Record, JsonObject> { @Override public JsonObject apply(final Record record) { return service.visit(new JsonVisitor(singer, service, jsonBuilderFactory), record); } @Override JsonObject apply(final Record record); }### Answer:
@Test void map() { final JsonObject object = new RecordJsonMapper(Json.createBuilderFactory(emptyMap()), new Singer(new IO(), ZonedDateTime::now)) .apply(factory .newRecordBuilder() .withString("name", "hello") .withInt("age", 1) .withBoolean("toggle", true) .withDateTime("date", ZonedDateTime.of(2019, 8, 23, 16, 31, 0, 0, ZoneId.of("UTC"))) .withLong("lg", 2L) .withBytes("bytes", "test".getBytes(StandardCharsets.UTF_8)) .withRecord("nested", factory .newRecordBuilder() .withString("value", "set") .withRecord("nested2", factory.newRecordBuilder().withInt("l2", 2).build()) .build()) .withArray(factory .newEntryBuilder() .withType(Schema.Type.ARRAY) .withName("array") .withElementSchema(factory.newSchemaBuilder(Schema.Type.STRING).build()) .build(), singleton("value-from-array")) .build()); assertEquals("{" + "\"name\":\"hello\"," + "\"age\":1," + "\"toggle\":true," + "\"date\":\"2019-08-23T16:31:00.000Z\"," + "\"lg\":2," + "\"bytes\":\"dGVzdA==\"," + "\"array\":[\"value-from-array\"]," + "\"nested\":{\"value\":\"set\",\"nested2\":{\"l2\":2}}}", object.toString()); } |
### Question:
ComponentResourceImpl implements ComponentResource { @Override public Dependencies getDependencies(final String[] ids) { if (ids.length == 0) { return new Dependencies(emptyMap()); } final Map<String, DependencyDefinition> dependencies = new HashMap<>(); for (final String id : ids) { if (virtualComponents.isExtensionEntity(id)) { final DependencyDefinition deps = ofNullable(virtualComponents.getDependenciesFor(id)) .orElseGet(() -> new DependencyDefinition(emptyList())); dependencies.put(id, deps); } else { final ComponentFamilyMeta.BaseMeta<Object> meta = componentDao.findById(id); dependencies.put(meta.getId(), getDependenciesFor(meta)); } } return new Dependencies(dependencies); } void clearCache(@Observes final DeployedComponent deployedComponent); @Override Dependencies getDependencies(final String[] ids); @Override StreamingOutput getDependency(final String id); @Override ComponentIndices getIndex(final String language, final boolean includeIconContent, final String query); @Override Response familyIcon(final String id); @Override Response icon(final String id); @Override Map<String, String> migrate(final String id, final int version, final Map<String, String> config); @Override // TODO: max ids.length ComponentDetailList getDetail(final String language, final String[] ids); }### Answer:
@Test void getDependencies() { final String compId = client.getJdbcId(); final Dependencies dependencies = base .path("component/dependencies") .queryParam("identifier", compId) .request(APPLICATION_JSON_TYPE) .get(Dependencies.class); assertEquals(1, dependencies.getDependencies().size()); final DependencyDefinition definition = dependencies.getDependencies().get(compId); assertNotNull(definition); assertEquals(1, definition.getDependencies().size()); assertEquals("org.apache.tomee:ziplock:jar:7.0.5", definition.getDependencies().iterator().next()); } |
### Question:
ComponentResourceImpl implements ComponentResource { @Override public StreamingOutput getDependency(final String id) { final ComponentFamilyMeta.BaseMeta<?> component = componentDao.findById(id); final Supplier<InputStream> streamProvider; if (component != null) { final Path file = componentManagerService .manager() .findPlugin(component.getParent().getPlugin()) .orElseThrow(() -> new WebApplicationException(Response .status(Response.Status.NOT_FOUND) .type(APPLICATION_JSON_TYPE) .entity(new ErrorPayload(PLUGIN_MISSING, "No plugin matching the id: " + id)) .build())) .getContainerFile() .orElseThrow(() -> new WebApplicationException(Response .status(Response.Status.NOT_FOUND) .type(APPLICATION_JSON_TYPE) .entity(new ErrorPayload(PLUGIN_MISSING, "No dependency matching the id: " + id)) .build())); if (!Files.exists(file)) { return onMissingJar(id); } streamProvider = () -> { try { return Files.newInputStream(file); } catch (final IOException e) { throw new IllegalStateException(e); } }; } else { final Artifact artifact = Artifact.from(id); if (virtualDependenciesService.isVirtual(id)) { streamProvider = virtualDependenciesService.retrieveArtifact(artifact); if (streamProvider == null) { return onMissingJar(id); } } else { final Path file = componentManagerService.manager().getContainer().resolve(artifact.toPath()); if (!Files.exists(file)) { return onMissingJar(id); } streamProvider = () -> { try { return Files.newInputStream(file); } catch (final IOException e) { throw new IllegalStateException(e); } }; } } return output -> { final byte[] buffer = new byte[40960]; try (final InputStream stream = new BufferedInputStream(streamProvider.get(), buffer.length)) { int count; while ((count = stream.read(buffer)) >= 0) { if (count == 0) { continue; } output.write(buffer, 0, count); } } }; } void clearCache(@Observes final DeployedComponent deployedComponent); @Override Dependencies getDependencies(final String[] ids); @Override StreamingOutput getDependency(final String id); @Override ComponentIndices getIndex(final String language, final boolean includeIconContent, final String query); @Override Response familyIcon(final String id); @Override Response icon(final String id); @Override Map<String, String> migrate(final String id, final int version, final Map<String, String> config); @Override // TODO: max ids.length ComponentDetailList getDetail(final String language, final String[] ids); }### Answer:
@Test void getDependency(final TestInfo info, @TempDir final File folder) { final Function<String, File> download = id -> { final InputStream stream = base .path("component/dependency/{id}") .resolveTemplate("id", id) .request(APPLICATION_OCTET_STREAM_TYPE) .get(InputStream.class); final File file = new File(folder, info.getTestMethod().get().getName() + ".jar"); try (final OutputStream outputStream = new FileOutputStream(file)) { IO.copy(stream, outputStream); } catch (final IOException e) { throw new IllegalStateException(e); } return file; }; final Consumer<File> jarValidator = file -> { assertTrue(file.exists()); try (final JarFile jar = new JarFile(file)) { assertTrue(jar.entries().hasMoreElements()); } catch (final IOException e) { fail(e.getMessage()); } }; final File zipLock = download.apply("org.apache.tomee:ziplock:jar:7.0.5"); jarValidator.accept(zipLock); final File component = download.apply(client.getJdbcId()); jarValidator.accept(component); } |
### Question:
ComponentResourceImpl implements ComponentResource { @Override public ComponentIndices getIndex(final String language, final boolean includeIconContent, final String query) { final Locale locale = localeMapper.mapLocale(language); caches.evictIfNeeded(indicesPerRequest, configuration.getMaxCacheSize() - 1); return indicesPerRequest.computeIfAbsent(new RequestKey(locale, includeIconContent, query), k -> { final Predicate<ComponentIndex> filter = queryLanguageCompiler.compile(query, componentEvaluators); return new ComponentIndices(Stream .concat(findDeployedComponents(includeIconContent, locale), virtualComponents .getDetails() .stream() .map(detail -> new ComponentIndex(detail.getId(), detail.getDisplayName(), detail.getId().getFamily(), new Icon(detail.getIcon(), null, null), new Icon(virtualComponents.getFamilyIconFor(detail.getId().getFamilyId()), null, null), detail.getVersion(), singletonList(detail.getId().getFamily()), detail.getLinks()))) .filter(filter) .collect(toList())); }); } void clearCache(@Observes final DeployedComponent deployedComponent); @Override Dependencies getDependencies(final String[] ids); @Override StreamingOutput getDependency(final String id); @Override ComponentIndices getIndex(final String language, final boolean includeIconContent, final String query); @Override Response familyIcon(final String id); @Override Response icon(final String id); @Override Map<String, String> migrate(final String id, final int version, final Map<String, String> config); @Override // TODO: max ids.length ComponentDetailList getDetail(final String language, final String[] ids); }### Answer:
@Test void getIndex() { assertIndex(client.fetchIndex()); } |
### Question:
ComponentResourceImpl implements ComponentResource { @Override public Map<String, String> migrate(final String id, final int version, final Map<String, String> config) { if (virtualComponents.isExtensionEntity(id)) { return config; } return ofNullable(componentDao.findById(id)) .orElseThrow(() -> new WebApplicationException(Response .status(Response.Status.NOT_FOUND) .entity(new ErrorPayload(ErrorDictionary.COMPONENT_MISSING, "Didn't find component " + id)) .build())) .getMigrationHandler() .get() .migrate(version, config); } void clearCache(@Observes final DeployedComponent deployedComponent); @Override Dependencies getDependencies(final String[] ids); @Override StreamingOutput getDependency(final String id); @Override ComponentIndices getIndex(final String language, final boolean includeIconContent, final String query); @Override Response familyIcon(final String id); @Override Response icon(final String id); @Override Map<String, String> migrate(final String id, final int version, final Map<String, String> config); @Override // TODO: max ids.length ComponentDetailList getDetail(final String language, final String[] ids); }### Answer:
@Test void migrate() { final Map<String, String> migrated = base .path("component/migrate/{id}/{version}") .resolveTemplate("id", client.getJdbcId()) .resolveTemplate("version", 1) .request(APPLICATION_JSON_TYPE) .post(entity(new HashMap<String, String>() { { } }, APPLICATION_JSON_TYPE), new GenericType<Map<String, String>>() { }); assertEquals(1, migrated.size()); assertEquals("true", migrated.get("migrated")); } |
### Question:
EnvironmentResourceImpl implements EnvironmentResource { @Override public Environment get() { return new Environment(latestApiVersion, version, commit, time, configuration.getChangeLastUpdatedAtStartup() ? findLastUpdated() : service.findLastUpdated()); } @Override Environment get(); }### Answer:
@Test void environment() { final Environment environment = base.path("environment").request(APPLICATION_JSON_TYPE).get(Environment.class); assertEquals(1, environment.getLatestApiVersion()); Stream .of(environment.getCommit(), environment.getTime(), environment.getVersion()) .forEach(Assertions::assertNotNull); assertTrue(environment.getLastUpdated().compareTo(new Date(0)) > 0); } |
### Question:
ActionResourceImpl implements ActionResource { @Override public CompletionStage<Response> execute(final String family, final String type, final String action, final String lang, final Map<String, String> params) { return virtualActions .getAction(family, type, action) .map(it -> it.getHandler().apply(params, lang).exceptionally(this::onError)) .orElseGet(() -> doExecuteLocalAction(family, type, action, lang, params)); } @Override CompletionStage<Response> execute(final String family, final String type, final String action,
final String lang, final Map<String, String> params); @Override ActionList getIndex(final String[] types, final String[] families, final String language); }### Answer:
@Test void execute() { final Response error = base .path("action/execute") .queryParam("type", "healthcheck") .queryParam("family", "chain") .queryParam("action", "default") .request(APPLICATION_JSON_TYPE) .post(Entity.entity(new HashMap<String, String>() { { put("dataSet.urls[0]", "empty"); } }, APPLICATION_JSON_TYPE)); assertEquals(200, error.getStatus()); assertEquals(HealthCheckStatus.Status.OK, error.readEntity(HealthCheckStatus.class).getStatus()); } |
### Question:
LocalPartitionMapper extends Named implements Mapper, Delegated { @Override public Input create() { return Input.class.isInstance(input) ? Input.class.cast(input) : new InputImpl(rootName(), name(), plugin(), input); } protected LocalPartitionMapper(); LocalPartitionMapper(final String rootName, final String name, final String plugin,
final Serializable instance); @Override long assess(); @Override List<Mapper> split(final long desiredSize); @Override Input create(); @Override boolean isStream(); @Override void start(); @Override void stop(); @Override Object getDelegate(); }### Answer:
@Test void createReader() { final Mapper mapper = new LocalPartitionMapper("Root", "Test", "Plugin", new Component()); final Input input = mapper.create(); assertTrue(Record.class.isInstance(input.next())); assertNotSame(input.next(), input.next()); }
@Test void serialization() throws IOException, ClassNotFoundException { final LocalPartitionMapper mapper = Serializer.roundTrip(new LocalPartitionMapper("Root", "Test", "Plugin", new Component())); assertEquals("Root", mapper.rootName()); assertEquals("Test", mapper.name()); assertEquals("Plugin", mapper.plugin()); final Input input = mapper.create(); assertNotNull(input); } |
### Question:
ConfigurationTypeResourceImpl implements ConfigurationTypeResource { @Override public Map<String, String> migrate(final String id, final int version, final Map<String, String> config) { if (virtualComponents.isExtensionEntity(id)) { return config; } final Config configuration = ofNullable(configurations.findById(id)) .orElseThrow(() -> new WebApplicationException(Response .status(Response.Status.NOT_FOUND) .entity(new ErrorPayload(ErrorDictionary.CONFIGURATION_MISSING, "Didn't find configuration " + id)) .build())); final Map<String, String> configToMigrate = new HashMap<>(config); final String versionKey = configuration.getMeta().getPath() + ".__version"; final boolean addedVersion = configToMigrate.putIfAbsent(versionKey, Integer.toString(version)) == null; final Map<String, String> migrated = configuration.getMigrationHandler().migrate(version, configToMigrate); if (addedVersion) { migrated.remove(versionKey); } return migrated; } void clearCache(@Observes final DeployedComponent deployedComponent); @Override ConfigTypeNodes getRepositoryModel(final String language, final boolean lightPayload, final String query); @Override ConfigTypeNodes getDetail(final String language, final String[] ids); @Override Map<String, String> migrate(final String id, final int version, final Map<String, String> config); }### Answer:
@Test void migrate() { final Map<String, String> config = ws .read(Map.class, "post", "/configurationtype/migrate/amRiYy1jb21wb25lbnQjamRiYyNkYXRhc2V0I2pkYmM/-2", "{}"); assertEquals("true", config.get("configuration.migrated")); assertEquals("1", config.get("configuration.size")); } |
### Question:
CustomCollectors { public static <T, K, V> Collector<T, ?, LinkedHashMap<K, V>> toLinkedMap( final Function<? super T, ? extends K> keyMapper, final Function<? super T, ? extends V> valueMapper) { return toMap(keyMapper, valueMapper, (v1, v2) -> { throw new IllegalArgumentException("conflict on key " + v1); }, LinkedHashMap::new); } static Collector<T, ?, LinkedHashMap<K, V>> toLinkedMap(
final Function<? super T, ? extends K> keyMapper, final Function<? super T, ? extends V> valueMapper); }### Answer:
@Test void ensureOrderIsPreserved() { final List<String> expected = asList("a", "b", "c"); assertIterableEquals(expected, expected.stream().collect(toLinkedMap(identity(), identity())).keySet()); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.