1/*
2 *  Licensed to the Apache Software Foundation (ASF) under one or more
3 *  contributor license agreements.  See the NOTICE file distributed with
4 *  this work for additional information regarding copyright ownership.
5 *  The ASF licenses this file to You under the Apache License, Version 2.0
6 *  (the "License"); you may not use this file except in compliance with
7 *  the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 */
17
18package org.apache.harmony.nio.tests.java.nio.channels;
19
20import java.io.IOException;
21import java.io.InputStream;
22import java.io.OutputStream;
23import java.net.BindException;
24import java.net.ConnectException;
25import java.net.InetAddress;
26import java.net.InetSocketAddress;
27import java.net.ServerSocket;
28import java.net.Socket;
29import java.net.SocketAddress;
30import java.net.SocketException;
31import java.nio.Buffer;
32import java.nio.ByteBuffer;
33import java.nio.channels.AlreadyConnectedException;
34import java.nio.channels.ClosedChannelException;
35import java.nio.channels.ConnectionPendingException;
36import java.nio.channels.IllegalBlockingModeException;
37import java.nio.channels.NoConnectionPendingException;
38import java.nio.channels.NotYetConnectedException;
39import java.nio.channels.ServerSocketChannel;
40import java.nio.channels.SocketChannel;
41import java.nio.channels.UnresolvedAddressException;
42import java.nio.channels.UnsupportedAddressTypeException;
43import java.nio.channels.spi.SelectorProvider;
44
45import junit.framework.TestCase;
46import tests.support.Support_PortManager;
47
48/**
49 * Tests for SocketChannel and its default implementation.
50 */
51public class SocketChannelTest extends TestCase {
52
53    private static final int CAPACITY_NORMAL = 200;
54
55    private InetSocketAddress localAddr1;
56
57    private InetSocketAddress localAddr2;
58
59    private SocketChannel channel1;
60
61    private SocketChannel channel2;
62
63    private ServerSocket server1;
64
65    private ServerSocket server2;
66
67    private final static int TIMEOUT = 60000;
68
69    private final static int EOF = -1;
70
71    protected void setUp() throws Exception {
72        super.setUp();
73        this.localAddr1 = new InetSocketAddress("127.0.0.1",
74                Support_PortManager.getNextPort());
75        this.localAddr2 = new InetSocketAddress("127.0.0.1",
76                Support_PortManager.getNextPort());
77        this.channel1 = SocketChannel.open();
78        this.channel2 = SocketChannel.open();
79        this.server1 = new ServerSocket(localAddr1.getPort());
80    }
81
82    protected void tearDown() throws Exception {
83        super.tearDown();
84        if (null != this.channel1) {
85            try {
86                this.channel1.close();
87            } catch (Exception e) {
88                //ignore
89            }
90        }
91        if (null != this.channel2) {
92            try {
93                this.channel2.close();
94            } catch (Exception e) {
95                //ignore
96            }
97        }
98        if (null != this.server1) {
99            try {
100                this.server1.close();
101            } catch (Exception e) {
102                //ignore
103            }
104        }
105        if (null != this.server2) {
106            try {
107                this.server2.close();
108            } catch (Exception e) {
109                //ignore
110            }
111        }
112    }
113
114    // -------------------------------------------------------------------
115    // Test for methods in abstract class.
116    // -------------------------------------------------------------------
117    /*
118     * Test method for 'java.nio.channels.SocketChannel.validOps()'
119     */
120    public void testValidOps() {
121        MockSocketChannel testMSChannel = new MockSocketChannel(null);
122        assertEquals(13, this.channel1.validOps());
123        assertEquals(13, testMSChannel.validOps());
124    }
125
126    /*
127     * Test method for 'java.nio.channels.SocketChannel.open()'
128     */
129    public void testOpen() throws IOException {
130        java.nio.ByteBuffer[] buf = new java.nio.ByteBuffer[1];
131        buf[0] = java.nio.ByteBuffer.allocateDirect(CAPACITY_NORMAL);
132        MockSocketChannel testMSChannel = new MockSocketChannel(null);
133        MockSocketChannel testMSChannelnotnull = new MockSocketChannel(
134                SelectorProvider.provider());
135        assertNull(testMSChannel.provider());
136        assertNotNull(testMSChannelnotnull.provider());
137        assertNotNull(this.channel1);
138        assertEquals(this.channel1.provider(), testMSChannelnotnull.provider());
139        try {
140            this.channel1.write(buf);
141            fail("Should throw NotYetConnectedException");
142        } catch (NotYetConnectedException e) {
143            // correct
144        }
145    }
146
147    /*
148     * Test method for 'java.nio.channels.SocketChannel.open(SocketAddress)'
149     */
150    public void testOpenSocketAddress_Null() throws IOException {
151        SocketChannel channel1IP = null;
152        try {
153            channel1IP = SocketChannel.open(null);
154            fail("Should throw an IllegalArgumentException");
155        } catch (IllegalArgumentException e) {
156            // correct
157        }
158        assertNull(channel1IP);
159    }
160
161    /*
162     * Test method for 'java.nio.channels.SocketChannel.read(ByteBuffer[])'
163     */
164    public void testReadByteBufferArray() throws IOException {
165        java.nio.ByteBuffer[] byteBuf = null;
166        MockSocketChannel testMSChannelnull = new MockSocketChannel(null);
167        MockSocketChannel testMSChannel = new MockSocketChannel(
168                SelectorProvider.provider());
169        ServerSocket testServer = new ServerSocket(Support_PortManager
170                .getNextPort());
171        try {
172            try {
173                this.channel1.read(byteBuf);
174                fail("Should throw NPE");
175            } catch (NullPointerException e) {
176                // correct
177            }
178            byteBuf = new java.nio.ByteBuffer[CAPACITY_NORMAL];
179            try {
180                this.channel1.read(byteBuf);
181                fail("Should throw NotYetConnectedException");
182            } catch (NotYetConnectedException e) {
183                // correct
184            }
185            long readNum = CAPACITY_NORMAL;
186            readNum = testMSChannel.read(byteBuf);
187            assertEquals(0, readNum);
188            readNum = CAPACITY_NORMAL;
189            readNum = testMSChannelnull.read(byteBuf);
190            assertEquals(0, readNum);
191        } finally {
192            testServer.close();
193        }
194    }
195
196    /*
197     * Test method for 'java.nio.channels.SocketChannel.read(ByteBuffer[])'
198     */
199    public void testReadByteBufferArray_BufNull() throws IOException {
200        java.nio.ByteBuffer[] byteBuf = null;
201        MockSocketChannel testMSChannelnull = new MockSocketChannel(null);
202        MockSocketChannel testMSChannel = new MockSocketChannel(
203                SelectorProvider.provider());
204        try {
205            this.channel1.read(byteBuf);
206            fail("Should throw NPE");
207        } catch (NullPointerException e) {
208            // correct
209        }
210        try {
211            testMSChannel.read(byteBuf);
212            fail("Should throw NPE");
213        } catch (NullPointerException e) {
214            // correct
215        }
216        try {
217            testMSChannelnull.read(byteBuf);
218            fail("Should throw NPE");
219        } catch (NullPointerException e) {
220            // correct
221        }
222    }
223
224    /*
225     * Test method for 'java.nio.channels.SocketChannel.write(ByteBuffer[])'
226     */
227    public void testWriteByteBufferArray() throws IOException {
228        java.nio.ByteBuffer[] byteBuf = null;
229        MockSocketChannel testMSChannelnull = new MockSocketChannel(null);
230        MockSocketChannel testMSChannel = new MockSocketChannel(
231                SelectorProvider.provider());
232        try {
233            this.channel1.write(byteBuf);
234            fail("Should throw NPE");
235        } catch (NullPointerException e) {
236            // correct
237        }
238        byteBuf = new java.nio.ByteBuffer[CAPACITY_NORMAL];
239        try {
240            this.channel1.write(byteBuf);
241            fail("Should throw NotYetConnectedException");
242        } catch (NotYetConnectedException e) {
243            // correct
244        }
245        testMSChannel.write(byteBuf);
246        testMSChannelnull.write(byteBuf);
247    }
248
249    /*
250     * Test method for 'java.nio.channels.SocketChannel.write(ByteBuffer[])'
251     */
252    public void testWriteByteBufferArray_BufNull() throws IOException {
253        java.nio.ByteBuffer[] byteBuf = null;
254        MockSocketChannel testMSChannelnull = new MockSocketChannel(null);
255        MockSocketChannel testMSChannel = new MockSocketChannel(
256                SelectorProvider.provider());
257        try {
258            this.channel1.write(byteBuf);
259            fail("Should throw NPE");
260        } catch (NullPointerException e) {
261            // correct
262        }
263        try {
264            testMSChannel.write(byteBuf);
265            fail("Should throw NPE");
266        } catch (NullPointerException e) {
267            // correct
268        }
269        try {
270            testMSChannelnull.write(byteBuf);
271            fail("Should throw NPE");
272        } catch (NullPointerException e) {
273            // correct
274        }
275    }
276
277    public void testSocket_BasicStatusBeforeConnect() throws IOException {
278        assertFalse(this.channel1.isConnected());// not connected
279        Socket s1 = this.channel1.socket();
280        assertSocketBeforeConnect(s1);
281        Socket s2 = this.channel1.socket();
282        // same
283        assertSame(s1, s2);
284    }
285
286    public void testSocket_Block_BasicStatusAfterConnect() throws IOException {
287        assertFalse(this.channel1.isConnected());// not connected
288        assertTrue(this.channel1.connect(localAddr1));
289
290        assertTrue(this.channel1.isConnected());
291        Socket s1 = this.channel1.socket();
292
293        assertSocketAfterConnect(s1, localAddr1);
294        Socket s2 = this.channel1.socket();
295        // same
296        assertSame(s1, s2);
297    }
298
299    public void testSocket_NonBlock_BasicStatusAfterConnect() throws Exception {
300        assertFalse(this.channel1.isConnected());// not connected
301        this.channel1.configureBlocking(false);
302        boolean connected = channel1.connect(localAddr1);
303        Socket s1 = null;
304        Socket s2 = null;
305        if (!connected) {
306            assertFalse(this.channel1.isConnected());
307            assertTrue(this.channel1.isConnectionPending());
308            s1 = this.channel1.socket();
309            // status of not connected
310            assertSocketBeforeConnect(s1);
311            s2 = this.channel1.socket();
312            // same
313            assertSame(s1, s2);
314        }
315
316        if (tryFinish()) {
317            assertTrue(this.channel1.isConnected());
318            s1 = this.channel1.socket();
319            assertSocketAfterConnect(s1, localAddr1);
320            s2 = this.channel1.socket();
321            // same
322            assertSame(s1, s2);
323        }
324    }
325
326    public void testSocket_Block_ActionsBeforeConnect() throws IOException {
327        assertFalse(this.channel1.isConnected());// not connected
328        Socket s = this.channel1.socket();
329        assertSocketAction_Block_BeforeConnect(s);
330    }
331
332    public void testSocket_Block_ActionsAfterConnect() throws IOException {
333        assertFalse(this.channel1.isConnected());// not connected
334        assertTrue(this.channel1.connect(localAddr1));
335        assertTrue(this.channel1.isConnected());
336        Socket s = this.channel1.socket();
337        assertSocketAction_Block_AfterConnect(s);
338
339    }
340
341    public void testSocket_NonBlock_ActionsAfterConnectBeforeFinish()
342            throws IOException {
343        assertFalse(this.channel1.isConnected());// not connected
344        this.channel1.configureBlocking(false);
345        boolean connected = channel1.connect(localAddr1);
346        if (!connected) {
347            assertFalse(this.channel1.isConnected());
348            assertTrue(this.channel1.isConnectionPending());
349            Socket s1 = this.channel1.socket();
350            // Action of not connected
351            assertSocketAction_NonBlock_BeforeConnect(s1);
352            Socket s2 = this.channel1.socket();
353            // same
354            assertSame(s1, s2);
355        }
356    }
357
358    public void testSocket_NonBlock_ActionsAfterConnectAfterFinish()
359            throws Exception {
360        assertFalse(this.channel1.isConnected());// not connected
361        this.channel1.configureBlocking(false);
362        channel1.connect(localAddr1);
363        if (tryFinish()) {
364            Socket s1 = this.channel1.socket();
365            assertSocketAction_NonBlock_AfterConnect(s1);
366            Socket s2 = this.channel1.socket();
367            // same
368            assertSame(s1, s2);
369        }
370    }
371
372    public void testSocket_getInetAddress() throws Exception {
373        Socket socket = channel1.socket();
374        assertNull(socket.getInetAddress());
375
376        channel1.connect(localAddr1);
377
378        assertNotNull(socket.getInetAddress());
379        assertEquals(localAddr1.getAddress(), socket.getInetAddress());
380    }
381
382    public void testSocket_getRemoteSocketAddress() throws Exception {
383        Socket socket = channel1.socket();
384        assertNull(socket.getRemoteSocketAddress());
385
386        channel1.connect(localAddr1);
387
388        assertNotNull(socket.getRemoteSocketAddress());
389        assertEquals(localAddr1, socket.getRemoteSocketAddress());
390    }
391
392    public void testSocket_getPort() throws Exception {
393        Socket socket = channel1.socket();
394        assertEquals(0, socket.getPort());
395
396        channel1.connect(localAddr1);
397
398        assertEquals(localAddr1.getPort(), socket.getPort());
399    }
400
401    public void testSocket_getLocalAddress() throws Exception {
402        Socket socket = channel1.socket();
403        assertNotNull(socket.getLocalAddress());
404
405        channel1.connect(localAddr1);
406
407        assertNotNull(socket.getLocalAddress());
408    }
409
410    public void testSocket_getLocalSocketAddress() throws Exception {
411        Socket socket = channel1.socket();
412        assertNull(socket.getLocalSocketAddress());
413
414        channel1.connect(localAddr1);
415
416        assertNotNull(socket.getLocalSocketAddress());
417    }
418
419    public void testSocket_getLocalPort() throws Exception {
420        Socket socket = channel1.socket();
421        assertEquals(-1, socket.getLocalPort());
422
423        channel1.connect(localAddr1);
424
425        assertTrue(-1 != socket.getLocalPort());
426        assertTrue(0 != socket.getLocalPort());
427    }
428
429    public void testSocket_bind() throws Exception {
430        Socket socket = channel1.socket();
431        socket.bind(new InetSocketAddress("127.0.0.1", 0));
432        assertEquals("127.0.0.1", socket.getLocalAddress().getHostAddress());
433        assertTrue(socket.getLocalPort() != -1);
434    }
435
436    private void assertSocketBeforeConnect(Socket s) throws IOException {
437        assertFalse(s.isBound());
438        assertFalse(s.isClosed());
439        assertFalse(s.isConnected());
440        assertFalse(s.getKeepAlive());
441        try {
442            s.getInputStream();
443            fail("Should throw SocketException.");
444        } catch (SocketException e) {
445            // OK.
446        }
447        assertFalse(s.getOOBInline());
448        try {
449            s.getOutputStream();
450            fail("Should throw SocketException.");
451        } catch (SocketException e) {
452            // OK.
453        }
454        assertEquals(-1, s.getSoLinger());
455        assertFalse(s.getTcpNoDelay());
456
457        assertFalse(s.isInputShutdown());
458        assertFalse(s.isOutputShutdown());
459
460        assertNull(s.getInetAddress());
461        assertEquals(s.getLocalAddress().getHostAddress(), "0.0.0.0");
462        // RI fails here. RI returns 0 while spec says unbound socket should
463        // return -1.
464        assertEquals(-1, s.getLocalPort());
465        assertFalse(s.getReuseAddress());
466        assertNull(s.getLocalSocketAddress());
467
468        // not connected
469        assertEquals(0, s.getPort());
470        assertTrue(s.getReceiveBufferSize() >= 8192);
471        assertNull(s.getRemoteSocketAddress());
472        assertTrue(s.getSendBufferSize() >= 8192);
473        assertEquals(0, s.getSoTimeout());
474        assertEquals(0, s.getTrafficClass());
475
476    }
477
478    private void assertSocketAfterConnect(Socket s, InetSocketAddress address)
479            throws IOException {
480        assertTrue(s.isBound());
481        assertFalse(s.isClosed());
482        assertTrue(s.isConnected());
483        assertFalse(s.getKeepAlive());
484
485        assertNotNull(s.getInputStream());
486        assertNotNull(s.getOutputStream());
487
488        assertFalse(s.getOOBInline());
489        assertEquals(-1, s.getSoLinger());
490        assertFalse(s.getTcpNoDelay());
491
492        assertFalse(s.isInputShutdown());
493        assertFalse(s.isOutputShutdown());
494
495        assertSame(s.getInetAddress(), address.getAddress());
496
497        assertEquals(s.getLocalAddress(), this.localAddr1.getAddress());
498        assertEquals(s.getPort(), address.getPort());
499        assertNotNull(s.getLocalSocketAddress());
500        assertTrue(s.getReceiveBufferSize() >= 8192);
501        assertEquals(s.getRemoteSocketAddress(), (SocketAddress) address);
502        // assertFalse(s.getReuseAddress());
503        assertTrue(s.getSendBufferSize() >= 8192);
504        assertEquals(0, s.getSoTimeout());
505        assertEquals(0, s.getTrafficClass());
506    }
507
508    private void assertSocketAction_Block_BeforeConnect(Socket s)
509            throws IOException {
510        assertFalse(this.channel1.isConnected());
511        this.server2 = new ServerSocket(localAddr2.getPort());
512        s.connect(localAddr2);
513        assertTrue(this.channel1.isConnected());
514        assertTrue(s.isConnected());
515
516        assertSocketAfterConnect(s, localAddr2);
517
518        try {
519            s.bind(localAddr2);
520            fail("Should throw AlreadyConnectedException");
521        } catch (AlreadyConnectedException e) {
522            // OK.
523        }
524
525        s.close();
526        assertTrue(s.isClosed());
527        assertFalse(this.channel1.isOpen());
528    }
529
530    private void assertSocketAction_NonBlock_BeforeConnect(Socket s)
531            throws IOException {
532        assertFalse(this.channel1.isConnected());
533        this.server2 = new ServerSocket(localAddr2.getPort());
534        try {
535            s.connect(localAddr2);
536            fail("Should throw IllegalBlockingModeException");
537        } catch (IllegalBlockingModeException e1) {
538            // OK.
539        }
540
541        if (this.channel1.isConnectionPending()) {
542            try {
543                s.bind(localAddr2);
544                fail("Should throw ConnectionPendingException");
545            } catch (ConnectionPendingException e1) {
546                // OK.
547            }
548        } else {
549            try {
550                s.bind(localAddr2);
551                fail("Should throw BindException");
552            } catch (BindException e1) {
553                // OK.
554            }
555        }
556
557        assertFalse(this.channel1.isConnected());
558        assertFalse(s.isConnected());
559
560        s.close();
561        assertTrue(s.isClosed());
562        assertFalse(this.channel1.isOpen());
563    }
564
565    private void assertSocketAction_Block_AfterConnect(Socket s)
566            throws IOException {
567        assertEquals(s.getPort(), localAddr1.getPort());
568        assertTrue(this.channel1.isConnected());
569        assertTrue(s.isConnected());
570        try {
571            s.connect(localAddr2);
572            fail("Should throw AlreadyConnectedException");
573        } catch (AlreadyConnectedException e) {
574            // OK.
575        }
576
577        try {
578            s.bind(localAddr2);
579            fail("Should throw AlreadyConnectedException");
580        } catch (AlreadyConnectedException e) {
581            // OK.
582        }
583
584        s.close();
585        assertTrue(s.isClosed());
586        assertFalse(this.channel1.isOpen());
587    }
588
589    private void assertSocketAction_NonBlock_AfterConnect(Socket s)
590            throws IOException {
591        assertEquals(s.getPort(), localAddr1.getPort());
592        assertTrue(this.channel1.isConnected());
593        assertTrue(s.isConnected());
594
595        if (this.channel1.isConnectionPending()) {
596            try {
597                s.connect(localAddr2);
598                fail("Should throw AlreadyConnectedException");
599            } catch (AlreadyConnectedException e) {
600                // OK.
601            }
602        } else {
603            try {
604                s.connect(localAddr2);
605                fail("Should throw IllegalBlockingModeException");
606            } catch (IllegalBlockingModeException e) {
607                // OK.
608            }
609        }
610
611        try {
612            s.bind(localAddr2);
613            fail("Should throw AlreadyConnectedException");
614        } catch (AlreadyConnectedException e) {
615            // OK.
616        }
617
618        s.close();
619        assertTrue(s.isClosed());
620        assertFalse(this.channel1.isOpen());
621    }
622
623    // -------------------------------------------------------------------
624    // Tests for connect(), finishConnect(),isConnected(),isConnectionPending()
625    // These methods are very close, so we test them together, call them "CFII".
626    // -------------------------------------------------------------------
627    /**
628     * connect-->finish-->close
629     */
630    public void testCFII_Norml_NoServer_Block() throws Exception {
631        // ensure
632        ensureServerClosed();
633        assertTrue(this.channel1.isBlocking());
634        statusNotConnected_NotPending();
635        // connect
636        try {
637            this.channel1.connect(localAddr1);
638            fail("Should throw a ConnectException here.");
639        } catch (ConnectException e) {
640            // OK.
641        }
642        statusChannelClosed();
643        try {
644            this.channel1.finishConnect();
645            fail("Should throw a ClosedChannelException here.");
646        } catch (ClosedChannelException e) {
647            // OK.
648        }
649    }
650
651    /**
652     * connect-->finish-->close
653     */
654    public void testCFII_Norml_NoServer_NonBlock() throws Exception {
655        connectNoServerNonBlock();
656
657        this.channel1.close();
658        statusChannelClosed();
659    }
660
661    /**
662     * connect-->finish-->close
663     */
664    public void testCFII_Norml_Server_Block() throws Exception {
665        connectServerBlock();
666
667        this.channel1.close();
668        statusChannelClosed();
669
670    }
671
672    /**
673     * connect-->finish-->close
674     */
675    public void testCFII_Norml_Server_NonBlock() throws Exception {
676        connectServerNonBlock();
677
678        this.channel1.close();
679        statusChannelClosed();
680    }
681
682    /**
683     * connect-->server closed-->finish-->close
684     */
685    public void testCFII_ServerClosed_Block() throws Exception {
686        // ensure
687        ensureServerOpen();
688        assertTrue(this.channel1.isBlocking());
689        statusNotConnected_NotPending();
690        // connect
691        assertTrue(this.channel1.connect(localAddr1));
692        statusConnected_NotPending();
693
694        ensureServerClosed();
695
696        tryFinish();
697
698        this.channel1.close();
699        statusChannelClosed();
700
701    }
702
703    /**
704     * connect-->server closed-->finish-->close
705     */
706    public void testCFII_ServerClosed_NonBlock() throws Exception {
707        // ensure
708        ensureServerOpen();
709        this.channel1.configureBlocking(false);
710        statusNotConnected_NotPending();
711        // connect
712        boolean connected = channel1.connect(localAddr1);
713        if (!connected) {
714            statusNotConnected_Pending();
715        }
716        ensureServerClosed();
717
718        tryFinish();
719
720        this.channel1.close();
721        statusChannelClosed();
722    }
723
724    /**
725     * connect-->finish-->server closed-->close
726     */
727    public void testCFII_ServerClosedAfterFinish_Block() throws Exception {
728        connectServerBlock();
729
730        ensureServerClosed();
731        assertTrue(this.channel1.isOpen());
732        this.channel1.close();
733        statusChannelClosed();
734
735    }
736
737    /**
738     * connect-->finish-->server closed-->close
739     */
740    public void testCFII_ServerClosedAfterFinish_NonBlock() throws Exception {
741        connectServerNonBlock();
742
743        ensureServerClosed();
744        assertTrue(this.channel1.isOpen());
745        this.channel1.close();
746        statusChannelClosed();
747    }
748
749    /**
750     * no server-->connect-->server open-->finish-->close
751     */
752    public void testCFII_ServerStartLater_Block() throws Exception {
753        // ensure
754        ensureServerClosed();
755        assertTrue(this.channel1.isBlocking());
756        statusNotConnected_NotPending();
757        // connect
758        try {
759            this.channel1.connect(localAddr1);
760            fail("Should throw a ConnectException here.");
761        } catch (ConnectException e) {
762            // OK.
763        }
764        statusChannelClosed();
765        ensureServerOpen();
766        try {
767            this.channel1.finishConnect();
768            fail("Should throw a ClosedChannelException here.");
769        } catch (ClosedChannelException e) {
770            // OK.
771        }
772    }
773
774    /**
775     * no server-->connect-->server open-->finish-->close
776     */
777    public void testCFII_ServerStartLater_NonBlock() throws Exception {
778        // ensure
779        ensureServerClosed();
780        this.channel1.configureBlocking(false);
781        statusNotConnected_NotPending();
782        // connect
783        assertFalse(this.channel1.connect(localAddr1));
784        statusNotConnected_Pending();
785
786        ensureServerOpen();
787
788        try {
789            assertFalse(this.channel1.finishConnect());
790            statusNotConnected_Pending();
791            this.channel1.close();
792        } catch (ConnectException e) {
793            // FIXME: assertEquals(e.getMessage(), "Connection refused");
794        }
795    }
796
797    /**
798     * connect-->finish-->finish-->close
799     */
800    public void testCFII_FinishTwice_NoServer_NonBlock() throws Exception {
801        // ensure
802        ensureServerClosed();
803        this.channel1.configureBlocking(false);
804        statusNotConnected_NotPending();
805        // connect
806        assertFalse(this.channel1.connect(localAddr1));
807        statusNotConnected_Pending();
808        try {
809            assertFalse(this.channel1.finishConnect());
810            statusNotConnected_Pending();
811            assertFalse(this.channel1.finishConnect());
812            statusNotConnected_Pending();
813            this.channel1.close();
814        } catch (ConnectException e) {
815          // FIXME: assertEquals(e.getMessage(), "Connection refused");
816        }
817        statusChannelClosed();
818    }
819
820    /**
821     * connect-->finish-->finish-->close
822     */
823    public void testCFII_FinishTwice_Server_Block() throws Exception {
824        connectServerBlock();
825        tryFinish();
826        this.channel1.close();
827        statusChannelClosed();
828
829    }
830
831    /**
832     * connect-->finish-->finish-->close
833     */
834    public void testCFII_FinishTwice_Server_NonBlock() throws Exception {
835        connectServerNonBlock();
836        tryFinish();
837        this.channel1.close();
838        statusChannelClosed();
839    }
840
841    /**
842     * connect-->finish-->connect-->close
843     */
844    public void testCFII_ConnectAfterFinish_NoServer_Block() throws Exception {
845        // ensure
846        ensureServerClosed();
847        assertTrue(this.channel1.isBlocking());
848        statusNotConnected_NotPending();
849        // connect
850        try {
851            this.channel1.connect(localAddr1);
852            fail("Should throw a ConnectException here.");
853        } catch (ConnectException e) {
854            // OK.
855        }
856        statusChannelClosed();
857        try {
858            this.channel1.finishConnect();
859            fail("Should throw a ClosedChannelException here.");
860        } catch (ClosedChannelException e) {
861            // OK.
862        }
863        statusChannelClosed();
864        try {
865            this.channel1.connect(localAddr1);
866            fail("Should throw a ClosedChannelException here.");
867        } catch (ClosedChannelException e) {
868            // OK.
869        }
870        statusChannelClosed();
871    }
872
873    /**
874     * connect-->finish-->connect-->close
875     */
876    public void testCFII_ConnectAfterFinish_NoServer_NonBlock()
877            throws Exception {
878        // ensure
879        ensureServerClosed();
880        this.channel1.configureBlocking(false);
881        statusNotConnected_NotPending();
882        // connect
883        assertFalse(this.channel1.connect(localAddr1));
884        statusNotConnected_Pending();
885        try {
886            assertFalse(this.channel1.finishConnect());
887            statusNotConnected_Pending();
888        } catch (ConnectException e) {
889            // FIXME: assertEquals(e.getMessage(), "Connection refused");
890        }
891
892        if (this.channel1.isOpen()) {
893
894            try {
895                this.channel1.connect(localAddr1);
896                fail("Should throw a ConnectionPendingException here.");
897            } catch (ConnectionPendingException e) {
898                // OK.
899            }
900            statusNotConnected_Pending();
901
902            // connect another addr
903            try {
904                this.channel1.connect(localAddr2);
905                fail("Should throw a ConnectionPendingException here.");
906            } catch (ConnectionPendingException e) {
907                // OK.
908            }
909            statusNotConnected_Pending();
910
911            // connect if server closed
912            ensureServerClosed();
913
914            try {
915                this.channel1.connect(localAddr1);
916                fail("Should throw a ConnectionPendingException here.");
917            } catch (ConnectionPendingException e) {
918                // OK.
919            }
920            statusNotConnected_Pending();
921
922            this.channel1.close();
923        }
924        statusChannelClosed();
925    }
926
927    /**
928     * connect-->finish-->connect-->close
929     */
930    public void testCFII_ConnectAfterFinish_Server_Block() throws Exception {
931        connectServerBlock();
932
933        if (!this.channel1.isConnected()) {
934            System.err
935                    .println("Connection fail, testCFII_ConnectAfterFinish_Server_Block is not finished.");
936            return;
937        }
938
939        try {
940            this.channel1.connect(localAddr1);
941            fail("Should throw an AlreadyConnectedException here.");
942        } catch (AlreadyConnectedException e) {
943            // OK.
944        }
945        statusConnected_NotPending();
946
947        // connect another addr
948        try {
949            this.channel1.connect(localAddr2);
950            fail("Should throw an AlreadyConnectedException here.");
951        } catch (AlreadyConnectedException e) {
952            // OK.
953        }
954        statusConnected_NotPending();
955
956        // connect if server closed
957        ensureServerClosed();
958
959        try {
960            this.channel1.connect(localAddr1);
961            fail("Should throw an AlreadyConnectedException here.");
962        } catch (AlreadyConnectedException e) {
963            // OK.
964        }
965        statusConnected_NotPending();
966
967        this.channel1.close();
968        statusChannelClosed();
969
970    }
971
972    /**
973     * connect-->finish-->connect-->close
974     */
975    public void testCFII_ConnectAfterFinish_Server_NonBlock() throws Exception {
976        connectServerNonBlock();
977
978        if (!this.channel1.isConnected()) {
979            System.err
980                    .println("Connection fail, testCFII_ConnectAfterFinish_Server_Block is not finished.");
981            return;
982        }
983        try {
984            this.channel1.connect(localAddr1);
985            fail("Should throw an AlreadyConnectedException or a ConnectionPendingException here.");
986        } catch (AlreadyConnectedException e) {
987            // OK.
988        }
989
990        statusConnected_NotPending();
991
992        // connect another addr
993        try {
994            this.channel1.connect(localAddr2);
995            fail("Should throw an AlreadyConnectedException here.");
996        } catch (AlreadyConnectedException e) {
997            // OK.
998        }
999        statusConnected_NotPending();
1000
1001        // connect if server closed
1002        ensureServerClosed();
1003
1004        try {
1005            this.channel1.connect(localAddr1);
1006            fail("Should throw an AlreadyConnectedException here.");
1007        } catch (AlreadyConnectedException e) {
1008            // OK.
1009        }
1010        statusConnected_NotPending();
1011
1012        this.channel1.close();
1013        statusChannelClosed();
1014    }
1015
1016    /**
1017     * connect-->connect-->finish-->close
1018     */
1019    public void testCFII_ConnectTwice_NoServer_NonBlock() throws Exception {
1020        // ensure
1021        ensureServerClosed();
1022        this.channel1.configureBlocking(false);
1023        statusNotConnected_NotPending();
1024        // connect
1025        assertFalse(this.channel1.connect(localAddr1));
1026        statusNotConnected_Pending();
1027
1028        try {
1029            this.channel1.connect(localAddr1);
1030            fail("Should throw a ConnectionPendingException here.");
1031        } catch (ConnectionPendingException e) {
1032            // OK.
1033        }
1034        statusNotConnected_Pending();
1035
1036        // connect another addr
1037        try {
1038            this.channel1.connect(localAddr2);
1039            fail("Should throw a ConnectionPendingException here.");
1040        } catch (ConnectionPendingException e) {
1041            // OK.
1042        }
1043        statusNotConnected_Pending();
1044
1045        // connect if server closed
1046        ensureServerClosed();
1047
1048        try {
1049            this.channel1.connect(localAddr1);
1050            fail("Should throw a ConnectionPendingException here.");
1051        } catch (ConnectionPendingException e) {
1052            // OK.
1053        }
1054        statusNotConnected_Pending();
1055
1056        try {
1057            assertFalse(this.channel1.finishConnect());
1058            statusNotConnected_Pending();
1059            this.channel1.close();
1060        } catch (ConnectException e) {
1061            // FIXME: assertEquals(e.getMessage(), "Connection refused");
1062        }
1063
1064        statusChannelClosed();
1065    }
1066
1067    /**
1068     * connect-->connect-->finish-->close
1069     */
1070    public void testCFII_ConnectTwice_Server_Block() throws Exception {
1071        // ensure
1072        ensureServerOpen();
1073        assertTrue(this.channel1.isBlocking());
1074        statusNotConnected_NotPending();
1075        // connect
1076        assertTrue(this.channel1.connect(localAddr1));
1077        statusConnected_NotPending();
1078
1079        try {
1080            this.channel1.connect(localAddr1);
1081            fail("Should throw an AlreadyConnectedException here.");
1082        } catch (AlreadyConnectedException e) {
1083            // OK.
1084        }
1085        statusConnected_NotPending();
1086
1087        // connect another addr
1088        try {
1089            this.channel1.connect(localAddr2);
1090            fail("Should throw an AlreadyConnectedException here.");
1091        } catch (AlreadyConnectedException e) {
1092            // OK.
1093        }
1094        statusConnected_NotPending();
1095
1096        // connect if server closed
1097        ensureServerClosed();
1098
1099        try {
1100            this.channel1.connect(localAddr1);
1101            fail("Should throw an AlreadyConnectedException here.");
1102        } catch (AlreadyConnectedException e) {
1103            // OK.
1104        }
1105        statusConnected_NotPending();
1106
1107        tryFinish();
1108
1109        this.channel1.close();
1110        statusChannelClosed();
1111
1112    }
1113
1114    /**
1115     * connect-->connect-->finish-->close
1116     */
1117    public void testCFII_ConnectTwice_Server_NonBlock() throws Exception {
1118        // ensure
1119        ensureServerOpen();
1120        this.channel1.configureBlocking(false);
1121        statusNotConnected_NotPending();
1122        // connect
1123        boolean connected = channel1.connect(localAddr1);
1124        if (!connected) {
1125            statusNotConnected_Pending();
1126
1127            try {
1128                this.channel1.connect(localAddr1);
1129                fail("Should throw a ConnectionPendingException here.");
1130            } catch (ConnectionPendingException e) {
1131                // OK.
1132            }
1133            statusNotConnected_Pending();
1134
1135            // connect another addr
1136            try {
1137                this.channel1.connect(localAddr2);
1138                fail("Should throw a ConnectionPendingException here.");
1139            } catch (ConnectionPendingException e) {
1140                // OK.
1141            }
1142            statusNotConnected_Pending();
1143
1144            // connect if server closed
1145            ensureServerClosed();
1146
1147            try {
1148                this.channel1.connect(localAddr1);
1149                fail("Should throw a ConnectionPendingException here.");
1150            } catch (ConnectionPendingException e) {
1151                // OK.
1152            }
1153            statusNotConnected_Pending();
1154        }
1155        tryFinish();
1156
1157        this.channel1.close();
1158        statusChannelClosed();
1159    }
1160
1161    /**
1162     * finish-->connect-->finish-->close
1163     */
1164    public void testCFII_FinishFirst_NoServer_Block() throws Exception {
1165        // ensure
1166        ensureServerClosed();
1167        assertTrue(this.channel1.isBlocking());
1168        statusNotConnected_NotPending();
1169        // finish
1170        try {
1171            this.channel1.finishConnect();
1172            fail("Should throw NoConnectionPendingException");
1173        } catch (NoConnectionPendingException e) {
1174            // OK.
1175        }
1176        statusNotConnected_NotPending();
1177        // connect
1178        try {
1179            this.channel1.connect(localAddr1);
1180            fail("Should throw a ConnectException here.");
1181        } catch (ConnectException e) {
1182            // OK.
1183        }
1184        statusChannelClosed();
1185        try {
1186            this.channel1.finishConnect();
1187            fail("Should throw a ClosedChannelException here.");
1188        } catch (ClosedChannelException e) {
1189            // OK.
1190        }
1191        statusChannelClosed();
1192    }
1193
1194    /**
1195     * finish-->connect-->finish-->close
1196     */
1197    public void testCFII_FinishFirst_NoServer_NonBlock() throws Exception {
1198        // ensure
1199        ensureServerClosed();
1200        this.channel1.configureBlocking(false);
1201        statusNotConnected_NotPending();
1202        // finish
1203        try {
1204            this.channel1.finishConnect();
1205            fail("Should throw NoConnectionPendingException");
1206        } catch (NoConnectionPendingException e) {
1207            // OK.
1208        }
1209        statusNotConnected_NotPending();
1210        // connect
1211        assertFalse(this.channel1.connect(localAddr1));
1212        statusNotConnected_Pending();
1213
1214        try {
1215            assertFalse(this.channel1.finishConnect());
1216            statusNotConnected_Pending();
1217            this.channel1.close();
1218        } catch (ConnectException e) {
1219            // FIXME: assertEquals(e.getMessage(), "Connection refused");
1220        }
1221
1222        statusChannelClosed();
1223    }
1224
1225    /**
1226     * finish-->connect-->finish-->close
1227     */
1228    public void testCFII_FinishFirst_Server_Block() throws Exception {
1229        // ensure
1230        ensureServerOpen();
1231        assertTrue(this.channel1.isBlocking());
1232        statusNotConnected_NotPending();
1233        // finish
1234        try {
1235            this.channel1.finishConnect();
1236            fail("Should throw NoConnectionPendingException");
1237        } catch (NoConnectionPendingException e) {
1238            // OK.
1239        }
1240        statusNotConnected_NotPending();
1241        // connect
1242        assertTrue(this.channel1.connect(localAddr1));
1243        statusConnected_NotPending();
1244
1245        tryFinish();
1246
1247        this.channel1.close();
1248        statusChannelClosed();
1249
1250    }
1251
1252    /**
1253     * finish-->connect-->finish-->close
1254     */
1255    public void testCFII_FinishFirst_Server_NonBlock() throws Exception {
1256        // ensure
1257        ensureServerOpen();
1258        this.channel1.configureBlocking(false);
1259        statusNotConnected_NotPending();
1260        // finish
1261        try {
1262            this.channel1.finishConnect();
1263            fail("Should throw NoConnectionPendingException");
1264        } catch (NoConnectionPendingException e) {
1265            // OK.
1266        }
1267        statusNotConnected_NotPending();
1268        // connect
1269        boolean connected = channel1.connect(localAddr1);
1270        if (!connected) {
1271            statusNotConnected_Pending();
1272        }
1273        tryFinish();
1274
1275        this.channel1.close();
1276        statusChannelClosed();
1277    }
1278
1279    public void testCFII_Null() throws Exception {
1280        statusNotConnected_NotPending();
1281        try {
1282            this.channel1.connect(null);
1283            fail("Should throw an IllegalArgumentException here.");
1284        } catch (IllegalArgumentException e) {
1285            // OK.
1286        }
1287    }
1288
1289    public void testCFII_UnsupportedType() throws Exception {
1290        class SubSocketAddress extends SocketAddress {
1291            private static final long serialVersionUID = 1L;
1292
1293            //empty
1294            public SubSocketAddress() {
1295                super();
1296            }
1297        }
1298        statusNotConnected_NotPending();
1299        SocketAddress newTypeAddress = new SubSocketAddress();
1300        try {
1301            this.channel1.connect(newTypeAddress);
1302            fail("Should throw an UnsupportedAddressTypeException here.");
1303        } catch (UnsupportedAddressTypeException e) {
1304            // OK.
1305        }
1306    }
1307
1308    public void testCFII_Unresolved() throws IOException {
1309        statusNotConnected_NotPending();
1310        InetSocketAddress unresolved = new InetSocketAddress(
1311                "unresolved address", 1080);
1312        try {
1313            this.channel1.connect(unresolved);
1314            fail("Should throw an UnresolvedAddressException here.");
1315        } catch (UnresolvedAddressException e) {
1316            // OK.
1317        }
1318    }
1319
1320    public void testCFII_EmptyHost() throws Exception {
1321        statusNotConnected_NotPending();
1322        ServerSocket server = new ServerSocket(0);
1323        int port = server.getLocalPort();
1324        server.close();
1325        try {
1326            this.channel1.connect(new InetSocketAddress("", port));
1327            fail("Should throw ConnectException");
1328        } catch (ConnectException e) {
1329            // correct
1330        }
1331    }
1332
1333    public void testCFII_CloseFirst() throws Exception {
1334        this.channel1.close();
1335        statusChannelClosed();
1336        ensureServerOpen();
1337        try {
1338            this.channel1.connect(localAddr1);
1339            fail("Should throw ClosedChannelException.");
1340        } catch (ClosedChannelException e) {
1341            // OK.
1342        }
1343        statusChannelClosed();
1344        try {
1345            this.channel1.finishConnect();
1346            fail("Should throw ClosedChannelException.");
1347        } catch (ClosedChannelException e) {
1348            // OK.
1349        }
1350        statusChannelClosed();
1351        try {
1352            this.channel1.configureBlocking(false);
1353            fail("Should throw ClosedChannelException.");
1354        } catch (ClosedChannelException e) {
1355            // OK.
1356        }
1357        statusChannelClosed();
1358    }
1359
1360    public void testCFII_StatusAfterFinish() throws Exception {
1361        // 1. close server, finish must return false, check the status
1362        ensureServerClosed();
1363
1364        // 1.1 block mode
1365        assertTrue(this.channel1.isBlocking());
1366        try {
1367            channel1.connect(localAddr1);
1368            fail("Should throw ConnectException");
1369        } catch (ConnectException e) {
1370            // OK.
1371        }
1372        assertFalse(this.channel1.isOpen());
1373
1374        assertFalse(this.channel1.isOpen());
1375        assertTrue(this.channel1.isBlocking());
1376        assertFalse(this.channel1.isConnectionPending());
1377
1378        // 1.2 non block mode
1379        this.channel1 = SocketChannel.open();
1380        this.channel1.configureBlocking(false);
1381        assertFalse(this.channel1.connect(localAddr1));
1382        try {
1383            assertFalse(this.channel1.finishConnect());
1384            statusNotConnected_Pending();
1385            this.channel1.close();
1386        } catch (ConnectException e) {
1387            System.out.println(e.getMessage());
1388        }
1389
1390        // 2. start server, finish usually return true, check the status
1391        ensureServerOpen();
1392
1393        // 2.1 block mode
1394        this.channel1 = SocketChannel.open();
1395        assertTrue(this.channel1.isBlocking());
1396        assertTrue(this.channel1.connect(localAddr1));
1397        assertTrue(this.channel1.finishConnect());
1398        statusConnected_NotPending();
1399        this.channel1.close();
1400
1401        // 2.2 non block mode
1402        this.channel1 = SocketChannel.open();
1403        this.channel1.configureBlocking(false);
1404        assertFalse(this.channel1.connect(localAddr1));
1405        tryFinish();
1406        this.channel1.close();
1407    }
1408
1409    private void ensureServerClosed() throws IOException {
1410        if (null != this.server1) {
1411            this.server1.close();
1412            assertTrue(this.server1.isClosed());
1413        }
1414        if (null != this.server2) {
1415            this.server2.close();
1416            assertTrue(this.server2.isClosed());
1417        }
1418    }
1419
1420    private void ensureServerOpen() throws IOException {
1421        ensureServerClosed();
1422        this.server1 = new ServerSocket(localAddr1.getPort());
1423        this.server2 = new ServerSocket(localAddr2.getPort());
1424        assertTrue(this.server1.isBound());
1425        assertTrue(this.server2.isBound());
1426    }
1427
1428    private void connectNoServerNonBlock() throws Exception {
1429        // ensure
1430        ensureServerClosed();
1431        this.channel1.configureBlocking(false);
1432        statusNotConnected_NotPending();
1433        // connect
1434        assertFalse(this.channel1.connect(localAddr1));
1435        statusNotConnected_Pending();
1436        try {
1437            assertFalse(this.channel1.finishConnect());
1438            statusNotConnected_Pending();
1439        } catch (ConnectException e) {
1440            // FIXME: assertEquals(e.getMessage(), "Connection refused");
1441        }
1442    }
1443
1444    private void connectServerNonBlock() throws Exception {
1445        // ensure
1446        ensureServerOpen();
1447        this.channel1.configureBlocking(false);
1448        statusNotConnected_NotPending();
1449        // connect
1450        boolean connected = channel1.connect(localAddr1);
1451        if (!connected) {
1452            statusNotConnected_Pending();
1453        }
1454        tryFinish();
1455    }
1456
1457    private void connectServerBlock() throws Exception {
1458        // ensure
1459        ensureServerOpen();
1460        assertTrue(this.channel1.isBlocking());
1461        statusNotConnected_NotPending();
1462        // connect
1463        assertTrue(this.channel1.connect(localAddr1));
1464        statusConnected_NotPending();
1465        tryFinish();
1466    }
1467
1468    private void statusChannelClosed() {
1469        assertFalse(this.channel1.isConnected());
1470        assertFalse(this.channel1.isConnectionPending());
1471        assertFalse(this.channel1.isOpen());
1472    }
1473
1474    private void statusNotConnected_NotPending() {
1475        assertFalse(this.channel1.isConnected());
1476        assertFalse(this.channel1.isConnectionPending());
1477        assertTrue(this.channel1.isOpen());
1478    }
1479
1480    private void statusNotConnected_Pending() {
1481        assertFalse(this.channel1.isConnected());
1482        assertTrue(this.channel1.isConnectionPending());
1483        assertTrue(this.channel1.isOpen());
1484    }
1485
1486    private void statusConnected_NotPending() {
1487        assertTrue(this.channel1.isConnected());
1488        assertFalse(this.channel1.isConnectionPending());
1489        assertTrue(this.channel1.isOpen());
1490    }
1491
1492    private boolean tryFinish() throws IOException {
1493        /*
1494         * the result of finish will be asserted in multi-thread tests.
1495         */
1496        boolean connected = false;
1497        assertTrue(this.channel1.isOpen());
1498        try {
1499            connected = this.channel1.finishConnect();
1500        } catch (SocketException e) {
1501            // Finish connection failed, probably due to reset by peer error.
1502        }
1503        if (connected) {
1504            statusConnected_NotPending();
1505        }
1506        return connected;
1507    }
1508
1509    // -------------------------------------------------------------------
1510    // Original tests. Test method for CFII with real data.
1511    // -------------------------------------------------------------------
1512
1513    /**
1514     *
1515     * 'SocketChannelImpl.connect(SocketAddress)'
1516     */
1517    public void testCFII_Data_ConnectWithServer() throws Exception {
1518        ensureServerOpen();
1519        java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
1520                .allocate(CAPACITY_NORMAL);
1521        java.nio.ByteBuffer[] writeBufArr = new java.nio.ByteBuffer[1];
1522        writeBufArr[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
1523        assertFalse(this.channel1.isRegistered());
1524        assertTrue(this.channel1.isBlocking());
1525
1526        this.channel1.connect(localAddr1);
1527
1528        assertTrue(this.channel1.isBlocking());
1529        assertTrue(this.channel1.isConnected());
1530        assertFalse(this.channel1.isConnectionPending());
1531        assertTrue(this.channel1.isOpen());
1532        assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
1533        assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBufArr, 0, 1));
1534
1535        this.channel1.configureBlocking(false);
1536        try {
1537            this.channel1.connect(localAddr1);
1538            fail("Should throw AlreadyConnectedException");
1539        } catch (AlreadyConnectedException e) {
1540            // correct
1541        }
1542
1543        assertFalse(this.channel1.isRegistered());
1544        tryFinish();
1545    }
1546
1547    /*
1548     * Test method for 'SocketChannelImpl.connect(SocketAddress)'
1549     */
1550    public void testCFII_Data_ConnectWithServer_nonBlocking() throws Exception {
1551        ensureServerOpen();
1552        java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
1553                .allocate(CAPACITY_NORMAL);
1554        java.nio.ByteBuffer[] writeBufArr = new java.nio.ByteBuffer[1];
1555        writeBufArr[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
1556        assertFalse(this.channel1.isRegistered());
1557        assertTrue(this.channel1.isBlocking());
1558        this.channel1.configureBlocking(false);
1559        this.channel1.connect(localAddr1);
1560
1561        assertFalse(this.channel1.isBlocking());
1562        boolean connected = channel1.isConnected();
1563        if (!connected) {
1564            assertTrue(this.channel1.isConnectionPending());
1565            assertTrue(this.channel1.isOpen());
1566        }
1567        if (tryFinish()) {
1568            assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
1569            assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBufArr, 0, 1));
1570
1571            this.channel1.configureBlocking(false);
1572            try {
1573                this.channel1.connect(localAddr1);
1574                fail("Should throw AlreadyConnectedException");
1575            } catch (AlreadyConnectedException e) {
1576                // correct
1577            }
1578        }
1579
1580        assertFalse(this.channel1.isRegistered());
1581        tryFinish();
1582    }
1583
1584    /*
1585     * Test method for 'SocketChannelImpl.finishConnect()'
1586     */
1587    public void testCFII_Data_FinishConnect_nonBlocking() throws IOException {
1588        ensureServerOpen();
1589
1590        java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
1591                .allocate(CAPACITY_NORMAL);
1592        java.nio.ByteBuffer[] writeBufArr = new java.nio.ByteBuffer[1];
1593        writeBufArr[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
1594
1595        this.channel1.configureBlocking(false);
1596        try {
1597            this.channel1.finishConnect();
1598            fail("Should throw NoConnectionPendingException");
1599        } catch (NoConnectionPendingException e) {
1600            // correct
1601        }
1602        boolean connected = channel1.connect(localAddr1);
1603        if (!connected) {
1604            assertFalse(this.channel1.isBlocking());
1605            assertFalse(this.channel1.isConnected());
1606            assertTrue(this.channel1.isConnectionPending());
1607            assertTrue(this.channel1.isOpen());
1608        }
1609        this.server1.accept();
1610        if (tryFinish()) {
1611            assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
1612            assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBufArr, 0, 1));
1613            try {
1614                this.channel1.connect(localAddr1);
1615                fail("Should throw AlreadyConnectedException");
1616            } catch (AlreadyConnectedException e) {
1617                // correct
1618            }
1619        }
1620        assertFalse(this.channel1.isRegistered());
1621        tryFinish();
1622    }
1623
1624    public void testCFII_Data_FinishConnect_AddrSetServerStartLater()
1625            throws IOException, InterruptedException {
1626        ensureServerClosed();
1627        java.nio.ByteBuffer[] writeBufArr = new java.nio.ByteBuffer[1];
1628        writeBufArr[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
1629        this.channel1.configureBlocking(false);
1630        try {
1631            SocketChannel.open(localAddr1);
1632            fail("Should throw ConnectException");
1633        } catch (ConnectException e) {
1634            // correct
1635        }
1636        assertTrue(this.channel1.isOpen());
1637        assertFalse(this.channel1.isBlocking());
1638        assertFalse(this.channel1.isConnectionPending());
1639        this.channel1.configureBlocking(true);
1640        try {
1641            this.channel1.finishConnect();
1642            fail("Should throw NoConnectionPendingException");
1643        } catch (NoConnectionPendingException e) {
1644            // correct
1645        }
1646        try {
1647            this.channel1.connect(localAddr2);
1648            fail("Should throw ConnectException");
1649        } catch (ConnectException e) {
1650            // correct
1651        }
1652
1653        assertTrue(this.channel1.isBlocking());
1654        try {
1655            this.channel1.finishConnect();
1656            fail("Should throw ClosedChannelException");
1657        } catch (ClosedChannelException e) {
1658            // correct
1659        }
1660        assertFalse(this.channel1.isConnected());
1661        // finish after finish OK
1662        assertFalse(this.channel1.isConnectionPending());
1663        this.channel1 = SocketChannel.open();
1664        this.channel1.configureBlocking(false);
1665        this.channel1.connect(localAddr1);
1666        assertFalse(this.channel1.isConnected());
1667        ensureServerOpen();
1668        // cannot connect?
1669        try {
1670            assertFalse(this.channel1.finishConnect());
1671            assertFalse(this.channel1.isBlocking());
1672            assertFalse(this.channel1.isConnected());
1673            assertTrue(this.channel1.isConnectionPending());
1674            assertTrue(this.channel1.isOpen());
1675            try {
1676                this.channel1.connect(localAddr1);
1677                fail("Should throw ConnectionPendingException");
1678            } catch (ConnectionPendingException e) {
1679                // correct
1680            }
1681            this.channel1.configureBlocking(true);
1682            try {
1683                this.channel1.connect(localAddr1);
1684                fail("Should throw ConnectionPendingException");
1685            } catch (ConnectionPendingException e) {
1686                // correct
1687            }
1688            tryFinish();
1689        } catch (ConnectException e) {
1690            // FIXME: assertEquals(e.getMessage(), "Connection refused");
1691        }
1692    }
1693
1694    public void testCFII_Data_FinishConnect_ServerStartLater()
1695            throws IOException {
1696        ensureServerClosed();
1697        java.nio.ByteBuffer[] writeBufArr = new java.nio.ByteBuffer[1];
1698        writeBufArr[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
1699        this.channel1.configureBlocking(true);
1700        try {
1701            this.channel1.finishConnect();
1702            fail("Should throw NoConnectionPendingException");
1703        } catch (NoConnectionPendingException e) {
1704            // correct
1705        }
1706        try {
1707            this.channel1.connect(localAddr1);
1708            fail("Should throw ConnectException");
1709        } catch (ConnectException e) {
1710            // correct
1711        }
1712
1713        try {
1714            this.channel1.finishConnect();
1715            fail("Should throw ClosedChannelException");
1716        } catch (ClosedChannelException e) {
1717            // correct
1718        }
1719        assertFalse(this.channel1.isConnected());
1720        // finish after finish OK
1721        assertFalse(this.channel1.isConnectionPending());
1722        this.channel1 = SocketChannel.open();
1723        this.channel1.configureBlocking(false);
1724        this.channel1.connect(localAddr1);
1725        assertFalse(this.channel1.isConnected());
1726        ensureServerOpen();
1727        // cannot connect?
1728        try {
1729            assertFalse(this.channel1.finishConnect());
1730            assertFalse(this.channel1.isBlocking());
1731            assertFalse(this.channel1.isConnected());
1732            assertTrue(this.channel1.isConnectionPending());
1733            assertTrue(this.channel1.isOpen());
1734            try {
1735                this.channel1.connect(localAddr1);
1736                fail("Should throw ConnectionPendingException");
1737            } catch (ConnectionPendingException e) {
1738                // correct
1739            }
1740            this.channel1.configureBlocking(true);
1741            try {
1742                this.channel1.connect(localAddr1);
1743                fail("Should throw ConnectionPendingException");
1744            } catch (ConnectionPendingException e) {
1745                // correct
1746            }
1747            tryFinish();
1748        } catch (ConnectException e) {
1749            // FIXME: assertEquals(e.getMessage(), "Connection refused");
1750        }
1751    }
1752
1753    public void testCFII_Data_FinishConnect_Blocking() throws IOException {
1754        ensureServerOpen();
1755        java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
1756                .allocate(CAPACITY_NORMAL);
1757        java.nio.ByteBuffer[] writeBufArr = new java.nio.ByteBuffer[1];
1758        writeBufArr[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
1759        this.channel1.configureBlocking(true);
1760        try {
1761            this.channel1.finishConnect();
1762            fail("Should throw NoConnectionPendingException");
1763        } catch (NoConnectionPendingException e) {
1764            // correct
1765        }
1766
1767        this.channel1.connect(localAddr1);
1768
1769        assertTrue(this.channel1.isConnected());
1770        assertFalse(this.channel1.isConnectionPending());
1771        assertTrue(this.channel1.isOpen());
1772        if (tryFinish()) {
1773            assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
1774            assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBufArr, 0, 1));
1775
1776            try {
1777                this.channel1.connect(localAddr1);
1778                fail("Should throw AlreadyConnectedException");
1779            } catch (AlreadyConnectedException e) {
1780                // correct
1781            }
1782        }
1783        assertFalse(this.channel1.isRegistered());
1784        tryFinish();
1785    }
1786
1787    /**
1788     * Regression test for Harmony-1947.
1789     */
1790    public void test_finishConnect() throws Exception {
1791        SocketAddress address = new InetSocketAddress("localhost", 0);
1792
1793        ServerSocketChannel theServerChannel = ServerSocketChannel.open();
1794        ServerSocket serversocket = theServerChannel.socket();
1795        serversocket.setReuseAddress(true);
1796        // Bind the socket
1797        serversocket.bind(address);
1798
1799        boolean doneNonBlockingConnect = false;
1800        // Loop so that we make sure we're definitely testing finishConnect()
1801        while (!doneNonBlockingConnect) {
1802            channel1 = SocketChannel.open();
1803
1804            // Set the SocketChannel to non-blocking so that connect(..) does
1805            // not block
1806            channel1.configureBlocking(false);
1807            boolean connected = channel1.connect(new InetSocketAddress("localhost",serversocket.getLocalPort()));
1808            if (!connected) {
1809                // Now set the SocketChannel back to blocking so that
1810                // finishConnect() blocks.
1811                channel1.configureBlocking(true);
1812                doneNonBlockingConnect = channel1.finishConnect();
1813            }
1814            if (doneNonBlockingConnect) {
1815                tryFinish();
1816            }
1817            channel1.close();
1818        }
1819        if (!serversocket.isClosed()) {
1820            serversocket.close();
1821        }
1822    }
1823
1824    // -------------------------------------------------------------------
1825    // End of original tests. Test method for CFII with real data.
1826    // -------------------------------------------------------------------
1827
1828    /**
1829     * @tests java.nio.channels.SocketChannel#read(ByteBuffer)
1830     */
1831    public void test_readLjava_nio_ByteBuffer_Blocking() throws IOException {
1832        // initialize write content
1833        byte[] writeContent = new byte[CAPACITY_NORMAL];
1834        for (int i = 0; i < writeContent.length; i++) {
1835            writeContent[i] = (byte) i;
1836        }
1837        // establish connection
1838        channel1.connect(localAddr1);
1839        Socket acceptedSocket = server1.accept();
1840
1841        // use OutputStream.write to send CAPACITY_NORMAL bytes data
1842        OutputStream out = acceptedSocket.getOutputStream();
1843        out.write(writeContent);
1844        // use close to guarantee all data is sent
1845        acceptedSocket.close();
1846
1847        ByteBuffer readContent = ByteBuffer.allocate(CAPACITY_NORMAL + 1);
1848        int totalCount = 0;
1849        int count = 0;
1850        long startTime = System.currentTimeMillis();
1851        // use SocketChannel.read to read data
1852        while (totalCount <= CAPACITY_NORMAL) {
1853            count = channel1.read(readContent);
1854            if (EOF == count) {
1855                break;
1856            }
1857            totalCount += count;
1858            // if the channel could not finish reading in TIMEOUT ms, the
1859            // test fails. It is used to guarantee the test never hangs even
1860            // if there are bugs of SocketChannel implementation. For
1861            // blocking read, it possibly returns 0 in some cases.
1862            assertTimeout(startTime, TIMEOUT);
1863        }
1864        assertEquals(CAPACITY_NORMAL, totalCount);
1865        readContent.flip();
1866        for (int i = 0; i < CAPACITY_NORMAL; i++) {
1867            assertEquals(writeContent[i], readContent.get());
1868        }
1869    }
1870
1871    /**
1872     * @tests java.nio.channels.SocketChannel#read(ByteBuffer)
1873     */
1874    public void test_readLjava_nio_ByteBuffer_Nonblocking() throws IOException {
1875        // initialize write content
1876        byte[] writeContent = new byte[CAPACITY_NORMAL];
1877        for (int i = 0; i < writeContent.length; i++) {
1878            writeContent[i] = (byte) i;
1879        }
1880
1881        // establish connection
1882        channel1.connect(localAddr1);
1883        Socket acceptedSocket = server1.accept();
1884        // use OutputStream.write to write CAPACITY_NORMAL bytes data.
1885        OutputStream out = acceptedSocket.getOutputStream();
1886        out.write(writeContent);
1887        // use close to guarantee all data is sent
1888        acceptedSocket.close();
1889
1890        channel1.configureBlocking(false);
1891        ByteBuffer readContent = ByteBuffer.allocate(CAPACITY_NORMAL + 1);
1892        int totalCount = 0;
1893        int count = 0;
1894        long startTime = System.currentTimeMillis();
1895        // use SocketChannel.read to read data
1896        while (totalCount <= CAPACITY_NORMAL) {
1897            count = channel1.read(readContent);
1898            if (EOF == count) {
1899                break;
1900            }
1901            totalCount += count;
1902            // if the channel could not finish reading in TIMEOUT ms, the
1903            // test fails. It is used to guarantee the test never hangs even
1904            // if there are bugs of SocketChannel implementation.
1905            assertTimeout(startTime, TIMEOUT);
1906        }
1907
1908        // assert read content
1909        assertEquals(CAPACITY_NORMAL, totalCount);
1910        assertEquals(CAPACITY_NORMAL, readContent.position());
1911        readContent.flip();
1912        for (int i = 0; i < CAPACITY_NORMAL; i++) {
1913            assertEquals(writeContent[i], readContent.get());
1914        }
1915    }
1916
1917    /**
1918     * @tests java.nio.channels.SocketChannel#write(ByteBuffer)
1919     */
1920    public void test_writeLjava_nio_ByteBuffer_Blocking() throws IOException {
1921        // initialize write content
1922        ByteBuffer writeContent = ByteBuffer.allocate(CAPACITY_NORMAL);
1923        for (int i = 0; i < CAPACITY_NORMAL; i++) {
1924            writeContent.put((byte) i);
1925        }
1926        writeContent.flip();
1927        // establish connection
1928        channel1.connect(localAddr1);
1929        Socket acceptedSocket = server1.accept();
1930
1931        // use SocketChannel.write(ByteBuffer) to write CAPACITY_NORMAL bytes
1932        // data
1933        int writtenCount = channel1.write(writeContent);
1934        // assert written count and ByteBuffer position
1935        assertEquals(CAPACITY_NORMAL, writtenCount);
1936        assertEquals(CAPACITY_NORMAL, writeContent.position());
1937        // use close to guarantee all data is sent
1938        channel1.close();
1939
1940        InputStream in = acceptedSocket.getInputStream();
1941        int totalCount = 0;
1942        int count = 0;
1943        byte[] readContent = new byte[CAPACITY_NORMAL + 1];
1944        // if the channel could not finish reading in TIMEOUT ms, the test
1945        // fails. It is used to guarantee the test never hangs even if there
1946        // are bugs of SocketChannel implementation.
1947        acceptedSocket.setSoTimeout(TIMEOUT);
1948
1949        // use InputStream.read to read data.
1950        while (totalCount <= CAPACITY_NORMAL) {
1951            count = in.read(readContent, totalCount, readContent.length
1952                    - totalCount);
1953            if (EOF == count) {
1954                break;
1955            }
1956            totalCount += count;
1957        }
1958
1959        // assert read content
1960        assertEquals(CAPACITY_NORMAL, totalCount);
1961        writeContent.flip();
1962        for (int i = 0; i < CAPACITY_NORMAL; i++) {
1963            assertEquals(writeContent.get(), readContent[i]);
1964        }
1965    }
1966
1967    /**
1968     * @tests java.nio.channels.SocketChannel#write(ByteBuffer)
1969     */
1970    public void test_writeLjava_nio_ByteBuffer_NonBlocking() throws Exception {
1971        // initialize write content
1972        ByteBuffer writeContent = ByteBuffer.allocate(CAPACITY_NORMAL);
1973        for (int i = 0; i < CAPACITY_NORMAL; i++) {
1974            writeContent.put((byte) i);
1975        }
1976        writeContent.flip();
1977
1978        // establish connection
1979        channel1.connect(localAddr1);
1980        Socket acceptedSocket = server1.accept();
1981
1982        channel1.configureBlocking(false);
1983        int writtenTotalCount = 0;
1984        int writtenCount = 0;
1985        long startTime = System.currentTimeMillis();
1986        // use SocketChannel.write(ByteBuffer) to write CAPACITY_NORMAL bytes
1987        while (writtenTotalCount < CAPACITY_NORMAL) {
1988            writtenCount = channel1.write(writeContent);
1989            writtenTotalCount += writtenCount;
1990            // if the channel could not finish writing in TIMEOUT ms, the
1991            // test fails. It is used to guarantee the test never hangs even
1992            // if there are bugs of SocketChannel implementation.
1993            assertTimeout(startTime, TIMEOUT);
1994        }
1995        // assert written count and ByteBuffer position
1996        assertEquals(CAPACITY_NORMAL, writtenTotalCount);
1997        assertEquals(CAPACITY_NORMAL, writeContent.position());
1998        // use close to guarantee all data is sent
1999        channel1.close();
2000
2001        InputStream in = acceptedSocket.getInputStream();
2002        byte[] readContent = new byte[CAPACITY_NORMAL + 1];
2003        int totalCount = 0;
2004        int count = 0;
2005        // if the channel could not finish reading in TIMEOUT ms, the test
2006        // fails. It is used to guarantee the test never hangs even if there
2007        // are bugs of SocketChannel implementation.
2008        acceptedSocket.setSoTimeout(TIMEOUT);
2009        // use InputStream.read to read data.
2010        while (totalCount <= CAPACITY_NORMAL) {
2011            count = in.read(readContent, totalCount, readContent.length
2012                    - totalCount);
2013            if (EOF == count) {
2014                break;
2015            }
2016            totalCount += count;
2017        }
2018        // assert read content
2019        assertEquals(CAPACITY_NORMAL, totalCount);
2020        writeContent.flip();
2021        for (int i = 0; i < CAPACITY_NORMAL; i++) {
2022            assertEquals(writeContent.get(), readContent[i]);
2023        }
2024    }
2025
2026    /*
2027     * Fails if the difference between current time and start time is greater
2028     * than timeout.
2029     */
2030    private void assertTimeout(long startTime, long timeout) {
2031        long currentTime = System.currentTimeMillis();
2032        if ((currentTime - startTime) > timeout) {
2033            fail("Timeout");
2034        }
2035    }
2036
2037    // -------------------------------------------------
2038    // Test for read/write but no real data expressed
2039    // -------------------------------------------------
2040
2041    public void testReadByteBuffer() throws Exception {
2042        assertTrue(this.server1.isBound());
2043        java.nio.ByteBuffer readBuf = java.nio.ByteBuffer
2044                .allocate(CAPACITY_NORMAL);
2045        assertFalse(this.channel1.isRegistered());
2046        assertTrue(this.channel1.isBlocking());
2047        assertFalse(this.channel1.isConnected());
2048        assertFalse(this.channel1.isConnectionPending());
2049        assertTrue(this.channel1.isOpen());
2050        // note: blocking-mode will make the read process endless!
2051        this.channel1.configureBlocking(false);
2052        try {
2053            channel1.read(readBuf);
2054            fail("Should throw NotYetConnectedException");
2055        } catch (NotYetConnectedException e) {
2056            // correct
2057        }
2058        boolean connected = this.channel1.connect(localAddr1);
2059        if (!connected) {
2060            assertFalse(this.channel1.isBlocking());
2061            assertTrue(this.channel1.isConnectionPending());
2062            assertFalse(this.channel1.isConnected());
2063        }
2064        if (tryFinish()) {
2065            assertEquals(0, this.channel1.read(readBuf));
2066        }
2067
2068        this.channel1.close();
2069        try {
2070            channel1.read(readBuf);
2071            fail("Should throw ClosedChannelException");
2072        } catch (ClosedChannelException e) {
2073            // correct
2074        }
2075    }
2076
2077    public void testReadByteBuffer_Direct() throws Exception {
2078        assertTrue(this.server1.isBound());
2079        java.nio.ByteBuffer readBuf = java.nio.ByteBuffer
2080                .allocateDirect(CAPACITY_NORMAL);
2081        assertFalse(this.channel1.isRegistered());
2082        assertTrue(this.channel1.isBlocking());
2083        assertFalse(this.channel1.isConnected());
2084        assertFalse(this.channel1.isConnectionPending());
2085        assertTrue(this.channel1.isOpen());
2086        // note: blocking-mode will make the read process endless!
2087        this.channel1.configureBlocking(false);
2088        try {
2089            channel1.read(readBuf);
2090            fail("Should throw NotYetConnectedException");
2091        } catch (NotYetConnectedException e) {
2092            // correct
2093        }
2094        boolean connected = this.channel1.connect(localAddr1);
2095        if (!connected) {
2096            assertFalse(this.channel1.isBlocking());
2097            assertTrue(this.channel1.isConnectionPending());
2098            assertFalse(this.channel1.isConnected());
2099        }
2100        if (tryFinish()) {
2101            assertEquals(0, this.channel1.read(readBuf));
2102        }
2103
2104        this.channel1.close();
2105        try {
2106            channel1.read(readBuf);
2107            fail("Should throw ClosedChannelException");
2108        } catch (ClosedChannelException e) {
2109            // correct
2110        }
2111    }
2112
2113    public void testReadByteBuffer_Direct2() throws IOException {
2114        byte[] request = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
2115        ByteBuffer buffer = ByteBuffer.allocateDirect(128);
2116
2117        ServerSocketChannel server = ServerSocketChannel.open();
2118        server.socket().bind(
2119                new InetSocketAddress(InetAddress.getLocalHost(), 0), 5);
2120        Socket client = new Socket(InetAddress.getLocalHost(), server.socket()
2121                .getLocalPort());
2122        client.setTcpNoDelay(false);
2123        Socket worker = server.socket().accept();
2124        SocketChannel workerChannel = worker.getChannel();
2125
2126        OutputStream out = client.getOutputStream();
2127        out.write(request);
2128        out.close();
2129
2130        buffer.limit(5);
2131        int bytesRead = workerChannel.read(buffer);
2132        assertEquals(5, bytesRead);
2133        assertEquals(5, buffer.position());
2134
2135        buffer.limit(request.length);
2136        bytesRead = workerChannel.read(buffer);
2137        assertEquals(6, bytesRead);
2138
2139        buffer.flip();
2140        assertEquals(request.length, buffer.limit());
2141
2142        assertEquals(ByteBuffer.wrap(request), buffer);
2143
2144        client.close();
2145        worker.close();
2146        server.close();
2147    }
2148
2149    public void testReadByteBuffer_BufNull() throws Exception {
2150        assertTrue(this.server1.isBound());
2151        java.nio.ByteBuffer readBuf = java.nio.ByteBuffer.allocate(0);
2152        // note: blocking-mode will make the read process endless!
2153        this.channel1.configureBlocking(false);
2154        try {
2155            channel1.read((java.nio.ByteBuffer) null);
2156            fail("Should throw NPE");
2157        } catch (NullPointerException e) {
2158            // correct
2159        }
2160        this.channel1.connect(localAddr1);
2161        if (tryFinish()) {
2162            try {
2163                this.channel1.read((java.nio.ByteBuffer) null);
2164                fail("Should throw NPE");
2165            } catch (NullPointerException e) {
2166                // correct
2167            }
2168            assertEquals(0, this.channel1.read(readBuf));
2169        }
2170        this.server1.close();
2171        try {
2172            channel1.read((java.nio.ByteBuffer) null);
2173            fail("Should throw NPE");
2174        } catch (NullPointerException e) {
2175            // correct
2176        }
2177    }
2178
2179    /*
2180     * SocketChannelImpl.read(ByteBuffer[], int, int)'
2181     */
2182    public void testReadByteBufferArrayIntInt() throws Exception {
2183        assertTrue(this.server1.isBound());
2184        java.nio.ByteBuffer[] readBuf = new java.nio.ByteBuffer[2];
2185        readBuf[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
2186        readBuf[1] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
2187        assertFalse(this.channel1.isRegistered());
2188        assertTrue(this.channel1.isBlocking());
2189        assertFalse(this.channel1.isConnected());
2190        assertFalse(this.channel1.isConnectionPending());
2191        assertTrue(this.channel1.isOpen());
2192        // note: blocking-mode will make the read process endless!
2193        this.channel1.configureBlocking(false);
2194        try {
2195            channel1.read(readBuf, 0, 1);
2196            fail("Should throw NotYetConnectedException");
2197        } catch (NotYetConnectedException e) {
2198            // correct
2199        }
2200        boolean connected = this.channel1.connect(localAddr1);
2201        if (!connected) {
2202            assertFalse(this.channel1.isBlocking());
2203            assertTrue(this.channel1.isConnectionPending());
2204            assertFalse(this.channel1.isConnected());
2205        }
2206        if (tryFinish()) {
2207            assertEquals(0, this.channel1.read(readBuf, 0, 1));
2208            assertEquals(0, this.channel1.read(readBuf, 0, 2));
2209        }
2210
2211        this.channel1.close();
2212        try {
2213            channel1.read(readBuf, 0, 1);
2214            fail("Should throw ClosedChannelException");
2215        } catch (ClosedChannelException e) {
2216            // correct
2217        }
2218    }
2219
2220    /*
2221     * SocketChannelImpl.read(ByteBuffer[], int, int)'
2222     */
2223    public void testReadByteBufferArrayIntInt_Direct() throws Exception {
2224        assertTrue(this.server1.isBound());
2225        java.nio.ByteBuffer[] readBuf = new java.nio.ByteBuffer[2];
2226        readBuf[0] = java.nio.ByteBuffer.allocateDirect(CAPACITY_NORMAL);
2227        readBuf[1] = java.nio.ByteBuffer.allocateDirect(CAPACITY_NORMAL);
2228        assertFalse(this.channel1.isRegistered());
2229        assertTrue(this.channel1.isBlocking());
2230        assertFalse(this.channel1.isConnected());
2231        assertFalse(this.channel1.isConnectionPending());
2232        assertTrue(this.channel1.isOpen());
2233        // note: blocking-mode will make the read process endless!
2234        this.channel1.configureBlocking(false);
2235        try {
2236            channel1.read(readBuf, 0, 1);
2237            fail("Should throw NotYetConnectedException");
2238        } catch (NotYetConnectedException e) {
2239            // correct
2240        }
2241        boolean connected = this.channel1.connect(localAddr1);
2242        if (!connected) {
2243            assertFalse(this.channel1.isBlocking());
2244            assertTrue(this.channel1.isConnectionPending());
2245            assertFalse(this.channel1.isConnected());
2246        }
2247        if (tryFinish()) {
2248            assertEquals(0, this.channel1.read(readBuf, 0, 1));
2249            assertEquals(0, this.channel1.read(readBuf, 0, 2));
2250        }
2251
2252        this.channel1.close();
2253        try {
2254            channel1.read(readBuf, 0, 1);
2255            fail("Should throw ClosedChannelException");
2256        } catch (ClosedChannelException e) {
2257            // correct
2258        }
2259    }
2260
2261    public void testReadByteBufferArrayIntInt_BufNull() throws Exception {
2262        assertTrue(this.server1.isBound());
2263        java.nio.ByteBuffer[] readBuf = new java.nio.ByteBuffer[2];
2264        readBuf[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
2265        assertFalse(this.channel1.isRegistered());
2266        assertTrue(this.channel1.isBlocking());
2267        assertFalse(this.channel1.isConnected());
2268        assertFalse(this.channel1.isConnectionPending());
2269        assertTrue(this.channel1.isOpen());
2270        // note: blocking-mode will make the read process endless!
2271        this.channel1.configureBlocking(false);
2272        try {
2273            channel1.read(null, 0, 0);
2274            fail("Should throw NPE");
2275        } catch (NullPointerException e) {
2276            // correct
2277        }
2278        this.channel1.connect(localAddr1);
2279        if (tryFinish()) {
2280
2281            try {
2282                channel1.read(null, 0, 0);
2283                fail("Should throw NPE");
2284            } catch (NullPointerException e) {
2285                // correct
2286            }
2287            try {
2288                channel1.read(readBuf, 0, 2);
2289                fail("Should throw NPE");
2290            } catch (NullPointerException e) {
2291                // correct
2292            }
2293
2294            assertEquals(0, this.channel1.read(readBuf, 0, 1));
2295        }
2296        this.channel1.close();
2297        try {
2298            channel1.read(null, 0, 1);
2299            fail("Should throw NPE");
2300        } catch (NullPointerException e) {
2301            // correct
2302        }
2303    }
2304
2305    public void testWriteByteBuffer() throws IOException {
2306        assertTrue(this.server1.isBound());
2307        java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
2308                .allocate(CAPACITY_NORMAL);
2309        assertFalse(this.channel1.isRegistered());
2310        assertTrue(this.channel1.isBlocking());
2311        assertFalse(this.channel1.isConnected());
2312        assertFalse(this.channel1.isConnectionPending());
2313        assertTrue(this.channel1.isOpen());
2314        try {
2315            channel1.write(writeBuf);
2316            fail("Should throw NotYetConnectedException");
2317        } catch (NotYetConnectedException e) {
2318            // correct
2319        }
2320        this.channel1.connect(localAddr1);
2321        assertTrue(this.channel1.isBlocking());
2322        assertTrue(this.channel1.isConnected());
2323        assertFalse(this.channel1.isConnectionPending());
2324        assertTrue(this.channel1.isOpen());
2325        assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
2326
2327        this.channel1.close();
2328        try {
2329            channel1.write(writeBuf);
2330            fail("Should throw ClosedChannelException");
2331        } catch (ClosedChannelException e) {
2332            // correct
2333        }
2334    }
2335
2336    public void testWriteByteBuffer_Direct() throws IOException {
2337        assertTrue(this.server1.isBound());
2338        java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
2339                .allocateDirect(CAPACITY_NORMAL);
2340        assertFalse(this.channel1.isRegistered());
2341        assertTrue(this.channel1.isBlocking());
2342        assertFalse(this.channel1.isConnected());
2343        assertFalse(this.channel1.isConnectionPending());
2344        assertTrue(this.channel1.isOpen());
2345        try {
2346            channel1.write(writeBuf);
2347            fail("Should throw NotYetConnectedException");
2348        } catch (NotYetConnectedException e) {
2349            // correct
2350        }
2351        this.channel1.connect(localAddr1);
2352        assertTrue(this.channel1.isBlocking());
2353        assertTrue(this.channel1.isConnected());
2354        assertFalse(this.channel1.isConnectionPending());
2355        assertTrue(this.channel1.isOpen());
2356        assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
2357
2358        this.channel1.close();
2359        try {
2360            channel1.write(writeBuf);
2361            fail("Should throw ClosedChannelException");
2362        } catch (ClosedChannelException e) {
2363            // correct
2364        }
2365    }
2366
2367    public void testWriteByteBuffer_BufNull() throws IOException {
2368        assertTrue(this.server1.isBound());
2369        java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer.allocate(0);
2370        this.channel1.connect(localAddr1);
2371        assertEquals(this.channel1.write(writeBuf), 0);
2372        try {
2373            this.channel1.write((java.nio.ByteBuffer) null);
2374            fail("Should throw NPE");
2375        } catch (NullPointerException e) {
2376            // correct
2377        }
2378    }
2379
2380    /*
2381     * SocketChannelImpl.write(ByteBuffer[], int, int)'
2382     */
2383    public void testWriteByteBufferArrayIntInt() throws IOException {
2384        java.nio.ByteBuffer[] writeBuf = new java.nio.ByteBuffer[2];
2385        writeBuf[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
2386        writeBuf[1] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
2387        assertFalse(this.channel1.isRegistered());
2388        assertTrue(this.channel1.isBlocking());
2389        assertFalse(this.channel1.isConnected());
2390        assertFalse(this.channel1.isConnectionPending());
2391        assertTrue(this.channel1.isOpen());
2392        try {
2393            channel1.write(writeBuf, 0, 1);
2394            fail("Should throw NotYetConnectedException");
2395        } catch (NotYetConnectedException e) {
2396            // correct
2397        }
2398        this.channel1.connect(localAddr1);
2399        assertTrue(this.channel1.isBlocking());
2400        assertTrue(this.channel1.isConnected());
2401        assertFalse(this.channel1.isConnectionPending());
2402        assertTrue(this.channel1.isOpen());
2403        assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf, 0, 1));
2404        // still writes the same size as above
2405        assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf, 0, 2));
2406        writeBuf[0].flip();
2407        writeBuf[1].flip();
2408        assertEquals(CAPACITY_NORMAL * 2, this.channel1.write(writeBuf, 0, 2));
2409        this.channel1.close();
2410        try {
2411            channel1.write(writeBuf);
2412            fail("Should throw ClosedChannelException");
2413        } catch (ClosedChannelException e) {
2414            // correct
2415        }
2416    }
2417
2418    /*
2419     * SocketChannelImpl.write(ByteBuffer[], int, int)'
2420     */
2421    public void testWriteByteBufferArrayIntInt_Direct() throws IOException {
2422        java.nio.ByteBuffer[] writeBuf = new java.nio.ByteBuffer[2];
2423        writeBuf[0] = java.nio.ByteBuffer.allocateDirect(CAPACITY_NORMAL);
2424        writeBuf[1] = java.nio.ByteBuffer.allocateDirect(CAPACITY_NORMAL);
2425        assertFalse(this.channel1.isRegistered());
2426        assertTrue(this.channel1.isBlocking());
2427        assertFalse(this.channel1.isConnected());
2428        assertFalse(this.channel1.isConnectionPending());
2429        assertTrue(this.channel1.isOpen());
2430        try {
2431            channel1.write(writeBuf, 0, 1);
2432            fail("Should throw NotYetConnectedException");
2433        } catch (NotYetConnectedException e) {
2434            // correct
2435        }
2436        this.channel1.connect(localAddr1);
2437        assertTrue(this.channel1.isBlocking());
2438        assertTrue(this.channel1.isConnected());
2439        assertFalse(this.channel1.isConnectionPending());
2440        assertTrue(this.channel1.isOpen());
2441        assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf, 0, 1));
2442        // still writes the same size as above
2443        assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf, 0, 2));
2444        writeBuf[0].flip();
2445        writeBuf[1].flip();
2446        assertEquals(CAPACITY_NORMAL * 2, this.channel1.write(writeBuf, 0, 2));
2447        this.channel1.close();
2448        try {
2449            channel1.write(writeBuf);
2450            fail("Should throw ClosedChannelException");
2451        } catch (ClosedChannelException e) {
2452            // correct
2453        }
2454    }
2455
2456    public void testWriteByteBufferArrayIntInt_BufNull() throws IOException {
2457        java.nio.ByteBuffer[] writeBuf = new java.nio.ByteBuffer[0];
2458
2459        this.channel1.connect(localAddr1);
2460        try {
2461            this.channel1.write(null, 0, 1);
2462            fail("Should throw NPE");
2463        } catch (NullPointerException e) {
2464            // correct
2465        }
2466        assertEquals(0, this.channel1.write(writeBuf, 0, 0));
2467        try {
2468            this.channel1.write(writeBuf, 0, 1);
2469            fail("Should throw IndexOutOfBoundsException");
2470        } catch (IndexOutOfBoundsException e) {
2471            // correct
2472        }
2473        writeBuf = new java.nio.ByteBuffer[1];
2474        try {
2475            this.channel1.write(writeBuf, 0, 1);
2476            fail("Should throw NPE");
2477        } catch (NullPointerException e) {
2478            // correct
2479        }
2480        try {
2481            this.channel1.write(writeBuf, 0, 2);
2482            fail("Should throw IndexOutOfBoundsException");
2483        } catch (IndexOutOfBoundsException e) {
2484            // correct
2485        }
2486        this.server1.close();
2487        try {
2488            channel1.read(null, 0, 1);
2489            fail("Should throw NPE");
2490        } catch (NullPointerException e) {
2491            // correct
2492        }
2493    }
2494
2495    public void testWriteByteBufferArrayIntInt_SizeError() throws IOException {
2496        java.nio.ByteBuffer[] buf = new java.nio.ByteBuffer[1];
2497        this.channel1.connect(localAddr1);
2498        assertEquals(0, this.channel1.write(buf, 0, 0));
2499        try {
2500            this.channel1.write(buf, -1, 1);
2501            fail();
2502        } catch (IndexOutOfBoundsException expected) {
2503        }
2504        try {
2505            this.channel1.write(buf, 0, -1);
2506            fail();
2507        } catch (IndexOutOfBoundsException expected) {
2508        }
2509        try {
2510            this.channel1.write(buf, 0, 2);
2511            fail();
2512        } catch (IndexOutOfBoundsException expected) {
2513        }
2514        try {
2515            this.channel1.write(buf, 2, 0);
2516            fail();
2517        } catch (IndexOutOfBoundsException expected) {
2518        }
2519        try {
2520            this.channel1.write(null, 0, 0);
2521            fail();
2522        } catch (NullPointerException expected) {
2523        }
2524        this.server1.close();
2525    }
2526
2527    public void testReadByteBufferArrayIntInt_SizeError() throws IOException {
2528        java.nio.ByteBuffer[] buf = new java.nio.ByteBuffer[1];
2529        this.channel1.connect(localAddr1);
2530        assertEquals(0, this.channel1.read(buf, 0, 0));
2531        try {
2532            this.channel1.read(buf, -1, 1);
2533            fail();
2534        } catch (IndexOutOfBoundsException expected) {
2535        }
2536        try {
2537            this.channel1.read(buf, 0, -1);
2538            fail();
2539        } catch (IndexOutOfBoundsException expected) {
2540        }
2541        try {
2542            this.channel1.read(buf, 0, 2);
2543            fail();
2544        } catch (IndexOutOfBoundsException expected) {
2545        }
2546        try {
2547            this.channel1.read(buf, 2, 0);
2548            fail();
2549        } catch (IndexOutOfBoundsException expected) {
2550        }
2551        try {
2552            this.channel1.read(null, 0, 0);
2553            fail();
2554        } catch (NullPointerException expected) {
2555        }
2556        this.server1.close();
2557    }
2558
2559    /*
2560     * ==========================================================================
2561     * Tests for read/write real data
2562     * ==========================================================================
2563     */
2564
2565
2566    /**
2567     * @tests java.nio.channels.SocketChannel#read(ByteBuffer[])
2568     */
2569    public void test_read$LByteBuffer() throws IOException {
2570        MockSocketChannel sc = new MockSocketChannel(null);
2571        ByteBuffer [] byteBufferArray = { ByteBuffer.allocate(1), ByteBuffer.allocate(1)};
2572        // Verify that calling read(ByteBuffer[]) leads to the method
2573        // read(ByteBuffer[], int, int) being called with a 0 for the
2574        // second parameter and targets.length as the third parameter.
2575        sc.read(byteBufferArray);
2576        assertTrue(sc.isReadCalled);
2577    }
2578    /**
2579     * @tests java.nio.channels.SocketChannel#read(ByteBuffer[],int,int)
2580     */
2581    public void test_read$LByteBufferII_blocking() throws Exception {
2582        assert_read$LByteBuffer(true);
2583    }
2584
2585    /**
2586     * @tests java.nio.channels.SocketChannel#read(ByteBuffer[],int,int)
2587     */
2588    public void test_read$LByteBufferII_nonblocking() throws Exception {
2589        assert_read$LByteBuffer(false);
2590    }
2591
2592    private void assert_read$LByteBuffer(boolean isBlocking) throws IOException {
2593        // initialize write content
2594        byte[] writeContent = new byte[CAPACITY_NORMAL * 2];
2595        for (int i = 0; i < CAPACITY_NORMAL * 2; i++) {
2596            writeContent[i] = (byte) i;
2597        }
2598        ByteBuffer[] readContents = new ByteBuffer[2];
2599        readContents[0] = ByteBuffer.allocate(CAPACITY_NORMAL);
2600        readContents[1] = ByteBuffer.allocate(CAPACITY_NORMAL + 1);
2601        // establish connection
2602        channel1.connect(localAddr1);
2603        Socket acceptedSocket = server1.accept();
2604        // use OutputStream.write to send CAPACITY_NORMAL * 2 bytes data
2605        OutputStream out = acceptedSocket.getOutputStream();
2606        out.write(writeContent);
2607        // use close to guarantee all data is sent
2608        acceptedSocket.close();
2609        // configure block/nonblock mode
2610        channel1.configureBlocking(isBlocking);
2611        long startTime = System.currentTimeMillis();
2612        long totalRead = 0;
2613        long countRead = 0;
2614
2615        while (totalRead <= CAPACITY_NORMAL * 2) {
2616            countRead = channel1.read(readContents, 0, 2);
2617            if (0 == countRead && !readContents[1].hasRemaining()) {
2618                // read returns 0 because readContents is full
2619                break;
2620            }
2621            if (EOF == countRead) {
2622                break;
2623            }
2624            totalRead += countRead;
2625            // if the channel could not finish reading in TIMEOUT ms, the
2626            // test fails. It is used to guarantee the test never hangs even
2627            // if there are bugs of SocketChannel implementation. For
2628            // blocking read, it possibly returns 0 in some cases.
2629            assertTimeout(startTime, TIMEOUT);
2630        }
2631
2632        // assert total bytes read and the position of ByteBuffers
2633        assertEquals(CAPACITY_NORMAL * 2, totalRead);
2634        assertEquals(CAPACITY_NORMAL, readContents[0].position());
2635        assertEquals(CAPACITY_NORMAL, readContents[1].position());
2636        // assert read content
2637        readContents[0].flip();
2638        readContents[1].flip();
2639        for (int i = 0; i < CAPACITY_NORMAL; i++) {
2640            assertEquals(writeContent[i], readContents[0].get());
2641        }
2642        for (int i = CAPACITY_NORMAL; i < CAPACITY_NORMAL * 2; i++) {
2643            assertEquals(writeContent[i], readContents[1].get());
2644        }
2645    }
2646
2647    /**
2648     * @tests java.nio.channels.SocketChannel#write(ByteBuffer[],int,int)
2649     */
2650    public void test_write$LByteBufferII_blocking() throws Exception {
2651        assert_write$LByteBuffer(true);
2652    }
2653
2654    /**
2655     * @tests java.nio.channels.SocketChannel#write(ByteBuffer[],int,int)
2656     */
2657    public void test_write$LByteBufferII_nonblocking()
2658            throws Exception {
2659        assert_write$LByteBuffer(false);
2660    }
2661
2662    private void assert_write$LByteBuffer(boolean isBlocking)
2663            throws IOException {
2664        // initialize write contents
2665        ByteBuffer writeContents[] = new ByteBuffer[2];
2666        writeContents[0] = ByteBuffer.allocate(CAPACITY_NORMAL);
2667        writeContents[1] = ByteBuffer.allocate(CAPACITY_NORMAL);
2668        for (int i = 0; i < CAPACITY_NORMAL; i++) {
2669            writeContents[0].put((byte) i);
2670        }
2671        for (int i = CAPACITY_NORMAL; i < CAPACITY_NORMAL * 2; i++) {
2672            writeContents[1].put((byte) i);
2673        }
2674        writeContents[0].flip();
2675        writeContents[1].flip();
2676        // establish connection
2677        channel1.connect(localAddr1);
2678        Socket acceptedSocket = server1.accept();
2679        // set blocking/nonblocking mode
2680        channel1.configureBlocking(isBlocking);
2681
2682        assertEquals(CAPACITY_NORMAL, channel1.write(writeContents, 0, 1));
2683        assertEquals(CAPACITY_NORMAL, channel1.write(writeContents, 1, 1));
2684
2685        // assert written count and ByteBuffer position
2686        assertEquals(CAPACITY_NORMAL, writeContents[0].position());
2687        assertEquals(CAPACITY_NORMAL, writeContents[1].position());
2688        // use close to guarantee all data is sent
2689        channel1.close();
2690        InputStream in = acceptedSocket.getInputStream();
2691        byte[] readContent = new byte[CAPACITY_NORMAL * 2 + 1];
2692        int totalCount = 0;
2693        int count = 0;
2694        // if the channel could not finish reading in TIMEOUT ms, the test
2695        // fails. It is used to guarantee the test never hangs even if there
2696        // are bugs of SocketChannel implementation.
2697        acceptedSocket.setSoTimeout(TIMEOUT);
2698        // use InputStream.read to read data.
2699        while (totalCount <= CAPACITY_NORMAL) {
2700            count = in.read(readContent, totalCount, readContent.length
2701                    - totalCount);
2702            if (EOF == count) {
2703                break;
2704            }
2705            totalCount += count;
2706        }
2707        // assert read content
2708        assertEquals(CAPACITY_NORMAL * 2, totalCount);
2709        writeContents[0].flip();
2710        writeContents[1].flip();
2711        for (int i = 0; i < CAPACITY_NORMAL; i++) {
2712            assertEquals(writeContents[0].get(), readContent[i]);
2713        }
2714        for (int i = CAPACITY_NORMAL; i < CAPACITY_NORMAL * 2; i++) {
2715            assertEquals(writeContents[1].get(), readContent[i]);
2716        }
2717    }
2718
2719    /**
2720     * @tests java.nio.channels.SocketChannel#write(ByteBuffer[])
2721     */
2722    public void test_write$LByteBuffer() throws IOException {
2723        MockSocketChannel sc = new MockSocketChannel(null);
2724        ByteBuffer [] byteBufferArray = { ByteBuffer.allocate(1), ByteBuffer.allocate(1)};
2725        // Verify that calling write(ByteBuffer[]) leads to the method
2726        // write(ByteBuffer[], int, int) being called with a 0 for the
2727        // second parameter and sources.length as the third parameter.
2728        sc.write(byteBufferArray);
2729        assertTrue(sc.isWriteCalled);
2730    }
2731
2732    /**
2733     * @tests java.nio.channels.SocketChannel#write(ByteBuffer[])
2734     */
2735    public void test_writev() throws Exception {
2736        ServerSocketChannel ssc = ServerSocketChannel.open();
2737        ssc.socket().bind(localAddr2);
2738        SocketChannel sc = SocketChannel.open();
2739        sc.connect(localAddr2);
2740        SocketChannel sock = ssc.accept();
2741        ByteBuffer[] buf = { ByteBuffer.allocate(10), ByteBuffer.allocateDirect(20) };
2742
2743        while (buf[0].remaining() != 0 && buf[1].remaining() !=0) {
2744            assertTrue(sc.write(buf, 0, 2) >= 0);
2745        }
2746
2747        ByteBuffer target = ByteBuffer.allocate(30);
2748
2749        while (target.remaining() != 0) {
2750            assertTrue(sock.read(target) >=0);
2751        }
2752
2753        ssc.close();
2754        sc.close();
2755        sock.close();
2756    }
2757
2758    /**
2759     * @tests java.nio.channels.SocketChannel#write(ByteBuffer[])
2760     */
2761    public void test_writev2() throws Exception {
2762        ServerSocketChannel ssc = ServerSocketChannel.open();
2763        ssc.configureBlocking(false);
2764        ssc.socket().bind(null);
2765        SocketChannel sc = SocketChannel.open();
2766        sc.configureBlocking(false);
2767        boolean connected = sc.connect(ssc.socket().getLocalSocketAddress());
2768        SocketChannel sock = ssc.accept();
2769        if (!connected) {
2770            sc.finishConnect();
2771        }
2772
2773        ByteBuffer buf1 = ByteBuffer.allocate(10);
2774        sc.socket().setSendBufferSize(512);
2775        int bufSize = sc.socket().getSendBufferSize();
2776        ByteBuffer buf2 = ByteBuffer.allocate(bufSize * 10);
2777
2778        ByteBuffer[] sent = new ByteBuffer[2];
2779        sent[0] = buf1;
2780        sent[1] = buf2;
2781
2782        long whole = buf1.remaining() + buf2.remaining();
2783
2784        long write = sc.write(sent);
2785        ssc.close();
2786        sc.close();
2787        sock.close();
2788
2789        assertTrue(whole == (write + buf1.remaining() + buf2.remaining()));
2790    }
2791
2792    /**
2793     * @tests java.nio.channels.SocketChannel#write(ByteBuffer[])
2794     *
2795     * In non-blocking mode, the native system call will return EAGAIN/EWOULDBLOCK error
2796     * code on Linux/Unix and return WSATRY_AGAIN/WSAEWOULDBLOCK error code on Windows.
2797     * These error code means try again but not fatal error, so we should not throw exception.
2798     */
2799    public void test_write$NonBlockingException() throws Exception {
2800        ServerSocketChannel ssc = ServerSocketChannel.open();
2801        ssc.configureBlocking(false);
2802        ssc.socket().bind(null);
2803        SocketChannel sc = SocketChannel.open();
2804        sc.configureBlocking(false);
2805        boolean connected = sc.connect(ssc.socket().getLocalSocketAddress());
2806        SocketChannel sock = ssc.accept();
2807        if (!connected) {
2808            sc.finishConnect();
2809        }
2810
2811        try {
2812            for (int i = 0; i < 100; i++) {
2813                ByteBuffer buf1 = ByteBuffer.allocate(10);
2814                sc.socket().setSendBufferSize(512);
2815                int bufSize = sc.socket().getSendBufferSize();
2816                ByteBuffer buf2 = ByteBuffer.allocate(bufSize * 10);
2817
2818                ByteBuffer[] sent = new ByteBuffer[2];
2819                sent[0] = buf1;
2820                sent[1] = buf2;
2821
2822                sc.write(sent);
2823            }
2824        } finally {
2825            ssc.close();
2826            sc.close();
2827            sock.close();
2828        }
2829
2830    }
2831
2832    /**
2833     * @tests java.nio.channels.SocketChannel#write(ByteBuffer[])
2834     */
2835    public void test_write$LByteBuffer2() throws IOException {
2836        // Set-up
2837        ServerSocketChannel server = ServerSocketChannel.open();
2838        server.socket().bind(null);
2839        SocketChannel client = SocketChannel.open();
2840        client.connect(server.socket().getLocalSocketAddress());
2841        SocketChannel worker = server.accept();
2842
2843        // Test overlapping buffers
2844        byte[] data = "Hello world!".getBytes("UTF-8");
2845        ByteBuffer[] buffers = new ByteBuffer[3];
2846        buffers[0] = ByteBuffer.wrap(data, 0, 6);
2847        buffers[1] = ByteBuffer.wrap(data, 6, data.length - 6);
2848        buffers[2] = ByteBuffer.wrap(data);
2849
2850        // Write them out, read what we wrote and check it
2851        client.write(buffers);
2852        client.close();
2853        ByteBuffer readBuffer = ByteBuffer.allocate(1024);
2854        while (EOF != worker.read(readBuffer)) {};
2855        readBuffer.flip();
2856        Buffer expected = ByteBuffer.allocate(1024).put(data).put(data).flip();
2857        assertEquals(expected, readBuffer);
2858
2859        // Tidy-up
2860        worker.close();
2861        server.close();
2862    }
2863
2864    /**
2865     * @tests java.nio.channels.SocketChannel#write(ByteBuffer[])
2866     */
2867    public void test_write$LByteBuffer_buffers() throws IOException {
2868        // Set-up
2869        ServerSocketChannel server = ServerSocketChannel.open();
2870        server.socket().bind(null);
2871        SocketChannel client = SocketChannel.open();
2872        client.connect(server.socket().getLocalSocketAddress());
2873        SocketChannel worker = server.accept();
2874
2875        // A variety of buffer types to write
2876        byte[] data = "Hello world!".getBytes("UTF-8");
2877        ByteBuffer[] buffers = new ByteBuffer[3];
2878        buffers[0] = ByteBuffer.wrap(data, 0, 2);
2879        assertFalse(buffers[0].isDirect());
2880        assertTrue(buffers[0].hasArray());
2881
2882        buffers[1] = ByteBuffer.wrap(data, 2, 4).asReadOnlyBuffer();
2883        assertFalse(buffers[1].isDirect());
2884        assertFalse(buffers[1].hasArray());
2885
2886        buffers[2] = ByteBuffer.allocateDirect(42);
2887        buffers[2].put(data, 6, data.length - 6);
2888        buffers[2].flip();
2889        assertTrue(buffers[2].isDirect());
2890        // Android's direct buffers do have a backing array.
2891        assertTrue(buffers[2].hasArray());
2892
2893        // Write them out, read what we wrote and check it
2894        client.write(buffers);
2895        client.close();
2896        ByteBuffer readBuffer = ByteBuffer.allocate(1024);
2897        while (EOF != worker.read(readBuffer)) {};
2898        readBuffer.flip();
2899        assertEquals(ByteBuffer.wrap(data), readBuffer);
2900
2901        // Tidy-up
2902        worker.close();
2903        server.close();
2904    }
2905
2906    /**
2907     * @tests java.nio.channels.SocketChannel#write(ByteBuffer[])
2908     */
2909    public void test_write$LByteBuffer_writes() throws IOException {
2910        // Set-up
2911        ServerSocketChannel server = ServerSocketChannel.open();
2912        server.socket().bind(null);
2913        SocketChannel client = SocketChannel.open();
2914        client.connect(server.socket().getLocalSocketAddress());
2915        SocketChannel worker = server.accept();
2916
2917        // Data to write
2918        byte[] data = "Hello world!".getBytes("UTF-8");
2919        ByteBuffer[] buffers = new ByteBuffer[3];
2920        buffers[0] = ByteBuffer.wrap(data, 0, 6);
2921        buffers[1] = ByteBuffer.wrap("world!".getBytes("UTF-8"));
2922        buffers[2] = buffers[0];
2923        assertTrue(buffers[0].hasArray());
2924
2925        // Test a sequence of write calls
2926        client.write(buffers, 0, 0); // write nothing
2927        client.write(buffers, 1, 0); // write nothing
2928        client.write(buffers, 0, 1); // write "Hello "
2929        assertEquals("Failed to drain buffer 0", 0, buffers[0].remaining());
2930        assertEquals("Shouldn't touch buffer 1", buffers[1].limit(), buffers[1]
2931                .remaining());
2932        client.write(buffers, 0, 2); // writes "world!"
2933        assertEquals("Failed to drain buffer 1", 0, buffers[1].remaining());
2934        client.write(buffers, 0, 3); // write nothing
2935        client.close();
2936
2937        // Read what we wrote and check it
2938        ByteBuffer readBuffer = ByteBuffer.allocate(1024);
2939        while (EOF != worker.read(readBuffer)) {};
2940        readBuffer.flip();
2941        assertEquals(ByteBuffer.wrap(data), readBuffer);
2942
2943        // Tidy-up
2944        worker.close();
2945        server.close();
2946    }
2947
2948    /**
2949     * @tests java.nio.channels.SocketChannel#write(ByteBuffer[])
2950     */
2951    public void test_write$LByteBuffer_invalid() throws IOException {
2952        // Set-up
2953        ServerSocketChannel server = ServerSocketChannel.open();
2954        server.socket().bind(null);
2955
2956        SocketChannel client = SocketChannel.open();
2957        client.connect(server.socket().getLocalSocketAddress());
2958
2959        SocketChannel worker = server.accept();
2960
2961        // Do some stuff
2962        try {
2963            client.write((ByteBuffer[]) null);
2964            fail("Should throw a NPE");
2965        } catch (NullPointerException e) {
2966            // expected
2967        }
2968        try {
2969            client.write((ByteBuffer[]) null, 0, 0);
2970            fail("Should throw a NPE");
2971        } catch (NullPointerException e) {
2972            // expected
2973        }
2974        try {
2975            client.write((ByteBuffer[]) null, 1, 0);
2976            fail("Should throw a NPE");
2977        } catch (NullPointerException e) {
2978            // expected
2979        }
2980        try {
2981            client.write((ByteBuffer[]) null, 0, 1);
2982            fail("Should throw a NPE");
2983        } catch (NullPointerException e) {
2984            // expected
2985        }
2986        try {
2987            client.write((ByteBuffer[]) null, 1, 1);
2988            fail("Should throw a NPE");
2989        } catch (NullPointerException e) {
2990            // expected
2991        }
2992
2993        ByteBuffer[] buffers = new ByteBuffer[1];
2994        buffers[0] = ByteBuffer.wrap("Hello ".getBytes("UTF-8"));
2995
2996        try {
2997            client.write(buffers, -1, 1);
2998            fail();
2999        } catch (IndexOutOfBoundsException expected) {
3000        }
3001        try {
3002            client.write(buffers, 0, -1);
3003            fail();
3004        } catch (IndexOutOfBoundsException expected) {
3005        }
3006        try {
3007            client.write(buffers, 0, 2);
3008            fail();
3009        } catch (IndexOutOfBoundsException expected) {
3010        }
3011        try {
3012            client.write(buffers, 2, 0);
3013            fail();
3014        } catch (IndexOutOfBoundsException expected) {
3015        }
3016        try {
3017            client.write(null, 0, 0);
3018            fail();
3019        } catch (NullPointerException expected) {
3020        }
3021
3022        // Tidy-up
3023        worker.close();
3024        client.close();
3025        server.close();
3026    }
3027
3028    public void testSocket_configureblocking() throws IOException {
3029        byte[] serverWBuf = new byte[CAPACITY_NORMAL];
3030        for (int i = 0; i < serverWBuf.length; i++) {
3031            serverWBuf[i] = (byte) i;
3032        }
3033        java.nio.ByteBuffer buf = java.nio.ByteBuffer
3034                .allocate(CAPACITY_NORMAL + 1);
3035        channel1.connect(localAddr1);
3036        server1.accept();
3037        Socket sock = this.channel1.socket();
3038        channel1.configureBlocking(false);
3039        assertFalse(channel1.isBlocking());
3040        OutputStream channelSocketOut = sock.getOutputStream();
3041        try {
3042            // write operation is not allowed in non-blocking mode
3043            channelSocketOut.write(buf.array());
3044            fail("Non-Blocking mode should cause IllegalBlockingModeException");
3045        } catch (IllegalBlockingModeException e) {
3046            // correct
3047        }
3048        channel1.configureBlocking(true);
3049        assertTrue(channel1.isBlocking());
3050        // write operation is allowed in blocking mode
3051        channelSocketOut.write(buf.array());
3052    }
3053
3054    /**
3055     * @tests SocketChannel#read(ByteBuffer[], int, int) when remote server
3056     *        closed
3057     */
3058    public void test_socketChannel_read_ByteBufferII_remoteClosed()
3059            throws Exception {
3060        // regression 1 for HARMONY-549
3061        ServerSocketChannel ssc = ServerSocketChannel.open();
3062        ssc.socket().bind(localAddr2);
3063        SocketChannel sc = SocketChannel.open();
3064        sc.connect(localAddr2);
3065        ssc.accept().close();
3066        ByteBuffer[] buf = { ByteBuffer.allocate(10) };
3067        assertEquals(-1, sc.read(buf, 0, 1));
3068        ssc.close();
3069        sc.close();
3070    }
3071
3072    /**
3073     * @tests SocketChannel#write(ByteBuffer[], int, int)
3074     */
3075    public void test_socketChannel_write_ByteBufferII() throws Exception {
3076        // regression 2 for HARMONY-549
3077        ServerSocketChannel ssc = ServerSocketChannel.open();
3078        ssc.socket().bind(localAddr2);
3079        SocketChannel sc = SocketChannel.open();
3080        sc.connect(localAddr2);
3081        SocketChannel sock = ssc.accept();
3082        ByteBuffer[] buf = { ByteBuffer.allocate(10), null };
3083        try {
3084            sc.write(buf, 0, 2);
3085            fail("should throw NPE");
3086        } catch (NullPointerException e) {
3087            // expected
3088        }
3089        ssc.close();
3090        sc.close();
3091        ByteBuffer target = ByteBuffer.allocate(10);
3092        assertEquals(-1, sock.read(target));
3093    }
3094
3095    /**
3096     * @tests SocketChannel#read(ByteBuffer[], int, int) with a null ByteBuffer
3097     */
3098    public void test_socketChannel_read_ByteBufferII_bufNULL() throws Exception {
3099        // regression 3 for HARMONY-549
3100        ServerSocketChannel ssc = ServerSocketChannel.open();
3101        ssc.socket().bind(localAddr2);
3102        SocketChannel sc = SocketChannel.open();
3103        sc.connect(localAddr2);
3104        ssc.accept();
3105        ByteBuffer[] buf = new ByteBuffer[2];
3106        buf[0] = ByteBuffer.allocate(1);
3107        // let buf[1] be null
3108        try {
3109            sc.read(buf, 0, 2);
3110            fail("should throw NullPointerException");
3111        } catch (NullPointerException e) {
3112            // expected
3113        }
3114        ssc.close();
3115        sc.close();
3116    }
3117
3118    /**
3119     * @tests SocketChannel#write(ByteBuffer) after close
3120     */
3121    public void test_socketChannel_write_close() throws Exception {
3122        // regression 4 for HARMONY-549
3123        ServerSocketChannel ssc = ServerSocketChannel.open();
3124        ssc.socket().bind(localAddr2);
3125        SocketChannel sc = SocketChannel.open();
3126        sc.connect(localAddr2);
3127        SocketChannel sock = ssc.accept();
3128        ByteBuffer buf = null;
3129        ssc.close();
3130        sc.close();
3131        try {
3132            sc.write(buf);
3133            fail("should throw NPE");
3134        } catch (NullPointerException e) {
3135            // expected
3136        }
3137        sock.close();
3138    }
3139
3140    /**
3141     * @tests SocketChannel#write(ByteBuffer) if position is not zero
3142     */
3143    public void test_socketChannel_write_ByteBuffer_posNotZero()
3144            throws Exception {
3145        // regression 5 for HARMONY-549
3146        final String testStr = "Hello World";
3147        ByteBuffer readBuf = ByteBuffer.allocate(11);
3148        ByteBuffer buf = ByteBuffer.wrap(testStr.getBytes());
3149        ServerSocketChannel ssc = ServerSocketChannel.open();
3150        ssc.socket().bind(localAddr2);
3151        SocketChannel sc = SocketChannel.open();
3152        sc.connect(localAddr2);
3153        buf.position(2);
3154        ssc.accept().write(buf);
3155        assertEquals(9, sc.read(readBuf));
3156        buf.flip();
3157        readBuf.flip();
3158        byte[] read = new byte[9];
3159        byte[] write = new byte[11];
3160        buf.get(write);
3161        readBuf.get(read);
3162        for (int i = 0; i < 9; i++) {
3163            assertEquals(read[i], write[i + 2]);
3164        }
3165    }
3166
3167    /**
3168     * @tests SocketChannelImpl#read(ByteBuffer[])
3169     */
3170    public void test_read_$ByteBuffer_Blocking() throws IOException {
3171        // regression test for Harmony-728
3172        byte[] data = new byte[CAPACITY_NORMAL];
3173        for (int i = 0; i < CAPACITY_NORMAL; i++) {
3174            data[i] = (byte) i;
3175        }
3176        ByteBuffer[] buf = new ByteBuffer[2];
3177        buf[0] = ByteBuffer.allocate(CAPACITY_NORMAL);
3178        buf[1] = ByteBuffer.allocate(CAPACITY_NORMAL);
3179        channel1.connect(localAddr1);
3180        Socket socket = null;
3181        try {
3182            socket = server1.accept();
3183            OutputStream out = socket.getOutputStream();
3184            out.write(data);
3185            // should not block here
3186            channel1.read(buf);
3187        } finally {
3188            if (null != socket) {
3189                socket.close();
3190            }
3191        }
3192    }
3193
3194    public void test_socket_getOutputStream_nonBlocking_read_Exception() throws IOException {
3195        byte[] buf = new byte[1];
3196        channel1.connect(this.localAddr1);
3197        InputStream is = channel1.socket().getInputStream();
3198        channel1.configureBlocking(false);
3199        try {
3200            is.read();
3201            fail();
3202        } catch (IllegalBlockingModeException expected) {
3203        }
3204        try {
3205            is.read(null);
3206            fail();
3207        } catch (NullPointerException expected) {
3208        }
3209        try {
3210            is.read(buf, -1, 1);
3211            fail();
3212        } catch (IndexOutOfBoundsException expected) {
3213        }
3214        try {
3215            is.read(buf, 0, -1);
3216            fail();
3217        } catch (IndexOutOfBoundsException expected) {
3218        }
3219        try {
3220            is.read(buf, 0, 2);
3221            fail();
3222        } catch (IndexOutOfBoundsException expected) {
3223        }
3224        try {
3225            is.read(buf, 2, 0);
3226            fail();
3227        } catch (IndexOutOfBoundsException expected) {
3228        }
3229        try {
3230            is.read(null, 0, 0);
3231            fail();
3232        } catch (NullPointerException expected) {
3233        }
3234
3235        is.close();
3236
3237        try {
3238            is.read();
3239            fail();
3240        } catch (IllegalBlockingModeException expected) {
3241        }
3242        try {
3243            is.read(null);
3244            fail();
3245        } catch (NullPointerException expected) {
3246        }
3247        try {
3248            is.read(buf, -1, 1);
3249            fail();
3250        } catch (IndexOutOfBoundsException expected) {
3251        }
3252        try {
3253            is.read(buf, 0, -1);
3254            fail();
3255        } catch (IndexOutOfBoundsException expected) {
3256        }
3257        try {
3258            is.read(buf, 0, 2);
3259            fail();
3260        } catch (IndexOutOfBoundsException expected) {
3261        }
3262        try {
3263            is.read(buf, 2, 0);
3264            fail();
3265        } catch (IndexOutOfBoundsException expected) {
3266        }
3267        try {
3268            is.read(null, 0, 0);
3269            fail();
3270        } catch (NullPointerException expected) {
3271        }
3272    }
3273
3274    public void test_socket_getOutputStream_blocking_read_Exception() throws IOException {
3275        byte[] buf = new byte[1];
3276        channel1.connect(this.localAddr1);
3277        InputStream is = channel1.socket().getInputStream();
3278        try {
3279            is.read(null);
3280            fail();
3281        } catch (NullPointerException expected) {
3282        }
3283        try {
3284            is.read(buf, -1, 1);
3285            fail();
3286        } catch (IndexOutOfBoundsException expected) {
3287        }
3288        try {
3289            is.read(buf, 0, -1);
3290            fail();
3291        } catch (IndexOutOfBoundsException expected) {
3292        }
3293        try {
3294            is.read(buf, 0, 2);
3295            fail();
3296        } catch (IndexOutOfBoundsException expected) {
3297        }
3298        try {
3299            is.read(buf, 2, 0);
3300            fail();
3301        } catch (IndexOutOfBoundsException expected) {
3302        }
3303        try {
3304            is.read(null, 0, 0);
3305            fail();
3306        } catch (NullPointerException expected) {
3307        }
3308
3309        is.close();
3310
3311        try {
3312            is.read(null);
3313            fail();
3314        } catch (NullPointerException expected) {
3315        }
3316        try {
3317            is.read(buf, -1, 1);
3318            fail();
3319        } catch (IndexOutOfBoundsException expected) {
3320        }
3321        try {
3322            is.read(buf, 0, -1);
3323            fail();
3324        } catch (IndexOutOfBoundsException expected) {
3325        }
3326        try {
3327            is.read(buf, 0, 2);
3328            fail();
3329        } catch (IndexOutOfBoundsException expected) {
3330        }
3331        try {
3332            is.read(buf, 2, 0);
3333            fail();
3334        } catch (IndexOutOfBoundsException expected) {
3335        }
3336        try {
3337            is.read(null, 0, 0);
3338            fail();
3339        } catch (NullPointerException expected) {
3340        }
3341    }
3342
3343    public void test_socket_getOutputStream_nonBlocking_write_Exception() throws IOException {
3344        byte[] buf = new byte[1];
3345        channel1.connect(this.localAddr1);
3346        OutputStream os = channel1.socket().getOutputStream();
3347        channel1.configureBlocking(false);
3348
3349        try {
3350            os.write(1);
3351            fail();
3352        } catch (IllegalBlockingModeException expected) {
3353        }
3354        try {
3355            os.write(null);
3356            fail();
3357        } catch (NullPointerException expected) {
3358        }
3359        try {
3360            os.write(buf, -1, 1);
3361            fail();
3362        } catch (IndexOutOfBoundsException expected) {
3363        }
3364        try {
3365            os.write(buf, 0, -1);
3366            fail();
3367        } catch (IndexOutOfBoundsException expected) {
3368        }
3369        try {
3370            os.write(buf, 0, 2);
3371            fail();
3372        } catch (IndexOutOfBoundsException expected) {
3373        }
3374        try {
3375            os.write(buf, 2, 0);
3376            fail();
3377        } catch (IndexOutOfBoundsException expected) {
3378        }
3379        try {
3380            os.write(null, 0, 0);
3381            fail();
3382        } catch (NullPointerException expected) {
3383        }
3384
3385        os.close();
3386
3387        try {
3388            os.write(1);
3389            fail();
3390        } catch (IllegalBlockingModeException expected) {
3391        }
3392        try {
3393            os.write(null);
3394            fail();
3395        } catch (NullPointerException expected) {
3396        }
3397        try {
3398            os.write(buf, -1, 1);
3399            fail();
3400        } catch (IndexOutOfBoundsException expected) {
3401        }
3402        try {
3403            os.write(buf, 0, -1);
3404            fail();
3405        } catch (IndexOutOfBoundsException expected) {
3406        }
3407        try {
3408            os.write(buf, 0, 2);
3409            fail();
3410        } catch (IndexOutOfBoundsException expected) {
3411        }
3412        try {
3413            os.write(buf, 2, 0);
3414            fail();
3415        } catch (IndexOutOfBoundsException expected) {
3416        }
3417        try {
3418            os.write(null, 0, 0);
3419            fail();
3420        } catch (NullPointerException expected) {
3421        }
3422    }
3423
3424    public void test_socket_getOutputStream_blocking_write_Exception() throws IOException {
3425        byte[] buf = new byte[1];
3426        channel1.connect(this.localAddr1);
3427        OutputStream os = channel1.socket().getOutputStream();
3428        try {
3429            os.write(null);
3430            fail();
3431        } catch (NullPointerException expected) {
3432        }
3433        try {
3434            os.write(buf, -1, 1);
3435            fail();
3436        } catch (IndexOutOfBoundsException expected) {
3437        }
3438        try {
3439            os.write(buf, 0, -1);
3440            fail();
3441        } catch (IndexOutOfBoundsException expected) {
3442        }
3443        try {
3444            os.write(buf, 0, 2);
3445            fail();
3446        } catch (IndexOutOfBoundsException expected) {
3447        }
3448        try {
3449            os.write(buf, 2, 0);
3450            fail();
3451        } catch (IndexOutOfBoundsException expected) {
3452        }
3453        try {
3454            os.write(null, 0, 0);
3455            fail();
3456        } catch (NullPointerException expected) {
3457        }
3458
3459        os.close();
3460
3461        try {
3462            os.write(null);
3463            fail();
3464        } catch (NullPointerException expected) {
3465        }
3466        try {
3467            os.write(buf, -1, 1);
3468            fail();
3469        } catch (IndexOutOfBoundsException expected) {
3470        }
3471        try {
3472            os.write(buf, 0, -1);
3473            fail();
3474        } catch (IndexOutOfBoundsException expected) {
3475        }
3476        try {
3477            os.write(buf, 0, 2);
3478            fail();
3479        } catch (IndexOutOfBoundsException expected) {
3480        }
3481        try {
3482            os.write(buf, 2, 0);
3483            fail();
3484        } catch (IndexOutOfBoundsException expected) {
3485        }
3486        try {
3487            os.write(null, 0, 0);
3488            fail();
3489        } catch (NullPointerException expected) {
3490        }
3491    }
3492
3493    /**
3494     * @tests SocketChannelImpl#socket().getOutputStream().write(int)
3495     */
3496    public void test_socket_getOutputStream_write_oneByte()
3497            throws IOException {
3498
3499        // Regression test for Harmony-3475
3500
3501        int MAGIC = 123;
3502
3503        channel1.connect(this.localAddr1);
3504
3505        OutputStream os = channel1.socket().getOutputStream();
3506
3507        Socket acceptedSocket = server1.accept();
3508
3509        InputStream in = acceptedSocket.getInputStream();
3510
3511        os.write(MAGIC);
3512        channel1.close();
3513
3514        int lastByte =  in.read();
3515        if (lastByte == -1) {
3516            fail("Server received nothing. Expected 1 byte.");
3517        } else if (lastByte != MAGIC) {
3518            fail("Server received wrong single byte: " + lastByte +
3519                 ", expected: " + MAGIC);
3520        }
3521
3522        lastByte = in.read();
3523        if (lastByte != -1) {
3524            fail("Server received too long sequence. Expected 1 byte.");
3525        }
3526    }
3527
3528    public void testSocket_setOptions() throws IOException {
3529        channel1.connect(localAddr1);
3530        Socket socket = channel1.socket();
3531
3532        ByteBuffer buffer = ByteBuffer.wrap(new byte[] {1, 2, 3});
3533        socket.setKeepAlive(true);
3534        channel1.write(buffer);
3535
3536        socket.setOOBInline(true);
3537        channel1.write(buffer);
3538
3539        socket.setReceiveBufferSize(100);
3540        channel1.write(buffer);
3541
3542        socket.setReuseAddress(true);
3543        channel1.write(buffer);
3544
3545        socket.setSendBufferSize(100);
3546        channel1.write(buffer);
3547
3548        socket.setSoLinger(true, 100);
3549        channel1.write(buffer);
3550
3551        socket.setSoTimeout(1000);
3552        channel1.write(buffer);
3553
3554        socket.setTcpNoDelay(true);
3555        channel1.write(buffer);
3556
3557        socket.setTrafficClass(10);
3558        channel1.write(buffer);
3559    }
3560
3561    class MockSocketChannel extends SocketChannel{
3562
3563        private boolean isWriteCalled = false;
3564
3565        private boolean isReadCalled = false;
3566
3567        public MockSocketChannel(SelectorProvider provider){
3568            super(provider);
3569        }
3570
3571        public Socket socket() {
3572            return null;
3573        }
3574
3575        public boolean isConnected() {
3576            return false;
3577        }
3578
3579        public boolean isConnectionPending() {
3580            return false;
3581        }
3582
3583        public boolean connect(SocketAddress address) throws IOException {
3584            return false;
3585        }
3586
3587        public boolean finishConnect() throws IOException {
3588            return false;
3589        }
3590
3591        public int read(ByteBuffer target) throws IOException {
3592            return 0;
3593        }
3594
3595        public long read(ByteBuffer[] targets, int offset, int length) throws IOException {
3596            // Verify that calling read(ByteBuffer[]) leads to the method
3597            // read(ByteBuffer[], int, int) being called with a 0 for the
3598            // second parameter and targets.length as the third parameter.
3599            if(0 == offset && length == targets.length){
3600                isReadCalled = true;
3601            }
3602            return 0;
3603        }
3604
3605        public int write(ByteBuffer source) throws IOException {
3606            return 0;
3607        }
3608
3609        public long write(ByteBuffer[] sources, int offset, int length) throws IOException {
3610            // Verify that calling write(ByteBuffer[]) leads to the method
3611            // write(ByteBuffer[], int, int) being called with a 0 for the
3612            // second parameter and sources.length as the third parameter.
3613            if(0 == offset && length == sources.length){
3614                isWriteCalled = true;
3615            }
3616            return 0;
3617        }
3618
3619        protected void implCloseSelectableChannel() throws IOException {
3620            // empty
3621        }
3622
3623        protected void implConfigureBlocking(boolean blockingMode) throws IOException {
3624            // empty
3625        }
3626
3627    }
3628}
3629