1/*
2 * Copyright (c) 2000, 2012, 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/* @test
25 * @bug 6191269 6709457 8000330
26 * @summary Test truncate method of FileChannel
27 * @key randomness
28 */
29
30import java.io.*;
31import java.nio.ByteBuffer;
32import java.nio.channels.*;
33import java.nio.file.Files;
34import static java.nio.file.StandardOpenOption.*;
35import static java.nio.charset.StandardCharsets.*;
36import java.util.Random;
37
38
39/**
40 * Testing FileChannel's truncate method.
41 */
42
43public class Truncate {
44    private static final Random generator = new Random();
45
46    public static void main(String[] args) throws Exception {
47        File blah = File.createTempFile("blah", null);
48        blah.deleteOnExit();
49        try {
50            basicTest(blah);
51            appendTest(blah);
52            exceptionTests(blah);
53        } finally {
54            blah.delete();
55        }
56    }
57
58    /**
59     * Basic test of asserts in truncate's specification.
60     */
61    static void basicTest(File blah) throws Exception {
62        for(int i=0; i<100; i++) {
63            long testSize = generator.nextInt(1000) + 10;
64            initTestFile(blah, testSize);
65
66            try (FileChannel fc = (i < 50) ?
67                 new RandomAccessFile(blah, "rw").getChannel() :
68                 FileChannel.open(blah.toPath(), READ, WRITE))
69                {
70                    if (fc.size() != testSize)
71                        throw new RuntimeException("Size failed");
72
73                    long position = generator.nextInt((int)testSize*2);
74                    fc.position(position);
75
76                    long newSize = generator.nextInt((int)testSize*2);
77                    fc.truncate(newSize);
78
79                    // check new size
80                    if (newSize > testSize) {
81                        if (fc.size() != testSize)
82                            throw new RuntimeException("Attempt to expand file changed size");
83                    } else {
84                        if (fc.size() != newSize)
85                            throw new RuntimeException("Unexpected size after truncate");
86                    }
87
88                    // check new position
89                    if (position > newSize) {
90                        if (fc.position() != newSize)
91                            throw new RuntimeException("Position greater than size");
92                    } else {
93                        if (fc.position() != position)
94                            throw new RuntimeException("Truncate changed position");
95                    };
96                }
97        }
98    }
99
100    /**
101     * Test behavior of truncate method when file is opened for append
102     */
103    static void appendTest(File blah) throws Exception {
104        for (int i=0; i<10; i++) {
105            long testSize = generator.nextInt(1000) + 10;
106            initTestFile(blah, testSize);
107            try (FileChannel fc = (i < 5) ?
108                 new FileOutputStream(blah, true).getChannel() :
109                 FileChannel.open(blah.toPath(), APPEND))
110                {
111                    // truncate file
112                    long newSize = generator.nextInt((int)testSize);
113                    fc.truncate(newSize);
114                    if (fc.size() != newSize)
115                        throw new RuntimeException("Truncate failed");
116
117                    // write one byte
118                    ByteBuffer buf = ByteBuffer.allocate(1);
119                    buf.put((byte)'x');
120                    buf.flip();
121                    fc.write(buf);
122                    if (fc.size() != (newSize+1))
123                        throw new RuntimeException("Unexpected size");
124                }
125        }
126    }
127
128    /**
129     * Test exceptions specified by truncate method
130     */
131    static void exceptionTests(File blah) throws Exception {
132        // check exceptions when channel opened for read access
133        try (FileChannel fc = FileChannel.open(blah.toPath(), READ)) {
134            long size = fc.size();
135
136            // open channel
137            checkException(fc, 0L, NonWritableChannelException.class);
138
139            checkException(fc, -1L, NonWritableChannelException.class,
140                           IllegalArgumentException.class);
141
142            checkException(fc, size+1L, NonWritableChannelException.class);
143
144            // closed channel
145            fc.close();
146
147            checkException(fc, 0L, ClosedChannelException.class);
148
149            checkException(fc, -1L, ClosedChannelException.class,
150                           IllegalArgumentException.class);
151
152            checkException(fc, size+1L, ClosedChannelException.class);
153        }
154
155        // check exceptions when channel opened for write access
156        try (FileChannel fc = FileChannel.open(blah.toPath(), WRITE)) {
157            long size = fc.size();
158
159            // open channel
160            checkException(fc, -1L, IllegalArgumentException.class);
161
162            // closed channel
163            fc.close();
164
165            checkException(fc, 0L, ClosedChannelException.class);
166
167            checkException(fc, -1L, ClosedChannelException.class,
168                           IllegalArgumentException.class);
169
170            checkException(fc, size+1L, ClosedChannelException.class);
171        }
172    }
173
174    /**
175     * Checks that FileChannel truncate throws one of the expected exceptions
176     * when invoked with the given size.
177     */
178    private static void checkException(FileChannel fc, long size, Class<?>... expected)
179        throws IOException
180    {
181        Exception exc = null;
182        try {
183            fc.truncate(size);
184        } catch (Exception actual) {
185            exc = actual;
186        }
187        if (exc != null) {
188            for (Class<?> clazz: expected) {
189                if (clazz.isInstance(exc)) {
190                    return;
191                }
192            }
193        }
194        System.err.println("Expected one of");
195        for (Class<?> clazz: expected) {
196            System.err.println(clazz);
197        }
198        if (exc == null) {
199            throw new RuntimeException("No expection thrown");
200        } else {
201            throw new RuntimeException("Unexpected exception thrown", exc);
202        }
203    }
204
205    /**
206     * Creates file blah of specified size in bytes.
207     */
208    private static void initTestFile(File blah, long size) throws Exception {
209        try (BufferedWriter writer = Files.newBufferedWriter(blah.toPath(), ISO_8859_1)) {
210            for(int i=0; i<size; i++) {
211                writer.write("e");
212            }
213        }
214    }
215}
216