[apktool] 01/07: test
Markus Koschany
apo-guest at moszumanska.debian.org
Tue Feb 16 19:06:46 GMT 2016
This is an automated email from the git hooks/post-receive script.
apo-guest pushed a commit to branch master
in repository apktool.
commit 818b20cb03aea8ba19b5baac2d1525f0944ed548
Author: Markus Koschany <apo at debian.org>
Date: Tue Feb 16 17:51:57 2016 +0100
test
---
debian/patches/LEDataInputStream.java.patch | 2 +-
debian/patches/series | 1 +
debian/patches/test.patch | 530 ++++++++++++++++++++++++++++
3 files changed, 532 insertions(+), 1 deletion(-)
diff --git a/debian/patches/LEDataInputStream.java.patch b/debian/patches/LEDataInputStream.java.patch
index 2dd33a5..b0c0a1a 100644
--- a/debian/patches/LEDataInputStream.java.patch
+++ b/debian/patches/LEDataInputStream.java.patch
@@ -9,7 +9,7 @@ Subject: LEDataInputStream.java
diff --git a/brut.apktool/apktool-lib/src/main/java/com/mindprod/ledatastream/LEDataInputStream.java b/brut.apktool/apktool-lib/src/main/java/com/mindprod/ledatastream/LEDataInputStream.java
new file mode 100644
-index 0000000..293cb1d
+index 0000000..9418e64
--- /dev/null
+++ b/brut.apktool/apktool-lib/src/main/java/com/mindprod/ledatastream/LEDataInputStream.java
@@ -0,0 +1,186 @@
diff --git a/debian/patches/series b/debian/patches/series
index 90d6b09..d74f901 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,3 +1,4 @@
use_system_aapt.patch
build.patch
LEDataInputStream.java.patch
+test.patch
diff --git a/debian/patches/test.patch b/debian/patches/test.patch
new file mode 100644
index 0000000..860d1bb
--- /dev/null
+++ b/debian/patches/test.patch
@@ -0,0 +1,530 @@
+From: Markus Koschany <apo at debian.org>
+Date: Tue, 16 Feb 2016 17:51:48 +0100
+Subject: test
+
+---
+ .../mindprod/ledatastream/LEDataInputStream.java | 516 +++++++++++++--------
+ 1 file changed, 330 insertions(+), 186 deletions(-)
+
+diff --git a/brut.apktool/apktool-lib/src/main/java/com/mindprod/ledatastream/LEDataInputStream.java b/brut.apktool/apktool-lib/src/main/java/com/mindprod/ledatastream/LEDataInputStream.java
+index 9418e64..b650e4b 100644
+--- a/brut.apktool/apktool-lib/src/main/java/com/mindprod/ledatastream/LEDataInputStream.java
++++ b/brut.apktool/apktool-lib/src/main/java/com/mindprod/ledatastream/LEDataInputStream.java
+@@ -1,186 +1,330 @@
+-/*******************************************************************************
+- * Copyright (c) 2000, 2011 IBM Corporation and others.
+- * All rights reserved. This program and the accompanying materials
+- * are made available under the terms of the Eclipse Public License v1.0
+- * which accompanies this distribution, and is available at
+- * http://www.eclipse.org/legal/epl-v10.html
+- *
+- * Contributors:
+- * IBM Corporation - initial API and implementation
+- *******************************************************************************/
+-package com.mindprod.ledatastream;
+-
+-
+-import java.io.*;
+-
+-public final class LEDataInputStream extends InputStream {
+- int position;
+- InputStream in;
+-
+- /**
+- * The byte array containing the bytes to read.
+- */
+- protected byte[] buf;
+-
+- /**
+- * The current position within the byte array <code>buf</code>. A value
+- * equal to buf.length indicates no bytes available. A value of
+- * 0 indicates the buffer is full.
+- */
+- protected int pos;
+-
+-
+- public LEDataInputStream(InputStream input) {
+- this(input, 512);
+- }
+-
+- public LEDataInputStream(InputStream input, int bufferSize) {
+- this.in = input;
+- if (bufferSize > 0) {
+- buf = new byte[bufferSize];
+- pos = bufferSize;
+- }
+- else throw new IllegalArgumentException();
+- }
+-
+- public void close() throws IOException {
+- buf = null;
+- if (in != null) {
+- in.close();
+- in = null;
+- }
+- }
+-
+- /**
+- * Answer how many bytes were read.
+- */
+- public int getPosition() {
+- return position;
+- }
+-
+- /**
+- * Answers how many bytes are available for reading without blocking
+- */
+- public int available() throws IOException {
+- if (buf == null) throw new IOException();
+- return (buf.length - pos) + in.available();
+- }
+-
+- /**
+- * Answer the next byte of the input stream.
+- */
+- public int read() throws IOException {
+- if (buf == null) throw new IOException();
+- if (pos < buf.length) {
+- position++;
+- return (buf[pos++] & 0xFF);
+- }
+- int c = in.read();
+- if (c != -1) position++;
+- return c;
+- }
+-
+- /**
+- * Don't imitate the JDK behaviour of reading a random number
+- * of bytes when you can actually read them all.
+- */
+- public int read(byte b[], int off, int len) throws IOException {
+- int read = 0, count;
+- while (read != len && (count = readData(b, off, len - read)) != -1) {
+- off += count;
+- read += count;
+- }
+- position += read;
+- if (read == 0 && read != len) return -1;
+- return read;
+- }
+-
+- /**
+- * Reads at most <code>length</code> bytes from this LEDataInputStream and
+- * stores them in byte array <code>buffer</code> starting at <code>offset</code>.
+- * <p>
+- * Answer the number of bytes actually read or -1 if no bytes were read and
+- * end of stream was encountered. This implementation reads bytes from
+- * the pushback buffer first, then the target stream if more bytes are required
+- * to satisfy <code>count</code>.
+- * </p>
+- * @param buffer the byte array in which to store the read bytes.
+- * @param offset the offset in <code>buffer</code> to store the read bytes.
+- * @param length the maximum number of bytes to store in <code>buffer</code>.
+- *
+- * @return int the number of bytes actually read or -1 if end of stream.
+- *
+- * @exception java.io.IOException if an IOException occurs.
+- */
+- private int readData(byte[] buffer, int offset, int length) throws IOException {
+- if (buf == null) throw new IOException();
+- if (offset < 0 || offset > buffer.length ||
+- length < 0 || (length > buffer.length - offset)) {
+- throw new ArrayIndexOutOfBoundsException();
+- }
+-
+- int cacheCopied = 0;
+- int newOffset = offset;
+-
+- // Are there pushback bytes available?
+- int available = buf.length - pos;
+- if (available > 0) {
+- cacheCopied = (available >= length) ? length : available;
+- System.arraycopy(buf, pos, buffer, newOffset, cacheCopied);
+- newOffset += cacheCopied;
+- pos += cacheCopied;
+- }
+-
+- // Have we copied enough?
+- if (cacheCopied == length) return length;
+-
+- int inCopied = in.read(buffer, newOffset, length - cacheCopied);
+-
+- if (inCopied > 0) return inCopied + cacheCopied;
+- if (cacheCopied == 0) return inCopied;
+- return cacheCopied;
+- }
+-
+- /**
+- * Answer an integer comprised of the next
+- * four bytes of the input stream.
+- */
+- public int readInt() throws IOException {
+- byte[] buf = new byte[4];
+- read(buf);
+- return ((buf[3] & 0xFF) << 24) |
+- ((buf[2] & 0xFF) << 16) |
+- ((buf[1] & 0xFF) << 8) |
+- (buf[0] & 0xFF);
+- }
+-
+- /**
+- * Answer a short comprised of the next
+- * two bytes of the input stream.
+- */
+- public short readShort() throws IOException {
+- byte[] buf = new byte[2];
+- read(buf);
+- return (short)(((buf[1] & 0xFF) << 8) | (buf[0] & 0xFF));
+- }
+-
+- /**
+- * Push back the entire content of the given buffer <code>b</code>.
+- * <p>
+- * The bytes are pushed so that they would be read back b[0], b[1], etc.
+- * If the push back buffer cannot handle the bytes copied from <code>b</code>,
+- * an IOException will be thrown and no byte will be pushed back.
+- * </p>
+- *
+- * @param b the byte array containing bytes to push back into the stream
+- *
+- * @exception java.io.IOException if the pushback buffer is too small
+- */
+- public void unread(byte[] b) throws IOException {
+- int length = b.length;
+- if (length > pos) throw new IOException();
+- position -= length;
+- pos -= length;
+- System.arraycopy(b, 0, buf, pos, length);
+- }
+-}
++/*
++ * @(#)LEDataInputStream.java
++ *
++ * Summary: Little-Endian version of DataInputStream.
++ *
++ * Copyright: (c) 1998-2010 Roedy Green, Canadian Mind Products, http://mindprod.com
++ *
++ * Licence: This software may be copied and used freely for any purpose but military.
++ * http://mindprod.com/contact/nonmil.html
++ *
++ * Requires: JDK 1.1+
++ *
++ * Created with: IntelliJ IDEA IDE.
++ *
++ * Version History:
++ * 1.8 2007-05-24
++ */
++package com.mindprod.ledatastream;
++
++import java.io.DataInput;
++import java.io.DataInputStream;
++import java.io.IOException;
++import java.io.InputStream;
++
++/**
++ * Little-Endian version of DataInputStream.
++ * <p/>
++ * Very similar to DataInputStream except it reads little-endian instead of
++ * big-endian binary data. We can't extend DataInputStream directly since it has
++ * only final methods, though DataInputStream itself is not final. This forces
++ * us implement LEDataInputStream with a DataInputStream object, and use wrapper
++ * methods.
++ *
++ * @author Roedy Green, Canadian Mind Products
++ * @version 1.8 2007-05-24
++ * @since 1998
++ */
++public final class LEDataInputStream implements DataInput {
++ // ------------------------------ CONSTANTS ------------------------------
++
++ /**
++ * undisplayed copyright notice.
++ *
++ * @noinspection UnusedDeclaration
++ */
++ private static final String EMBEDDED_COPYRIGHT = "copyright (c) 1999-2010 Roedy Green, Canadian Mind Products, http://mindprod.com";
++
++ // ------------------------------ FIELDS ------------------------------
++
++ /**
++ * to get at the big-Endian methods of a basic DataInputStream
++ *
++ * @noinspection WeakerAccess
++ */
++ protected final DataInputStream dis;
++
++ /**
++ * to get at the a basic readBytes method.
++ *
++ * @noinspection WeakerAccess
++ */
++ protected final InputStream is;
++
++ /**
++ * work array for buffering input.
++ *
++ * @noinspection WeakerAccess
++ */
++ protected final byte[] work;
++
++ // -------------------------- PUBLIC STATIC METHODS
++ // --------------------------
++
++ /**
++ * Note. This is a STATIC method!
++ *
++ * @param in
++ * stream to read UTF chars from (endian irrelevant)
++ *
++ * @return string from stream
++ * @throws IOException
++ * if read fails.
++ */
++ public static String readUTF(DataInput in) throws IOException {
++ return DataInputStream.readUTF(in);
++ }
++
++ // -------------------------- PUBLIC INSTANCE METHODS
++ // --------------------------
++
++ /**
++ * constructor.
++ *
++ * @param in
++ * binary inputstream of little-endian data.
++ */
++ public LEDataInputStream(InputStream in) {
++ this.is = in;
++ this.dis = new DataInputStream(in);
++ work = new byte[8];
++ }
++
++ /**
++ * close.
++ *
++ * @throws IOException
++ * if close fails.
++ */
++ public final void close() throws IOException {
++ dis.close();
++ }
++
++ /**
++ * Read bytes. Watch out, read may return fewer bytes than requested.
++ *
++ * @param ba
++ * where the bytes go.
++ * @param off
++ * offset in buffer, not offset in file.
++ * @param len
++ * count of bytes to read.
++ *
++ * @return how many bytes read.
++ * @throws IOException
++ * if read fails.
++ */
++ public final int read(byte ba[], int off, int len) throws IOException {
++ // For efficiency, we avoid one layer of wrapper
++ return is.read(ba, off, len);
++ }
++
++ /**
++ * read only a one-byte boolean.
++ *
++ * @return true or false.
++ * @throws IOException
++ * if read fails.
++ * @see java.io.DataInput#readBoolean()
++ */
++ @Override
++ public final boolean readBoolean() throws IOException {
++ return dis.readBoolean();
++ }
++
++ /**
++ * read byte.
++ *
++ * @return the byte read.
++ * @throws IOException
++ * if read fails.
++ * @see java.io.DataInput#readByte()
++ */
++ @Override
++ public final byte readByte() throws IOException {
++ return dis.readByte();
++ }
++
++ /**
++ * Read on char. like DataInputStream.readChar except little endian.
++ *
++ * @return little endian 16-bit unicode char from the stream.
++ * @throws IOException
++ * if read fails.
++ */
++ @Override
++ public final char readChar() throws IOException {
++ dis.readFully(work, 0, 2);
++ return (char) ((work[1] & 0xff) << 8 | (work[0] & 0xff));
++ }
++
++ /**
++ * Read a double. like DataInputStream.readDouble except little endian.
++ *
++ * @return little endian IEEE double from the datastream.
++ * @throws IOException
++ */
++ @Override
++ public final double readDouble() throws IOException {
++ return Double.longBitsToDouble(readLong());
++ }
++
++ /**
++ * Read one float. Like DataInputStream.readFloat except little endian.
++ *
++ * @return little endian IEEE float from the datastream.
++ * @throws IOException
++ * if read fails.
++ */
++ @Override
++ public final float readFloat() throws IOException {
++ return Float.intBitsToFloat(readInt());
++ }
++
++ /**
++ * Read bytes until the array is filled.
++ *
++ * @see java.io.DataInput#readFully(byte[])
++ */
++ @Override
++ public final void readFully(byte ba[]) throws IOException {
++ dis.readFully(ba, 0, ba.length);
++ }
++
++ /**
++ * Read bytes until the count is satisfied.
++ *
++ * @throws IOException
++ * if read fails.
++ * @see java.io.DataInput#readFully(byte[],int,int)
++ */
++ @Override
++ public final void readFully(byte ba[], int off, int len) throws IOException {
++ dis.readFully(ba, off, len);
++ }
++
++ /**
++ * Read an int, 32-bits. Like DataInputStream.readInt except little endian.
++ *
++ * @return little-endian binary int from the datastream
++ * @throws IOException
++ * if read fails.
++ */
++ @Override
++ public final int readInt() throws IOException {
++ dis.readFully(work, 0, 4);
++ return (work[3]) << 24 | (work[2] & 0xff) << 16 | (work[1] & 0xff) << 8
++ | (work[0] & 0xff);
++ }
++
++ /**
++ * Read a line.
++ *
++ * @return a rough approximation of the 8-bit stream as a 16-bit unicode
++ * string
++ * @throws IOException
++ * @noinspection deprecation
++ * @deprecated This method does not properly convert bytes to characters.
++ * Use a Reader instead with a little-endian encoding.
++ */
++ @Deprecated
++ @Override
++ public final String readLine() throws IOException {
++ return dis.readLine();
++ }
++
++ /**
++ * read a long, 64-bits. Like DataInputStream.readLong except little endian.
++ *
++ * @return little-endian binary long from the datastream.
++ * @throws IOException
++ */
++ @Override
++ public final long readLong() throws IOException {
++ dis.readFully(work, 0, 8);
++ return (long) (work[7]) << 56 |
++ /* long cast needed or shift done modulo 32 */
++ (long) (work[6] & 0xff) << 48 | (long) (work[5] & 0xff) << 40
++ | (long) (work[4] & 0xff) << 32 | (long) (work[3] & 0xff) << 24
++ | (long) (work[2] & 0xff) << 16 | (long) (work[1] & 0xff) << 8
++ | work[0] & 0xff;
++ }
++
++ /**
++ * Read short, 16-bits. Like DataInputStream.readShort except little endian.
++ *
++ * @return little endian binary short from stream.
++ * @throws IOException
++ * if read fails.
++ */
++ @Override
++ public final short readShort() throws IOException {
++ dis.readFully(work, 0, 2);
++ return (short) ((work[1] & 0xff) << 8 | (work[0] & 0xff));
++ }
++
++ /**
++ * Read UTF counted string.
++ *
++ * @return String read.
++ */
++ @Override
++ public final String readUTF() throws IOException {
++ return dis.readUTF();
++ }
++
++ /**
++ * Read an unsigned byte. Note: returns an int, even though says Byte
++ * (non-Javadoc)
++ *
++ * @throws IOException
++ * if read fails.
++ * @see java.io.DataInput#readUnsignedByte()
++ */
++ @Override
++ public final int readUnsignedByte() throws IOException {
++ return dis.readUnsignedByte();
++ }
++
++ /**
++ * Read an unsigned short, 16 bits. Like DataInputStream.readUnsignedShort
++ * except little endian. Note, returns int even though it reads a short.
++ *
++ * @return little-endian int from the stream.
++ * @throws IOException
++ * if read fails.
++ */
++ @Override
++ public final int readUnsignedShort() throws IOException {
++ dis.readFully(work, 0, 2);
++ return ((work[1] & 0xff) << 8 | (work[0] & 0xff));
++ }
++
++ /**
++ * Skip over bytes in the stream. See the general contract of the
++ * <code>skipBytes</code> method of <code>DataInput</code>.
++ * <p/>
++ * Bytes for this operation are read from the contained input stream.
++ *
++ * @param n
++ * the number of bytes to be skipped.
++ *
++ * @return the actual number of bytes skipped.
++ * @throws IOException
++ * if an I/O error occurs.
++ */
++ @Override
++ public final int skipBytes(int n) throws IOException {
++ return dis.skipBytes(n);
++ }
++}
+\ No newline at end of file
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-java/apktool.git
More information about the pkg-java-commits
mailing list