| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE |
| * file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file |
| * to You under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the |
| * License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on |
| * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations under the License. |
| */ |
| package org.apache.tuweni.bytes; |
| |
| import static java.nio.ByteOrder.LITTLE_ENDIAN; |
| import static org.junit.jupiter.api.Assertions.assertArrayEquals; |
| import static org.junit.jupiter.api.Assertions.assertEquals; |
| import static org.junit.jupiter.api.Assertions.assertNotEquals; |
| import static org.junit.jupiter.api.Assertions.assertSame; |
| import static org.junit.jupiter.api.Assertions.assertThrows; |
| |
| import java.util.Arrays; |
| import java.util.stream.Stream; |
| |
| import io.netty.buffer.ByteBuf; |
| import io.netty.buffer.Unpooled; |
| import org.junit.jupiter.api.Test; |
| import org.junit.jupiter.params.ParameterizedTest; |
| import org.junit.jupiter.params.provider.Arguments; |
| import org.junit.jupiter.params.provider.MethodSource; |
| |
| class BytesTest extends CommonBytesTests { |
| |
| @Override |
| Bytes h(String hex) { |
| return Bytes.fromHexString(hex); |
| } |
| |
| @Override |
| MutableBytes m(int size) { |
| return MutableBytes.create(size); |
| } |
| |
| @Override |
| Bytes w(byte[] bytes) { |
| return Bytes.wrap(bytes); |
| } |
| |
| @Override |
| Bytes of(int... bytes) { |
| return Bytes.of(bytes); |
| } |
| |
| @Test |
| void wrapEmpty() { |
| Bytes wrap = Bytes.wrap(new byte[0]); |
| assertEquals(Bytes.EMPTY, wrap); |
| } |
| |
| @ParameterizedTest |
| @MethodSource("wrapProvider") |
| void wrap(Object arr) { |
| byte[] bytes = (byte[]) arr; |
| Bytes value = Bytes.wrap(bytes); |
| assertEquals(bytes.length, value.size()); |
| assertArrayEquals(value.toArray(), bytes); |
| } |
| |
| @SuppressWarnings("UnusedMethod") |
| private static Stream<Arguments> wrapProvider() { |
| return Stream |
| .of( |
| Arguments.of(new Object[] {new byte[10]}), |
| Arguments.of(new Object[] {new byte[] {1}}), |
| Arguments.of(new Object[] {new byte[] {1, 2, 3, 4}}), |
| Arguments.of(new Object[] {new byte[] {-1, 127, -128}})); |
| } |
| |
| @Test |
| void wrapNull() { |
| assertThrows(NullPointerException.class, () -> Bytes.wrap((byte[]) null)); |
| } |
| |
| /** |
| * Checks that modifying a wrapped array modifies the value itself. |
| */ |
| @Test |
| void wrapReflectsUpdates() { |
| byte[] bytes = new byte[] {1, 2, 3, 4, 5}; |
| Bytes value = Bytes.wrap(bytes); |
| |
| assertEquals(bytes.length, value.size()); |
| assertArrayEquals(value.toArray(), bytes); |
| |
| bytes[1] = 127; |
| bytes[3] = 127; |
| |
| assertEquals(bytes.length, value.size()); |
| assertArrayEquals(value.toArray(), bytes); |
| } |
| |
| @Test |
| void wrapSliceEmpty() { |
| assertEquals(Bytes.EMPTY, Bytes.wrap(new byte[0], 0, 0)); |
| assertEquals(Bytes.EMPTY, Bytes.wrap(new byte[] {1, 2, 3}, 0, 0)); |
| assertEquals(Bytes.EMPTY, Bytes.wrap(new byte[] {1, 2, 3}, 2, 0)); |
| } |
| |
| @ParameterizedTest |
| @MethodSource("wrapSliceProvider") |
| void wrapSlice(Object arr, int offset, int length) { |
| assertWrapSlice((byte[]) arr, offset, length); |
| } |
| |
| @SuppressWarnings("UnusedMethod") |
| private static Stream<Arguments> wrapSliceProvider() { |
| return Stream |
| .of( |
| Arguments.of(new byte[] {1, 2, 3, 4}, 0, 4), |
| Arguments.of(new byte[] {1, 2, 3, 4}, 0, 2), |
| Arguments.of(new byte[] {1, 2, 3, 4}, 2, 1), |
| Arguments.of(new byte[] {1, 2, 3, 4}, 2, 2)); |
| } |
| |
| private void assertWrapSlice(byte[] bytes, int offset, int length) { |
| Bytes value = Bytes.wrap(bytes, offset, length); |
| assertEquals(length, value.size()); |
| assertArrayEquals(value.toArray(), Arrays.copyOfRange(bytes, offset, offset + length)); |
| } |
| |
| @Test |
| void wrapSliceNull() { |
| assertThrows(NullPointerException.class, () -> Bytes.wrap(null, 0, 2)); |
| } |
| |
| @Test |
| void wrapSliceNegativeOffset() { |
| assertThrows(IndexOutOfBoundsException.class, () -> assertWrapSlice(new byte[] {1, 2, 3, 4}, -1, 4)); |
| } |
| |
| @Test |
| void wrapSliceOutOfBoundOffset() { |
| assertThrows(IndexOutOfBoundsException.class, () -> assertWrapSlice(new byte[] {1, 2, 3, 4}, 5, 1)); |
| } |
| |
| @Test |
| void wrapSliceNegativeLength() { |
| Throwable exception = |
| assertThrows(IllegalArgumentException.class, () -> assertWrapSlice(new byte[] {1, 2, 3, 4}, 0, -2)); |
| assertEquals("Invalid negative length", exception.getMessage()); |
| } |
| |
| @Test |
| void wrapSliceTooBig() { |
| Throwable exception = |
| assertThrows(IllegalArgumentException.class, () -> assertWrapSlice(new byte[] {1, 2, 3, 4}, 2, 3)); |
| assertEquals("Provided length 3 is too big: the value has only 2 bytes from offset 2", exception.getMessage()); |
| } |
| |
| /** |
| * Checks that modifying a wrapped array modifies the value itself, but only if within the wrapped slice. |
| */ |
| @Test |
| void wrapSliceReflectsUpdates() { |
| byte[] bytes = new byte[] {1, 2, 3, 4, 5}; |
| assertWrapSlice(bytes, 2, 2); |
| bytes[2] = 127; |
| bytes[3] = 127; |
| assertWrapSlice(bytes, 2, 2); |
| |
| Bytes wrapped = Bytes.wrap(bytes, 2, 2); |
| Bytes copy = wrapped.copy(); |
| |
| // Modify the bytes outside of the wrapped slice and check this doesn't affect the value (that |
| // it is still equal to the copy from before the updates) |
| bytes[0] = 127; |
| assertEquals(copy, wrapped); |
| |
| // Sanity check for copy(): modify within the wrapped slice and check the copy differs now. |
| bytes[2] = 42; |
| assertEquals("0x2a7f", wrapped.toHexString()); |
| assertEquals(Bytes.fromHexString("0x7f7f"), copy); |
| } |
| |
| @Test |
| void ofBytes() { |
| assertArrayEquals(Bytes.of().toArray(), new byte[] {}); |
| assertArrayEquals(Bytes.of((byte) 1, (byte) 2).toArray(), new byte[] {1, 2}); |
| assertArrayEquals(Bytes.of((byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5).toArray(), new byte[] {1, 2, 3, 4, 5}); |
| assertArrayEquals(Bytes.of((byte) -1, (byte) 2, (byte) -3).toArray(), new byte[] {-1, 2, -3}); |
| } |
| |
| @Test |
| void ofInts() { |
| assertArrayEquals(Bytes.of(1, 2).toArray(), new byte[] {1, 2}); |
| assertArrayEquals(Bytes.of(1, 2, 3, 4, 5).toArray(), new byte[] {1, 2, 3, 4, 5}); |
| assertArrayEquals(Bytes.of(0xff, 0x7f, 0x80).toArray(), new byte[] {-1, 127, -128}); |
| } |
| |
| @Test |
| void ofIntsTooBig() { |
| Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.of(2, 3, 256)); |
| assertEquals("3th value 256 does not fit a byte", exception.getMessage()); |
| } |
| |
| @Test |
| void ofIntsTooLow() { |
| Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.of(2, -1, 3)); |
| assertEquals("2th value -1 does not fit a byte", exception.getMessage()); |
| } |
| |
| @Test |
| void minimalBytes() { |
| assertEquals(h("0x"), Bytes.minimalBytes(0)); |
| assertEquals(h("0x01"), Bytes.minimalBytes(1)); |
| assertEquals(h("0x04"), Bytes.minimalBytes(4)); |
| assertEquals(h("0x10"), Bytes.minimalBytes(16)); |
| assertEquals(h("0xFF"), Bytes.minimalBytes(255)); |
| assertEquals(h("0x0100"), Bytes.minimalBytes(256)); |
| assertEquals(h("0x0200"), Bytes.minimalBytes(512)); |
| assertEquals(h("0x010000"), Bytes.minimalBytes(1L << 16)); |
| assertEquals(h("0x01000000"), Bytes.minimalBytes(1L << 24)); |
| assertEquals(h("0x0100000000"), Bytes.minimalBytes(1L << 32)); |
| assertEquals(h("0x010000000000"), Bytes.minimalBytes(1L << 40)); |
| assertEquals(h("0x01000000000000"), Bytes.minimalBytes(1L << 48)); |
| assertEquals(h("0x0100000000000000"), Bytes.minimalBytes(1L << 56)); |
| assertEquals(h("0xFFFFFFFFFFFFFFFF"), Bytes.minimalBytes(-1L)); |
| } |
| |
| @Test |
| void ofUnsignedShort() { |
| assertEquals(h("0x0000"), Bytes.ofUnsignedShort(0)); |
| assertEquals(h("0x0001"), Bytes.ofUnsignedShort(1)); |
| assertEquals(h("0x0100"), Bytes.ofUnsignedShort(256)); |
| assertEquals(h("0xFFFF"), Bytes.ofUnsignedShort(65535)); |
| } |
| |
| @Test |
| void ofUnsignedShortLittleEndian() { |
| assertEquals(h("0x0000"), Bytes.ofUnsignedShort(0, LITTLE_ENDIAN)); |
| assertEquals(h("0x0100"), Bytes.ofUnsignedShort(1, LITTLE_ENDIAN)); |
| assertEquals(h("0x0001"), Bytes.ofUnsignedShort(256, LITTLE_ENDIAN)); |
| assertEquals(h("0xFFFF"), Bytes.ofUnsignedShort(65535, LITTLE_ENDIAN)); |
| } |
| |
| @Test |
| void ofUnsignedShortNegative() { |
| Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.ofUnsignedShort(-1)); |
| assertEquals( |
| "Value -1 cannot be represented as an unsigned short (it is negative or too big)", |
| exception.getMessage()); |
| } |
| |
| @Test |
| void ofUnsignedShortTooBig() { |
| Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.ofUnsignedShort(65536)); |
| assertEquals( |
| "Value 65536 cannot be represented as an unsigned short (it is negative or too big)", |
| exception.getMessage()); |
| } |
| |
| @Test |
| void asUnsignedBigIntegerConstants() { |
| assertEquals(bi("0"), Bytes.EMPTY.toUnsignedBigInteger()); |
| assertEquals(bi("1"), Bytes.of(1).toUnsignedBigInteger()); |
| } |
| |
| @Test |
| void asSignedBigIntegerConstants() { |
| assertEquals(bi("0"), Bytes.EMPTY.toBigInteger()); |
| assertEquals(bi("1"), Bytes.of(1).toBigInteger()); |
| } |
| |
| @Test |
| void fromHexStringLenient() { |
| assertEquals(Bytes.of(), Bytes.fromHexStringLenient("")); |
| assertEquals(Bytes.of(), Bytes.fromHexStringLenient("0x")); |
| assertEquals(Bytes.of(0), Bytes.fromHexStringLenient("0")); |
| assertEquals(Bytes.of(0), Bytes.fromHexStringLenient("0x0")); |
| assertEquals(Bytes.of(0), Bytes.fromHexStringLenient("00")); |
| assertEquals(Bytes.of(0), Bytes.fromHexStringLenient("0x00")); |
| assertEquals(Bytes.of(1), Bytes.fromHexStringLenient("0x1")); |
| assertEquals(Bytes.of(1), Bytes.fromHexStringLenient("0x01")); |
| assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("1FF2A")); |
| assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x1FF2A")); |
| assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x1ff2a")); |
| assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x1fF2a")); |
| assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("01FF2A")); |
| assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x01FF2A")); |
| assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x01ff2A")); |
| } |
| |
| @Test |
| void compareTo() { |
| assertEquals(1, Bytes.of(0x05).compareTo(Bytes.of(0x01))); |
| assertEquals(1, Bytes.of(0x05).compareTo(Bytes.of(0x01))); |
| assertEquals(1, Bytes.of(0xef).compareTo(Bytes.of(0x01))); |
| assertEquals(1, Bytes.of(0xef).compareTo(Bytes.of(0x00, 0x01))); |
| assertEquals(1, Bytes.of(0x00, 0x00, 0xef).compareTo(Bytes.of(0x00, 0x01))); |
| assertEquals(1, Bytes.of(0x00, 0xef).compareTo(Bytes.of(0x00, 0x00, 0x01))); |
| assertEquals(1, Bytes.of(0xef, 0xf0).compareTo(Bytes.of(0xff))); |
| assertEquals(1, Bytes.of(0xef, 0xf0).compareTo(Bytes.of(0x01))); |
| assertEquals(1, Bytes.of(0xef, 0xf1).compareTo(Bytes.of(0xef, 0xf0))); |
| assertEquals(1, Bytes.of(0x00, 0x00, 0x01).compareTo(Bytes.of(0x00, 0x00))); |
| assertEquals(0, Bytes.of(0xef, 0xf0).compareTo(Bytes.of(0xef, 0xf0))); |
| assertEquals(-1, Bytes.of(0xef, 0xf0).compareTo(Bytes.of(0xef, 0xf5))); |
| assertEquals(-1, Bytes.of(0xef).compareTo(Bytes.of(0xff))); |
| assertEquals(-1, Bytes.of(0x01).compareTo(Bytes.of(0xff))); |
| assertEquals(-1, Bytes.of(0x01).compareTo(Bytes.of(0x01, 0xff))); |
| assertEquals(-1, Bytes.of(0x00, 0x00, 0x01).compareTo(Bytes.of(0x00, 0x02))); |
| assertEquals(-1, Bytes.of(0x00, 0x01).compareTo(Bytes.of(0x00, 0x00, 0x05))); |
| assertEquals(0, Bytes.fromHexString("0x0000").compareTo(Bytes.fromHexString("0x00"))); |
| assertEquals(0, Bytes.fromHexString("0x00").compareTo(Bytes.fromHexString("0x0000"))); |
| assertEquals(0, Bytes.fromHexString("0x000000").compareTo(Bytes.fromHexString("0x000000"))); |
| assertEquals(-1, Bytes.fromHexString("0x000001").compareTo(Bytes.fromHexString("0x0001"))); |
| } |
| |
| @Test |
| void fromHexStringLenientInvalidInput() { |
| Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.fromHexStringLenient("foo")); |
| assertEquals("Illegal character 'o' found at index 1 in hex binary representation", exception.getMessage()); |
| } |
| |
| @Test |
| void fromHexStringLenientLeftPadding() { |
| assertEquals(Bytes.of(), Bytes.fromHexStringLenient("", 0)); |
| assertEquals(Bytes.of(0), Bytes.fromHexStringLenient("", 1)); |
| assertEquals(Bytes.of(0, 0), Bytes.fromHexStringLenient("", 2)); |
| assertEquals(Bytes.of(0, 0), Bytes.fromHexStringLenient("0x", 2)); |
| assertEquals(Bytes.of(0, 0, 0), Bytes.fromHexStringLenient("0", 3)); |
| assertEquals(Bytes.of(0, 0, 0), Bytes.fromHexStringLenient("0x0", 3)); |
| assertEquals(Bytes.of(0, 0, 0), Bytes.fromHexStringLenient("00", 3)); |
| assertEquals(Bytes.of(0, 0, 0), Bytes.fromHexStringLenient("0x00", 3)); |
| assertEquals(Bytes.of(0, 0, 1), Bytes.fromHexStringLenient("0x1", 3)); |
| assertEquals(Bytes.of(0, 0, 1), Bytes.fromHexStringLenient("0x01", 3)); |
| assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("1FF2A", 3)); |
| assertEquals(Bytes.of(0x00, 0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x1FF2A", 4)); |
| assertEquals(Bytes.of(0x00, 0x00, 0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x1ff2a", 5)); |
| assertEquals(Bytes.of(0x00, 0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x1fF2a", 4)); |
| assertEquals(Bytes.of(0x00, 0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("01FF2A", 4)); |
| assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x01FF2A", 3)); |
| assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x01ff2A", 3)); |
| } |
| |
| @Test |
| void fromHexStringLenientLeftPaddingInvalidInput() { |
| Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.fromHexStringLenient("foo", 10)); |
| assertEquals("Illegal character 'o' found at index 1 in hex binary representation", exception.getMessage()); |
| } |
| |
| @Test |
| void fromHexStringLenientLeftPaddingInvalidSize() { |
| Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.fromHexStringLenient("0x001F34", 2)); |
| assertEquals("Hex value is too large: expected at most 2 bytes but got 3", exception.getMessage()); |
| } |
| |
| @Test |
| void fromHexString() { |
| assertEquals(Bytes.of(), Bytes.fromHexString("0x")); |
| assertEquals(Bytes.of(0), Bytes.fromHexString("00")); |
| assertEquals(Bytes.of(0), Bytes.fromHexString("0x00")); |
| assertEquals(Bytes.of(1), Bytes.fromHexString("0x01")); |
| assertEquals(Bytes.of(1, 0xff, 0x2a), Bytes.fromHexString("01FF2A")); |
| assertEquals(Bytes.of(1, 0xff, 0x2a), Bytes.fromHexString("0x01FF2A")); |
| assertEquals(Bytes.of(1, 0xff, 0x2a), Bytes.fromHexString("0x01ff2a")); |
| assertEquals(Bytes.of(1, 0xff, 0x2a), Bytes.fromHexString("0x01fF2a")); |
| } |
| |
| @Test |
| void fromHexStringInvalidInput() { |
| Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.fromHexString("fooo")); |
| assertEquals("Illegal character 'o' found at index 1 in hex binary representation", exception.getMessage()); |
| } |
| |
| @Test |
| void fromHexStringNotLenient() { |
| Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.fromHexString("0x100")); |
| assertEquals("Invalid odd-length hex binary representation", exception.getMessage()); |
| } |
| |
| @Test |
| void fromHexStringLeftPadding() { |
| assertEquals(Bytes.of(), Bytes.fromHexString("0x", 0)); |
| assertEquals(Bytes.of(0, 0), Bytes.fromHexString("0x", 2)); |
| assertEquals(Bytes.of(0, 0, 0, 0), Bytes.fromHexString("0x", 4)); |
| assertEquals(Bytes.of(0, 0), Bytes.fromHexString("00", 2)); |
| assertEquals(Bytes.of(0, 0), Bytes.fromHexString("0x00", 2)); |
| assertEquals(Bytes.of(0, 0, 1), Bytes.fromHexString("0x01", 3)); |
| assertEquals(Bytes.of(0x00, 0x01, 0xff, 0x2a), Bytes.fromHexString("01FF2A", 4)); |
| assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexString("0x01FF2A", 3)); |
| assertEquals(Bytes.of(0x00, 0x00, 0x01, 0xff, 0x2a), Bytes.fromHexString("0x01ff2a", 5)); |
| assertEquals(Bytes.of(0x00, 0x00, 0x01, 0xff, 0x2a), Bytes.fromHexString("0x01fF2a", 5)); |
| } |
| |
| @Test |
| void fromHexStringLeftPaddingInvalidInput() { |
| Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.fromHexString("fooo", 4)); |
| assertEquals("Illegal character 'o' found at index 1 in hex binary representation", exception.getMessage()); |
| } |
| |
| @Test |
| void fromHexStringLeftPaddingNotLenient() { |
| Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.fromHexString("0x100", 4)); |
| assertEquals("Invalid odd-length hex binary representation", exception.getMessage()); |
| } |
| |
| @Test |
| void fromHexStringLeftPaddingInvalidSize() { |
| Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.fromHexStringLenient("0x001F34", 2)); |
| assertEquals("Hex value is too large: expected at most 2 bytes but got 3", exception.getMessage()); |
| } |
| |
| @Test |
| void fromBase64Roundtrip() { |
| Bytes value = Bytes.fromBase64String("deadbeefISDAbest"); |
| assertEquals("deadbeefISDAbest", value.toBase64String()); |
| } |
| |
| @Test |
| void littleEndianRoundtrip() { |
| int val = Integer.MAX_VALUE - 5; |
| Bytes littleEndianEncoded = Bytes.ofUnsignedInt(val, LITTLE_ENDIAN); |
| assertEquals(4, littleEndianEncoded.size()); |
| Bytes bigEndianEncoded = Bytes.ofUnsignedInt(val); |
| assertEquals(bigEndianEncoded.get(0), littleEndianEncoded.get(3)); |
| assertEquals(bigEndianEncoded.get(1), littleEndianEncoded.get(2)); |
| assertEquals(bigEndianEncoded.get(2), littleEndianEncoded.get(1)); |
| assertEquals(bigEndianEncoded.get(3), littleEndianEncoded.get(0)); |
| |
| int read = littleEndianEncoded.toInt(LITTLE_ENDIAN); |
| assertEquals(val, read); |
| } |
| |
| @Test |
| void littleEndianLongRoundtrip() { |
| long val = 1L << 46; |
| Bytes littleEndianEncoded = Bytes.ofUnsignedLong(val, LITTLE_ENDIAN); |
| assertEquals(8, littleEndianEncoded.size()); |
| Bytes bigEndianEncoded = Bytes.ofUnsignedLong(val); |
| assertEquals(bigEndianEncoded.get(0), littleEndianEncoded.get(7)); |
| assertEquals(bigEndianEncoded.get(1), littleEndianEncoded.get(6)); |
| assertEquals(bigEndianEncoded.get(2), littleEndianEncoded.get(5)); |
| assertEquals(bigEndianEncoded.get(3), littleEndianEncoded.get(4)); |
| assertEquals(bigEndianEncoded.get(4), littleEndianEncoded.get(3)); |
| assertEquals(bigEndianEncoded.get(5), littleEndianEncoded.get(2)); |
| assertEquals(bigEndianEncoded.get(6), littleEndianEncoded.get(1)); |
| assertEquals(bigEndianEncoded.get(7), littleEndianEncoded.get(0)); |
| |
| long read = littleEndianEncoded.toLong(LITTLE_ENDIAN); |
| assertEquals(val, read); |
| } |
| |
| @Test |
| void reverseBytes() { |
| Bytes bytes = Bytes.fromHexString("0x000102030405"); |
| assertEquals(Bytes.fromHexString("0x050403020100"), bytes.reverse()); |
| } |
| |
| @Test |
| void reverseBytesEmptyArray() { |
| Bytes bytes = Bytes.fromHexString("0x"); |
| assertEquals(Bytes.fromHexString("0x"), bytes.reverse()); |
| } |
| |
| @Test |
| void mutableBytesIncrement() { |
| MutableBytes one = MutableBytes.of(1); |
| one.increment(); |
| assertEquals(Bytes.of(2), one); |
| } |
| |
| @Test |
| void mutableBytesIncrementMax() { |
| MutableBytes maxed = MutableBytes.of(1, 0xFF); |
| maxed.increment(); |
| assertEquals(Bytes.of(2, 0), maxed); |
| } |
| |
| @Test |
| void mutableBytesIncrementOverflow() { |
| MutableBytes maxed = MutableBytes.of(0xFF, 0xFF, 0xFF); |
| maxed.increment(); |
| assertEquals(Bytes.of(0, 0, 0), maxed); |
| } |
| |
| @Test |
| void mutableBytesDecrement() { |
| MutableBytes one = MutableBytes.of(2); |
| one.decrement(); |
| assertEquals(Bytes.of(1), one); |
| } |
| |
| @Test |
| void mutableBytesDecrementMax() { |
| MutableBytes maxed = MutableBytes.of(1, 0); |
| maxed.decrement(); |
| assertEquals(Bytes.of(0, 0xFF), maxed); |
| } |
| |
| @Test |
| void mutableBytesDecrementOverflow() { |
| MutableBytes maxed = MutableBytes.of(0x00, 0x00, 0x00); |
| maxed.decrement(); |
| assertEquals(Bytes.of(0xFF, 0xFF, 0xFF), maxed); |
| } |
| |
| @Test |
| void concatenation() { |
| MutableBytes value1 = MutableBytes.wrap(Bytes.fromHexString("deadbeef").toArrayUnsafe()); |
| Bytes result = Bytes.concatenate(value1, value1); |
| assertEquals(Bytes.fromHexString("deadbeefdeadbeef"), result); |
| value1.set(0, (byte) 0); |
| assertEquals(Bytes.fromHexString("deadbeefdeadbeef"), result); |
| } |
| |
| @Test |
| void wrap() { |
| MutableBytes value1 = MutableBytes.wrap(Bytes.fromHexString("deadbeef").toArrayUnsafe()); |
| Bytes result = Bytes.wrap(value1, value1); |
| assertEquals(Bytes.fromHexString("deadbeefdeadbeef"), result); |
| value1.set(0, (byte) 0); |
| assertEquals(Bytes.fromHexString("0x00adbeef00adbeef"), result); |
| } |
| |
| @Test |
| void random() { |
| Bytes value = Bytes.random(20); |
| assertNotEquals(value, Bytes.random(20)); |
| assertEquals(20, value.size()); |
| } |
| |
| @Test |
| void getInt() { |
| Bytes value = Bytes.fromHexString("0x00000001"); |
| assertEquals(1, value.getInt(0)); |
| assertEquals(16777216, value.getInt(0, LITTLE_ENDIAN)); |
| assertEquals(1, value.toInt()); |
| assertEquals(16777216, value.toInt(LITTLE_ENDIAN)); |
| } |
| |
| @Test |
| void getLong() { |
| Bytes value = Bytes.fromHexString("0x0000000000000001"); |
| assertEquals(1, value.getLong(0)); |
| assertEquals(72057594037927936L, value.getLong(0, LITTLE_ENDIAN)); |
| assertEquals(1, value.toLong()); |
| assertEquals(72057594037927936L, value.toLong(LITTLE_ENDIAN)); |
| } |
| |
| @Test |
| void numberOfLeadingZeros() { |
| Bytes value = Bytes.fromHexString("0x00000001"); |
| assertEquals(31, value.numberOfLeadingZeros()); |
| } |
| |
| @Test |
| void and() { |
| Bytes value = Bytes.fromHexString("0x01000001").and(Bytes.fromHexString("0x01000000")); |
| assertEquals(Bytes.fromHexString("0x01000000"), value); |
| } |
| |
| @Test |
| void andResult() { |
| MutableBytes result = MutableBytes.create(4); |
| Bytes.fromHexString("0x01000001").and(Bytes.fromHexString("0x01000000"), result); |
| assertEquals(Bytes.fromHexString("0x01000000"), result); |
| } |
| |
| @Test |
| void or() { |
| Bytes value = Bytes.fromHexString("0x01000001").or(Bytes.fromHexString("0x01000000")); |
| assertEquals(Bytes.fromHexString("0x01000001"), value); |
| } |
| |
| @Test |
| void orResult() { |
| MutableBytes result = MutableBytes.create(4); |
| Bytes.fromHexString("0x01000001").or(Bytes.fromHexString("0x01000000"), result); |
| assertEquals(Bytes.fromHexString("0x01000001"), result); |
| } |
| |
| @Test |
| void xor() { |
| Bytes value = Bytes.fromHexString("0x01000001").xor(Bytes.fromHexString("0x01000000")); |
| assertEquals(Bytes.fromHexString("0x00000001"), value); |
| } |
| |
| @Test |
| void xorResult() { |
| MutableBytes result = MutableBytes.create(4); |
| Bytes.fromHexString("0x01000001").xor(Bytes.fromHexString("0x01000000"), result); |
| assertEquals(Bytes.fromHexString("0x00000001"), result); |
| } |
| |
| @Test |
| void not() { |
| Bytes value = Bytes.fromHexString("0x01000001").not(); |
| assertEquals(Bytes.fromHexString("0xfefffffe"), value); |
| } |
| |
| @Test |
| void notResult() { |
| MutableBytes result = MutableBytes.create(4); |
| Bytes.fromHexString("0x01000001").not(result); |
| assertEquals(Bytes.fromHexString("0xfefffffe"), result); |
| } |
| |
| @Test |
| void shiftRight() { |
| Bytes value = Bytes.fromHexString("0x01000001").shiftRight(2); |
| assertEquals(Bytes.fromHexString("0x00400000"), value); |
| } |
| |
| @Test |
| void shiftRightResult() { |
| MutableBytes result = MutableBytes.create(4); |
| Bytes.fromHexString("0x01000001").shiftRight(2, result); |
| assertEquals(Bytes.fromHexString("0x00400000"), result); |
| } |
| |
| @Test |
| void shiftLeft() { |
| Bytes value = Bytes.fromHexString("0x01000001").shiftLeft(2); |
| assertEquals(Bytes.fromHexString("0x04000004"), value); |
| } |
| |
| @Test |
| void shiftLeftResult() { |
| MutableBytes result = MutableBytes.create(4); |
| Bytes.fromHexString("0x01000001").shiftLeft(2, result); |
| assertEquals(Bytes.fromHexString("0x04000004"), result); |
| } |
| |
| @Test |
| void commonPrefix() { |
| Bytes value = Bytes.fromHexString("0x01234567"); |
| Bytes value2 = Bytes.fromHexString("0x01236789"); |
| assertEquals(2, value.commonPrefixLength(value2)); |
| assertEquals(Bytes.fromHexString("0x0123"), value.commonPrefix(value2)); |
| } |
| |
| @Test |
| void testWrapByteBufEmpty() { |
| ByteBuf buffer = Unpooled.buffer(0); |
| assertSame(Bytes.EMPTY, Bytes.wrapByteBuf(buffer)); |
| } |
| |
| @Test |
| void testWrapByteBufWithIndexEmpty() { |
| ByteBuf buffer = Unpooled.buffer(3); |
| assertSame(Bytes.EMPTY, Bytes.wrapByteBuf(buffer, 3, 0)); |
| } |
| |
| @Test |
| void testWrapByteBufSizeWithOffset() { |
| ByteBuf buffer = Unpooled.buffer(10); |
| assertEquals(1, Bytes.wrapByteBuf(buffer, 1, 1).size()); |
| } |
| |
| @Test |
| void testWrapByteBufSize() { |
| ByteBuf buffer = Unpooled.buffer(20); |
| assertEquals(20, Bytes.wrapByteBuf(buffer).size()); |
| } |
| |
| @Test |
| void testWrapByteBufReadableBytes() { |
| ByteBuf buffer = Unpooled.buffer(20).writeByte(3); |
| assertEquals(1, Bytes.wrapByteBuf(buffer, 0, buffer.readableBytes()).size()); |
| } |
| |
| @Test |
| void segmentBytes() { |
| Bytes b = Bytes |
| .wrap( |
| Bytes32.ZERO, |
| Bytes32.random(), |
| Bytes32.rightPad(Bytes.fromHexStringLenient("0x1")), |
| Bytes.fromHexString("0xf000")); |
| Bytes32[] result = Bytes.segment(b); |
| assertEquals(4, result.length); |
| assertEquals(Bytes32.rightPad(Bytes.fromHexString("0xf000")), result[3]); |
| } |
| |
| @Test |
| void segments() { |
| Bytes value = Bytes.fromHexString("0x7b600035f660115760006000526001601ff35b60016000526001601ff3600052601c6000f3"); |
| Bytes32[] result = Bytes.segment(value); |
| assertEquals(Bytes.fromHexString("0x7b600035f660115760006000526001601ff35b60016000526001601ff3600052"), result[0]); |
| assertEquals(Bytes.fromHexString("0x601c6000f3000000000000000000000000000000000000000000000000000000"), result[1]); |
| } |
| |
| @Test |
| void testTrimLeadingZeros() { |
| Bytes b = Bytes.fromHexString("0x000000f300567800"); |
| assertEquals(Bytes.fromHexString("0xf300567800"), b.trimLeadingZeros()); |
| } |
| |
| @Test |
| void testTrimTrailingZeros() { |
| Bytes b = Bytes.fromHexString("0x000000f300567800"); |
| assertEquals(Bytes.fromHexString("0x000000f3005678"), b.trimTrailingZeros()); |
| } |
| } |