1 /* Licensed to the Apache Software Foundation (ASF) under one or more
2  * contributor license agreements.  See the NOTICE file distributed with
3  * this work for additional information regarding copyright ownership.
4  * The ASF licenses this file to You under the Apache License, Version 2.0
5  * (the "License"); you may not use this file except in compliance with
6  * the License.  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 libcore.java.nio.channels;
18 
19 import java.io.File;
20 import java.io.FileInputStream;
21 import java.io.FileNotFoundException;
22 import java.io.FileOutputStream;
23 import java.io.IOException;
24 import java.io.RandomAccessFile;
25 import java.io.UnsupportedEncodingException;
26 import java.nio.ByteBuffer;
27 import java.nio.MappedByteBuffer;
28 import java.nio.channels.ClosedChannelException;
29 import java.nio.channels.DatagramChannel;
30 import java.nio.channels.FileChannel;
31 import java.nio.channels.FileLock;
32 import java.nio.channels.NonWritableChannelException;
33 import java.nio.channels.OverlappingFileLockException;
34 import java.nio.channels.ReadableByteChannel;
35 import java.nio.channels.WritableByteChannel;
36 import java.util.Arrays;
37 import junit.framework.TestCase;
38 
39 public final class OldFileChannelTest extends TestCase {
40 
41     private static final int CAPACITY = 100;
42 
43     private static final String CONTENT = "MYTESTSTRING needs to be a little long";
44 
45     private static final byte[] TEST_BYTES;
46 
47     static {
48         try {
49             TEST_BYTES = "test".getBytes("iso8859-1");
50         } catch (UnsupportedEncodingException e) {
51             throw new Error(e);
52         }
53     }
54 
55     private static final int CONTENT_LENGTH = CONTENT.length();
56 
57     private static final byte[] CONTENT_AS_BYTES = CONTENT.getBytes();
58 
59     private static final int CONTENT_AS_BYTES_LENGTH = CONTENT_AS_BYTES.length;
60 
61     private FileChannel readOnlyFileChannel;
62 
63     private FileChannel writeOnlyFileChannel;
64 
65     private FileChannel readWriteFileChannel;
66 
67     private File fileOfReadOnlyFileChannel;
68 
69     private File fileOfWriteOnlyFileChannel;
70 
71     private File fileOfReadWriteFileChannel;
72 
73     // to read content from FileChannel
74     private FileInputStream fis;
75 
76     private FileLock fileLock;
77 
setUp()78     protected void setUp() throws Exception {
79         fileOfReadOnlyFileChannel = File.createTempFile(
80                 "File_of_readOnlyFileChannel", "tmp");
81         fileOfReadOnlyFileChannel.deleteOnExit();
82         fileOfWriteOnlyFileChannel = File.createTempFile(
83                 "File_of_writeOnlyFileChannel", "tmp");
84         fileOfWriteOnlyFileChannel.deleteOnExit();
85         fileOfReadWriteFileChannel = File.createTempFile(
86                 "File_of_readWriteFileChannel", "tmp");
87         fileOfReadWriteFileChannel.deleteOnExit();
88         fis = null;
89         fileLock = null;
90         readOnlyFileChannel = new FileInputStream(fileOfReadOnlyFileChannel)
91                 .getChannel();
92         writeOnlyFileChannel = new FileOutputStream(fileOfWriteOnlyFileChannel)
93                 .getChannel();
94         readWriteFileChannel = new RandomAccessFile(fileOfReadWriteFileChannel,
95                 "rw").getChannel();
96     }
97 
tearDown()98     protected void tearDown() {
99         if (null != readOnlyFileChannel) {
100             try {
101                 readOnlyFileChannel.close();
102             } catch (IOException e) {
103                 // do nothing
104             }
105         }
106         if (null != writeOnlyFileChannel) {
107             try {
108                 writeOnlyFileChannel.close();
109             } catch (IOException e) {
110                 // do nothing
111             }
112         }
113         if (null != readWriteFileChannel) {
114             try {
115                 readWriteFileChannel.close();
116             } catch (IOException e) {
117                 // do nothing
118             }
119         }
120         if (null != fis) {
121             try {
122                 fis.close();
123             } catch (IOException e) {
124                 // do nothing
125             }
126         }
127 
128         if (null != fileLock) {
129             try {
130                 fileLock.release();
131             } catch (IOException e) {
132                 // do nothing
133             }
134         }
135 
136         if (null != fileOfReadOnlyFileChannel) {
137             fileOfReadOnlyFileChannel.delete();
138         }
139         if (null != fileOfWriteOnlyFileChannel) {
140             fileOfWriteOnlyFileChannel.delete();
141         }
142         if (null != fileOfReadWriteFileChannel) {
143             fileOfReadWriteFileChannel.delete();
144         }
145     }
146 
test_forceZ()147     public void test_forceZ() throws Exception {
148         ByteBuffer writeBuffer = ByteBuffer.wrap(CONTENT_AS_BYTES);
149         writeOnlyFileChannel.write(writeBuffer);
150         writeOnlyFileChannel.force(true);
151 
152         byte[] readBuffer = new byte[CONTENT_AS_BYTES_LENGTH];
153         fis = new FileInputStream(fileOfWriteOnlyFileChannel);
154         fis.read(readBuffer);
155         assertTrue(Arrays.equals(CONTENT_AS_BYTES, readBuffer));
156 
157         writeOnlyFileChannel.write(writeBuffer);
158         writeOnlyFileChannel.force(false);
159         fis.close();
160 
161         readBuffer = new byte[CONTENT_AS_BYTES_LENGTH];
162         fis = new FileInputStream(fileOfWriteOnlyFileChannel);
163         fis.read(readBuffer);
164         assertTrue(Arrays.equals(CONTENT_AS_BYTES, readBuffer));
165         fis.close();
166     }
167 
168 
169     /**
170      * Initializes test file.
171      *
172      * @param file
173      * @throws FileNotFoundException
174      * @throws IOException
175      */
writeDataToFile(File file)176     private void writeDataToFile(File file) throws FileNotFoundException,
177             IOException {
178         FileOutputStream fos = new FileOutputStream(file);
179         try {
180             fos.write(CONTENT_AS_BYTES);
181         } finally {
182             fos.close();
183         }
184     }
185 
186     /**
187      * Initializes large test file.
188      *
189      * @param file the file to be written
190      * @param size the content size to be written
191      * @throws FileNotFoundException
192      * @throws IOException
193      */
writeLargeDataToFile(File file, int size)194     private void writeLargeDataToFile(File file, int size)
195             throws FileNotFoundException, IOException {
196         FileOutputStream fos = new FileOutputStream(file);
197         byte[] buf = new byte[size];
198 
199         try {
200             // we don't care about content - just need a particular file size
201             fos.write(buf);
202         } finally {
203             fos.close();
204         }
205     }
206 
test_tryLockJJZ_IllegalArgument()207     public void test_tryLockJJZ_IllegalArgument() throws Exception {
208         try {
209             writeOnlyFileChannel.tryLock(0, -1, false);
210             fail("should throw IllegalArgumentException");
211         } catch (IllegalArgumentException e) {
212             // expected
213         }
214 
215         try {
216             writeOnlyFileChannel.tryLock(-1, 0, false);
217             fail("should throw IllegalArgumentException");
218         } catch (IllegalArgumentException e) {
219             // expected
220         }
221 
222         try {
223             readWriteFileChannel.tryLock(-1, -1, false);
224             fail("should throw IllegalArgumentException");
225         } catch (IllegalArgumentException e) {
226             // expected
227         }
228 
229         try {
230             readWriteFileChannel.tryLock(Long.MAX_VALUE, 1, false);
231             fail("should throw IllegalArgumentException");
232         } catch (IllegalArgumentException e) {
233             // expected
234         }
235     }
236 
testTryLockVeryLarge()237     public void testTryLockVeryLarge() throws IOException {
238         long tooBig = Integer.MAX_VALUE + 1L;
239         FileLock lock = readWriteFileChannel.tryLock(tooBig, 1, false);
240         assertLockFails(tooBig, 1);
241         lock.release();
242 
243         lock = readWriteFileChannel.tryLock(0, tooBig, false);
244         assertLockFails(0, 1);
245         lock.release();
246     }
247 
testTryLockOverlapping()248     public void testTryLockOverlapping() throws IOException {
249         FileLock lockOne = readWriteFileChannel.tryLock(0, 10, false);
250         FileLock lockTwo = readWriteFileChannel.tryLock(10, 20, false);
251         assertLockFails(0, 10);
252         lockOne.release();
253         assertLockFails(5, 10);
254         lockOne = readWriteFileChannel.tryLock(0, 10, false);
255         lockTwo.release();
256         lockOne.release();
257     }
258 
test_readLByteBufferJ_IllegalArgument()259     public void test_readLByteBufferJ_IllegalArgument() throws Exception {
260         ByteBuffer readBuffer = ByteBuffer.allocate(CAPACITY);
261 
262         try {
263             readOnlyFileChannel.read(readBuffer, -1);
264             fail("should throw IllegalArgumentException");
265         } catch (IllegalArgumentException e) {
266             // expected
267         }
268 
269         try {
270             writeOnlyFileChannel.read(readBuffer, -1);
271             fail("should throw IllegalArgumentException");
272         } catch (IllegalArgumentException e) {
273             // expected
274         }
275 
276         try {
277             readWriteFileChannel.read(readBuffer, -1);
278             fail("should throw IllegalArgumentException");
279         } catch (IllegalArgumentException e) {
280             // expected
281         }
282 
283         // throws IllegalArgumentException first.
284         readOnlyFileChannel.close();
285         try {
286             readOnlyFileChannel.read(readBuffer, -1);
287             fail("should throw IllegalArgumentException");
288         } catch (IllegalArgumentException e) {
289             // expected
290         }
291 
292         writeOnlyFileChannel.close();
293         try {
294             writeOnlyFileChannel.read(readBuffer, -1);
295             fail("should throw IllegalArgumentException");
296         } catch (IllegalArgumentException e) {
297             // expected
298         }
299 
300         readWriteFileChannel.close();
301         try {
302             readWriteFileChannel.read(readBuffer, -1);
303             fail("should throw IllegalArgumentException");
304         } catch (IllegalArgumentException e) {
305             // expected
306         }
307     }
308 
test_read$LByteBufferII_Null()309     public void test_read$LByteBufferII_Null() throws Exception {
310 
311         try {
312             readOnlyFileChannel.read(null, 0, 1);
313             fail("should throw NullPointerException");
314         } catch (NullPointerException e) {
315             // expected
316         }
317         try {
318             readOnlyFileChannel.read(null, 0, 3);
319             fail("should throw NullPointerException");
320         } catch (NullPointerException e) {
321             // expected
322         }
323         try {
324             readOnlyFileChannel.read(null, 1, 2);
325             fail("should throw NullPointerException");
326         } catch (NullPointerException e) {
327             // expected
328         }
329         try {
330             readOnlyFileChannel.read(null, 2, 1);
331             fail("should throw NullPointerException");
332         } catch (NullPointerException e) {
333             // expected
334         }
335         try {
336             readOnlyFileChannel.read(null, 3, 0);
337             fail("should throw NullPointerException");
338         } catch (NullPointerException e) {
339             // expected
340         }
341 
342         try {
343             writeOnlyFileChannel.read(null, 0, 1);
344             fail("should throw NullPointerException");
345         } catch (NullPointerException e) {
346             // expected
347         }
348         try {
349             writeOnlyFileChannel.read(null, 0, 3);
350             fail("should throw NullPointerException");
351         } catch (NullPointerException e) {
352             // expected
353         }
354         try {
355             writeOnlyFileChannel.read(null, 1, 2);
356             fail("should throw NullPointerException");
357         } catch (NullPointerException e) {
358             // expected
359         }
360         try {
361             writeOnlyFileChannel.read(null, 2, 1);
362             fail("should throw NullPointerException");
363         } catch (NullPointerException e) {
364             // expected
365         }
366         try {
367             writeOnlyFileChannel.read(null, 3, 0);
368             fail("should throw NullPointerException");
369         } catch (NullPointerException e) {
370             // expected
371         }
372 
373         try {
374             readWriteFileChannel.read(null, 0, 1);
375             fail("should throw NullPointerException");
376         } catch (NullPointerException e) {
377             // expected
378         }
379         try {
380             readWriteFileChannel.read(null, 0, 3);
381             fail("should throw NullPointerException");
382         } catch (NullPointerException e) {
383             // expected
384         }
385         try {
386             readWriteFileChannel.read(null, 1, 2);
387             fail("should throw NullPointerException");
388         } catch (NullPointerException e) {
389             // expected
390         }
391         try {
392             readWriteFileChannel.read(null, 2, 1);
393             fail("should throw NullPointerException");
394         } catch (NullPointerException e) {
395             // expected
396         }
397         try {
398             readWriteFileChannel.read(null, 3, 0);
399             fail("should throw NullPointerException");
400         } catch (NullPointerException e) {
401             // expected
402         }
403 
404         // first throws NullPointerException
405         readOnlyFileChannel.close();
406         try {
407             readOnlyFileChannel.read(null, 0, 1);
408             fail("should throw NullPointerException");
409         } catch (NullPointerException e) {
410             // expected
411         }
412         try {
413             readOnlyFileChannel.read(null, 0, 3);
414             fail("should throw NullPointerException");
415         } catch (NullPointerException e) {
416             // expected
417         }
418         try {
419             readOnlyFileChannel.read(null, 1, 2);
420             fail("should throw NullPointerException");
421         } catch (NullPointerException e) {
422             // expected
423         }
424         try {
425             readOnlyFileChannel.read(null, 2, 1);
426             fail("should throw NullPointerException");
427         } catch (NullPointerException e) {
428             // expected
429         }
430         try {
431             readOnlyFileChannel.read(null, 3, 0);
432             fail("should throw NullPointerException");
433         } catch (NullPointerException e) {
434             // expected
435         }
436 
437         readWriteFileChannel.close();
438         try {
439             readWriteFileChannel.read(null, 0, 1);
440             fail("should throw NullPointerException");
441         } catch (NullPointerException e) {
442             // expected
443         }
444         try {
445             readWriteFileChannel.read(null, 0, 3);
446             fail("should throw NullPointerException");
447         } catch (NullPointerException e) {
448             // expected
449         }
450         try {
451             readWriteFileChannel.read(null, 1, 2);
452             fail("should throw NullPointerException");
453         } catch (NullPointerException e) {
454             // expected
455         }
456         try {
457             readWriteFileChannel.read(null, 2, 1);
458             fail("should throw NullPointerException");
459         } catch (NullPointerException e) {
460             // expected
461         }
462         try {
463             readWriteFileChannel.read(null, 3, 0);
464             fail("should throw NullPointerException");
465         } catch (NullPointerException e) {
466             // expected
467         }
468 
469         writeOnlyFileChannel.close();
470         try {
471             writeOnlyFileChannel.read(null, 0, 1);
472             fail("should throw NullPointerException");
473         } catch (NullPointerException e) {
474             // expected
475         }
476         try {
477             writeOnlyFileChannel.read(null, 0, 3);
478             fail("should throw NullPointerException");
479         } catch (NullPointerException e) {
480             // expected
481         }
482         try {
483             writeOnlyFileChannel.read(null, 1, 2);
484             fail("should throw NullPointerException");
485         } catch (NullPointerException e) {
486             // expected
487         }
488         try {
489             writeOnlyFileChannel.read(null, 2, 1);
490             fail("should throw NullPointerException");
491         } catch (NullPointerException e) {
492             // expected
493         }
494         try {
495             writeOnlyFileChannel.read(null, 3, 0);
496             fail("should throw NullPointerException");
497         } catch (NullPointerException e) {
498             // expected
499         }
500     }
501 
502 
doTestForIOOBException(FileChannel channel, ByteBuffer[] buffer)503     private void doTestForIOOBException(FileChannel channel,
504             ByteBuffer[] buffer) throws IOException{
505         try {
506             channel.read(buffer, -1, 0);
507             fail("should throw IndexOutOfBoundException");
508         } catch (IndexOutOfBoundsException e) {
509             // expected
510         }
511         try {
512             channel.read(buffer, 0, -1);
513             fail("should throw IndexOutOfBoundException");
514         } catch (IndexOutOfBoundsException e) {
515             // expected
516         }
517         try {
518             channel.read(buffer, 0, 3);
519             fail("should throw IndexOutOfBoundException");
520         } catch (IndexOutOfBoundsException e) {
521             // expected
522         }
523         try {
524             channel.read(buffer, 1, 2);
525             fail("should throw IndexOutOfBoundException");
526         } catch (IndexOutOfBoundsException e) {
527             // expected
528         }
529         try {
530             channel.read(buffer, 2, 1);
531             fail("should throw IndexOutOfBoundException");
532         } catch (IndexOutOfBoundsException e) {
533             // expected
534         }
535         try {
536             channel.read(buffer, 3, 0);
537             fail("should throw IndexOutOfBoundException");
538         } catch (IndexOutOfBoundsException e) {
539             // expected
540         }
541     }
542 
test_read$LByteBufferII_IndexOutOfBound()543     public void test_read$LByteBufferII_IndexOutOfBound() throws Exception {
544         ByteBuffer[] readBuffers = new ByteBuffer[2];
545         readBuffers[0] = ByteBuffer.allocate(CAPACITY);
546         readBuffers[1] = ByteBuffer.allocate(CAPACITY);
547         ByteBuffer[] readBuffersNull = new ByteBuffer[2];
548 
549         doTestForIOOBException(readOnlyFileChannel, readBuffers);
550         doTestForIOOBException(readWriteFileChannel, readBuffers);
551         doTestForIOOBException(writeOnlyFileChannel, readBuffers);
552 
553         doTestForIOOBException(readOnlyFileChannel, readBuffersNull);
554         doTestForIOOBException(readWriteFileChannel, readBuffersNull);
555         doTestForIOOBException(writeOnlyFileChannel, readBuffersNull);
556         try {
557             readOnlyFileChannel.read(null, -1, 0);
558             fail("should throw IndexOutOfBoundException");
559         } catch (NullPointerException expected) {
560         } catch (IndexOutOfBoundsException expected) {
561         }
562         try {
563             readOnlyFileChannel.read(null, 0, -1);
564             fail("should throw IndexOutOfBoundException");
565         } catch (NullPointerException expected) {
566         } catch (IndexOutOfBoundsException expected) {
567         }
568 
569         try {
570             readWriteFileChannel.read(null, -1, 0);
571             fail("should throw IndexOutOfBoundException");
572         } catch (NullPointerException expected) {
573         } catch (IndexOutOfBoundsException expected) {
574         }
575         try {
576             readWriteFileChannel.read(null, 0, -1);
577             fail("should throw IndexOutOfBoundException");
578         } catch (NullPointerException expected) {
579         } catch (IndexOutOfBoundsException expected) {
580         }
581 
582         try {
583             writeOnlyFileChannel.read(null, -1, 0);
584             fail("should throw IndexOutOfBoundException");
585         } catch (NullPointerException expected) {
586         } catch (IndexOutOfBoundsException expected) {
587         }
588         try {
589             writeOnlyFileChannel.read(null, 0, -1);
590             fail("should throw IndexOutOfBoundException");
591         } catch (NullPointerException expected) {
592         } catch (IndexOutOfBoundsException expected) {
593         }
594 
595         readOnlyFileChannel.close();
596         doTestForIOOBException(readOnlyFileChannel, readBuffers);
597         doTestForIOOBException(readOnlyFileChannel, readBuffersNull);
598 
599         readWriteFileChannel.close();
600         doTestForIOOBException(readWriteFileChannel, readBuffers);
601         doTestForIOOBException(readWriteFileChannel, readBuffersNull);
602 
603         writeOnlyFileChannel.close();
604         doTestForIOOBException(writeOnlyFileChannel, readBuffers);
605         doTestForIOOBException(writeOnlyFileChannel, readBuffersNull);
606     }
607 
test_read$LByteBufferII_EmptyFile()608     public void test_read$LByteBufferII_EmptyFile() throws Exception {
609         ByteBuffer[] readBuffers = new ByteBuffer[2];
610         readBuffers[0] = ByteBuffer.allocate(CAPACITY);
611         readBuffers[1] = ByteBuffer.allocate(CAPACITY);
612         long result = readOnlyFileChannel.read(readBuffers, 0, 2);
613         assertEquals(-1, result);
614         assertEquals(0, readBuffers[0].position());
615         assertEquals(0, readBuffers[1].position());
616     }
617 
test_read$LByteBufferII_EmptyBuffers()618     public void test_read$LByteBufferII_EmptyBuffers() throws Exception {
619         ByteBuffer[] readBuffers = new ByteBuffer[2];
620         readBuffers[0] = ByteBuffer.allocate(CAPACITY);
621 
622         try {
623             readOnlyFileChannel.read(readBuffers, 0, 2);
624         } catch (NullPointerException e) {
625             // expected
626         }
627 
628         writeDataToFile(fileOfReadOnlyFileChannel);
629         readBuffers[0] = ByteBuffer.allocate(CAPACITY);
630         try {
631             readOnlyFileChannel.read(readBuffers, 0, 2);
632         } catch (NullPointerException e) {
633             // expected
634         }
635 
636         long result = readOnlyFileChannel.read(readBuffers, 0, 1);
637         assertEquals(CONTENT_AS_BYTES_LENGTH, result);
638     }
639 
test_isOpen()640     public void test_isOpen() throws Exception {
641         // Regression for HARMONY-40
642         File logFile = File.createTempFile("out", "tmp");
643         logFile.deleteOnExit();
644         FileOutputStream out = new FileOutputStream(logFile, true);
645         FileChannel channel = out.getChannel();
646         out.write(1);
647         assertTrue("Assert 0: Channel is not open", channel.isOpen());
648         out.close();
649         assertFalse("Assert 0: Channel is still open", channel.isOpen());
650     }
651 
test_writeLByteBuffer_Closed()652     public void test_writeLByteBuffer_Closed() throws Exception {
653         ByteBuffer writeBuffer = ByteBuffer.allocate(CAPACITY);
654 
655         readOnlyFileChannel.close();
656         try {
657             readOnlyFileChannel.write(writeBuffer);
658             fail("should throw ClosedChannelException");
659         } catch (ClosedChannelException e) {
660             // expected
661         }
662 
663         writeOnlyFileChannel.close();
664         try {
665             writeOnlyFileChannel.write(writeBuffer);
666             fail("should throw ClosedChannelException");
667         } catch (ClosedChannelException e) {
668             // expected
669         }
670 
671         readWriteFileChannel.close();
672         try {
673             readWriteFileChannel.write(writeBuffer);
674             fail("should throw ClosedChannelException");
675         } catch (ClosedChannelException e) {
676             // expected
677         }
678 
679         // should throw ClosedChannelException first
680         try {
681             readWriteFileChannel.read((ByteBuffer) null);
682             fail("should throw ClosedChannelException");
683         } catch (NullPointerException e) {
684         } catch (ClosedChannelException e) {
685         }
686 
687         try {
688             readOnlyFileChannel.write((ByteBuffer) null);
689             fail("should throw ClosedChannelException");
690         } catch (NullPointerException e) {
691         } catch (ClosedChannelException e) {
692         }
693 
694         writeOnlyFileChannel.close();
695         try {
696             writeOnlyFileChannel.write((ByteBuffer) null);
697             fail("should throw ClosedChannelException");
698         } catch (NullPointerException e) {
699         } catch (ClosedChannelException e) {
700         }
701     }
702 
test_writeLByteBufferJ_Postion_As_Long()703     public void test_writeLByteBufferJ_Postion_As_Long() throws Exception {
704         ByteBuffer writeBuffer = ByteBuffer.wrap(TEST_BYTES);
705         try {
706             writeOnlyFileChannel.write(writeBuffer, Long.MAX_VALUE);
707         } catch (IOException e) {
708             // expected
709         }
710     }
711 
test_writeLByteBufferJ_IllegalArgument()712     public void test_writeLByteBufferJ_IllegalArgument() throws Exception {
713         ByteBuffer writeBuffer = ByteBuffer.allocate(CAPACITY);
714 
715         try {
716             readOnlyFileChannel.write(writeBuffer, -1);
717             fail("should throw IllegalArgumentException");
718         } catch (IllegalArgumentException e) {
719             // expected
720         }
721 
722         try {
723             writeOnlyFileChannel.write(writeBuffer, -1);
724             fail("should throw IllegalArgumentException");
725         } catch (IllegalArgumentException e) {
726             // expected
727         }
728 
729         try {
730             readWriteFileChannel.write(writeBuffer, -1);
731             fail("should throw IllegalArgumentException");
732         } catch (IllegalArgumentException e) {
733             // expected
734         }
735 
736         // throws IllegalArgumentException first.
737         readOnlyFileChannel.close();
738         try {
739             readOnlyFileChannel.write(writeBuffer, -1);
740             fail("should throw IllegalArgumentException");
741         } catch (IllegalArgumentException e) {
742             // expected
743         }
744 
745         writeOnlyFileChannel.close();
746         try {
747             writeOnlyFileChannel.write(writeBuffer, -1);
748             fail("should throw IllegalArgumentException");
749         } catch (IllegalArgumentException e) {
750             // expected
751         }
752 
753         readWriteFileChannel.close();
754         try {
755             readWriteFileChannel.write(writeBuffer, -1);
756             fail("should throw IllegalArgumentException");
757         } catch (IllegalArgumentException e) {
758             // expected
759         }
760     }
761 
test_writeLByteBufferJ_NonZeroPosition()762     public void test_writeLByteBufferJ_NonZeroPosition() throws Exception {
763         final int pos = 5;
764         ByteBuffer writeBuffer = ByteBuffer.wrap(CONTENT_AS_BYTES);
765         writeBuffer.position(pos);
766         int result = writeOnlyFileChannel.write(writeBuffer, pos);
767         assertEquals(CONTENT_AS_BYTES_LENGTH - pos, result);
768         assertEquals(CONTENT_AS_BYTES_LENGTH, writeBuffer.position());
769         writeOnlyFileChannel.close();
770 
771         assertEquals(CONTENT_AS_BYTES_LENGTH, fileOfWriteOnlyFileChannel
772                 .length());
773 
774         fis = new FileInputStream(fileOfWriteOnlyFileChannel);
775         byte[] inputBuffer = new byte[CONTENT_AS_BYTES_LENGTH - pos];
776         fis.skip(pos);
777         fis.read(inputBuffer);
778         String test = CONTENT.substring(pos);
779         assertTrue(Arrays.equals(test.getBytes(), inputBuffer));
780     }
781 
test_write$LByteBuffer_Closed()782     public void test_write$LByteBuffer_Closed() throws Exception {
783         ByteBuffer[] writeBuffers = new ByteBuffer[2];
784         writeBuffers[0] = ByteBuffer.allocate(CAPACITY);
785         writeBuffers[1] = ByteBuffer.allocate(CAPACITY);
786 
787         readOnlyFileChannel.close();
788         try {
789             readOnlyFileChannel.write(writeBuffers);
790             fail("should throw ClosedChannelException");
791         } catch (ClosedChannelException e) {
792             // expected
793         }
794 
795         writeOnlyFileChannel.close();
796         try {
797             writeOnlyFileChannel.write(writeBuffers);
798             fail("should throw ClosedChannelException");
799         } catch (ClosedChannelException e) {
800             // expected
801         }
802 
803         readWriteFileChannel.close();
804         try {
805             readWriteFileChannel.write(writeBuffers);
806             fail("should throw ClosedChannelException");
807         } catch (ClosedChannelException e) {
808             // expected
809         }
810     }
811 
test_write$LByteBuffer_ReadOnly()812     public void test_write$LByteBuffer_ReadOnly() throws Exception {
813         ByteBuffer[] writeBuffers = new ByteBuffer[2];
814         writeBuffers[0] = ByteBuffer.allocate(CAPACITY);
815         writeBuffers[1] = ByteBuffer.allocate(CAPACITY);
816 
817         try {
818             readOnlyFileChannel.write(writeBuffers);
819             fail("should throw NonWritableChannelException");
820         } catch (NonWritableChannelException e) {
821             // expected
822         }
823     }
824 
test_write$LByteBuffer_EmptyBuffers()825     public void test_write$LByteBuffer_EmptyBuffers() throws Exception {
826         ByteBuffer[] writeBuffers = new ByteBuffer[2];
827         writeBuffers[0] = ByteBuffer.allocate(this.CONTENT_LENGTH);
828         try {
829             writeOnlyFileChannel.write(writeBuffers);
830             fail("should throw NullPointerException");
831         } catch (NullPointerException e) {
832             // expected
833         }
834 
835         try {
836             readWriteFileChannel.write(writeBuffers);
837             fail("should throw NullPointerException");
838         } catch (NullPointerException e) {
839             // expected
840         }
841     }
842 
test_write$LByteBuffer()843     public void test_write$LByteBuffer() throws Exception {
844         ByteBuffer[] writeBuffers = new ByteBuffer[2];
845         writeBuffers[0] = ByteBuffer.wrap(CONTENT_AS_BYTES);
846         writeBuffers[1] = ByteBuffer.wrap(CONTENT_AS_BYTES);
847 
848         long result = writeOnlyFileChannel.write(writeBuffers);
849         assertEquals(CONTENT_AS_BYTES_LENGTH * 2, result);
850         assertEquals(CONTENT_AS_BYTES_LENGTH, writeBuffers[0].position());
851         assertEquals(CONTENT_AS_BYTES_LENGTH, writeBuffers[1].position());
852         writeOnlyFileChannel.close();
853 
854         assertEquals(CONTENT_AS_BYTES_LENGTH * 2, fileOfWriteOnlyFileChannel
855                 .length());
856 
857         fis = new FileInputStream(fileOfWriteOnlyFileChannel);
858         byte[] inputBuffer = new byte[CONTENT_AS_BYTES_LENGTH];
859         fis.read(inputBuffer);
860         byte[] expectedResult = new byte[CONTENT_AS_BYTES_LENGTH * 2];
861         System.arraycopy(CONTENT_AS_BYTES, 0, expectedResult, 0,
862                 CONTENT_AS_BYTES_LENGTH);
863         System.arraycopy(CONTENT_AS_BYTES, 0, expectedResult,
864                 CONTENT_AS_BYTES_LENGTH, CONTENT_AS_BYTES_LENGTH);
865         assertTrue(Arrays.equals(CONTENT_AS_BYTES, inputBuffer));
866     }
867 
test_write$LByteBufferII_Null()868     public void test_write$LByteBufferII_Null() throws Exception {
869         ByteBuffer[] writeBuffers = null;
870 
871         try {
872             readOnlyFileChannel.write(writeBuffers, 1, 2);
873             fail("should throw NullPointerException");
874         } catch (NullPointerException e) {
875             // expected
876         }
877 
878         try {
879             writeOnlyFileChannel.write(writeBuffers, 1, 2);
880             fail("should throw NullPointerException");
881         } catch (NullPointerException e) {
882             // expected
883         }
884 
885         try {
886             readWriteFileChannel.write(writeBuffers, 1, 2);
887             fail("should throw NullPointerException");
888         } catch (NullPointerException e) {
889             // expected
890         }
891 
892         // first throws NullPointerException
893         readOnlyFileChannel.close();
894         try {
895             readOnlyFileChannel.write(writeBuffers, 1, 2);
896             fail("should throw NullPointerException");
897         } catch (NullPointerException e) {
898             // expected
899         }
900 
901         writeOnlyFileChannel.close();
902         try {
903             writeOnlyFileChannel.write(writeBuffers, 1, 2);
904             fail("should throw NullPointerException");
905         } catch (NullPointerException e) {
906             // expected
907         }
908 
909         readWriteFileChannel.close();
910         try {
911             readWriteFileChannel.write(writeBuffers, 1, 2);
912             fail("should throw NullPointerException");
913         } catch (NullPointerException e) {
914             // expected
915         }
916     }
917 
test_write$LByteBufferII_IndexOutOfBound()918     public void test_write$LByteBufferII_IndexOutOfBound() throws Exception {
919         ByteBuffer[] writeBuffers = new ByteBuffer[2];
920         writeBuffers[0] = ByteBuffer.allocate(this.CONTENT_LENGTH);
921         writeBuffers[1] = ByteBuffer.allocate(this.CONTENT_LENGTH);
922 
923         try {
924             writeOnlyFileChannel.write(writeBuffers, -1, 0);
925             fail("should throw IndexOutOfBoundsException");
926         } catch (IndexOutOfBoundsException e) {
927             // expected
928         }
929         try {
930             writeOnlyFileChannel.write(writeBuffers, 0, -1);
931             fail("should throw IndexOutOfBoundsException");
932         } catch (IndexOutOfBoundsException e) {
933             // expected
934         }
935         try {
936             writeOnlyFileChannel.write(writeBuffers, 0, 3);
937             fail("should throw IndexOutOfBoundsException");
938         } catch (IndexOutOfBoundsException e) {
939             // expected
940         }
941         try {
942             writeOnlyFileChannel.write(writeBuffers, 1, 2);
943             fail("should throw IndexOutOfBoundsException");
944         } catch (IndexOutOfBoundsException e) {
945             // expected
946         }
947         try {
948             writeOnlyFileChannel.write(writeBuffers, 2, 1);
949             fail("should throw IndexOutOfBoundsException");
950         } catch (IndexOutOfBoundsException e) {
951             // expected
952         }
953         try {
954             writeOnlyFileChannel.write(writeBuffers, 3, 0);
955             fail("should throw IndexOutOfBoundsException");
956         } catch (IndexOutOfBoundsException e) {
957             // expected
958         }
959 
960         try {
961             readWriteFileChannel.write(writeBuffers, -1, 0);
962             fail("should throw IndexOutOfBoundsException");
963         } catch (IndexOutOfBoundsException e) {
964             // expected
965         }
966         try {
967             readWriteFileChannel.write(writeBuffers, 0, -1);
968             fail("should throw IndexOutOfBoundsException");
969         } catch (IndexOutOfBoundsException e) {
970             // expected
971         }
972         try {
973             readWriteFileChannel.write(writeBuffers, 0, 3);
974             fail("should throw IndexOutOfBoundsException");
975         } catch (IndexOutOfBoundsException e) {
976             // expected
977         }
978         try {
979             readWriteFileChannel.write(writeBuffers, 1, 2);
980             fail("should throw IndexOutOfBoundsException");
981         } catch (IndexOutOfBoundsException e) {
982             // expected
983         }
984         try {
985             readWriteFileChannel.write(writeBuffers, 2, 1);
986             fail("should throw IndexOutOfBoundsException");
987         } catch (IndexOutOfBoundsException e) {
988             // expected
989         }
990         try {
991             readWriteFileChannel.write(writeBuffers, 3, 0);
992             fail("should throw IndexOutOfBoundsException");
993         } catch (IndexOutOfBoundsException e) {
994             // expected
995         }
996 
997         try {
998             readOnlyFileChannel.write(writeBuffers, -1, 0);
999             fail("should throw IndexOutOfBoundsException");
1000         } catch (IndexOutOfBoundsException e) {
1001             // expected
1002         }
1003         try {
1004             readOnlyFileChannel.write(writeBuffers, 0, -1);
1005             fail("should throw IndexOutOfBoundsException");
1006         } catch (IndexOutOfBoundsException e) {
1007             // expected
1008         }
1009         try {
1010             readOnlyFileChannel.write(writeBuffers, 0, 3);
1011             fail("should throw IndexOutOfBoundsException");
1012         } catch (IndexOutOfBoundsException e) {
1013             // expected
1014         }
1015         try {
1016             readOnlyFileChannel.write(writeBuffers, 1, 2);
1017             fail("should throw IndexOutOfBoundsException");
1018         } catch (IndexOutOfBoundsException e) {
1019             // expected
1020         }
1021         try {
1022             readOnlyFileChannel.write(writeBuffers, 2, 1);
1023             fail("should throw IndexOutOfBoundsException");
1024         } catch (IndexOutOfBoundsException e) {
1025             // expected
1026         }
1027         try {
1028             readOnlyFileChannel.write(writeBuffers, 3, 0);
1029             fail("should throw IndexOutOfBoundsException");
1030         } catch (IndexOutOfBoundsException e) {
1031             // expected
1032         }
1033     }
1034 
test_write$LByteBufferII_EmptyBuffers()1035     public void test_write$LByteBufferII_EmptyBuffers() throws Exception {
1036         ByteBuffer[] writeBuffers = new ByteBuffer[2];
1037         writeBuffers[0] = ByteBuffer.allocate(this.CONTENT_LENGTH);
1038         try {
1039             writeOnlyFileChannel.write(writeBuffers, 0, 2);
1040             fail("should throw NullPointerException");
1041         } catch (NullPointerException e) {
1042             // expected
1043         }
1044 
1045         try {
1046             readWriteFileChannel.write(writeBuffers, 0, 2);
1047             fail("should throw NullPointerException");
1048         } catch (NullPointerException e) {
1049             // expected
1050         }
1051     }
1052 
test_transferToJJLWritableByteChannel_IllegalArgument()1053     public void test_transferToJJLWritableByteChannel_IllegalArgument()
1054             throws Exception {
1055         WritableByteChannel writableByteChannel = DatagramChannel.open();
1056         try {
1057             readOnlyFileChannel.transferTo(10, -1, writableByteChannel);
1058             fail("should throw IllegalArgumentException.");
1059         } catch (IllegalArgumentException e) {
1060             // expected
1061         }
1062 
1063         try {
1064             readWriteFileChannel.transferTo(-1, 10, writableByteChannel);
1065             fail("should throw IllegalArgumentException.");
1066         } catch (IllegalArgumentException e) {
1067             // expected
1068         }
1069     }
1070 
assertLockFails(long position, long size)1071     private void assertLockFails(long position, long size) throws IOException {
1072         try {
1073             readWriteFileChannel.tryLock(position, size, false);
1074             fail();
1075         } catch (OverlappingFileLockException expected) {
1076         }
1077     }
1078 }
1079