frameworks/base/tests/CoreTests/android/core/DeflateTest.java

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package android.core;
  18
  19 import junit.framework.TestCase;
  20
  21 import java.io.UnsupportedEncodingException;
  22 import java.util.zip.DataFormatException;
  23 import java.util.zip.Deflater;
  24 import java.util.zip.Inflater;
  25 import android.test.suitebuilder.annotation.LargeTest;
  26
  27 public class DeflateTest extends TestCase {
  28
  29     @LargeTest
  30     public void testDeflate() throws Exception {
  31         simpleTest();
  32
  33         bigTest(0, 1738149618);
  34         bigTest(1, 934350518);
  35         bigTest(2, -532869390);
  36     }
  37
  38     /*
  39      * Simple inflate/deflate test, taken from the reference docs for the
  40      * Inflater/Deflater classes.
  41      */
  42     private void simpleTest()
  43             throws UnsupportedEncodingException, DataFormatException {
  44         // Encode a String into bytes
  45         String inputString = "blahblahblah??";
  46         byte[] input = inputString.getBytes("UTF-8");
  47
  48         // Compress the bytes
  49         byte[] output = new byte[100];
  50         Deflater compresser = new Deflater();
  51         compresser.setInput(input);
  52         compresser.finish();
  53         int compressedDataLength = compresser.deflate(output);
  54
  55         // Decompress the bytes
  56         Inflater decompresser = new Inflater();
  57         decompresser.setInput(output, 0, compressedDataLength);
  58         byte[] result = new byte[100];
  59         int resultLength = decompresser.inflate(result);
  60
  61         // Decode the bytes into a String
  62         String outputString = new String(result, 0, resultLength, "UTF-8");
  63
  64         assertEquals(inputString, outputString);
  65         assertEquals(compresser.getAdler(), decompresser.getAdler());
  66
  67         decompresser.end();
  68     }
  69
  70     /*
  71      * "step" determines how compressible the data is.
  72      *
  73      * Note we must set "nowrap" to false, or the Adler-32 doesn't get
  74      * computed.
  75      */
  76     private void bigTest(int step, int expectedAdler)
  77             throws UnsupportedEncodingException, DataFormatException {
  78         byte[] input = new byte[128 * 1024];
  79         byte[] comp = new byte[128 * 1024 + 512];
  80         byte[] output = new byte[128 * 1024 + 512];
  81         Inflater inflater = new Inflater(false);
  82         Deflater deflater = new Deflater(Deflater.BEST_COMPRESSION, false);
  83
  84         createSample(input, step);
  85
  86         compress(deflater, input, comp);
  87         expand(inflater, comp, (int) deflater.getBytesWritten(), output);
  88
  89         assertEquals(inflater.getBytesWritten(), input.length);
  90         assertEquals(deflater.getAdler(), inflater.getAdler());
  91         assertEquals(deflater.getAdler(), expectedAdler);
  92     }
  93
  94     /*
  95      * Create a large data sample.
  96      * stepStep = 0 --> >99% compression
  97      * stepStep = 1 --> ~30% compression
  98      * stepStep = 2 --> no compression
  99      */
 100     private void createSample(byte[] sample, int stepStep) {
 101         byte val, step;
 102         int i, j, offset;
 103
 104         assertTrue(sample.length >= 128 * 1024);
 105
 106         val = 0;
 107         step = 1;
 108         offset = 0;
 109         for (i = 0; i < (128 * 1024) / 256; i++) {
 110             for (j = 0; j < 256; j++) {
 111                 sample[offset++] = val;
 112                 val += step;
 113             }
 114
 115             step += stepStep;
 116         }
 117     }
 118
 119     private static final int LOCAL_BUF_SIZE = 256;
 120
 121     /*
 122      * Compress all data in "in" to "out".  We use a small window on input
 123      * and output to exercise that part of the code.
 124      *
 125      * It's the caller's responsibility to ensure that "out" has enough
 126      * space.
 127      */
 128     private void compress(Deflater deflater, byte[] inBuf, byte[] outBuf) {
 129         int inCount = inBuf.length;        // use all
 130         int inPosn;
 131         int outPosn;
 132
 133         inPosn = outPosn = 0;
 134
 135         //System.out.println("### starting compress");
 136
 137         while (!deflater.finished()) {
 138             int want = -1, got;
 139
 140             // only read if the input buffer is empty
 141             if (deflater.needsInput() && inCount != 0) {
 142                 want = (inCount < LOCAL_BUF_SIZE) ? inCount : LOCAL_BUF_SIZE;
 143
 144                 deflater.setInput(inBuf, inPosn, want);
 145
 146                 inCount -= want;
 147                 inPosn += want;
 148                 if (inCount == 0) {
 149                     deflater.finish();
 150                 }
 151             }
 152
 153             // deflate to current position in output buffer
 154             int compCount;
 155
 156             compCount = deflater.deflate(outBuf, outPosn, LOCAL_BUF_SIZE);
 157             outPosn += compCount;
 158
 159             //System.out.println("Compressed " + want + ", output " + compCount);
 160         }
 161     }
 162
 163     /*
 164      * Expand data from "inBuf" to "outBuf".  Uses a small window to better
 165      * exercise the code.
 166      */
 167     private void expand(Inflater inflater, byte[] inBuf, int inCount,
 168             byte[] outBuf) throws DataFormatException {
 169         int inPosn;
 170         int outPosn;
 171
 172         inPosn = outPosn = 0;
 173
 174         //System.out.println("### starting expand, inCount is " + inCount);
 175
 176         while (!inflater.finished()) {
 177             int want = -1, got;
 178
 179             // only read if the input buffer is empty
 180             if (inflater.needsInput() && inCount != 0) {
 181                 want = (inCount < LOCAL_BUF_SIZE) ? inCount : LOCAL_BUF_SIZE;
 182
 183                 inflater.setInput(inBuf, inPosn, want);
 184
 185                 inCount -= want;
 186                 inPosn += want;
 187             }
 188
 189             // inflate to current position in output buffer
 190             int compCount;
 191
 192             compCount = inflater.inflate(outBuf, outPosn, LOCAL_BUF_SIZE);
 193             outPosn += compCount;
 194
 195             //System.out.println("Expanded " + want + ", output " + compCount);
 196         }
 197     }
 198 }
 199