1/*
2 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24/**
25 *  @test
26 *  @bug  4181483
27 *  @summary Test if InputStream methods will check if the stream
28 *          has been closed.
29 */
30
31import java.io.*;
32
33public enum OpsAfterClose {
34
35        READ { boolean check(InputStream is) {
36                    try {
37                        int read = is.read();
38                        System.out.println("read returns: " + read);
39                    } catch (IOException io) {
40                        System.out.print("Excep Msg: "+ io.getMessage() + ", ");
41                        return true;
42                    }
43                    return false;
44             } },
45
46        READ_BUF { boolean check(InputStream is) {
47                    try {
48                        byte buf[] = new byte[2];
49                        int read = is.read(buf);
50                        System.out.println("read(buf) returns: " + read);
51                    } catch (IOException io) {
52                        System.out.print("Excep Msg: "+ io.getMessage() + ", ");
53                        return true;
54                    }
55                    return false;
56            } },
57        READ_BUF_OFF { boolean check(InputStream is) {
58                    try {
59                        byte buf[] = new byte[2];
60                        int len = 1;
61                        int read = is.read(buf, 0, len);
62                        System.out.println("read(buf, 0, len) returns: " + read);
63                    } catch (IOException io) {
64                        System.out.print("Excep Msg: "+ io.getMessage() + ", ");
65                        return true;
66                    }
67                    return false;
68             } },
69        AVAILABLE { boolean check(InputStream is) {
70                    try {
71                        int avail = is.available();
72                        System.out.println("available() returns: " + avail);
73                        return false;
74                    } catch (IOException io) {
75                        System.out.print("Excep Msg: "+ io.getMessage() + ", ");
76                        return true;
77                    }
78             } },
79        SKIP { boolean check(InputStream is) {
80                    try {
81                        long skipped = is.skip(1);
82                        System.out.println("skip() returns: " + skipped);
83                    } catch (IOException io) {
84                        System.out.print("Excep Msg: "+ io.getMessage() + ", ");
85                        return true;
86                    }
87                    return false;
88             } },
89        MARK { boolean check(InputStream is) {
90                    is.mark(20);
91                    return true;
92             } },
93        RESET { boolean check(InputStream is) {
94                    try {
95                        is.reset();
96                    } catch (IOException io) {
97                        System.out.print("Excep Msg: "+ io.getMessage() + ", ");
98                        return true;
99                    }
100                    return false;
101             } },
102        MARK_SUPPORTED { boolean check(InputStream is) {
103                    is.markSupported();
104                    return true;
105             } },
106        CLOSE { boolean check(InputStream is) {
107                try {
108                    is.close();
109                    return true; // No Exception thrown on windows for FileInputStream
110                } catch (IOException io) {
111                    System.out.print("Excep Msg: "+ io.getMessage() + ", ");
112                    return true; // Exception thrown on solaris and linux for FileInputStream
113                }
114             } };
115
116    abstract boolean check(InputStream is);
117
118    public static void main(String args[]) throws Exception {
119
120        boolean failed = false;
121
122        File f = new File(System.getProperty("test.dir", "."),
123                          "f.txt");
124        f.createNewFile();
125        f.deleteOnExit();
126
127        FileInputStream fis = new FileInputStream(f);
128        try {
129            if (testInputStream(fis)) {
130                failed = true;
131            }
132            if (testFileInputStream(fis)) {
133                failed = true;
134            }
135        } finally {
136            fis.close();
137        }
138
139        BufferedInputStream bs =  new BufferedInputStream(
140                                        new FileInputStream(f));
141        try {
142            if (testInputStream(bs)) {
143                failed = true;
144            }
145        } finally {
146            bs.close();
147        }
148
149        DataInputStream dis = new DataInputStream(
150                                new FileInputStream(f));
151        try {
152            if (testInputStream(dis)) {
153                failed = true;
154            }
155        } finally {
156            dis.close();
157        }
158
159        PushbackInputStream pbis = new PushbackInputStream(
160                                new ByteArrayInputStream(new byte[20]));
161        if (testInputStream(pbis)) {
162            failed = true;
163        }
164
165        if (testPushbackInputStream(pbis)) {
166            failed = true;
167        }
168
169        PipedInputStream pis = new PipedInputStream(new PipedOutputStream());
170        if (testInputStream(pis)) {
171            failed = true;
172        }
173
174        /**
175         * The SequenceInputStream and  ObjectInputStream does not throw IOException
176
177        SequenceInputStream sqis = new SequenceInputStream(
178                                        new FileInputStream(f),
179                                        new PipedInputStream(new PipedOutputStream())
180                                    );
181        if (testInputStream(sqis)) {
182            failed = true;
183        }
184
185        String serStr = "abc";
186        ObjectOutputStream oos = new ObjectOutputStream(
187                                    new FileOutputStream(f));
188        oos.writeObject(serStr);
189        oos.close();
190
191        ObjectInputStream ois = new ObjectInputStream(
192                                    new FileInputStream(f));
193        if (testInputStream(ois)) {
194            failed = true;
195        }
196
197        */
198
199        if (failed) {
200            throw new Exception(
201                "Some Op for some Stream failed, check the failed status above");
202        }
203    }
204
205    private static boolean testInputStream(InputStream is)
206            throws Exception {
207        is.close();
208        boolean failed = false;
209        boolean result;
210        System.out.println("Testing :" + is);
211        for (OpsAfterClose op : OpsAfterClose.values()) {
212
213            if (op.equals(AVAILABLE) && (is instanceof PipedInputStream)) {
214                // skip the test as available() returns 0
215                continue;
216            }
217
218            result = op.check(is);
219            if (!result) {
220                failed = true;
221            }
222           System.out.println(op + ":" + result);
223        }
224        if (failed) {
225            System.out.println("Test failed for the failed operation{s}" +
226                        " above for :" + is);
227        }
228        return failed;
229    }
230
231    private static boolean testPushbackInputStream(PushbackInputStream pis)
232                throws Exception {
233        boolean failed = false;
234        try {
235            pis.unread(1);
236            System.out.println("Test failed for unread(int):" + pis);
237            failed = true;
238        } catch (IOException io) {
239           System.out.println("UNREAD(int):true");
240        }
241
242        byte buf[] = new byte[2];
243        try {
244            pis.unread(buf, 0, 2);
245            System.out.println("Test failed for unread(buf, offset, len):" +
246                                pis);
247            failed = true;
248        } catch (IOException io) {
249           System.out.println("UNREAD(buf, offset, len):true");
250        }
251        try {
252            pis.unread(buf);
253            System.out.println("Test failed for unread(char[] buf):" + pis);
254            failed = true;
255        } catch (IOException io) {
256           System.out.println("UNREAD(buf):true");
257        }
258        return failed;
259    }
260
261    private static boolean testFileInputStream(FileInputStream fis)
262                throws Exception {
263        boolean failed = false;
264        try {
265            fis.getFD();
266            System.out.println("GetFD: true");
267        } catch (IOException io) {
268           System.out.println("GetFD: false");
269           failed = true;
270        }
271        fis.getChannel();
272        System.out.println("GetChannel: true");
273        return failed;
274    }
275}
276