diff --git a/CHANGELOG.md b/CHANGELOG.md index b4aa62e..ea0f28f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,8 +11,8 @@ - `Property` classes that represent properties of packed components - Enhanced `Bag` API: - Added interface `AnyBag` - - `copyFrom(AnyBag)` method - - `copyFrom(AnyBag, boolean)` method + - `copyFrom` methods for replacing elements with those of another bag + - `copyPartFrom` method for copying some elements from another bag - `clear(Mask)` method - Removed `Bag(int)` constructor - Introduced `BooleanBag` diff --git a/retinazer-generator/src/main/kotlin/com/github/antag99/retinazer/generator/Bags.kt b/retinazer-generator/src/main/kotlin/com/github/antag99/retinazer/generator/Bags.kt index 658ab36..0457e60 100644 --- a/retinazer-generator/src/main/kotlin/com/github/antag99/retinazer/generator/Bags.kt +++ b/retinazer-generator/src/main/kotlin/com/github/antag99/retinazer/generator/Bags.kt @@ -139,18 +139,53 @@ ${ } @Override - public void copyFrom($genericBagName bag) { - copyFrom(bag, true); + public void copyFrom($genericBagName from) { + copyFrom(from, true); } @Override - public void copyFrom($genericBagName bag, boolean clearExceeding) { - if (buffer.length < bag.buffer.length) - buffer = new $rawTypeName[bag.buffer.length]; - System.arraycopy(bag.buffer, 0, buffer, 0, bag.buffer.length); - if (clearExceeding && buffer.length > bag.buffer.length) { + public void copyFrom($genericBagName from, boolean clearExceeding) { + copyFrom(from, from.buffer.length, clearExceeding); + } + + @Override + public void copyFrom($genericBagName from, int length) { + copyFrom(from, length, true); + } + + @Override + public void copyFrom($genericBagName from, int length, boolean clearExceeding) { + copyFrom(from, 0, length, clearExceeding); + } + + @Override + public void copyFrom($genericBagName from, int fromOffset, int length) { + copyFrom(from, fromOffset, length, true); + } + + @Override + public void copyFrom($genericBagName from, int fromOffset, int length, boolean clearExceeding) { + if (buffer.length < length) + buffer = new $rawTypeName[length]; + // Maximum number of elements that can be copied from the given buffer + int copyLength = Math.min(length, from.buffer.length - fromOffset); + System.arraycopy(from.buffer, fromOffset, buffer, 0, copyLength); + if (clearExceeding && buffer.length > copyLength) { + $rawTypeName[] buffer = this.buffer; + for (int i = copyLength, n = buffer.length; i < n; i++) + buffer[i] = $defaultValue; + } + } + + @Override + public void copyPartFrom($genericBagName from, int fromOffset, int toOffset, int length) { + ensureCapacity(toOffset + length); + // Maximum number of elements that can be copied from the given buffer + int maxLength = from.buffer.length - fromOffset; + System.arraycopy(from.buffer, fromOffset, buffer, toOffset, Math.min(length, maxLength)); + if (maxLength < length) { $rawTypeName[] buffer = this.buffer; - for (int i = bag.buffer.length, n = buffer.length; i < n; i++) + for (int i = toOffset + maxLength, n = toOffset + length; i < n; i++) buffer[i] = $defaultValue; } } @@ -475,26 +510,141 @@ ${ @Test public void testCopyFrom() { + // Test copyFrom(bag) and copyFrom(bag, clearExceeding) $genericBagName bag0, bag1; + $genericTypeName e0 = $testValue, e1 = $testValue, e2 = $testValue, e3 = $testValue; bag0 = new $genericBagName(); - bag0.set(0, $testValue); - bag0.set(5, $testValue); - + bag0.set(0, e0); + bag0.set(3, e1); + bag0.set(9, e2); bag1 = new $genericBagName(); - bag1.set(9, $testValue); - + bag1.copyFrom(bag0); + assertEquals(($wrapperTypeName) e0, ($wrapperTypeName) bag1.get(0)); + assertEquals(($wrapperTypeName) e1, ($wrapperTypeName) bag1.get(3)); + assertEquals(($wrapperTypeName) e2, ($wrapperTypeName) bag1.get(9)); + bag1 = new $genericBagName(); + bag1.set(53, e3); bag1.copyFrom(bag0, false); - assertNotEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(0)); - assertNotEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(5)); - assertNotEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(9)); + assertEquals(($wrapperTypeName) e0, ($wrapperTypeName) bag1.get(0)); + assertEquals(($wrapperTypeName) e1, ($wrapperTypeName) bag1.get(3)); + assertEquals(($wrapperTypeName) e2, ($wrapperTypeName) bag1.get(9)); + assertEquals(($wrapperTypeName) e3, ($wrapperTypeName) bag1.get(53)); + bag1 = new $genericBagName(); + bag1.set(53, e3); + bag1.copyFrom(bag0, true); + assertEquals(($wrapperTypeName) e0, ($wrapperTypeName) bag1.get(0)); + assertEquals(($wrapperTypeName) e1, ($wrapperTypeName) bag1.get(3)); + assertEquals(($wrapperTypeName) e2, ($wrapperTypeName) bag1.get(9)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(53)); + + // Test copyFrom(bag, length) and copyFrom(bag, length, clearExceeding) + bag0 = new $genericBagName(); + bag0.set(4, e0); + bag0.set(7, e1); + bag1 = new $genericBagName(); + bag1.copyFrom(bag0, 3); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(0)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(1)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(2)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(3)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(4)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(5)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(6)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(7)); + bag1 = new $genericBagName(); + bag1.copyFrom(bag0, 5); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(0)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(1)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(2)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(3)); + assertEquals(($wrapperTypeName) e0, ($wrapperTypeName) bag1.get(4)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(5)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(6)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(7)); + bag1 = new $genericBagName(); + bag1.set(8, e2); + bag1.copyFrom(bag0, 8, true); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(0)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(1)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(2)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(3)); + assertEquals(($wrapperTypeName) e0, ($wrapperTypeName) bag1.get(4)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(5)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(6)); + assertEquals(($wrapperTypeName) e1, ($wrapperTypeName) bag1.get(7)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(8)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(9)); - bag1.copyFrom(bag0); - assertNotEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(0)); - assertNotEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(5)); + // Test copyFrom(bag, fromOffset, length) and copyFrom(bag, fromOffset, length, clearExceeding) + bag0 = new $genericBagName(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(6, e2); + bag1 = new $genericBagName(); + bag1.copyFrom(bag0, 3, 2); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(0)); + assertEquals(($wrapperTypeName) e1, ($wrapperTypeName) bag1.get(1)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(2)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(3)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(4)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(5)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(6)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(7)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(8)); + bag0 = new $genericBagName(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(10, e2); + bag1 = new $genericBagName(); + bag1.set(7, e3); + bag1.copyFrom(bag0, 3, 2, false); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(0)); + assertEquals(($wrapperTypeName) e1, ($wrapperTypeName) bag1.get(1)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(2)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(3)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(4)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(5)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(6)); + assertEquals(($wrapperTypeName) e3, ($wrapperTypeName) bag1.get(7)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(8)); assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(9)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) bag1.get(10)); + } - bag0.copyFrom(bag1); + @Test + public void testCopyPartFrom() { + $genericBagName b0, b1; + $genericTypeName e0 = $testValue, e1 = $testValue, e2 = $testValue, e3 = $testValue; + b0 = new $genericBagName(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new $genericBagName(); + b1.set(0, e3); + b1.set(33, e0); + b1.copyPartFrom(b0, 14, 1, 33); + assertEquals(($wrapperTypeName) e1, ($wrapperTypeName) b1.get(1)); + assertEquals(($wrapperTypeName) e2, ($wrapperTypeName) b1.get(8)); + assertEquals(($wrapperTypeName) e3, ($wrapperTypeName) b1.get(0)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) b1.get(32)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) b1.get(33)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) b1.get(34)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) b1.get(35)); + b0 = new $genericBagName(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new $genericBagName(); + b1.set(0, e3); + b1.copyPartFrom(b0, 14, 1, 8); + assertEquals(($wrapperTypeName) e1, ($wrapperTypeName) b1.get(1)); + assertEquals(($wrapperTypeName) e2, ($wrapperTypeName) b1.get(8)); + assertEquals(($wrapperTypeName) e3, ($wrapperTypeName) b1.get(0)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) b1.get(32)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) b1.get(33)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) b1.get(34)); + assertEquals(($wrapperTypeName) $defaultValue, ($wrapperTypeName) b1.get(35)); } } """ diff --git a/retinazer/src/main/java/com/github/antag99/retinazer/util/AnyBag.java b/retinazer/src/main/java/com/github/antag99/retinazer/util/AnyBag.java index f4c85c5..8a8b6ed 100644 --- a/retinazer/src/main/java/com/github/antag99/retinazer/util/AnyBag.java +++ b/retinazer/src/main/java/com/github/antag99/retinazer/util/AnyBag.java @@ -29,13 +29,108 @@ */ public interface AnyBag> { - void copyFrom(T bag); + /** + * Copies the contents from the other bag into this bag. + * Clears any exceeding elements in the buffer of this bag. + * + * @param from + * the other bag. + */ + void copyFrom(T from); - void copyFrom(T bag, boolean clearExceeding); + /** + * Copies the contents from the other bag into this bag. + * + * @param from + * the other bag. + * @param clearExceeding + * whether to clear elements past the copied part. + */ + void copyFrom(T from, boolean clearExceeding); + /** + * Copies the contents from the other bag into this bag. + * Clears any exceeding elements in the buffer of this bag. + * + * @param from + * the other bag. + * @param length + * amount of items to copy. + */ + void copyFrom(T from, int length); + + /** + * Copies the contents from the other bag into this bag. + * + * @param from + * the other bag. + * @param length + * amount of items to copy. + * @param clearExceeding + * whether to clear elements past the copied part. + */ + void copyFrom(T from, int length, boolean clearExceeding); + + /** + * Copies the contents from the other bag into this bag. + * Clears any exceeding elements in the buffer of this bag. + * + * @param from + * the other bag. + * @param fromOffset + * offset into the other bag. + * @param length + * amount of items to copy. + */ + void copyFrom(T from, int fromOffset, int length); + + /** + * Copies the contents from the other bag into this bag. + * + * @param from + * the other bag. + * @param fromOffset + * offset into the other bag. + * @param length + * amount of items to copy. + * @param clearExceeding + * whether to clear elements past the copied part. + */ + void copyFrom(T from, int fromOffset, int length, boolean clearExceeding); + + /** + * Copies a part from the other bag into this bag. + * + * @param from + * the other bag. + * @param fromOffset + * offset into the other bag. + * @param toOffset + * offset into this bag. + * @param length + * amount of items to copy. + */ + void copyPartFrom(T from, int fromOffset, int toOffset, int length); + + /** + * Ensures the backing buffer of this bag has the specified capacity. + * + * @param capacity + * the capacity, will be increased to the nearest power of two. + */ void ensureCapacity(int capacity); + /** + * Resets all elements of this bag. + */ void clear(); + /** + * Resets all elements set in the given mask. Bits in the + * mask that exceed the capacity of this bag will be ignored. + * + * @param mask + * the mask. + */ void clear(Mask mask); } diff --git a/retinazer/src/main/java/com/github/antag99/retinazer/util/Bag.java b/retinazer/src/main/java/com/github/antag99/retinazer/util/Bag.java index 48582a1..0e7bd93 100644 --- a/retinazer/src/main/java/com/github/antag99/retinazer/util/Bag.java +++ b/retinazer/src/main/java/com/github/antag99/retinazer/util/Bag.java @@ -55,18 +55,53 @@ public Bag() { } @Override - public void copyFrom(Bag bag) { - copyFrom(bag, true); + public void copyFrom(Bag from) { + copyFrom(from, true); } @Override - public void copyFrom(Bag bag, boolean clearExceeding) { - if (buffer.length < bag.buffer.length) - buffer = new Object[bag.buffer.length]; - System.arraycopy(bag.buffer, 0, buffer, 0, bag.buffer.length); - if (clearExceeding && buffer.length > bag.buffer.length) { + public void copyFrom(Bag from, boolean clearExceeding) { + copyFrom(from, from.buffer.length, clearExceeding); + } + + @Override + public void copyFrom(Bag from, int length) { + copyFrom(from, length, true); + } + + @Override + public void copyFrom(Bag from, int length, boolean clearExceeding) { + copyFrom(from, 0, length, clearExceeding); + } + + @Override + public void copyFrom(Bag from, int fromOffset, int length) { + copyFrom(from, fromOffset, length, true); + } + + @Override + public void copyFrom(Bag from, int fromOffset, int length, boolean clearExceeding) { + if (buffer.length < length) + buffer = new Object[length]; + // Maximum number of elements that can be copied from the given buffer + int copyLength = Math.min(length, from.buffer.length - fromOffset); + System.arraycopy(from.buffer, fromOffset, buffer, 0, copyLength); + if (clearExceeding && buffer.length > copyLength) { + Object[] buffer = this.buffer; + for (int i = copyLength, n = buffer.length; i < n; i++) + buffer[i] = null; + } + } + + @Override + public void copyPartFrom(Bag from, int fromOffset, int toOffset, int length) { + ensureCapacity(toOffset + length); + // Maximum number of elements that can be copied from the given buffer + int maxLength = from.buffer.length - fromOffset; + System.arraycopy(from.buffer, fromOffset, buffer, toOffset, Math.min(length, maxLength)); + if (maxLength < length) { Object[] buffer = this.buffer; - for (int i = bag.buffer.length, n = buffer.length; i < n; i++) + for (int i = toOffset + maxLength, n = toOffset + length; i < n; i++) buffer[i] = null; } } diff --git a/retinazer/src/main/java/com/github/antag99/retinazer/util/BooleanBag.java b/retinazer/src/main/java/com/github/antag99/retinazer/util/BooleanBag.java index 72d414e..5d1a31d 100644 --- a/retinazer/src/main/java/com/github/antag99/retinazer/util/BooleanBag.java +++ b/retinazer/src/main/java/com/github/antag99/retinazer/util/BooleanBag.java @@ -42,18 +42,53 @@ public BooleanBag() { } @Override - public void copyFrom(BooleanBag bag) { - copyFrom(bag, true); + public void copyFrom(BooleanBag from) { + copyFrom(from, true); } @Override - public void copyFrom(BooleanBag bag, boolean clearExceeding) { - if (buffer.length < bag.buffer.length) - buffer = new boolean[bag.buffer.length]; - System.arraycopy(bag.buffer, 0, buffer, 0, bag.buffer.length); - if (clearExceeding && buffer.length > bag.buffer.length) { + public void copyFrom(BooleanBag from, boolean clearExceeding) { + copyFrom(from, from.buffer.length, clearExceeding); + } + + @Override + public void copyFrom(BooleanBag from, int length) { + copyFrom(from, length, true); + } + + @Override + public void copyFrom(BooleanBag from, int length, boolean clearExceeding) { + copyFrom(from, 0, length, clearExceeding); + } + + @Override + public void copyFrom(BooleanBag from, int fromOffset, int length) { + copyFrom(from, fromOffset, length, true); + } + + @Override + public void copyFrom(BooleanBag from, int fromOffset, int length, boolean clearExceeding) { + if (buffer.length < length) + buffer = new boolean[length]; + // Maximum number of elements that can be copied from the given buffer + int copyLength = Math.min(length, from.buffer.length - fromOffset); + System.arraycopy(from.buffer, fromOffset, buffer, 0, copyLength); + if (clearExceeding && buffer.length > copyLength) { + boolean[] buffer = this.buffer; + for (int i = copyLength, n = buffer.length; i < n; i++) + buffer[i] = false; + } + } + + @Override + public void copyPartFrom(BooleanBag from, int fromOffset, int toOffset, int length) { + ensureCapacity(toOffset + length); + // Maximum number of elements that can be copied from the given buffer + int maxLength = from.buffer.length - fromOffset; + System.arraycopy(from.buffer, fromOffset, buffer, toOffset, Math.min(length, maxLength)); + if (maxLength < length) { boolean[] buffer = this.buffer; - for (int i = bag.buffer.length, n = buffer.length; i < n; i++) + for (int i = toOffset + maxLength, n = toOffset + length; i < n; i++) buffer[i] = false; } } diff --git a/retinazer/src/main/java/com/github/antag99/retinazer/util/ByteBag.java b/retinazer/src/main/java/com/github/antag99/retinazer/util/ByteBag.java index 8798a04..3774a49 100644 --- a/retinazer/src/main/java/com/github/antag99/retinazer/util/ByteBag.java +++ b/retinazer/src/main/java/com/github/antag99/retinazer/util/ByteBag.java @@ -42,18 +42,53 @@ public ByteBag() { } @Override - public void copyFrom(ByteBag bag) { - copyFrom(bag, true); + public void copyFrom(ByteBag from) { + copyFrom(from, true); } @Override - public void copyFrom(ByteBag bag, boolean clearExceeding) { - if (buffer.length < bag.buffer.length) - buffer = new byte[bag.buffer.length]; - System.arraycopy(bag.buffer, 0, buffer, 0, bag.buffer.length); - if (clearExceeding && buffer.length > bag.buffer.length) { + public void copyFrom(ByteBag from, boolean clearExceeding) { + copyFrom(from, from.buffer.length, clearExceeding); + } + + @Override + public void copyFrom(ByteBag from, int length) { + copyFrom(from, length, true); + } + + @Override + public void copyFrom(ByteBag from, int length, boolean clearExceeding) { + copyFrom(from, 0, length, clearExceeding); + } + + @Override + public void copyFrom(ByteBag from, int fromOffset, int length) { + copyFrom(from, fromOffset, length, true); + } + + @Override + public void copyFrom(ByteBag from, int fromOffset, int length, boolean clearExceeding) { + if (buffer.length < length) + buffer = new byte[length]; + // Maximum number of elements that can be copied from the given buffer + int copyLength = Math.min(length, from.buffer.length - fromOffset); + System.arraycopy(from.buffer, fromOffset, buffer, 0, copyLength); + if (clearExceeding && buffer.length > copyLength) { + byte[] buffer = this.buffer; + for (int i = copyLength, n = buffer.length; i < n; i++) + buffer[i] = (byte) 0; + } + } + + @Override + public void copyPartFrom(ByteBag from, int fromOffset, int toOffset, int length) { + ensureCapacity(toOffset + length); + // Maximum number of elements that can be copied from the given buffer + int maxLength = from.buffer.length - fromOffset; + System.arraycopy(from.buffer, fromOffset, buffer, toOffset, Math.min(length, maxLength)); + if (maxLength < length) { byte[] buffer = this.buffer; - for (int i = bag.buffer.length, n = buffer.length; i < n; i++) + for (int i = toOffset + maxLength, n = toOffset + length; i < n; i++) buffer[i] = (byte) 0; } } diff --git a/retinazer/src/main/java/com/github/antag99/retinazer/util/CharBag.java b/retinazer/src/main/java/com/github/antag99/retinazer/util/CharBag.java index 8f8e3c4..1ae0d75 100644 --- a/retinazer/src/main/java/com/github/antag99/retinazer/util/CharBag.java +++ b/retinazer/src/main/java/com/github/antag99/retinazer/util/CharBag.java @@ -42,18 +42,53 @@ public CharBag() { } @Override - public void copyFrom(CharBag bag) { - copyFrom(bag, true); + public void copyFrom(CharBag from) { + copyFrom(from, true); } @Override - public void copyFrom(CharBag bag, boolean clearExceeding) { - if (buffer.length < bag.buffer.length) - buffer = new char[bag.buffer.length]; - System.arraycopy(bag.buffer, 0, buffer, 0, bag.buffer.length); - if (clearExceeding && buffer.length > bag.buffer.length) { + public void copyFrom(CharBag from, boolean clearExceeding) { + copyFrom(from, from.buffer.length, clearExceeding); + } + + @Override + public void copyFrom(CharBag from, int length) { + copyFrom(from, length, true); + } + + @Override + public void copyFrom(CharBag from, int length, boolean clearExceeding) { + copyFrom(from, 0, length, clearExceeding); + } + + @Override + public void copyFrom(CharBag from, int fromOffset, int length) { + copyFrom(from, fromOffset, length, true); + } + + @Override + public void copyFrom(CharBag from, int fromOffset, int length, boolean clearExceeding) { + if (buffer.length < length) + buffer = new char[length]; + // Maximum number of elements that can be copied from the given buffer + int copyLength = Math.min(length, from.buffer.length - fromOffset); + System.arraycopy(from.buffer, fromOffset, buffer, 0, copyLength); + if (clearExceeding && buffer.length > copyLength) { + char[] buffer = this.buffer; + for (int i = copyLength, n = buffer.length; i < n; i++) + buffer[i] = (char) 0; + } + } + + @Override + public void copyPartFrom(CharBag from, int fromOffset, int toOffset, int length) { + ensureCapacity(toOffset + length); + // Maximum number of elements that can be copied from the given buffer + int maxLength = from.buffer.length - fromOffset; + System.arraycopy(from.buffer, fromOffset, buffer, toOffset, Math.min(length, maxLength)); + if (maxLength < length) { char[] buffer = this.buffer; - for (int i = bag.buffer.length, n = buffer.length; i < n; i++) + for (int i = toOffset + maxLength, n = toOffset + length; i < n; i++) buffer[i] = (char) 0; } } diff --git a/retinazer/src/main/java/com/github/antag99/retinazer/util/DoubleBag.java b/retinazer/src/main/java/com/github/antag99/retinazer/util/DoubleBag.java index 3f3c945..1cc8639 100644 --- a/retinazer/src/main/java/com/github/antag99/retinazer/util/DoubleBag.java +++ b/retinazer/src/main/java/com/github/antag99/retinazer/util/DoubleBag.java @@ -42,18 +42,53 @@ public DoubleBag() { } @Override - public void copyFrom(DoubleBag bag) { - copyFrom(bag, true); + public void copyFrom(DoubleBag from) { + copyFrom(from, true); } @Override - public void copyFrom(DoubleBag bag, boolean clearExceeding) { - if (buffer.length < bag.buffer.length) - buffer = new double[bag.buffer.length]; - System.arraycopy(bag.buffer, 0, buffer, 0, bag.buffer.length); - if (clearExceeding && buffer.length > bag.buffer.length) { + public void copyFrom(DoubleBag from, boolean clearExceeding) { + copyFrom(from, from.buffer.length, clearExceeding); + } + + @Override + public void copyFrom(DoubleBag from, int length) { + copyFrom(from, length, true); + } + + @Override + public void copyFrom(DoubleBag from, int length, boolean clearExceeding) { + copyFrom(from, 0, length, clearExceeding); + } + + @Override + public void copyFrom(DoubleBag from, int fromOffset, int length) { + copyFrom(from, fromOffset, length, true); + } + + @Override + public void copyFrom(DoubleBag from, int fromOffset, int length, boolean clearExceeding) { + if (buffer.length < length) + buffer = new double[length]; + // Maximum number of elements that can be copied from the given buffer + int copyLength = Math.min(length, from.buffer.length - fromOffset); + System.arraycopy(from.buffer, fromOffset, buffer, 0, copyLength); + if (clearExceeding && buffer.length > copyLength) { + double[] buffer = this.buffer; + for (int i = copyLength, n = buffer.length; i < n; i++) + buffer[i] = 0d; + } + } + + @Override + public void copyPartFrom(DoubleBag from, int fromOffset, int toOffset, int length) { + ensureCapacity(toOffset + length); + // Maximum number of elements that can be copied from the given buffer + int maxLength = from.buffer.length - fromOffset; + System.arraycopy(from.buffer, fromOffset, buffer, toOffset, Math.min(length, maxLength)); + if (maxLength < length) { double[] buffer = this.buffer; - for (int i = bag.buffer.length, n = buffer.length; i < n; i++) + for (int i = toOffset + maxLength, n = toOffset + length; i < n; i++) buffer[i] = 0d; } } diff --git a/retinazer/src/main/java/com/github/antag99/retinazer/util/FloatBag.java b/retinazer/src/main/java/com/github/antag99/retinazer/util/FloatBag.java index 3c99861..3d12521 100644 --- a/retinazer/src/main/java/com/github/antag99/retinazer/util/FloatBag.java +++ b/retinazer/src/main/java/com/github/antag99/retinazer/util/FloatBag.java @@ -42,18 +42,53 @@ public FloatBag() { } @Override - public void copyFrom(FloatBag bag) { - copyFrom(bag, true); + public void copyFrom(FloatBag from) { + copyFrom(from, true); } @Override - public void copyFrom(FloatBag bag, boolean clearExceeding) { - if (buffer.length < bag.buffer.length) - buffer = new float[bag.buffer.length]; - System.arraycopy(bag.buffer, 0, buffer, 0, bag.buffer.length); - if (clearExceeding && buffer.length > bag.buffer.length) { + public void copyFrom(FloatBag from, boolean clearExceeding) { + copyFrom(from, from.buffer.length, clearExceeding); + } + + @Override + public void copyFrom(FloatBag from, int length) { + copyFrom(from, length, true); + } + + @Override + public void copyFrom(FloatBag from, int length, boolean clearExceeding) { + copyFrom(from, 0, length, clearExceeding); + } + + @Override + public void copyFrom(FloatBag from, int fromOffset, int length) { + copyFrom(from, fromOffset, length, true); + } + + @Override + public void copyFrom(FloatBag from, int fromOffset, int length, boolean clearExceeding) { + if (buffer.length < length) + buffer = new float[length]; + // Maximum number of elements that can be copied from the given buffer + int copyLength = Math.min(length, from.buffer.length - fromOffset); + System.arraycopy(from.buffer, fromOffset, buffer, 0, copyLength); + if (clearExceeding && buffer.length > copyLength) { + float[] buffer = this.buffer; + for (int i = copyLength, n = buffer.length; i < n; i++) + buffer[i] = 0f; + } + } + + @Override + public void copyPartFrom(FloatBag from, int fromOffset, int toOffset, int length) { + ensureCapacity(toOffset + length); + // Maximum number of elements that can be copied from the given buffer + int maxLength = from.buffer.length - fromOffset; + System.arraycopy(from.buffer, fromOffset, buffer, toOffset, Math.min(length, maxLength)); + if (maxLength < length) { float[] buffer = this.buffer; - for (int i = bag.buffer.length, n = buffer.length; i < n; i++) + for (int i = toOffset + maxLength, n = toOffset + length; i < n; i++) buffer[i] = 0f; } } diff --git a/retinazer/src/main/java/com/github/antag99/retinazer/util/IntBag.java b/retinazer/src/main/java/com/github/antag99/retinazer/util/IntBag.java index 692512d..6830de5 100644 --- a/retinazer/src/main/java/com/github/antag99/retinazer/util/IntBag.java +++ b/retinazer/src/main/java/com/github/antag99/retinazer/util/IntBag.java @@ -42,18 +42,53 @@ public IntBag() { } @Override - public void copyFrom(IntBag bag) { - copyFrom(bag, true); + public void copyFrom(IntBag from) { + copyFrom(from, true); } @Override - public void copyFrom(IntBag bag, boolean clearExceeding) { - if (buffer.length < bag.buffer.length) - buffer = new int[bag.buffer.length]; - System.arraycopy(bag.buffer, 0, buffer, 0, bag.buffer.length); - if (clearExceeding && buffer.length > bag.buffer.length) { + public void copyFrom(IntBag from, boolean clearExceeding) { + copyFrom(from, from.buffer.length, clearExceeding); + } + + @Override + public void copyFrom(IntBag from, int length) { + copyFrom(from, length, true); + } + + @Override + public void copyFrom(IntBag from, int length, boolean clearExceeding) { + copyFrom(from, 0, length, clearExceeding); + } + + @Override + public void copyFrom(IntBag from, int fromOffset, int length) { + copyFrom(from, fromOffset, length, true); + } + + @Override + public void copyFrom(IntBag from, int fromOffset, int length, boolean clearExceeding) { + if (buffer.length < length) + buffer = new int[length]; + // Maximum number of elements that can be copied from the given buffer + int copyLength = Math.min(length, from.buffer.length - fromOffset); + System.arraycopy(from.buffer, fromOffset, buffer, 0, copyLength); + if (clearExceeding && buffer.length > copyLength) { + int[] buffer = this.buffer; + for (int i = copyLength, n = buffer.length; i < n; i++) + buffer[i] = 0; + } + } + + @Override + public void copyPartFrom(IntBag from, int fromOffset, int toOffset, int length) { + ensureCapacity(toOffset + length); + // Maximum number of elements that can be copied from the given buffer + int maxLength = from.buffer.length - fromOffset; + System.arraycopy(from.buffer, fromOffset, buffer, toOffset, Math.min(length, maxLength)); + if (maxLength < length) { int[] buffer = this.buffer; - for (int i = bag.buffer.length, n = buffer.length; i < n; i++) + for (int i = toOffset + maxLength, n = toOffset + length; i < n; i++) buffer[i] = 0; } } diff --git a/retinazer/src/main/java/com/github/antag99/retinazer/util/LongBag.java b/retinazer/src/main/java/com/github/antag99/retinazer/util/LongBag.java index dd0c43b..125df3f 100644 --- a/retinazer/src/main/java/com/github/antag99/retinazer/util/LongBag.java +++ b/retinazer/src/main/java/com/github/antag99/retinazer/util/LongBag.java @@ -42,18 +42,53 @@ public LongBag() { } @Override - public void copyFrom(LongBag bag) { - copyFrom(bag, true); + public void copyFrom(LongBag from) { + copyFrom(from, true); } @Override - public void copyFrom(LongBag bag, boolean clearExceeding) { - if (buffer.length < bag.buffer.length) - buffer = new long[bag.buffer.length]; - System.arraycopy(bag.buffer, 0, buffer, 0, bag.buffer.length); - if (clearExceeding && buffer.length > bag.buffer.length) { + public void copyFrom(LongBag from, boolean clearExceeding) { + copyFrom(from, from.buffer.length, clearExceeding); + } + + @Override + public void copyFrom(LongBag from, int length) { + copyFrom(from, length, true); + } + + @Override + public void copyFrom(LongBag from, int length, boolean clearExceeding) { + copyFrom(from, 0, length, clearExceeding); + } + + @Override + public void copyFrom(LongBag from, int fromOffset, int length) { + copyFrom(from, fromOffset, length, true); + } + + @Override + public void copyFrom(LongBag from, int fromOffset, int length, boolean clearExceeding) { + if (buffer.length < length) + buffer = new long[length]; + // Maximum number of elements that can be copied from the given buffer + int copyLength = Math.min(length, from.buffer.length - fromOffset); + System.arraycopy(from.buffer, fromOffset, buffer, 0, copyLength); + if (clearExceeding && buffer.length > copyLength) { + long[] buffer = this.buffer; + for (int i = copyLength, n = buffer.length; i < n; i++) + buffer[i] = 0L; + } + } + + @Override + public void copyPartFrom(LongBag from, int fromOffset, int toOffset, int length) { + ensureCapacity(toOffset + length); + // Maximum number of elements that can be copied from the given buffer + int maxLength = from.buffer.length - fromOffset; + System.arraycopy(from.buffer, fromOffset, buffer, toOffset, Math.min(length, maxLength)); + if (maxLength < length) { long[] buffer = this.buffer; - for (int i = bag.buffer.length, n = buffer.length; i < n; i++) + for (int i = toOffset + maxLength, n = toOffset + length; i < n; i++) buffer[i] = 0L; } } diff --git a/retinazer/src/main/java/com/github/antag99/retinazer/util/ShortBag.java b/retinazer/src/main/java/com/github/antag99/retinazer/util/ShortBag.java index 6326cd2..91d1693 100644 --- a/retinazer/src/main/java/com/github/antag99/retinazer/util/ShortBag.java +++ b/retinazer/src/main/java/com/github/antag99/retinazer/util/ShortBag.java @@ -42,18 +42,53 @@ public ShortBag() { } @Override - public void copyFrom(ShortBag bag) { - copyFrom(bag, true); + public void copyFrom(ShortBag from) { + copyFrom(from, true); } @Override - public void copyFrom(ShortBag bag, boolean clearExceeding) { - if (buffer.length < bag.buffer.length) - buffer = new short[bag.buffer.length]; - System.arraycopy(bag.buffer, 0, buffer, 0, bag.buffer.length); - if (clearExceeding && buffer.length > bag.buffer.length) { + public void copyFrom(ShortBag from, boolean clearExceeding) { + copyFrom(from, from.buffer.length, clearExceeding); + } + + @Override + public void copyFrom(ShortBag from, int length) { + copyFrom(from, length, true); + } + + @Override + public void copyFrom(ShortBag from, int length, boolean clearExceeding) { + copyFrom(from, 0, length, clearExceeding); + } + + @Override + public void copyFrom(ShortBag from, int fromOffset, int length) { + copyFrom(from, fromOffset, length, true); + } + + @Override + public void copyFrom(ShortBag from, int fromOffset, int length, boolean clearExceeding) { + if (buffer.length < length) + buffer = new short[length]; + // Maximum number of elements that can be copied from the given buffer + int copyLength = Math.min(length, from.buffer.length - fromOffset); + System.arraycopy(from.buffer, fromOffset, buffer, 0, copyLength); + if (clearExceeding && buffer.length > copyLength) { + short[] buffer = this.buffer; + for (int i = copyLength, n = buffer.length; i < n; i++) + buffer[i] = (short) 0; + } + } + + @Override + public void copyPartFrom(ShortBag from, int fromOffset, int toOffset, int length) { + ensureCapacity(toOffset + length); + // Maximum number of elements that can be copied from the given buffer + int maxLength = from.buffer.length - fromOffset; + System.arraycopy(from.buffer, fromOffset, buffer, toOffset, Math.min(length, maxLength)); + if (maxLength < length) { short[] buffer = this.buffer; - for (int i = bag.buffer.length, n = buffer.length; i < n; i++) + for (int i = toOffset + maxLength, n = toOffset + length; i < n; i++) buffer[i] = (short) 0; } } diff --git a/retinazer/src/test/java/com/github/antag99/retinazer/util/BagTest.java b/retinazer/src/test/java/com/github/antag99/retinazer/util/BagTest.java index ac30b92..c3037fa 100644 --- a/retinazer/src/test/java/com/github/antag99/retinazer/util/BagTest.java +++ b/retinazer/src/test/java/com/github/antag99/retinazer/util/BagTest.java @@ -275,25 +275,140 @@ public void testClear() { @Test public void testCopyFrom() { + // Test copyFrom(bag) and copyFrom(bag, clearExceeding) Bag bag0, bag1; + T e0 = (T) new Object(), e1 = (T) new Object(), e2 = (T) new Object(), e3 = (T) new Object(); bag0 = new Bag(); - bag0.set(0, (T) new Object()); - bag0.set(5, (T) new Object()); - + bag0.set(0, e0); + bag0.set(3, e1); + bag0.set(9, e2); bag1 = new Bag(); - bag1.set(9, (T) new Object()); - + bag1.copyFrom(bag0); + assertEquals((T) e0, (T) bag1.get(0)); + assertEquals((T) e1, (T) bag1.get(3)); + assertEquals((T) e2, (T) bag1.get(9)); + bag1 = new Bag(); + bag1.set(53, e3); bag1.copyFrom(bag0, false); - assertNotEquals((T) null, (T) bag1.get(0)); - assertNotEquals((T) null, (T) bag1.get(5)); - assertNotEquals((T) null, (T) bag1.get(9)); + assertEquals((T) e0, (T) bag1.get(0)); + assertEquals((T) e1, (T) bag1.get(3)); + assertEquals((T) e2, (T) bag1.get(9)); + assertEquals((T) e3, (T) bag1.get(53)); + bag1 = new Bag(); + bag1.set(53, e3); + bag1.copyFrom(bag0, true); + assertEquals((T) e0, (T) bag1.get(0)); + assertEquals((T) e1, (T) bag1.get(3)); + assertEquals((T) e2, (T) bag1.get(9)); + assertEquals((T) null, (T) bag1.get(53)); - bag1.copyFrom(bag0); - assertNotEquals((T) null, (T) bag1.get(0)); - assertNotEquals((T) null, (T) bag1.get(5)); + // Test copyFrom(bag, length) and copyFrom(bag, length, clearExceeding) + bag0 = new Bag(); + bag0.set(4, e0); + bag0.set(7, e1); + bag1 = new Bag(); + bag1.copyFrom(bag0, 3); + assertEquals((T) null, (T) bag1.get(0)); + assertEquals((T) null, (T) bag1.get(1)); + assertEquals((T) null, (T) bag1.get(2)); + assertEquals((T) null, (T) bag1.get(3)); + assertEquals((T) null, (T) bag1.get(4)); + assertEquals((T) null, (T) bag1.get(5)); + assertEquals((T) null, (T) bag1.get(6)); + assertEquals((T) null, (T) bag1.get(7)); + bag1 = new Bag(); + bag1.copyFrom(bag0, 5); + assertEquals((T) null, (T) bag1.get(0)); + assertEquals((T) null, (T) bag1.get(1)); + assertEquals((T) null, (T) bag1.get(2)); + assertEquals((T) null, (T) bag1.get(3)); + assertEquals((T) e0, (T) bag1.get(4)); + assertEquals((T) null, (T) bag1.get(5)); + assertEquals((T) null, (T) bag1.get(6)); + assertEquals((T) null, (T) bag1.get(7)); + bag1 = new Bag(); + bag1.set(8, e2); + bag1.copyFrom(bag0, 8, true); + assertEquals((T) null, (T) bag1.get(0)); + assertEquals((T) null, (T) bag1.get(1)); + assertEquals((T) null, (T) bag1.get(2)); + assertEquals((T) null, (T) bag1.get(3)); + assertEquals((T) e0, (T) bag1.get(4)); + assertEquals((T) null, (T) bag1.get(5)); + assertEquals((T) null, (T) bag1.get(6)); + assertEquals((T) e1, (T) bag1.get(7)); + assertEquals((T) null, (T) bag1.get(8)); assertEquals((T) null, (T) bag1.get(9)); - bag0.copyFrom(bag1); + // Test copyFrom(bag, fromOffset, length) and copyFrom(bag, fromOffset, length, clearExceeding) + bag0 = new Bag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(6, e2); + bag1 = new Bag(); + bag1.copyFrom(bag0, 3, 2); + assertEquals((T) null, (T) bag1.get(0)); + assertEquals((T) e1, (T) bag1.get(1)); + assertEquals((T) null, (T) bag1.get(2)); + assertEquals((T) null, (T) bag1.get(3)); + assertEquals((T) null, (T) bag1.get(4)); + assertEquals((T) null, (T) bag1.get(5)); + assertEquals((T) null, (T) bag1.get(6)); + assertEquals((T) null, (T) bag1.get(7)); + assertEquals((T) null, (T) bag1.get(8)); + bag0 = new Bag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(10, e2); + bag1 = new Bag(); + bag1.set(7, e3); + bag1.copyFrom(bag0, 3, 2, false); + assertEquals((T) null, (T) bag1.get(0)); + assertEquals((T) e1, (T) bag1.get(1)); + assertEquals((T) null, (T) bag1.get(2)); + assertEquals((T) null, (T) bag1.get(3)); + assertEquals((T) null, (T) bag1.get(4)); + assertEquals((T) null, (T) bag1.get(5)); + assertEquals((T) null, (T) bag1.get(6)); + assertEquals((T) e3, (T) bag1.get(7)); + assertEquals((T) null, (T) bag1.get(8)); + assertEquals((T) null, (T) bag1.get(9)); + assertEquals((T) null, (T) bag1.get(10)); + } + + @Test + public void testCopyPartFrom() { + Bag b0, b1; + T e0 = (T) new Object(), e1 = (T) new Object(), e2 = (T) new Object(), e3 = (T) new Object(); + b0 = new Bag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new Bag(); + b1.set(0, e3); + b1.set(33, e0); + b1.copyPartFrom(b0, 14, 1, 33); + assertEquals((T) e1, (T) b1.get(1)); + assertEquals((T) e2, (T) b1.get(8)); + assertEquals((T) e3, (T) b1.get(0)); + assertEquals((T) null, (T) b1.get(32)); + assertEquals((T) null, (T) b1.get(33)); + assertEquals((T) null, (T) b1.get(34)); + assertEquals((T) null, (T) b1.get(35)); + b0 = new Bag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new Bag(); + b1.set(0, e3); + b1.copyPartFrom(b0, 14, 1, 8); + assertEquals((T) e1, (T) b1.get(1)); + assertEquals((T) e2, (T) b1.get(8)); + assertEquals((T) e3, (T) b1.get(0)); + assertEquals((T) null, (T) b1.get(32)); + assertEquals((T) null, (T) b1.get(33)); + assertEquals((T) null, (T) b1.get(34)); + assertEquals((T) null, (T) b1.get(35)); } } diff --git a/retinazer/src/test/java/com/github/antag99/retinazer/util/BooleanBagTest.java b/retinazer/src/test/java/com/github/antag99/retinazer/util/BooleanBagTest.java index 0c0889c..7ddfb8f 100644 --- a/retinazer/src/test/java/com/github/antag99/retinazer/util/BooleanBagTest.java +++ b/retinazer/src/test/java/com/github/antag99/retinazer/util/BooleanBagTest.java @@ -266,25 +266,140 @@ public void testClear() { @Test public void testCopyFrom() { + // Test copyFrom(bag) and copyFrom(bag, clearExceeding) BooleanBag bag0, bag1; + boolean e0 = true, e1 = true, e2 = true, e3 = true; bag0 = new BooleanBag(); - bag0.set(0, true); - bag0.set(5, true); - + bag0.set(0, e0); + bag0.set(3, e1); + bag0.set(9, e2); bag1 = new BooleanBag(); - bag1.set(9, true); - + bag1.copyFrom(bag0); + assertEquals((Boolean) e0, (Boolean) bag1.get(0)); + assertEquals((Boolean) e1, (Boolean) bag1.get(3)); + assertEquals((Boolean) e2, (Boolean) bag1.get(9)); + bag1 = new BooleanBag(); + bag1.set(53, e3); bag1.copyFrom(bag0, false); - assertNotEquals((Boolean) false, (Boolean) bag1.get(0)); - assertNotEquals((Boolean) false, (Boolean) bag1.get(5)); - assertNotEquals((Boolean) false, (Boolean) bag1.get(9)); + assertEquals((Boolean) e0, (Boolean) bag1.get(0)); + assertEquals((Boolean) e1, (Boolean) bag1.get(3)); + assertEquals((Boolean) e2, (Boolean) bag1.get(9)); + assertEquals((Boolean) e3, (Boolean) bag1.get(53)); + bag1 = new BooleanBag(); + bag1.set(53, e3); + bag1.copyFrom(bag0, true); + assertEquals((Boolean) e0, (Boolean) bag1.get(0)); + assertEquals((Boolean) e1, (Boolean) bag1.get(3)); + assertEquals((Boolean) e2, (Boolean) bag1.get(9)); + assertEquals((Boolean) false, (Boolean) bag1.get(53)); - bag1.copyFrom(bag0); - assertNotEquals((Boolean) false, (Boolean) bag1.get(0)); - assertNotEquals((Boolean) false, (Boolean) bag1.get(5)); + // Test copyFrom(bag, length) and copyFrom(bag, length, clearExceeding) + bag0 = new BooleanBag(); + bag0.set(4, e0); + bag0.set(7, e1); + bag1 = new BooleanBag(); + bag1.copyFrom(bag0, 3); + assertEquals((Boolean) false, (Boolean) bag1.get(0)); + assertEquals((Boolean) false, (Boolean) bag1.get(1)); + assertEquals((Boolean) false, (Boolean) bag1.get(2)); + assertEquals((Boolean) false, (Boolean) bag1.get(3)); + assertEquals((Boolean) false, (Boolean) bag1.get(4)); + assertEquals((Boolean) false, (Boolean) bag1.get(5)); + assertEquals((Boolean) false, (Boolean) bag1.get(6)); + assertEquals((Boolean) false, (Boolean) bag1.get(7)); + bag1 = new BooleanBag(); + bag1.copyFrom(bag0, 5); + assertEquals((Boolean) false, (Boolean) bag1.get(0)); + assertEquals((Boolean) false, (Boolean) bag1.get(1)); + assertEquals((Boolean) false, (Boolean) bag1.get(2)); + assertEquals((Boolean) false, (Boolean) bag1.get(3)); + assertEquals((Boolean) e0, (Boolean) bag1.get(4)); + assertEquals((Boolean) false, (Boolean) bag1.get(5)); + assertEquals((Boolean) false, (Boolean) bag1.get(6)); + assertEquals((Boolean) false, (Boolean) bag1.get(7)); + bag1 = new BooleanBag(); + bag1.set(8, e2); + bag1.copyFrom(bag0, 8, true); + assertEquals((Boolean) false, (Boolean) bag1.get(0)); + assertEquals((Boolean) false, (Boolean) bag1.get(1)); + assertEquals((Boolean) false, (Boolean) bag1.get(2)); + assertEquals((Boolean) false, (Boolean) bag1.get(3)); + assertEquals((Boolean) e0, (Boolean) bag1.get(4)); + assertEquals((Boolean) false, (Boolean) bag1.get(5)); + assertEquals((Boolean) false, (Boolean) bag1.get(6)); + assertEquals((Boolean) e1, (Boolean) bag1.get(7)); + assertEquals((Boolean) false, (Boolean) bag1.get(8)); assertEquals((Boolean) false, (Boolean) bag1.get(9)); - bag0.copyFrom(bag1); + // Test copyFrom(bag, fromOffset, length) and copyFrom(bag, fromOffset, length, clearExceeding) + bag0 = new BooleanBag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(6, e2); + bag1 = new BooleanBag(); + bag1.copyFrom(bag0, 3, 2); + assertEquals((Boolean) false, (Boolean) bag1.get(0)); + assertEquals((Boolean) e1, (Boolean) bag1.get(1)); + assertEquals((Boolean) false, (Boolean) bag1.get(2)); + assertEquals((Boolean) false, (Boolean) bag1.get(3)); + assertEquals((Boolean) false, (Boolean) bag1.get(4)); + assertEquals((Boolean) false, (Boolean) bag1.get(5)); + assertEquals((Boolean) false, (Boolean) bag1.get(6)); + assertEquals((Boolean) false, (Boolean) bag1.get(7)); + assertEquals((Boolean) false, (Boolean) bag1.get(8)); + bag0 = new BooleanBag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(10, e2); + bag1 = new BooleanBag(); + bag1.set(7, e3); + bag1.copyFrom(bag0, 3, 2, false); + assertEquals((Boolean) false, (Boolean) bag1.get(0)); + assertEquals((Boolean) e1, (Boolean) bag1.get(1)); + assertEquals((Boolean) false, (Boolean) bag1.get(2)); + assertEquals((Boolean) false, (Boolean) bag1.get(3)); + assertEquals((Boolean) false, (Boolean) bag1.get(4)); + assertEquals((Boolean) false, (Boolean) bag1.get(5)); + assertEquals((Boolean) false, (Boolean) bag1.get(6)); + assertEquals((Boolean) e3, (Boolean) bag1.get(7)); + assertEquals((Boolean) false, (Boolean) bag1.get(8)); + assertEquals((Boolean) false, (Boolean) bag1.get(9)); + assertEquals((Boolean) false, (Boolean) bag1.get(10)); + } + + @Test + public void testCopyPartFrom() { + BooleanBag b0, b1; + boolean e0 = true, e1 = true, e2 = true, e3 = true; + b0 = new BooleanBag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new BooleanBag(); + b1.set(0, e3); + b1.set(33, e0); + b1.copyPartFrom(b0, 14, 1, 33); + assertEquals((Boolean) e1, (Boolean) b1.get(1)); + assertEquals((Boolean) e2, (Boolean) b1.get(8)); + assertEquals((Boolean) e3, (Boolean) b1.get(0)); + assertEquals((Boolean) false, (Boolean) b1.get(32)); + assertEquals((Boolean) false, (Boolean) b1.get(33)); + assertEquals((Boolean) false, (Boolean) b1.get(34)); + assertEquals((Boolean) false, (Boolean) b1.get(35)); + b0 = new BooleanBag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new BooleanBag(); + b1.set(0, e3); + b1.copyPartFrom(b0, 14, 1, 8); + assertEquals((Boolean) e1, (Boolean) b1.get(1)); + assertEquals((Boolean) e2, (Boolean) b1.get(8)); + assertEquals((Boolean) e3, (Boolean) b1.get(0)); + assertEquals((Boolean) false, (Boolean) b1.get(32)); + assertEquals((Boolean) false, (Boolean) b1.get(33)); + assertEquals((Boolean) false, (Boolean) b1.get(34)); + assertEquals((Boolean) false, (Boolean) b1.get(35)); } } diff --git a/retinazer/src/test/java/com/github/antag99/retinazer/util/ByteBagTest.java b/retinazer/src/test/java/com/github/antag99/retinazer/util/ByteBagTest.java index 19d3496..43e0e22 100644 --- a/retinazer/src/test/java/com/github/antag99/retinazer/util/ByteBagTest.java +++ b/retinazer/src/test/java/com/github/antag99/retinazer/util/ByteBagTest.java @@ -266,25 +266,140 @@ public void testClear() { @Test public void testCopyFrom() { + // Test copyFrom(bag) and copyFrom(bag, clearExceeding) ByteBag bag0, bag1; + byte e0 = (byte) 1, e1 = (byte) 1, e2 = (byte) 1, e3 = (byte) 1; bag0 = new ByteBag(); - bag0.set(0, (byte) 1); - bag0.set(5, (byte) 1); - + bag0.set(0, e0); + bag0.set(3, e1); + bag0.set(9, e2); bag1 = new ByteBag(); - bag1.set(9, (byte) 1); - + bag1.copyFrom(bag0); + assertEquals((Byte) e0, (Byte) bag1.get(0)); + assertEquals((Byte) e1, (Byte) bag1.get(3)); + assertEquals((Byte) e2, (Byte) bag1.get(9)); + bag1 = new ByteBag(); + bag1.set(53, e3); bag1.copyFrom(bag0, false); - assertNotEquals((Byte) (byte) 0, (Byte) bag1.get(0)); - assertNotEquals((Byte) (byte) 0, (Byte) bag1.get(5)); - assertNotEquals((Byte) (byte) 0, (Byte) bag1.get(9)); + assertEquals((Byte) e0, (Byte) bag1.get(0)); + assertEquals((Byte) e1, (Byte) bag1.get(3)); + assertEquals((Byte) e2, (Byte) bag1.get(9)); + assertEquals((Byte) e3, (Byte) bag1.get(53)); + bag1 = new ByteBag(); + bag1.set(53, e3); + bag1.copyFrom(bag0, true); + assertEquals((Byte) e0, (Byte) bag1.get(0)); + assertEquals((Byte) e1, (Byte) bag1.get(3)); + assertEquals((Byte) e2, (Byte) bag1.get(9)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(53)); - bag1.copyFrom(bag0); - assertNotEquals((Byte) (byte) 0, (Byte) bag1.get(0)); - assertNotEquals((Byte) (byte) 0, (Byte) bag1.get(5)); + // Test copyFrom(bag, length) and copyFrom(bag, length, clearExceeding) + bag0 = new ByteBag(); + bag0.set(4, e0); + bag0.set(7, e1); + bag1 = new ByteBag(); + bag1.copyFrom(bag0, 3); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(0)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(1)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(2)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(3)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(4)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(5)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(6)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(7)); + bag1 = new ByteBag(); + bag1.copyFrom(bag0, 5); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(0)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(1)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(2)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(3)); + assertEquals((Byte) e0, (Byte) bag1.get(4)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(5)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(6)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(7)); + bag1 = new ByteBag(); + bag1.set(8, e2); + bag1.copyFrom(bag0, 8, true); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(0)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(1)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(2)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(3)); + assertEquals((Byte) e0, (Byte) bag1.get(4)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(5)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(6)); + assertEquals((Byte) e1, (Byte) bag1.get(7)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(8)); assertEquals((Byte) (byte) 0, (Byte) bag1.get(9)); - bag0.copyFrom(bag1); + // Test copyFrom(bag, fromOffset, length) and copyFrom(bag, fromOffset, length, clearExceeding) + bag0 = new ByteBag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(6, e2); + bag1 = new ByteBag(); + bag1.copyFrom(bag0, 3, 2); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(0)); + assertEquals((Byte) e1, (Byte) bag1.get(1)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(2)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(3)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(4)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(5)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(6)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(7)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(8)); + bag0 = new ByteBag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(10, e2); + bag1 = new ByteBag(); + bag1.set(7, e3); + bag1.copyFrom(bag0, 3, 2, false); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(0)); + assertEquals((Byte) e1, (Byte) bag1.get(1)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(2)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(3)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(4)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(5)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(6)); + assertEquals((Byte) e3, (Byte) bag1.get(7)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(8)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(9)); + assertEquals((Byte) (byte) 0, (Byte) bag1.get(10)); + } + + @Test + public void testCopyPartFrom() { + ByteBag b0, b1; + byte e0 = (byte) 1, e1 = (byte) 1, e2 = (byte) 1, e3 = (byte) 1; + b0 = new ByteBag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new ByteBag(); + b1.set(0, e3); + b1.set(33, e0); + b1.copyPartFrom(b0, 14, 1, 33); + assertEquals((Byte) e1, (Byte) b1.get(1)); + assertEquals((Byte) e2, (Byte) b1.get(8)); + assertEquals((Byte) e3, (Byte) b1.get(0)); + assertEquals((Byte) (byte) 0, (Byte) b1.get(32)); + assertEquals((Byte) (byte) 0, (Byte) b1.get(33)); + assertEquals((Byte) (byte) 0, (Byte) b1.get(34)); + assertEquals((Byte) (byte) 0, (Byte) b1.get(35)); + b0 = new ByteBag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new ByteBag(); + b1.set(0, e3); + b1.copyPartFrom(b0, 14, 1, 8); + assertEquals((Byte) e1, (Byte) b1.get(1)); + assertEquals((Byte) e2, (Byte) b1.get(8)); + assertEquals((Byte) e3, (Byte) b1.get(0)); + assertEquals((Byte) (byte) 0, (Byte) b1.get(32)); + assertEquals((Byte) (byte) 0, (Byte) b1.get(33)); + assertEquals((Byte) (byte) 0, (Byte) b1.get(34)); + assertEquals((Byte) (byte) 0, (Byte) b1.get(35)); } } diff --git a/retinazer/src/test/java/com/github/antag99/retinazer/util/CharBagTest.java b/retinazer/src/test/java/com/github/antag99/retinazer/util/CharBagTest.java index 5e6ad8b..3253631 100644 --- a/retinazer/src/test/java/com/github/antag99/retinazer/util/CharBagTest.java +++ b/retinazer/src/test/java/com/github/antag99/retinazer/util/CharBagTest.java @@ -266,25 +266,140 @@ public void testClear() { @Test public void testCopyFrom() { + // Test copyFrom(bag) and copyFrom(bag, clearExceeding) CharBag bag0, bag1; + char e0 = (char) 1, e1 = (char) 1, e2 = (char) 1, e3 = (char) 1; bag0 = new CharBag(); - bag0.set(0, (char) 1); - bag0.set(5, (char) 1); - + bag0.set(0, e0); + bag0.set(3, e1); + bag0.set(9, e2); bag1 = new CharBag(); - bag1.set(9, (char) 1); - + bag1.copyFrom(bag0); + assertEquals((Character) e0, (Character) bag1.get(0)); + assertEquals((Character) e1, (Character) bag1.get(3)); + assertEquals((Character) e2, (Character) bag1.get(9)); + bag1 = new CharBag(); + bag1.set(53, e3); bag1.copyFrom(bag0, false); - assertNotEquals((Character) (char) 0, (Character) bag1.get(0)); - assertNotEquals((Character) (char) 0, (Character) bag1.get(5)); - assertNotEquals((Character) (char) 0, (Character) bag1.get(9)); + assertEquals((Character) e0, (Character) bag1.get(0)); + assertEquals((Character) e1, (Character) bag1.get(3)); + assertEquals((Character) e2, (Character) bag1.get(9)); + assertEquals((Character) e3, (Character) bag1.get(53)); + bag1 = new CharBag(); + bag1.set(53, e3); + bag1.copyFrom(bag0, true); + assertEquals((Character) e0, (Character) bag1.get(0)); + assertEquals((Character) e1, (Character) bag1.get(3)); + assertEquals((Character) e2, (Character) bag1.get(9)); + assertEquals((Character) (char) 0, (Character) bag1.get(53)); - bag1.copyFrom(bag0); - assertNotEquals((Character) (char) 0, (Character) bag1.get(0)); - assertNotEquals((Character) (char) 0, (Character) bag1.get(5)); + // Test copyFrom(bag, length) and copyFrom(bag, length, clearExceeding) + bag0 = new CharBag(); + bag0.set(4, e0); + bag0.set(7, e1); + bag1 = new CharBag(); + bag1.copyFrom(bag0, 3); + assertEquals((Character) (char) 0, (Character) bag1.get(0)); + assertEquals((Character) (char) 0, (Character) bag1.get(1)); + assertEquals((Character) (char) 0, (Character) bag1.get(2)); + assertEquals((Character) (char) 0, (Character) bag1.get(3)); + assertEquals((Character) (char) 0, (Character) bag1.get(4)); + assertEquals((Character) (char) 0, (Character) bag1.get(5)); + assertEquals((Character) (char) 0, (Character) bag1.get(6)); + assertEquals((Character) (char) 0, (Character) bag1.get(7)); + bag1 = new CharBag(); + bag1.copyFrom(bag0, 5); + assertEquals((Character) (char) 0, (Character) bag1.get(0)); + assertEquals((Character) (char) 0, (Character) bag1.get(1)); + assertEquals((Character) (char) 0, (Character) bag1.get(2)); + assertEquals((Character) (char) 0, (Character) bag1.get(3)); + assertEquals((Character) e0, (Character) bag1.get(4)); + assertEquals((Character) (char) 0, (Character) bag1.get(5)); + assertEquals((Character) (char) 0, (Character) bag1.get(6)); + assertEquals((Character) (char) 0, (Character) bag1.get(7)); + bag1 = new CharBag(); + bag1.set(8, e2); + bag1.copyFrom(bag0, 8, true); + assertEquals((Character) (char) 0, (Character) bag1.get(0)); + assertEquals((Character) (char) 0, (Character) bag1.get(1)); + assertEquals((Character) (char) 0, (Character) bag1.get(2)); + assertEquals((Character) (char) 0, (Character) bag1.get(3)); + assertEquals((Character) e0, (Character) bag1.get(4)); + assertEquals((Character) (char) 0, (Character) bag1.get(5)); + assertEquals((Character) (char) 0, (Character) bag1.get(6)); + assertEquals((Character) e1, (Character) bag1.get(7)); + assertEquals((Character) (char) 0, (Character) bag1.get(8)); assertEquals((Character) (char) 0, (Character) bag1.get(9)); - bag0.copyFrom(bag1); + // Test copyFrom(bag, fromOffset, length) and copyFrom(bag, fromOffset, length, clearExceeding) + bag0 = new CharBag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(6, e2); + bag1 = new CharBag(); + bag1.copyFrom(bag0, 3, 2); + assertEquals((Character) (char) 0, (Character) bag1.get(0)); + assertEquals((Character) e1, (Character) bag1.get(1)); + assertEquals((Character) (char) 0, (Character) bag1.get(2)); + assertEquals((Character) (char) 0, (Character) bag1.get(3)); + assertEquals((Character) (char) 0, (Character) bag1.get(4)); + assertEquals((Character) (char) 0, (Character) bag1.get(5)); + assertEquals((Character) (char) 0, (Character) bag1.get(6)); + assertEquals((Character) (char) 0, (Character) bag1.get(7)); + assertEquals((Character) (char) 0, (Character) bag1.get(8)); + bag0 = new CharBag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(10, e2); + bag1 = new CharBag(); + bag1.set(7, e3); + bag1.copyFrom(bag0, 3, 2, false); + assertEquals((Character) (char) 0, (Character) bag1.get(0)); + assertEquals((Character) e1, (Character) bag1.get(1)); + assertEquals((Character) (char) 0, (Character) bag1.get(2)); + assertEquals((Character) (char) 0, (Character) bag1.get(3)); + assertEquals((Character) (char) 0, (Character) bag1.get(4)); + assertEquals((Character) (char) 0, (Character) bag1.get(5)); + assertEquals((Character) (char) 0, (Character) bag1.get(6)); + assertEquals((Character) e3, (Character) bag1.get(7)); + assertEquals((Character) (char) 0, (Character) bag1.get(8)); + assertEquals((Character) (char) 0, (Character) bag1.get(9)); + assertEquals((Character) (char) 0, (Character) bag1.get(10)); + } + + @Test + public void testCopyPartFrom() { + CharBag b0, b1; + char e0 = (char) 1, e1 = (char) 1, e2 = (char) 1, e3 = (char) 1; + b0 = new CharBag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new CharBag(); + b1.set(0, e3); + b1.set(33, e0); + b1.copyPartFrom(b0, 14, 1, 33); + assertEquals((Character) e1, (Character) b1.get(1)); + assertEquals((Character) e2, (Character) b1.get(8)); + assertEquals((Character) e3, (Character) b1.get(0)); + assertEquals((Character) (char) 0, (Character) b1.get(32)); + assertEquals((Character) (char) 0, (Character) b1.get(33)); + assertEquals((Character) (char) 0, (Character) b1.get(34)); + assertEquals((Character) (char) 0, (Character) b1.get(35)); + b0 = new CharBag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new CharBag(); + b1.set(0, e3); + b1.copyPartFrom(b0, 14, 1, 8); + assertEquals((Character) e1, (Character) b1.get(1)); + assertEquals((Character) e2, (Character) b1.get(8)); + assertEquals((Character) e3, (Character) b1.get(0)); + assertEquals((Character) (char) 0, (Character) b1.get(32)); + assertEquals((Character) (char) 0, (Character) b1.get(33)); + assertEquals((Character) (char) 0, (Character) b1.get(34)); + assertEquals((Character) (char) 0, (Character) b1.get(35)); } } diff --git a/retinazer/src/test/java/com/github/antag99/retinazer/util/DoubleBagTest.java b/retinazer/src/test/java/com/github/antag99/retinazer/util/DoubleBagTest.java index d43dea9..ab5a4a7 100644 --- a/retinazer/src/test/java/com/github/antag99/retinazer/util/DoubleBagTest.java +++ b/retinazer/src/test/java/com/github/antag99/retinazer/util/DoubleBagTest.java @@ -266,25 +266,140 @@ public void testClear() { @Test public void testCopyFrom() { + // Test copyFrom(bag) and copyFrom(bag, clearExceeding) DoubleBag bag0, bag1; + double e0 = 1d, e1 = 1d, e2 = 1d, e3 = 1d; bag0 = new DoubleBag(); - bag0.set(0, 1d); - bag0.set(5, 1d); - + bag0.set(0, e0); + bag0.set(3, e1); + bag0.set(9, e2); bag1 = new DoubleBag(); - bag1.set(9, 1d); - + bag1.copyFrom(bag0); + assertEquals((Double) e0, (Double) bag1.get(0)); + assertEquals((Double) e1, (Double) bag1.get(3)); + assertEquals((Double) e2, (Double) bag1.get(9)); + bag1 = new DoubleBag(); + bag1.set(53, e3); bag1.copyFrom(bag0, false); - assertNotEquals((Double) 0d, (Double) bag1.get(0)); - assertNotEquals((Double) 0d, (Double) bag1.get(5)); - assertNotEquals((Double) 0d, (Double) bag1.get(9)); + assertEquals((Double) e0, (Double) bag1.get(0)); + assertEquals((Double) e1, (Double) bag1.get(3)); + assertEquals((Double) e2, (Double) bag1.get(9)); + assertEquals((Double) e3, (Double) bag1.get(53)); + bag1 = new DoubleBag(); + bag1.set(53, e3); + bag1.copyFrom(bag0, true); + assertEquals((Double) e0, (Double) bag1.get(0)); + assertEquals((Double) e1, (Double) bag1.get(3)); + assertEquals((Double) e2, (Double) bag1.get(9)); + assertEquals((Double) 0d, (Double) bag1.get(53)); - bag1.copyFrom(bag0); - assertNotEquals((Double) 0d, (Double) bag1.get(0)); - assertNotEquals((Double) 0d, (Double) bag1.get(5)); + // Test copyFrom(bag, length) and copyFrom(bag, length, clearExceeding) + bag0 = new DoubleBag(); + bag0.set(4, e0); + bag0.set(7, e1); + bag1 = new DoubleBag(); + bag1.copyFrom(bag0, 3); + assertEquals((Double) 0d, (Double) bag1.get(0)); + assertEquals((Double) 0d, (Double) bag1.get(1)); + assertEquals((Double) 0d, (Double) bag1.get(2)); + assertEquals((Double) 0d, (Double) bag1.get(3)); + assertEquals((Double) 0d, (Double) bag1.get(4)); + assertEquals((Double) 0d, (Double) bag1.get(5)); + assertEquals((Double) 0d, (Double) bag1.get(6)); + assertEquals((Double) 0d, (Double) bag1.get(7)); + bag1 = new DoubleBag(); + bag1.copyFrom(bag0, 5); + assertEquals((Double) 0d, (Double) bag1.get(0)); + assertEquals((Double) 0d, (Double) bag1.get(1)); + assertEquals((Double) 0d, (Double) bag1.get(2)); + assertEquals((Double) 0d, (Double) bag1.get(3)); + assertEquals((Double) e0, (Double) bag1.get(4)); + assertEquals((Double) 0d, (Double) bag1.get(5)); + assertEquals((Double) 0d, (Double) bag1.get(6)); + assertEquals((Double) 0d, (Double) bag1.get(7)); + bag1 = new DoubleBag(); + bag1.set(8, e2); + bag1.copyFrom(bag0, 8, true); + assertEquals((Double) 0d, (Double) bag1.get(0)); + assertEquals((Double) 0d, (Double) bag1.get(1)); + assertEquals((Double) 0d, (Double) bag1.get(2)); + assertEquals((Double) 0d, (Double) bag1.get(3)); + assertEquals((Double) e0, (Double) bag1.get(4)); + assertEquals((Double) 0d, (Double) bag1.get(5)); + assertEquals((Double) 0d, (Double) bag1.get(6)); + assertEquals((Double) e1, (Double) bag1.get(7)); + assertEquals((Double) 0d, (Double) bag1.get(8)); assertEquals((Double) 0d, (Double) bag1.get(9)); - bag0.copyFrom(bag1); + // Test copyFrom(bag, fromOffset, length) and copyFrom(bag, fromOffset, length, clearExceeding) + bag0 = new DoubleBag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(6, e2); + bag1 = new DoubleBag(); + bag1.copyFrom(bag0, 3, 2); + assertEquals((Double) 0d, (Double) bag1.get(0)); + assertEquals((Double) e1, (Double) bag1.get(1)); + assertEquals((Double) 0d, (Double) bag1.get(2)); + assertEquals((Double) 0d, (Double) bag1.get(3)); + assertEquals((Double) 0d, (Double) bag1.get(4)); + assertEquals((Double) 0d, (Double) bag1.get(5)); + assertEquals((Double) 0d, (Double) bag1.get(6)); + assertEquals((Double) 0d, (Double) bag1.get(7)); + assertEquals((Double) 0d, (Double) bag1.get(8)); + bag0 = new DoubleBag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(10, e2); + bag1 = new DoubleBag(); + bag1.set(7, e3); + bag1.copyFrom(bag0, 3, 2, false); + assertEquals((Double) 0d, (Double) bag1.get(0)); + assertEquals((Double) e1, (Double) bag1.get(1)); + assertEquals((Double) 0d, (Double) bag1.get(2)); + assertEquals((Double) 0d, (Double) bag1.get(3)); + assertEquals((Double) 0d, (Double) bag1.get(4)); + assertEquals((Double) 0d, (Double) bag1.get(5)); + assertEquals((Double) 0d, (Double) bag1.get(6)); + assertEquals((Double) e3, (Double) bag1.get(7)); + assertEquals((Double) 0d, (Double) bag1.get(8)); + assertEquals((Double) 0d, (Double) bag1.get(9)); + assertEquals((Double) 0d, (Double) bag1.get(10)); + } + + @Test + public void testCopyPartFrom() { + DoubleBag b0, b1; + double e0 = 1d, e1 = 1d, e2 = 1d, e3 = 1d; + b0 = new DoubleBag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new DoubleBag(); + b1.set(0, e3); + b1.set(33, e0); + b1.copyPartFrom(b0, 14, 1, 33); + assertEquals((Double) e1, (Double) b1.get(1)); + assertEquals((Double) e2, (Double) b1.get(8)); + assertEquals((Double) e3, (Double) b1.get(0)); + assertEquals((Double) 0d, (Double) b1.get(32)); + assertEquals((Double) 0d, (Double) b1.get(33)); + assertEquals((Double) 0d, (Double) b1.get(34)); + assertEquals((Double) 0d, (Double) b1.get(35)); + b0 = new DoubleBag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new DoubleBag(); + b1.set(0, e3); + b1.copyPartFrom(b0, 14, 1, 8); + assertEquals((Double) e1, (Double) b1.get(1)); + assertEquals((Double) e2, (Double) b1.get(8)); + assertEquals((Double) e3, (Double) b1.get(0)); + assertEquals((Double) 0d, (Double) b1.get(32)); + assertEquals((Double) 0d, (Double) b1.get(33)); + assertEquals((Double) 0d, (Double) b1.get(34)); + assertEquals((Double) 0d, (Double) b1.get(35)); } } diff --git a/retinazer/src/test/java/com/github/antag99/retinazer/util/FloatBagTest.java b/retinazer/src/test/java/com/github/antag99/retinazer/util/FloatBagTest.java index 6497403..3dc57cd 100644 --- a/retinazer/src/test/java/com/github/antag99/retinazer/util/FloatBagTest.java +++ b/retinazer/src/test/java/com/github/antag99/retinazer/util/FloatBagTest.java @@ -266,25 +266,140 @@ public void testClear() { @Test public void testCopyFrom() { + // Test copyFrom(bag) and copyFrom(bag, clearExceeding) FloatBag bag0, bag1; + float e0 = 1f, e1 = 1f, e2 = 1f, e3 = 1f; bag0 = new FloatBag(); - bag0.set(0, 1f); - bag0.set(5, 1f); - + bag0.set(0, e0); + bag0.set(3, e1); + bag0.set(9, e2); bag1 = new FloatBag(); - bag1.set(9, 1f); - + bag1.copyFrom(bag0); + assertEquals((Float) e0, (Float) bag1.get(0)); + assertEquals((Float) e1, (Float) bag1.get(3)); + assertEquals((Float) e2, (Float) bag1.get(9)); + bag1 = new FloatBag(); + bag1.set(53, e3); bag1.copyFrom(bag0, false); - assertNotEquals((Float) 0f, (Float) bag1.get(0)); - assertNotEquals((Float) 0f, (Float) bag1.get(5)); - assertNotEquals((Float) 0f, (Float) bag1.get(9)); + assertEquals((Float) e0, (Float) bag1.get(0)); + assertEquals((Float) e1, (Float) bag1.get(3)); + assertEquals((Float) e2, (Float) bag1.get(9)); + assertEquals((Float) e3, (Float) bag1.get(53)); + bag1 = new FloatBag(); + bag1.set(53, e3); + bag1.copyFrom(bag0, true); + assertEquals((Float) e0, (Float) bag1.get(0)); + assertEquals((Float) e1, (Float) bag1.get(3)); + assertEquals((Float) e2, (Float) bag1.get(9)); + assertEquals((Float) 0f, (Float) bag1.get(53)); - bag1.copyFrom(bag0); - assertNotEquals((Float) 0f, (Float) bag1.get(0)); - assertNotEquals((Float) 0f, (Float) bag1.get(5)); + // Test copyFrom(bag, length) and copyFrom(bag, length, clearExceeding) + bag0 = new FloatBag(); + bag0.set(4, e0); + bag0.set(7, e1); + bag1 = new FloatBag(); + bag1.copyFrom(bag0, 3); + assertEquals((Float) 0f, (Float) bag1.get(0)); + assertEquals((Float) 0f, (Float) bag1.get(1)); + assertEquals((Float) 0f, (Float) bag1.get(2)); + assertEquals((Float) 0f, (Float) bag1.get(3)); + assertEquals((Float) 0f, (Float) bag1.get(4)); + assertEquals((Float) 0f, (Float) bag1.get(5)); + assertEquals((Float) 0f, (Float) bag1.get(6)); + assertEquals((Float) 0f, (Float) bag1.get(7)); + bag1 = new FloatBag(); + bag1.copyFrom(bag0, 5); + assertEquals((Float) 0f, (Float) bag1.get(0)); + assertEquals((Float) 0f, (Float) bag1.get(1)); + assertEquals((Float) 0f, (Float) bag1.get(2)); + assertEquals((Float) 0f, (Float) bag1.get(3)); + assertEquals((Float) e0, (Float) bag1.get(4)); + assertEquals((Float) 0f, (Float) bag1.get(5)); + assertEquals((Float) 0f, (Float) bag1.get(6)); + assertEquals((Float) 0f, (Float) bag1.get(7)); + bag1 = new FloatBag(); + bag1.set(8, e2); + bag1.copyFrom(bag0, 8, true); + assertEquals((Float) 0f, (Float) bag1.get(0)); + assertEquals((Float) 0f, (Float) bag1.get(1)); + assertEquals((Float) 0f, (Float) bag1.get(2)); + assertEquals((Float) 0f, (Float) bag1.get(3)); + assertEquals((Float) e0, (Float) bag1.get(4)); + assertEquals((Float) 0f, (Float) bag1.get(5)); + assertEquals((Float) 0f, (Float) bag1.get(6)); + assertEquals((Float) e1, (Float) bag1.get(7)); + assertEquals((Float) 0f, (Float) bag1.get(8)); assertEquals((Float) 0f, (Float) bag1.get(9)); - bag0.copyFrom(bag1); + // Test copyFrom(bag, fromOffset, length) and copyFrom(bag, fromOffset, length, clearExceeding) + bag0 = new FloatBag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(6, e2); + bag1 = new FloatBag(); + bag1.copyFrom(bag0, 3, 2); + assertEquals((Float) 0f, (Float) bag1.get(0)); + assertEquals((Float) e1, (Float) bag1.get(1)); + assertEquals((Float) 0f, (Float) bag1.get(2)); + assertEquals((Float) 0f, (Float) bag1.get(3)); + assertEquals((Float) 0f, (Float) bag1.get(4)); + assertEquals((Float) 0f, (Float) bag1.get(5)); + assertEquals((Float) 0f, (Float) bag1.get(6)); + assertEquals((Float) 0f, (Float) bag1.get(7)); + assertEquals((Float) 0f, (Float) bag1.get(8)); + bag0 = new FloatBag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(10, e2); + bag1 = new FloatBag(); + bag1.set(7, e3); + bag1.copyFrom(bag0, 3, 2, false); + assertEquals((Float) 0f, (Float) bag1.get(0)); + assertEquals((Float) e1, (Float) bag1.get(1)); + assertEquals((Float) 0f, (Float) bag1.get(2)); + assertEquals((Float) 0f, (Float) bag1.get(3)); + assertEquals((Float) 0f, (Float) bag1.get(4)); + assertEquals((Float) 0f, (Float) bag1.get(5)); + assertEquals((Float) 0f, (Float) bag1.get(6)); + assertEquals((Float) e3, (Float) bag1.get(7)); + assertEquals((Float) 0f, (Float) bag1.get(8)); + assertEquals((Float) 0f, (Float) bag1.get(9)); + assertEquals((Float) 0f, (Float) bag1.get(10)); + } + + @Test + public void testCopyPartFrom() { + FloatBag b0, b1; + float e0 = 1f, e1 = 1f, e2 = 1f, e3 = 1f; + b0 = new FloatBag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new FloatBag(); + b1.set(0, e3); + b1.set(33, e0); + b1.copyPartFrom(b0, 14, 1, 33); + assertEquals((Float) e1, (Float) b1.get(1)); + assertEquals((Float) e2, (Float) b1.get(8)); + assertEquals((Float) e3, (Float) b1.get(0)); + assertEquals((Float) 0f, (Float) b1.get(32)); + assertEquals((Float) 0f, (Float) b1.get(33)); + assertEquals((Float) 0f, (Float) b1.get(34)); + assertEquals((Float) 0f, (Float) b1.get(35)); + b0 = new FloatBag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new FloatBag(); + b1.set(0, e3); + b1.copyPartFrom(b0, 14, 1, 8); + assertEquals((Float) e1, (Float) b1.get(1)); + assertEquals((Float) e2, (Float) b1.get(8)); + assertEquals((Float) e3, (Float) b1.get(0)); + assertEquals((Float) 0f, (Float) b1.get(32)); + assertEquals((Float) 0f, (Float) b1.get(33)); + assertEquals((Float) 0f, (Float) b1.get(34)); + assertEquals((Float) 0f, (Float) b1.get(35)); } } diff --git a/retinazer/src/test/java/com/github/antag99/retinazer/util/IntBagTest.java b/retinazer/src/test/java/com/github/antag99/retinazer/util/IntBagTest.java index 64fea98..6fa9afd 100644 --- a/retinazer/src/test/java/com/github/antag99/retinazer/util/IntBagTest.java +++ b/retinazer/src/test/java/com/github/antag99/retinazer/util/IntBagTest.java @@ -266,25 +266,140 @@ public void testClear() { @Test public void testCopyFrom() { + // Test copyFrom(bag) and copyFrom(bag, clearExceeding) IntBag bag0, bag1; + int e0 = 1, e1 = 1, e2 = 1, e3 = 1; bag0 = new IntBag(); - bag0.set(0, 1); - bag0.set(5, 1); - + bag0.set(0, e0); + bag0.set(3, e1); + bag0.set(9, e2); bag1 = new IntBag(); - bag1.set(9, 1); - + bag1.copyFrom(bag0); + assertEquals((Integer) e0, (Integer) bag1.get(0)); + assertEquals((Integer) e1, (Integer) bag1.get(3)); + assertEquals((Integer) e2, (Integer) bag1.get(9)); + bag1 = new IntBag(); + bag1.set(53, e3); bag1.copyFrom(bag0, false); - assertNotEquals((Integer) 0, (Integer) bag1.get(0)); - assertNotEquals((Integer) 0, (Integer) bag1.get(5)); - assertNotEquals((Integer) 0, (Integer) bag1.get(9)); + assertEquals((Integer) e0, (Integer) bag1.get(0)); + assertEquals((Integer) e1, (Integer) bag1.get(3)); + assertEquals((Integer) e2, (Integer) bag1.get(9)); + assertEquals((Integer) e3, (Integer) bag1.get(53)); + bag1 = new IntBag(); + bag1.set(53, e3); + bag1.copyFrom(bag0, true); + assertEquals((Integer) e0, (Integer) bag1.get(0)); + assertEquals((Integer) e1, (Integer) bag1.get(3)); + assertEquals((Integer) e2, (Integer) bag1.get(9)); + assertEquals((Integer) 0, (Integer) bag1.get(53)); - bag1.copyFrom(bag0); - assertNotEquals((Integer) 0, (Integer) bag1.get(0)); - assertNotEquals((Integer) 0, (Integer) bag1.get(5)); + // Test copyFrom(bag, length) and copyFrom(bag, length, clearExceeding) + bag0 = new IntBag(); + bag0.set(4, e0); + bag0.set(7, e1); + bag1 = new IntBag(); + bag1.copyFrom(bag0, 3); + assertEquals((Integer) 0, (Integer) bag1.get(0)); + assertEquals((Integer) 0, (Integer) bag1.get(1)); + assertEquals((Integer) 0, (Integer) bag1.get(2)); + assertEquals((Integer) 0, (Integer) bag1.get(3)); + assertEquals((Integer) 0, (Integer) bag1.get(4)); + assertEquals((Integer) 0, (Integer) bag1.get(5)); + assertEquals((Integer) 0, (Integer) bag1.get(6)); + assertEquals((Integer) 0, (Integer) bag1.get(7)); + bag1 = new IntBag(); + bag1.copyFrom(bag0, 5); + assertEquals((Integer) 0, (Integer) bag1.get(0)); + assertEquals((Integer) 0, (Integer) bag1.get(1)); + assertEquals((Integer) 0, (Integer) bag1.get(2)); + assertEquals((Integer) 0, (Integer) bag1.get(3)); + assertEquals((Integer) e0, (Integer) bag1.get(4)); + assertEquals((Integer) 0, (Integer) bag1.get(5)); + assertEquals((Integer) 0, (Integer) bag1.get(6)); + assertEquals((Integer) 0, (Integer) bag1.get(7)); + bag1 = new IntBag(); + bag1.set(8, e2); + bag1.copyFrom(bag0, 8, true); + assertEquals((Integer) 0, (Integer) bag1.get(0)); + assertEquals((Integer) 0, (Integer) bag1.get(1)); + assertEquals((Integer) 0, (Integer) bag1.get(2)); + assertEquals((Integer) 0, (Integer) bag1.get(3)); + assertEquals((Integer) e0, (Integer) bag1.get(4)); + assertEquals((Integer) 0, (Integer) bag1.get(5)); + assertEquals((Integer) 0, (Integer) bag1.get(6)); + assertEquals((Integer) e1, (Integer) bag1.get(7)); + assertEquals((Integer) 0, (Integer) bag1.get(8)); assertEquals((Integer) 0, (Integer) bag1.get(9)); - bag0.copyFrom(bag1); + // Test copyFrom(bag, fromOffset, length) and copyFrom(bag, fromOffset, length, clearExceeding) + bag0 = new IntBag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(6, e2); + bag1 = new IntBag(); + bag1.copyFrom(bag0, 3, 2); + assertEquals((Integer) 0, (Integer) bag1.get(0)); + assertEquals((Integer) e1, (Integer) bag1.get(1)); + assertEquals((Integer) 0, (Integer) bag1.get(2)); + assertEquals((Integer) 0, (Integer) bag1.get(3)); + assertEquals((Integer) 0, (Integer) bag1.get(4)); + assertEquals((Integer) 0, (Integer) bag1.get(5)); + assertEquals((Integer) 0, (Integer) bag1.get(6)); + assertEquals((Integer) 0, (Integer) bag1.get(7)); + assertEquals((Integer) 0, (Integer) bag1.get(8)); + bag0 = new IntBag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(10, e2); + bag1 = new IntBag(); + bag1.set(7, e3); + bag1.copyFrom(bag0, 3, 2, false); + assertEquals((Integer) 0, (Integer) bag1.get(0)); + assertEquals((Integer) e1, (Integer) bag1.get(1)); + assertEquals((Integer) 0, (Integer) bag1.get(2)); + assertEquals((Integer) 0, (Integer) bag1.get(3)); + assertEquals((Integer) 0, (Integer) bag1.get(4)); + assertEquals((Integer) 0, (Integer) bag1.get(5)); + assertEquals((Integer) 0, (Integer) bag1.get(6)); + assertEquals((Integer) e3, (Integer) bag1.get(7)); + assertEquals((Integer) 0, (Integer) bag1.get(8)); + assertEquals((Integer) 0, (Integer) bag1.get(9)); + assertEquals((Integer) 0, (Integer) bag1.get(10)); + } + + @Test + public void testCopyPartFrom() { + IntBag b0, b1; + int e0 = 1, e1 = 1, e2 = 1, e3 = 1; + b0 = new IntBag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new IntBag(); + b1.set(0, e3); + b1.set(33, e0); + b1.copyPartFrom(b0, 14, 1, 33); + assertEquals((Integer) e1, (Integer) b1.get(1)); + assertEquals((Integer) e2, (Integer) b1.get(8)); + assertEquals((Integer) e3, (Integer) b1.get(0)); + assertEquals((Integer) 0, (Integer) b1.get(32)); + assertEquals((Integer) 0, (Integer) b1.get(33)); + assertEquals((Integer) 0, (Integer) b1.get(34)); + assertEquals((Integer) 0, (Integer) b1.get(35)); + b0 = new IntBag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new IntBag(); + b1.set(0, e3); + b1.copyPartFrom(b0, 14, 1, 8); + assertEquals((Integer) e1, (Integer) b1.get(1)); + assertEquals((Integer) e2, (Integer) b1.get(8)); + assertEquals((Integer) e3, (Integer) b1.get(0)); + assertEquals((Integer) 0, (Integer) b1.get(32)); + assertEquals((Integer) 0, (Integer) b1.get(33)); + assertEquals((Integer) 0, (Integer) b1.get(34)); + assertEquals((Integer) 0, (Integer) b1.get(35)); } } diff --git a/retinazer/src/test/java/com/github/antag99/retinazer/util/LongBagTest.java b/retinazer/src/test/java/com/github/antag99/retinazer/util/LongBagTest.java index 1514b9b..3af1d51 100644 --- a/retinazer/src/test/java/com/github/antag99/retinazer/util/LongBagTest.java +++ b/retinazer/src/test/java/com/github/antag99/retinazer/util/LongBagTest.java @@ -266,25 +266,140 @@ public void testClear() { @Test public void testCopyFrom() { + // Test copyFrom(bag) and copyFrom(bag, clearExceeding) LongBag bag0, bag1; + long e0 = 1L, e1 = 1L, e2 = 1L, e3 = 1L; bag0 = new LongBag(); - bag0.set(0, 1L); - bag0.set(5, 1L); - + bag0.set(0, e0); + bag0.set(3, e1); + bag0.set(9, e2); bag1 = new LongBag(); - bag1.set(9, 1L); - + bag1.copyFrom(bag0); + assertEquals((Long) e0, (Long) bag1.get(0)); + assertEquals((Long) e1, (Long) bag1.get(3)); + assertEquals((Long) e2, (Long) bag1.get(9)); + bag1 = new LongBag(); + bag1.set(53, e3); bag1.copyFrom(bag0, false); - assertNotEquals((Long) 0L, (Long) bag1.get(0)); - assertNotEquals((Long) 0L, (Long) bag1.get(5)); - assertNotEquals((Long) 0L, (Long) bag1.get(9)); + assertEquals((Long) e0, (Long) bag1.get(0)); + assertEquals((Long) e1, (Long) bag1.get(3)); + assertEquals((Long) e2, (Long) bag1.get(9)); + assertEquals((Long) e3, (Long) bag1.get(53)); + bag1 = new LongBag(); + bag1.set(53, e3); + bag1.copyFrom(bag0, true); + assertEquals((Long) e0, (Long) bag1.get(0)); + assertEquals((Long) e1, (Long) bag1.get(3)); + assertEquals((Long) e2, (Long) bag1.get(9)); + assertEquals((Long) 0L, (Long) bag1.get(53)); - bag1.copyFrom(bag0); - assertNotEquals((Long) 0L, (Long) bag1.get(0)); - assertNotEquals((Long) 0L, (Long) bag1.get(5)); + // Test copyFrom(bag, length) and copyFrom(bag, length, clearExceeding) + bag0 = new LongBag(); + bag0.set(4, e0); + bag0.set(7, e1); + bag1 = new LongBag(); + bag1.copyFrom(bag0, 3); + assertEquals((Long) 0L, (Long) bag1.get(0)); + assertEquals((Long) 0L, (Long) bag1.get(1)); + assertEquals((Long) 0L, (Long) bag1.get(2)); + assertEquals((Long) 0L, (Long) bag1.get(3)); + assertEquals((Long) 0L, (Long) bag1.get(4)); + assertEquals((Long) 0L, (Long) bag1.get(5)); + assertEquals((Long) 0L, (Long) bag1.get(6)); + assertEquals((Long) 0L, (Long) bag1.get(7)); + bag1 = new LongBag(); + bag1.copyFrom(bag0, 5); + assertEquals((Long) 0L, (Long) bag1.get(0)); + assertEquals((Long) 0L, (Long) bag1.get(1)); + assertEquals((Long) 0L, (Long) bag1.get(2)); + assertEquals((Long) 0L, (Long) bag1.get(3)); + assertEquals((Long) e0, (Long) bag1.get(4)); + assertEquals((Long) 0L, (Long) bag1.get(5)); + assertEquals((Long) 0L, (Long) bag1.get(6)); + assertEquals((Long) 0L, (Long) bag1.get(7)); + bag1 = new LongBag(); + bag1.set(8, e2); + bag1.copyFrom(bag0, 8, true); + assertEquals((Long) 0L, (Long) bag1.get(0)); + assertEquals((Long) 0L, (Long) bag1.get(1)); + assertEquals((Long) 0L, (Long) bag1.get(2)); + assertEquals((Long) 0L, (Long) bag1.get(3)); + assertEquals((Long) e0, (Long) bag1.get(4)); + assertEquals((Long) 0L, (Long) bag1.get(5)); + assertEquals((Long) 0L, (Long) bag1.get(6)); + assertEquals((Long) e1, (Long) bag1.get(7)); + assertEquals((Long) 0L, (Long) bag1.get(8)); assertEquals((Long) 0L, (Long) bag1.get(9)); - bag0.copyFrom(bag1); + // Test copyFrom(bag, fromOffset, length) and copyFrom(bag, fromOffset, length, clearExceeding) + bag0 = new LongBag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(6, e2); + bag1 = new LongBag(); + bag1.copyFrom(bag0, 3, 2); + assertEquals((Long) 0L, (Long) bag1.get(0)); + assertEquals((Long) e1, (Long) bag1.get(1)); + assertEquals((Long) 0L, (Long) bag1.get(2)); + assertEquals((Long) 0L, (Long) bag1.get(3)); + assertEquals((Long) 0L, (Long) bag1.get(4)); + assertEquals((Long) 0L, (Long) bag1.get(5)); + assertEquals((Long) 0L, (Long) bag1.get(6)); + assertEquals((Long) 0L, (Long) bag1.get(7)); + assertEquals((Long) 0L, (Long) bag1.get(8)); + bag0 = new LongBag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(10, e2); + bag1 = new LongBag(); + bag1.set(7, e3); + bag1.copyFrom(bag0, 3, 2, false); + assertEquals((Long) 0L, (Long) bag1.get(0)); + assertEquals((Long) e1, (Long) bag1.get(1)); + assertEquals((Long) 0L, (Long) bag1.get(2)); + assertEquals((Long) 0L, (Long) bag1.get(3)); + assertEquals((Long) 0L, (Long) bag1.get(4)); + assertEquals((Long) 0L, (Long) bag1.get(5)); + assertEquals((Long) 0L, (Long) bag1.get(6)); + assertEquals((Long) e3, (Long) bag1.get(7)); + assertEquals((Long) 0L, (Long) bag1.get(8)); + assertEquals((Long) 0L, (Long) bag1.get(9)); + assertEquals((Long) 0L, (Long) bag1.get(10)); + } + + @Test + public void testCopyPartFrom() { + LongBag b0, b1; + long e0 = 1L, e1 = 1L, e2 = 1L, e3 = 1L; + b0 = new LongBag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new LongBag(); + b1.set(0, e3); + b1.set(33, e0); + b1.copyPartFrom(b0, 14, 1, 33); + assertEquals((Long) e1, (Long) b1.get(1)); + assertEquals((Long) e2, (Long) b1.get(8)); + assertEquals((Long) e3, (Long) b1.get(0)); + assertEquals((Long) 0L, (Long) b1.get(32)); + assertEquals((Long) 0L, (Long) b1.get(33)); + assertEquals((Long) 0L, (Long) b1.get(34)); + assertEquals((Long) 0L, (Long) b1.get(35)); + b0 = new LongBag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new LongBag(); + b1.set(0, e3); + b1.copyPartFrom(b0, 14, 1, 8); + assertEquals((Long) e1, (Long) b1.get(1)); + assertEquals((Long) e2, (Long) b1.get(8)); + assertEquals((Long) e3, (Long) b1.get(0)); + assertEquals((Long) 0L, (Long) b1.get(32)); + assertEquals((Long) 0L, (Long) b1.get(33)); + assertEquals((Long) 0L, (Long) b1.get(34)); + assertEquals((Long) 0L, (Long) b1.get(35)); } } diff --git a/retinazer/src/test/java/com/github/antag99/retinazer/util/ShortBagTest.java b/retinazer/src/test/java/com/github/antag99/retinazer/util/ShortBagTest.java index bbef176..8cbdc76 100644 --- a/retinazer/src/test/java/com/github/antag99/retinazer/util/ShortBagTest.java +++ b/retinazer/src/test/java/com/github/antag99/retinazer/util/ShortBagTest.java @@ -266,25 +266,140 @@ public void testClear() { @Test public void testCopyFrom() { + // Test copyFrom(bag) and copyFrom(bag, clearExceeding) ShortBag bag0, bag1; + short e0 = (short) 1, e1 = (short) 1, e2 = (short) 1, e3 = (short) 1; bag0 = new ShortBag(); - bag0.set(0, (short) 1); - bag0.set(5, (short) 1); - + bag0.set(0, e0); + bag0.set(3, e1); + bag0.set(9, e2); bag1 = new ShortBag(); - bag1.set(9, (short) 1); - + bag1.copyFrom(bag0); + assertEquals((Short) e0, (Short) bag1.get(0)); + assertEquals((Short) e1, (Short) bag1.get(3)); + assertEquals((Short) e2, (Short) bag1.get(9)); + bag1 = new ShortBag(); + bag1.set(53, e3); bag1.copyFrom(bag0, false); - assertNotEquals((Short) (short) 0, (Short) bag1.get(0)); - assertNotEquals((Short) (short) 0, (Short) bag1.get(5)); - assertNotEquals((Short) (short) 0, (Short) bag1.get(9)); + assertEquals((Short) e0, (Short) bag1.get(0)); + assertEquals((Short) e1, (Short) bag1.get(3)); + assertEquals((Short) e2, (Short) bag1.get(9)); + assertEquals((Short) e3, (Short) bag1.get(53)); + bag1 = new ShortBag(); + bag1.set(53, e3); + bag1.copyFrom(bag0, true); + assertEquals((Short) e0, (Short) bag1.get(0)); + assertEquals((Short) e1, (Short) bag1.get(3)); + assertEquals((Short) e2, (Short) bag1.get(9)); + assertEquals((Short) (short) 0, (Short) bag1.get(53)); - bag1.copyFrom(bag0); - assertNotEquals((Short) (short) 0, (Short) bag1.get(0)); - assertNotEquals((Short) (short) 0, (Short) bag1.get(5)); + // Test copyFrom(bag, length) and copyFrom(bag, length, clearExceeding) + bag0 = new ShortBag(); + bag0.set(4, e0); + bag0.set(7, e1); + bag1 = new ShortBag(); + bag1.copyFrom(bag0, 3); + assertEquals((Short) (short) 0, (Short) bag1.get(0)); + assertEquals((Short) (short) 0, (Short) bag1.get(1)); + assertEquals((Short) (short) 0, (Short) bag1.get(2)); + assertEquals((Short) (short) 0, (Short) bag1.get(3)); + assertEquals((Short) (short) 0, (Short) bag1.get(4)); + assertEquals((Short) (short) 0, (Short) bag1.get(5)); + assertEquals((Short) (short) 0, (Short) bag1.get(6)); + assertEquals((Short) (short) 0, (Short) bag1.get(7)); + bag1 = new ShortBag(); + bag1.copyFrom(bag0, 5); + assertEquals((Short) (short) 0, (Short) bag1.get(0)); + assertEquals((Short) (short) 0, (Short) bag1.get(1)); + assertEquals((Short) (short) 0, (Short) bag1.get(2)); + assertEquals((Short) (short) 0, (Short) bag1.get(3)); + assertEquals((Short) e0, (Short) bag1.get(4)); + assertEquals((Short) (short) 0, (Short) bag1.get(5)); + assertEquals((Short) (short) 0, (Short) bag1.get(6)); + assertEquals((Short) (short) 0, (Short) bag1.get(7)); + bag1 = new ShortBag(); + bag1.set(8, e2); + bag1.copyFrom(bag0, 8, true); + assertEquals((Short) (short) 0, (Short) bag1.get(0)); + assertEquals((Short) (short) 0, (Short) bag1.get(1)); + assertEquals((Short) (short) 0, (Short) bag1.get(2)); + assertEquals((Short) (short) 0, (Short) bag1.get(3)); + assertEquals((Short) e0, (Short) bag1.get(4)); + assertEquals((Short) (short) 0, (Short) bag1.get(5)); + assertEquals((Short) (short) 0, (Short) bag1.get(6)); + assertEquals((Short) e1, (Short) bag1.get(7)); + assertEquals((Short) (short) 0, (Short) bag1.get(8)); assertEquals((Short) (short) 0, (Short) bag1.get(9)); - bag0.copyFrom(bag1); + // Test copyFrom(bag, fromOffset, length) and copyFrom(bag, fromOffset, length, clearExceeding) + bag0 = new ShortBag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(6, e2); + bag1 = new ShortBag(); + bag1.copyFrom(bag0, 3, 2); + assertEquals((Short) (short) 0, (Short) bag1.get(0)); + assertEquals((Short) e1, (Short) bag1.get(1)); + assertEquals((Short) (short) 0, (Short) bag1.get(2)); + assertEquals((Short) (short) 0, (Short) bag1.get(3)); + assertEquals((Short) (short) 0, (Short) bag1.get(4)); + assertEquals((Short) (short) 0, (Short) bag1.get(5)); + assertEquals((Short) (short) 0, (Short) bag1.get(6)); + assertEquals((Short) (short) 0, (Short) bag1.get(7)); + assertEquals((Short) (short) 0, (Short) bag1.get(8)); + bag0 = new ShortBag(); + bag0.set(0, e0); + bag0.set(4, e1); + bag0.set(10, e2); + bag1 = new ShortBag(); + bag1.set(7, e3); + bag1.copyFrom(bag0, 3, 2, false); + assertEquals((Short) (short) 0, (Short) bag1.get(0)); + assertEquals((Short) e1, (Short) bag1.get(1)); + assertEquals((Short) (short) 0, (Short) bag1.get(2)); + assertEquals((Short) (short) 0, (Short) bag1.get(3)); + assertEquals((Short) (short) 0, (Short) bag1.get(4)); + assertEquals((Short) (short) 0, (Short) bag1.get(5)); + assertEquals((Short) (short) 0, (Short) bag1.get(6)); + assertEquals((Short) e3, (Short) bag1.get(7)); + assertEquals((Short) (short) 0, (Short) bag1.get(8)); + assertEquals((Short) (short) 0, (Short) bag1.get(9)); + assertEquals((Short) (short) 0, (Short) bag1.get(10)); + } + + @Test + public void testCopyPartFrom() { + ShortBag b0, b1; + short e0 = (short) 1, e1 = (short) 1, e2 = (short) 1, e3 = (short) 1; + b0 = new ShortBag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new ShortBag(); + b1.set(0, e3); + b1.set(33, e0); + b1.copyPartFrom(b0, 14, 1, 33); + assertEquals((Short) e1, (Short) b1.get(1)); + assertEquals((Short) e2, (Short) b1.get(8)); + assertEquals((Short) e3, (Short) b1.get(0)); + assertEquals((Short) (short) 0, (Short) b1.get(32)); + assertEquals((Short) (short) 0, (Short) b1.get(33)); + assertEquals((Short) (short) 0, (Short) b1.get(34)); + assertEquals((Short) (short) 0, (Short) b1.get(35)); + b0 = new ShortBag(); + b0.set(5, e0); + b0.set(14, e1); + b0.set(21, e2); + b1 = new ShortBag(); + b1.set(0, e3); + b1.copyPartFrom(b0, 14, 1, 8); + assertEquals((Short) e1, (Short) b1.get(1)); + assertEquals((Short) e2, (Short) b1.get(8)); + assertEquals((Short) e3, (Short) b1.get(0)); + assertEquals((Short) (short) 0, (Short) b1.get(32)); + assertEquals((Short) (short) 0, (Short) b1.get(33)); + assertEquals((Short) (short) 0, (Short) b1.get(34)); + assertEquals((Short) (short) 0, (Short) b1.get(35)); } }