/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed 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 android.content.res.cts;


import android.content.res.AssetFileDescriptor;
import android.os.ParcelFileDescriptor;
import android.test.AndroidTestCase;
import android.test.MoreAsserts;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class AssetFileDescriptor_AutoCloseInputStreamTest extends AndroidTestCase {
    private static final int FILE_END = -1;
    private static final String FILE_NAME = "testAssertFileDescriptorAutoCloseInputStream";
    private static final byte[] FILE_DATA = new byte[] {
            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
            };
    private static final int FILE_LENGTH = FILE_DATA.length;

    private File mFile;
    private AssetFileDescriptor mFd;
    private AssetFileDescriptor.AutoCloseInputStream mInput;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        mFile = new File(getContext().getFilesDir(), FILE_NAME);
        FileOutputStream outputStream = new FileOutputStream(mFile);
        outputStream.write(FILE_DATA);
        outputStream.close();
    }

    @Override
    protected void tearDown() throws Exception {
        super.tearDown();
        if (mFd != null) {
            mFd.close();
            mFd = null;
        }
        mFile.delete();
    }

    public void testSkip() throws IOException {
        openInput(0, FILE_LENGTH);
        assertEquals(FILE_DATA[0], mInput.read());
        assertEquals(0, mInput.skip(0));
        assertEquals(FILE_DATA[1], mInput.read());
        assertEquals(3, mInput.skip(3));
        assertEquals(FILE_DATA[5], mInput.read());
        assertEquals(3, mInput.skip(10));
        assertEquals(FILE_END, mInput.read());
    }

    public void testRead() throws IOException {
        openInput(0, FILE_LENGTH);
        for (int i = 0; i < FILE_LENGTH; i++) {
            assertEquals(FILE_DATA[i], mInput.read());
        }
        assertEquals(FILE_END, mInput.read());
    }

    public void testReadPartial() throws IOException {
        long len = 6;
        openInput(0, len);
        for (int i = 0; i < len; i++) {
            assertEquals(FILE_DATA[i], mInput.read());
        }
        assertEquals(FILE_END, mInput.read());
    }

    public void testReadBufferLen() throws IOException {
        openInput(0, FILE_LENGTH);
        byte[] buf = new byte[FILE_LENGTH];
        assertEquals(3, mInput.read(buf, 0, 3));
        assertEquals(3, mInput.read(buf, 3, 3));
        assertEquals(3, mInput.read(buf, 6, 4));
        MoreAsserts.assertEquals(FILE_DATA, buf);
        assertEquals(FILE_END, mInput.read(buf, 0, 4));
    }

    public void testReadBuffer() throws IOException {
        openInput(0, FILE_LENGTH);
        byte[] buf = new byte[6];
        assertEquals(6, mInput.read(buf));
        assertEquals(FILE_DATA[0], buf[0]);
        assertEquals(3, mInput.read(buf));
        assertEquals(FILE_DATA[6], buf[0]);
        assertEquals(FILE_END, mInput.read(buf));
    }

    public void testReadBufferPartial() throws IOException {
        long len = 8;
        openInput(0, len);
        byte[] buf = new byte[6];
        assertEquals(6, mInput.read(buf));
        assertEquals(FILE_DATA[0], buf[0]);
        assertEquals(2, mInput.read(buf));
        assertEquals(FILE_DATA[6], buf[0]);
        assertEquals(FILE_END, mInput.read(buf));
    }

    public void testAvailableRead() throws IOException {
        openInput(0, FILE_LENGTH);
        assertEquals(FILE_LENGTH, mInput.available());
        assertEquals(FILE_DATA[0], mInput.read());
        assertEquals(FILE_LENGTH -1 , mInput.available());
    }

    public void testAvailableReadBuffer() throws IOException {
        openInput(0, FILE_LENGTH);
        byte[] buf = new byte[3];
        assertEquals(FILE_LENGTH, mInput.available());
        assertEquals(buf.length, mInput.read(buf));
        assertEquals(FILE_LENGTH - buf.length, mInput.available());
    }

    public void testAvailableReadBufferLen() throws IOException {
        openInput(0, FILE_LENGTH);
        byte[] buf = new byte[3];
        assertEquals(FILE_LENGTH, mInput.available());
        assertEquals(2, mInput.read(buf, 0, 2));
        assertEquals(FILE_LENGTH - 2, mInput.available());
    }

    /*
     * Tests that AutoInputStream doesn't support mark().
     */
    public void testMark() throws IOException {
        openInput(0, FILE_LENGTH);
        assertFalse(mInput.markSupported());
        assertEquals(FILE_DATA[0], mInput.read());
        mInput.mark(FILE_LENGTH);  // should do nothing
        assertEquals(FILE_DATA[1], mInput.read());
        mInput.reset();  // should do nothing
        assertEquals(FILE_DATA[2], mInput.read());
    }

    public void testTwoFileDescriptorsWorkIndependently() throws IOException {
        openInput(0, FILE_LENGTH);

        AssetFileDescriptor fd2 = new AssetFileDescriptor(mFd.getParcelFileDescriptor(),
                0,
                FILE_LENGTH);
        AssetFileDescriptor.AutoCloseInputStream input2 =
                new AssetFileDescriptor.AutoCloseInputStream(fd2);

        input2.skip(2);
        input2.read();

        for (int i = 0; i < FILE_LENGTH; i++) {
            assertEquals(FILE_DATA[i], mInput.read());
        }
        assertEquals(FILE_END, mInput.read());
    }

    private void openInput(long startOffset, long length)
            throws IOException {
        if (mFd != null) {
            mFd.close();
            mFd = null;
        }
        ParcelFileDescriptor fd =
                ParcelFileDescriptor.open(mFile, ParcelFileDescriptor.MODE_READ_WRITE);
        mFd = new AssetFileDescriptor(fd, startOffset, length);
        mInput = new AssetFileDescriptor.AutoCloseInputStream(mFd);
    }
}