FileInputStreamTest.java revision b1f55cb6f95928be969a8fe5c7447e13f14d0a68 
1/*
2 * Copyright (C) 2010 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
17package libcore.java.io;
18
19import java.io.File;
20import java.io.FileDescriptor;
21import java.io.FileInputStream;
22import java.io.FileNotFoundException;
23import java.io.FileOutputStream;
24import java.io.IOException;
25import junit.framework.TestCase;
26
27import libcore.io.IoUtils;
28import libcore.io.Libcore;
29
30public final class FileInputStreamTest extends TestCase {
31    private static final int TOTAL_SIZE = 1024;
32    private static final int SKIP_SIZE = 100;
33
34    private static class DataFeeder extends Thread {
35        private FileDescriptor mOutFd;
36
37        public DataFeeder(FileDescriptor fd) {
38            mOutFd = fd;
39        }
40
41        @Override
42        public void run() {
43            try {
44                FileOutputStream fos = new FileOutputStream(mOutFd);
45                try {
46                    byte[] buffer = new byte[TOTAL_SIZE];
47                    for (int i = 0; i < buffer.length; ++i) {
48                        buffer[i] = (byte) i;
49                    }
50                    fos.write(buffer);
51                } finally {
52                    IoUtils.closeQuietly(fos);
53                    IoUtils.close(mOutFd);
54                }
55            } catch (IOException e) {
56                throw new RuntimeException(e);
57            }
58        }
59    }
60
61    private void verifyData(FileInputStream is, int start, int count) throws IOException {
62        byte buffer[] = new byte[count];
63        assertEquals(count, is.read(buffer));
64        for (int i = 0; i < count; ++i) {
65            assertEquals((byte) (i + start), buffer[i]);
66        }
67    }
68
69    public void testSkipInPipes() throws Exception {
70        FileDescriptor[] pipe = Libcore.os.pipe();
71        DataFeeder feeder = new DataFeeder(pipe[1]);
72        try {
73            feeder.start();
74            FileInputStream fis = new FileInputStream(pipe[0]);
75            fis.skip(SKIP_SIZE);
76            verifyData(fis, SKIP_SIZE, TOTAL_SIZE - SKIP_SIZE);
77            assertEquals(-1, fis.read());
78            feeder.join(1000);
79            assertFalse(feeder.isAlive());
80        } finally {
81            IoUtils.closeQuietly(pipe[0]);
82        }
83    }
84
85    public void testDirectories() throws Exception {
86        try {
87            new FileInputStream(".");
88            fail();
89        } catch (FileNotFoundException expected) {
90        }
91    }
92
93    private File makeFile() throws Exception {
94        File tmp = File.createTempFile("FileOutputStreamTest", "tmp");
95        FileOutputStream fos = new FileOutputStream(tmp);
96        fos.write(1);
97        fos.write(1);
98        fos.close();
99        return tmp;
100    }
101
102    public void testFileDescriptorOwnership() throws Exception {
103        File tmp = makeFile();
104
105        FileInputStream fis1 = new FileInputStream(tmp);
106        FileInputStream fis2 = new FileInputStream(fis1.getFD());
107
108        // Close the second FileDescriptor and check we can't use it...
109        fis2.close();
110        try {
111            fis2.available();
112            fail();
113        } catch (IOException expected) {
114        }
115        try {
116            fis2.read();
117            fail();
118        } catch (IOException expected) {
119        }
120        try {
121            fis2.read(new byte[1], 0, 1);
122            fail();
123        } catch (IOException expected) {
124        }
125        try {
126            fis2.skip(1);
127            fail();
128        } catch (IOException expected) {
129        }
130        // ...but that we can still use the first.
131        assertFalse(fis1.read() == -1);
132
133        // Close the first FileDescriptor and check we can't use it...
134        fis1.close();
135        try {
136            fis1.available();
137            fail();
138        } catch (IOException expected) {
139        }
140        try {
141            fis1.read();
142            fail();
143        } catch (IOException expected) {
144        }
145        try {
146            fis1.read(new byte[1], 0, 1);
147            fail();
148        } catch (IOException expected) {
149        }
150        try {
151            fis1.skip(1);
152            fail();
153        } catch (IOException expected) {
154        }
155    }
156
157    public void testClose() throws Exception {
158        File tmp = makeFile();
159        FileInputStream fis = new FileInputStream(tmp);
160
161        // Closing an already-closed stream is a no-op...
162        fis.close();
163        fis.close();
164
165        // But any explicit activity is an error.
166        try {
167            fis.available();
168            fail();
169        } catch (IOException expected) {
170        }
171        try {
172            fis.read();
173            fail();
174        } catch (IOException expected) {
175        }
176        try {
177            fis.read(new byte[1], 0, 1);
178            fail();
179        } catch (IOException expected) {
180        }
181        try {
182            fis.skip(1);
183            fail();
184        } catch (IOException expected) {
185        }
186        // Including 0-byte skips...
187        try {
188            fis.skip(0);
189            fail();
190        } catch (IOException expected) {
191        }
192        // ...but not 0-byte reads...
193        fis.read(new byte[0], 0, 0);
194    }
195}
196