| /* |
| * Copyright 2012, Google Inc. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| package org.jf.dexlib2.writer; |
| |
| import junit.framework.Assert; |
| import org.jf.dexlib2.ValueType; |
| import org.jf.util.ExceptionWithContext; |
| import org.jf.util.NakedByteArrayOutputStream; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| import java.io.IOException; |
| import java.util.Arrays; |
| import java.util.Random; |
| |
| public class DexDataWriterTest { |
| private Random random; |
| private NakedByteArrayOutputStream output = new NakedByteArrayOutputStream(); |
| private int startPosition; |
| private DexDataWriter writer; |
| |
| @Before |
| public void setup() throws IOException { |
| // use a predefined seed, so we get a deterministic result |
| random = new Random(); |
| output.reset(); |
| startPosition = 123; |
| int bufferSize = 256; |
| writer = new DexDataWriter(output, startPosition, bufferSize); |
| } |
| |
| // Note: we use int[] rather than byte[] so that we don't have to cast every value when manually constructing an |
| // array. |
| private void expectData(int... bytes) throws IOException { |
| Assert.assertEquals(startPosition+bytes.length, writer.getPosition()); |
| |
| writer.flush(); |
| byte[] writtenData = output.getBuffer(); |
| |
| for (int i=0; i<bytes.length; i++) { |
| Assert.assertEquals(String.format("Values not equal at index %d", i), (byte)bytes[i], writtenData[i]); |
| } |
| } |
| |
| private void expectData(byte[] bytes) throws IOException { |
| Assert.assertEquals(startPosition+bytes.length, writer.getPosition()); |
| |
| writer.flush(); |
| byte[] writtenData = output.getBuffer(); |
| |
| for (int i=0; i<bytes.length; i++) { |
| Assert.assertEquals(String.format("Values not equal at index %d", i), bytes[i], writtenData[i]); |
| } |
| } |
| |
| @Test |
| public void testWriteByte() throws IOException { |
| byte[] arr = new byte[257]; |
| for (int i=0; i<256; i++) { |
| arr[i] = (byte)i; |
| writer.write(i); |
| } |
| arr[256] = (byte)0x80; |
| writer.write(0x180); |
| |
| expectData(arr); |
| } |
| |
| @Test |
| public void testWriteByteArray() throws IOException { |
| byte[] arr = new byte[345]; |
| random.nextBytes(arr); |
| writer.write(arr); |
| |
| expectData(arr); |
| } |
| |
| @Test |
| public void testWriteByteArrayWithLengthAndOffset() throws IOException { |
| byte[] arr = new byte[345]; |
| random.nextBytes(arr); |
| writer.write(arr, 10, 300); |
| |
| expectData(Arrays.copyOfRange(arr, 10, 310)); |
| } |
| |
| @Test |
| public void testWriteLong() throws IOException { |
| writer.writeLong(0x1122334455667788L); |
| writer.writeLong(-0x1122334455667788L); |
| |
| expectData(0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, |
| 0x78, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE); |
| } |
| |
| @Test |
| public void testWriteInt() throws IOException { |
| writer.writeInt(0x11223344); |
| writer.writeInt(-0x11223344); |
| |
| expectData(0x44, 0x33, 0x22, 0x11, |
| 0xBC, 0xCC, 0xDD, 0xEE); |
| } |
| |
| @Test |
| public void testWriteShort() throws IOException { |
| writer.writeShort(0); |
| writer.writeShort(0x1122); |
| writer.writeShort(-0x1122); |
| writer.writeShort(0x7FFF); |
| writer.writeShort(-0x8000); |
| |
| expectData(0x00, 0x00, |
| 0x22, 0x11, |
| 0xDE, 0xEE, |
| 0xFF, 0x7F, |
| 0x00, 0x80); |
| } |
| |
| @Test(expected=ExceptionWithContext.class) |
| public void testWriteShortOutOfBounds() throws IOException { |
| writer.writeShort(0x8000); |
| } |
| |
| @Test(expected=ExceptionWithContext.class) |
| public void testWriteShortOutOfBounds2() throws IOException { |
| writer.writeShort(-0x8001); |
| } |
| |
| @Test |
| public void testWriteUshort() throws IOException { |
| writer.writeUshort(0); |
| writer.writeUshort(0x1122); |
| writer.writeUshort(0x8899); |
| writer.writeUshort(0xFFFF); |
| |
| expectData(0x00, 0x00, |
| 0x22, 0x11, |
| 0x99, 0x88, |
| 0xFF, 0xFF); |
| } |
| |
| @Test(expected=ExceptionWithContext.class) |
| public void testWriteUshortOutOfBounds() throws IOException { |
| writer.writeUshort(-1); |
| } |
| |
| @Test(expected=ExceptionWithContext.class) |
| public void testWriteUshortOutOfBounds2() throws IOException { |
| writer.writeUshort(0x10000); |
| } |
| |
| @Test |
| public void testWriteUbyte() throws IOException { |
| writer.writeUbyte(0); |
| writer.writeUbyte(1); |
| writer.writeUbyte(0x12); |
| writer.writeUbyte(0xFF); |
| |
| expectData(0x00, 0x01, 0x12, 0xFF); |
| } |
| |
| @Test(expected=ExceptionWithContext.class) |
| public void testWriteUbyteOutOfBounds() throws IOException { |
| writer.writeUbyte(-1); |
| } |
| |
| @Test(expected=ExceptionWithContext.class) |
| public void testWriteUbyteOutOfBounds2() throws IOException { |
| writer.writeUbyte(256); |
| } |
| |
| @Test |
| public void testWriteEncodedValueHeader() throws IOException { |
| writer.writeEncodedValueHeader(0x2, 0x1); |
| |
| expectData(0x22); |
| } |
| |
| private void testWriteEncodedIntHelper(int integerValue, int... encodedValue) throws IOException { |
| setup(); |
| writer.writeEncodedInt(ValueType.INT, integerValue); |
| |
| int[] arr = new int[encodedValue.length+1]; |
| arr[0] = ValueType.INT | ((encodedValue.length-1) << 5); |
| System.arraycopy(encodedValue, 0, arr, 1, encodedValue.length); |
| expectData(arr); |
| } |
| |
| @Test |
| public void testWriteEncodedInt() throws IOException { |
| testWriteEncodedIntHelper(0x00, 0x00); |
| testWriteEncodedIntHelper(0x40, 0x40); |
| testWriteEncodedIntHelper(0x7f, 0x7f); |
| testWriteEncodedIntHelper(0xff, 0xff, 0x00); |
| testWriteEncodedIntHelper(0xffff80, 0x80, 0xff, 0xff, 0x00); |
| testWriteEncodedIntHelper(0xffffff80, 0x80); |
| testWriteEncodedIntHelper(0xffffffff, 0xff); |
| testWriteEncodedIntHelper(0x100, 0x00, 0x01); |
| testWriteEncodedIntHelper(0x7fff, 0xff, 0x7f); |
| testWriteEncodedIntHelper(0x8000, 0x00, 0x80, 0x00); |
| testWriteEncodedIntHelper(0xffff8000, 0x00, 0x80); |
| testWriteEncodedIntHelper(0x10000, 0x00, 0x00, 0x01); |
| testWriteEncodedIntHelper(0x10203, 0x03, 0x02, 0x01); |
| testWriteEncodedIntHelper(0x810203, 0x03, 0x02, 0x81, 0x00); |
| testWriteEncodedIntHelper(0xff810203, 0x03, 0x02, 0x81); |
| testWriteEncodedIntHelper(0x1000000, 0x00, 0x00, 0x00, 0x01); |
| testWriteEncodedIntHelper(0x1020304, 0x04, 0x03, 0x02, 0x01); |
| testWriteEncodedIntHelper(0x7fffffff, 0xff, 0xff, 0xff, 0x7f); |
| testWriteEncodedIntHelper(0x80000000, 0x00, 0x00, 0x00, 0x80); |
| testWriteEncodedIntHelper(0x80000001, 0x01, 0x00, 0x00, 0x80); |
| } |
| |
| private void testWriteEncodedUintHelper(int integerValue, int... encodedValue) throws IOException { |
| setup(); |
| writer.writeEncodedUint(ValueType.METHOD, integerValue); |
| |
| int[] arr = new int[encodedValue.length+1]; |
| arr[0] = ValueType.METHOD | ((encodedValue.length-1) << 5); |
| System.arraycopy(encodedValue, 0, arr, 1, encodedValue.length); |
| expectData(arr); |
| } |
| |
| @Test |
| public void testWriteEncodedUint() throws IOException { |
| testWriteEncodedUintHelper(0x00, 0x00); |
| testWriteEncodedUintHelper(0x01, 0x01); |
| testWriteEncodedUintHelper(0x40, 0x40); |
| testWriteEncodedUintHelper(0x7f, 0x7f); |
| testWriteEncodedUintHelper(0x80, 0x80); |
| testWriteEncodedUintHelper(0x81, 0x81); |
| testWriteEncodedUintHelper(0xff, 0xff); |
| testWriteEncodedUintHelper(0x100, 0x00, 0x01); |
| testWriteEncodedUintHelper(0x180, 0x80, 0x01); |
| testWriteEncodedUintHelper(0x8080, 0x80, 0x80); |
| testWriteEncodedUintHelper(0x1234, 0x34, 0x12); |
| testWriteEncodedUintHelper(0x1000, 0x00, 0x10); |
| testWriteEncodedUintHelper(0x8000, 0x00, 0x80); |
| testWriteEncodedUintHelper(0xff00, 0x00, 0xff); |
| testWriteEncodedUintHelper(0xffff, 0xff, 0xff); |
| testWriteEncodedUintHelper(0x10000, 0x00, 0x00, 0x01); |
| testWriteEncodedUintHelper(0x1ffff, 0xff, 0xff, 0x01); |
| testWriteEncodedUintHelper(0x80ffff, 0xff, 0xff, 0x80); |
| testWriteEncodedUintHelper(0xffffff, 0xff, 0xff, 0xff); |
| testWriteEncodedUintHelper(0x1000000, 0x00, 0x00, 0x00, 0x01); |
| testWriteEncodedUintHelper(0x1020304, 0x04, 0x03, 0x02, 0x01); |
| testWriteEncodedUintHelper(0x80000000, 0x00, 0x00, 0x00, 0x80); |
| testWriteEncodedUintHelper(0x80ffffff, 0xff, 0xff, 0xff, 0x80); |
| testWriteEncodedUintHelper(0xffffffff, 0xff, 0xff, 0xff, 0xff); |
| } |
| |
| private void testWriteEncodedLongHelper(long longValue, int... encodedValue) throws IOException { |
| setup(); |
| writer.writeEncodedLong(ValueType.LONG, longValue); |
| |
| int[] arr = new int[encodedValue.length+1]; |
| arr[0] = ValueType.LONG | ((encodedValue.length-1) << 5); |
| System.arraycopy(encodedValue, 0, arr, 1, encodedValue.length); |
| expectData(arr); |
| } |
| |
| @Test |
| public void testWriteEncodedLong() throws IOException { |
| testWriteEncodedLongHelper(0x00L, 0x00); |
| testWriteEncodedLongHelper(0x40L, 0x40); |
| testWriteEncodedLongHelper(0x7fL, 0x7f); |
| testWriteEncodedLongHelper(0xffL, 0xff, 0x00); |
| testWriteEncodedLongHelper(0xffffffffffffff80L, 0x80); |
| testWriteEncodedLongHelper(0xffffffffffffffffL, 0xff); |
| |
| testWriteEncodedLongHelper(0x100L, 0x00, 0x01); |
| testWriteEncodedLongHelper(0x7fffL, 0xff, 0x7f); |
| testWriteEncodedLongHelper(0x8000L, 0x00, 0x80, 0x00); |
| testWriteEncodedLongHelper(0xffffffffffff8000L, 0x00, 0x80); |
| |
| testWriteEncodedLongHelper(0x10000L, 0x00, 0x00, 0x01); |
| testWriteEncodedLongHelper(0x10203L, 0x03, 0x02, 0x01); |
| testWriteEncodedLongHelper(0x810203L, 0x03, 0x02, 0x81, 0x00); |
| testWriteEncodedLongHelper(0xffffffffff810203L, 0x03, 0x02, 0x81); |
| |
| testWriteEncodedLongHelper(0x1000000L, 0x00, 0x00, 0x00, 0x01); |
| testWriteEncodedLongHelper(0x1020304L, 0x04, 0x03, 0x02, 0x01); |
| testWriteEncodedLongHelper(0x7fffffffL, 0xff, 0xff, 0xff, 0x7f); |
| testWriteEncodedLongHelper(0x80000000L, 0x00, 0x00, 0x00, 0x80, 0x00); |
| testWriteEncodedLongHelper(0xffffffff80000000L, 0x00, 0x00, 0x00, 0x80); |
| testWriteEncodedLongHelper(0xffffffff80000001L, 0x01, 0x00, 0x00, 0x80); |
| |
| testWriteEncodedLongHelper(0x100000000L, 0x00, 0x00, 0x00, 0x00, 0x01); |
| testWriteEncodedLongHelper(0x102030405L, 0x05, 0x04, 0x03, 0x02, 0x01); |
| testWriteEncodedLongHelper(0x7fffffffffL, 0xff, 0xff, 0xff, 0xff, 0x7f); |
| testWriteEncodedLongHelper(0x8000000000L, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00); |
| testWriteEncodedLongHelper(0xffffff8000000000L, 0x00, 0x00, 0x00, 0x00, 0x80); |
| testWriteEncodedLongHelper(0xffffff8000000001L, 0x01, 0x00, 0x00, 0x00, 0x80); |
| |
| testWriteEncodedLongHelper(0x10000000000L, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01); |
| testWriteEncodedLongHelper(0x10203040506L, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01); |
| testWriteEncodedLongHelper(0x7fffffffffffL, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f); |
| testWriteEncodedLongHelper(0x800000000000L, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00); |
| testWriteEncodedLongHelper(0xffff800000000000L, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80); |
| testWriteEncodedLongHelper(0xffff800000000001L, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80); |
| |
| testWriteEncodedLongHelper(0x1000000000000L, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01); |
| testWriteEncodedLongHelper(0x1020304050607L, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01); |
| testWriteEncodedLongHelper(0x7fffffffffffffL, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f); |
| testWriteEncodedLongHelper(0x80000000000000L, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00); |
| testWriteEncodedLongHelper(0xff80000000000000L, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80); |
| testWriteEncodedLongHelper(0xff80000000000001L, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80); |
| |
| testWriteEncodedLongHelper(0x100000000000000L, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01); |
| testWriteEncodedLongHelper(0x102030405060708L, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01); |
| testWriteEncodedLongHelper(0x7fffffffffffffffL, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f); |
| testWriteEncodedLongHelper(0x8000000000000000L, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80); |
| testWriteEncodedLongHelper(0x8000000000000001L, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80); |
| testWriteEncodedLongHelper(0xfeffffffffffffffL, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe); |
| |
| testWriteEncodedLongHelper(0x123456789ABCDEF0L, 0xF0, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12); |
| } |
| |
| private void testWriteRightZeroExtendedIntHelper(int intValue, int... encodedValue) throws IOException { |
| setup(); |
| writer.writeRightZeroExtendedInt(ValueType.FLOAT, intValue); |
| |
| int[] arr = new int[encodedValue.length+1]; |
| arr[0] = ValueType.FLOAT | ((encodedValue.length-1) << 5); |
| System.arraycopy(encodedValue, 0, arr, 1, encodedValue.length); |
| expectData(arr); |
| } |
| |
| @Test |
| public void testWriteRightZeroExtendedInt() throws IOException { |
| testWriteRightZeroExtendedIntHelper(0, 0x00); |
| |
| testWriteRightZeroExtendedIntHelper(0x01000000, 0x01); |
| testWriteRightZeroExtendedIntHelper(0x7f000000, 0x7f); |
| testWriteRightZeroExtendedIntHelper(0x80000000, 0x80); |
| testWriteRightZeroExtendedIntHelper(0xf0000000, 0xf0); |
| testWriteRightZeroExtendedIntHelper(0xff000000, 0xff); |
| |
| testWriteRightZeroExtendedIntHelper(0x010000, 0x01, 0x00); |
| testWriteRightZeroExtendedIntHelper(0x01100000, 0x10, 0x01); |
| testWriteRightZeroExtendedIntHelper(0x7f100000, 0x10, 0x7f); |
| testWriteRightZeroExtendedIntHelper(0x80100000, 0x10, 0x80); |
| testWriteRightZeroExtendedIntHelper(0xf0100000, 0x10, 0xf0); |
| testWriteRightZeroExtendedIntHelper(0xff100000, 0x10, 0xff); |
| testWriteRightZeroExtendedIntHelper(0xff000000, 0xff); |
| |
| testWriteRightZeroExtendedIntHelper(0x0100, 0x01, 0x00, 0x00); |
| testWriteRightZeroExtendedIntHelper(0x01101000, 0x10, 0x10, 0x01); |
| testWriteRightZeroExtendedIntHelper(0x7f101000, 0x10, 0x10, 0x7f); |
| testWriteRightZeroExtendedIntHelper(0x80101000, 0x10, 0x10, 0x80); |
| testWriteRightZeroExtendedIntHelper(0xf0101000, 0x10, 0x10, 0xf0); |
| testWriteRightZeroExtendedIntHelper(0xff101000, 0x10, 0x10, 0xff); |
| |
| testWriteRightZeroExtendedIntHelper(0x01, 0x01, 0x00, 0x00, 0x00); |
| testWriteRightZeroExtendedIntHelper(0x80, 0x80, 0x00, 0x00, 0x00); |
| testWriteRightZeroExtendedIntHelper(0xff, 0xff, 0x00, 0x00, 0x00); |
| testWriteRightZeroExtendedIntHelper(0x01101010, 0x10, 0x10, 0x10, 0x01); |
| testWriteRightZeroExtendedIntHelper(0x7f101010, 0x10, 0x10, 0x10, 0x7f); |
| testWriteRightZeroExtendedIntHelper(0x80101010, 0x10, 0x10, 0x10, 0x80); |
| testWriteRightZeroExtendedIntHelper(0xf0101010, 0x10, 0x10, 0x10, 0xf0); |
| testWriteRightZeroExtendedIntHelper(0xff101010, 0x10, 0x10, 0x10, 0xff); |
| } |
| |
| private void testWriteRightZeroExtendedLongHelper(long longValue, int... encodedValue) throws IOException { |
| setup(); |
| writer.writeRightZeroExtendedLong(ValueType.DOUBLE, longValue); |
| |
| int[] arr = new int[encodedValue.length+1]; |
| arr[0] = ValueType.DOUBLE | ((encodedValue.length-1) << 5); |
| System.arraycopy(encodedValue, 0, arr, 1, encodedValue.length); |
| expectData(arr); |
| } |
| |
| @Test |
| public void testWriteRightZeroExtendedLong() throws IOException { |
| testWriteRightZeroExtendedLongHelper(0, 0x00); |
| |
| testWriteRightZeroExtendedLongHelper(0x0100000000000000L, 0x01); |
| testWriteRightZeroExtendedLongHelper(0x7f00000000000000L, 0x7f); |
| testWriteRightZeroExtendedLongHelper(0x8000000000000000L, 0x80); |
| testWriteRightZeroExtendedLongHelper(0xf000000000000000L, 0xf0); |
| testWriteRightZeroExtendedLongHelper(0xff00000000000000L, 0xff); |
| |
| testWriteRightZeroExtendedLongHelper(0x01000000000000L, 0x01, 0x00); |
| testWriteRightZeroExtendedLongHelper(0x0110000000000000L, 0x10, 0x01); |
| testWriteRightZeroExtendedLongHelper(0x7f10000000000000L, 0x10, 0x7f); |
| testWriteRightZeroExtendedLongHelper(0x8010000000000000L, 0x10, 0x80); |
| testWriteRightZeroExtendedLongHelper(0xf010000000000000L, 0x10, 0xf0); |
| testWriteRightZeroExtendedLongHelper(0xff10000000000000L, 0x10, 0xff); |
| testWriteRightZeroExtendedLongHelper(0x7fff000000000000L, 0xff, 0x7f); |
| |
| testWriteRightZeroExtendedLongHelper(0x010000000000L, 0x01, 0x00, 0x00); |
| testWriteRightZeroExtendedLongHelper(0x0110100000000000L, 0x10, 0x10, 0x01); |
| testWriteRightZeroExtendedLongHelper(0x7f10100000000000L, 0x10, 0x10, 0x7f); |
| testWriteRightZeroExtendedLongHelper(0x8010100000000000L, 0x10, 0x10, 0x80); |
| testWriteRightZeroExtendedLongHelper(0xf010100000000000L, 0x10, 0x10, 0xf0); |
| testWriteRightZeroExtendedLongHelper(0xff10100000000000L, 0x10, 0x10, 0xff); |
| testWriteRightZeroExtendedLongHelper(0x7fffff0000000000L, 0xff, 0xff, 0x7f); |
| |
| testWriteRightZeroExtendedLongHelper(0x0100000000L, 0x01, 0x00, 0x00, 0x00); |
| testWriteRightZeroExtendedLongHelper(0x0110101000000000L, 0x10, 0x10, 0x10, 0x01); |
| testWriteRightZeroExtendedLongHelper(0x7f10101000000000L, 0x10, 0x10, 0x10, 0x7f); |
| testWriteRightZeroExtendedLongHelper(0x8010101000000000L, 0x10, 0x10, 0x10, 0x80); |
| testWriteRightZeroExtendedLongHelper(0xf010101000000000L, 0x10, 0x10, 0x10, 0xf0); |
| testWriteRightZeroExtendedLongHelper(0xff10101000000000L, 0x10, 0x10, 0x10, 0xff); |
| testWriteRightZeroExtendedLongHelper(0x7fffffff00000000L, 0xff, 0xff, 0xff, 0x7f); |
| |
| testWriteRightZeroExtendedLongHelper(0x01000000L, 0x01, 0x00, 0x00, 0x00, 0x00); |
| testWriteRightZeroExtendedLongHelper(0x0110101010000000L, 0x10, 0x10, 0x10, 0x10, 0x01); |
| testWriteRightZeroExtendedLongHelper(0x7f10101010000000L, 0x10, 0x10, 0x10, 0x10, 0x7f); |
| testWriteRightZeroExtendedLongHelper(0x8010101010000000L, 0x10, 0x10, 0x10, 0x10, 0x80); |
| testWriteRightZeroExtendedLongHelper(0xf010101010000000L, 0x10, 0x10, 0x10, 0x10, 0xf0); |
| testWriteRightZeroExtendedLongHelper(0xff10101010000000L, 0x10, 0x10, 0x10, 0x10, 0xff); |
| testWriteRightZeroExtendedLongHelper(0x7fffffffff000000L, 0xff, 0xff, 0xff, 0xff, 0x7f); |
| |
| testWriteRightZeroExtendedLongHelper(0x010000L, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00); |
| testWriteRightZeroExtendedLongHelper(0x0110101010100000L, 0x10, 0x10, 0x10, 0x10, 0x10, 0x01); |
| testWriteRightZeroExtendedLongHelper(0x7f10101010100000L, 0x10, 0x10, 0x10, 0x10, 0x10, 0x7f); |
| testWriteRightZeroExtendedLongHelper(0x8010101010100000L, 0x10, 0x10, 0x10, 0x10, 0x10, 0x80); |
| testWriteRightZeroExtendedLongHelper(0xf010101010100000L, 0x10, 0x10, 0x10, 0x10, 0x10, 0xf0); |
| testWriteRightZeroExtendedLongHelper(0xff10101010100000L, 0x10, 0x10, 0x10, 0x10, 0x10, 0xff); |
| testWriteRightZeroExtendedLongHelper(0x7fffffffffff0000L, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f); |
| |
| testWriteRightZeroExtendedLongHelper(0x0100L, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00); |
| testWriteRightZeroExtendedLongHelper(0x0110101010101000L, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x01); |
| testWriteRightZeroExtendedLongHelper(0x7f10101010101000L, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x7f); |
| testWriteRightZeroExtendedLongHelper(0x8010101010101000L, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x80); |
| testWriteRightZeroExtendedLongHelper(0xf010101010101000L, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xf0); |
| testWriteRightZeroExtendedLongHelper(0xff10101010101000L, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xff); |
| testWriteRightZeroExtendedLongHelper(0x7fffffffffffff00L, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f); |
| |
| testWriteRightZeroExtendedLongHelper(0x01L, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00); |
| testWriteRightZeroExtendedLongHelper(0x0110101010101010L, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x01); |
| testWriteRightZeroExtendedLongHelper(0x7f10101010101010L, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x7f); |
| testWriteRightZeroExtendedLongHelper(0x8010101010101010L, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x80); |
| testWriteRightZeroExtendedLongHelper(0xf010101010101010L, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xf0); |
| testWriteRightZeroExtendedLongHelper(0xff10101010101010L, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xff); |
| testWriteRightZeroExtendedLongHelper(Long.MAX_VALUE, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f); |
| testWriteRightZeroExtendedLongHelper(Long.MIN_VALUE, 0x80); |
| testWriteRightZeroExtendedLongHelper(-1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff); |
| } |
| |
| private void testWriteStringHelper(String stringValue, int... encodedValue) throws IOException { |
| setup(); |
| |
| writer.writeString(stringValue); |
| |
| expectData(encodedValue); |
| } |
| |
| @Test |
| public void testWriteString() throws IOException { |
| testWriteStringHelper(new String(new char[]{0x00}), 0xc0, 0x80); |
| testWriteStringHelper(new String(new char[]{0x01}), 0x01); |
| testWriteStringHelper(new String(new char[]{0x40}), 0x40); |
| testWriteStringHelper(new String(new char[]{0x7f}), 0x7f); |
| testWriteStringHelper(new String(new char[]{0x80}), 0xc2, 0x80); |
| testWriteStringHelper(new String(new char[]{0x81}), 0xc2, 0x81); |
| testWriteStringHelper(new String(new char[]{0x100}), 0xc4, 0x80); |
| testWriteStringHelper(new String(new char[]{0x7ff}), 0xdf, 0xbf); |
| testWriteStringHelper(new String(new char[]{0x800}), 0xe0, 0xa0, 0x80); |
| testWriteStringHelper(new String(new char[]{0x801}), 0xe0, 0xa0, 0x81); |
| testWriteStringHelper(new String(new char[]{0x1000}), 0xe1, 0x80, 0x80); |
| testWriteStringHelper(new String(new char[]{0x7fff}), 0xe7, 0xbf, 0xbf); |
| testWriteStringHelper(new String(new char[]{0x8000}), 0xe8, 0x80, 0x80); |
| testWriteStringHelper(new String(new char[]{0x8001}), 0xe8, 0x80, 0x81); |
| testWriteStringHelper(new String(new char[]{0xffff}), 0xef, 0xbf, 0xbf); |
| } |
| |
| @Test |
| public void testAlign() throws IOException { |
| // create a new writer so we can start at file position 0 |
| startPosition = 0; |
| writer = new DexDataWriter(output, startPosition, 256); |
| |
| writer.align(); |
| writer.write(1); |
| writer.align(); |
| writer.align(); |
| |
| writer.write(1); |
| writer.write(2); |
| writer.align(); |
| |
| writer.write(1); |
| writer.write(2); |
| writer.write(3); |
| writer.align(); |
| writer.align(); |
| |
| writer.write(1); |
| writer.write(2); |
| writer.write(3); |
| writer.write(4); |
| writer.align(); |
| writer.align(); |
| writer.align(); |
| writer.align(); |
| |
| writer.write(1); |
| writer.align(); |
| |
| expectData(0x01, 0x00, 0x00, 0x00, |
| 0x01, 0x02, 0x00, 0x00, |
| 0x01, 0x02, 0x03, 0x00, |
| 0x01, 0x02, 0x03, 0x04, |
| 0x01, 0x00, 0x00, 0x00); |
| } |
| } |
