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.net.DatagramPacket;
22import java.net.DatagramSocket;
23import java.net.InetAddress;
24import java.net.InetSocketAddress;
25import java.net.SocketAddress;
26import java.net.SocketException;
27import java.nio.ByteBuffer;
28import java.nio.channels.AsynchronousCloseException;
29import java.nio.channels.ClosedChannelException;
30import java.nio.channels.DatagramChannel;
31import java.nio.channels.IllegalBlockingModeException;
32import java.nio.channels.NotYetConnectedException;
33import java.nio.channels.UnresolvedAddressException;
34import java.nio.channels.UnsupportedAddressTypeException;
35import java.nio.channels.spi.SelectorProvider;
36import java.security.Permission;
37
38import junit.framework.TestCase;
39import tests.support.Support_PortManager;
40
41/**
42 * Test for DatagramChannel
43 *
44 */
45public class DatagramChannelTest extends TestCase {
46
47    private static final int CAPACITY_NORMAL = 200;
48
49    private static final int CAPACITY_1KB = 1024;
50
51    private static final int CAPACITY_64KB = 65536;
52
53    private static final int CAPACITY_ZERO = 0;
54
55    private static final int CAPACITY_ONE = 1;
56
57    private static final int TIME_UNIT = 500;
58
59    private InetSocketAddress localAddr1;
60
61    private InetSocketAddress localAddr2;
62
63    private DatagramChannel channel1;
64
65    private DatagramChannel channel2;
66
67    private DatagramSocket datagramSocket1;
68
69    private DatagramSocket datagramSocket2;
70
71    // The port to be used in test cases.
72    private int testPort;
73
74    protected void setUp() throws Exception {
75        super.setUp();
76        this.channel1 = DatagramChannel.open();
77        this.channel2 = DatagramChannel.open();
78        int[] ports = Support_PortManager.getNextPortsForUDP(5);
79        this.localAddr1 = new InetSocketAddress("127.0.0.1", ports[0]);
80        this.localAddr2 = new InetSocketAddress("127.0.0.1", ports[1]);
81        this.datagramSocket1 = new DatagramSocket(ports[2]);
82        this.datagramSocket2 = new DatagramSocket(ports[3]);
83        testPort = ports[4];
84    }
85
86    protected void tearDown() throws Exception {
87        if (null != this.channel1) {
88            try {
89                this.channel1.close();
90            } catch (Exception e) {
91                //ignore
92            }
93        }
94        if (null != this.channel2) {
95            try {
96                this.channel2.close();
97            } catch (Exception e) {
98                //ignore
99            }
100        }
101        if (null != this.datagramSocket1) {
102            try {
103                this.datagramSocket1.close();
104            } catch (Exception e) {
105                //ignore
106            }
107        }
108        if (null != this.datagramSocket2) {
109            try {
110                this.datagramSocket2.close();
111            } catch (Exception e) {
112                //ignore
113            }
114        }
115        localAddr1 = null;
116        localAddr2 = null;
117        super.tearDown();
118    }
119
120    // -------------------------------------------------------------------
121    // Test for methods in abstract class.
122    // -------------------------------------------------------------------
123    /*
124     * Test method for 'java.nio.channels.DatagramChannel.validOps()'
125     */
126    public void testValidOps() {
127        MockDatagramChannel testMock = new MockDatagramChannel(SelectorProvider
128                .provider());
129        MockDatagramChannel testMocknull = new MockDatagramChannel(null);
130        int val = this.channel1.validOps();
131        assertEquals(5, val);
132        assertEquals(val, testMock.validOps());
133        assertEquals(val, testMocknull.validOps());
134    }
135
136    /*
137     * Test method for 'java.nio.channels.DatagramChannel.open()'
138     */
139    public void testOpen() {
140        MockDatagramChannel testMock = new MockDatagramChannel(SelectorProvider
141                .provider());
142        MockDatagramChannel testMocknull = new MockDatagramChannel(null);
143        assertNull(testMocknull.provider());
144        assertNotNull(testMock.provider());
145        assertEquals(this.channel1.provider(), testMock.provider());
146        assertEquals(5, testMock.validOps());
147    }
148
149    /*
150     * Test method for 'java.nio.channels.DatagramChannel.read(ByteBuffer)'
151     */
152    public void testReadByteBufferArray() throws IOException {
153        final int testNum = 0;
154        long readres = testNum;
155        MockDatagramChannel testMock = new MockDatagramChannel(SelectorProvider
156                .provider());
157        MockDatagramChannel testMocknull = new MockDatagramChannel(null);
158        int bufSize = 10;
159        ByteBuffer[] readBuf = null;
160        try {
161            this.channel1.read(readBuf);
162            fail("Should throw NPE");
163        } catch (NullPointerException e) {
164            // correct
165        }
166        try {
167            readres = testMock.read(readBuf);
168            fail("Should throw NPE");
169        } catch (NullPointerException e) {
170            // correct
171        }
172        readBuf = new ByteBuffer[bufSize];
173        try {
174            readres = this.channel1.read(readBuf);
175            fail("Should throw NotYetConnectedException");
176        } catch (NotYetConnectedException e) {
177            // correct
178        }
179        readres = testMock.read(readBuf);
180        assertEquals(testNum, readres);
181        readres = testMocknull.read(readBuf);
182        assertEquals(testNum, readres);
183    }
184
185    /*
186     * Test method for 'java.nio.channels.DatagramChannel.read(ByteBuffer)'
187     */
188    public void testReadByteBufferArray_BufNull() throws IOException {
189        MockDatagramChannel testMock = new MockDatagramChannel(SelectorProvider
190                .provider());
191        MockDatagramChannel testMocknull = new MockDatagramChannel(null);
192
193        ByteBuffer[] readBuf = null;
194        try {
195            this.channel1.read(readBuf);
196            fail("Should throw NPE");
197        } catch (NullPointerException e) {
198            // correct
199        }
200        try {
201            testMock.read(readBuf);
202            fail("Should throw NPE");
203        } catch (NullPointerException e) {
204            // correct
205        }
206        try {
207            testMocknull.read(readBuf);
208            fail("Should throw NPE");
209        } catch (NullPointerException e) {
210            // correct
211        }
212    }
213
214    /*
215     * Test method for 'java.nio.channels.DatagramChannel.write(ByteBuffer)'
216     */
217    public void testWriteByteBuffer() throws IOException {
218        MockDatagramChannel testMock = new MockDatagramChannel(SelectorProvider
219                .provider());
220        MockDatagramChannel testMocknull = new MockDatagramChannel(null);
221        int bufSize = 10;
222        ByteBuffer[] readBuf = null;
223        try {
224            this.channel1.write(readBuf);
225            fail("Should throw NPE");
226        } catch (NullPointerException e) {
227            // correct
228        }
229        try {
230            testMock.write(readBuf);
231            fail("Should throw NPE");
232        } catch (NullPointerException e) {
233            // correct
234        }
235        readBuf = new ByteBuffer[bufSize];
236        try {
237            this.channel1.write(readBuf);
238            fail("Should throw NotYetConnectedException");
239        } catch (NotYetConnectedException e) {
240            // correct
241        }
242        long writeres = 0;
243        writeres = testMock.write(readBuf);
244
245        assertEquals(0, writeres);
246        writeres = testMocknull.write(readBuf);
247        assertEquals(0, writeres);
248    }
249
250    /*
251     * Test method for 'java.nio.channels.DatagramChannel.write(ByteBuffer)'
252     */
253    public void testWriteByteBuffer_Bufnull() throws IOException {
254        MockDatagramChannel testMock = new MockDatagramChannel(SelectorProvider
255                .provider());
256        MockDatagramChannel testMocknull = new MockDatagramChannel(null);
257        ByteBuffer[] readBuf = null;
258        try {
259            this.channel1.write(readBuf);
260            fail("Should throw NPE");
261        } catch (NullPointerException e) {
262            // correct
263        }
264        try {
265            testMock.write(readBuf);
266            fail("Should throw NPE");
267        } catch (NullPointerException e) {
268            // correct
269        }
270        try {
271            testMocknull.write(readBuf);
272            fail("Should throw NPE");
273        } catch (NullPointerException e) {
274            // correct
275        }
276    }
277
278    // -------------------------------------------------------------------
279    // Test for socket()
280    // -------------------------------------------------------------------
281
282    /**
283     * Test method for 'DatagramChannelImpl.socket()'
284     *
285     * @throws SocketException
286     */
287    public void testSocket_BasicStatusBeforeConnect() throws SocketException {
288        assertFalse(this.channel1.isConnected());// not connected
289        DatagramSocket s1 = this.channel1.socket();
290        assertSocketBeforeConnect(s1);
291        DatagramSocket s2 = this.channel1.socket();
292        // same
293        assertSame(s1, s2);
294    }
295
296    /**
297     * Test method for 'DatagramChannelImpl.socket()'
298     *
299     * @throws IOException
300     */
301    public void testSocket_Block_BasicStatusAfterConnect() throws IOException {
302        this.channel1.connect(localAddr1);
303        DatagramSocket s1 = this.channel1.socket();
304        assertSocketAfterConnect(s1);
305        DatagramSocket s2 = this.channel1.socket();
306        // same
307        assertSame(s1, s2);
308    }
309
310    public void testSocket_NonBlock_BasicStatusAfterConnect()
311            throws IOException {
312        this.channel1.connect(localAddr1);
313        this.channel1.configureBlocking(false);
314        DatagramSocket s1 = this.channel1.socket();
315        assertSocketAfterConnect(s1);
316        DatagramSocket s2 = this.channel1.socket();
317        // same
318        assertSame(s1, s2);
319    }
320
321    /**
322     * Test method for 'DatagramChannelImpl.socket()'
323     *
324     * @throws IOException
325     */
326    public void testSocket_ActionsBeforeConnect() throws IOException {
327        assertFalse(this.channel1.isConnected());// not connected
328        DatagramSocket s = this.channel1.socket();
329        assertSocketActionBeforeConnect(s);
330    }
331
332    /**
333     * Test method for 'DatagramChannelImpl.socket()'
334     *
335     * @throws IOException
336     */
337    public void testSocket_Block_ActionsAfterConnect() throws IOException {
338        assertFalse(this.channel1.isConnected());// not connected
339        this.channel1.connect(localAddr1);
340        DatagramSocket s = this.channel1.socket();
341        assertSocketActionAfterConnect(s);
342    }
343
344    public void testSocket_NonBlock_ActionsAfterConnect() throws IOException {
345        this.channel1.connect(localAddr1);
346        this.channel1.configureBlocking(false);
347        DatagramSocket s = this.channel1.socket();
348        assertSocketActionAfterConnect(s);
349    }
350
351    private void assertSocketBeforeConnect(DatagramSocket s)
352            throws SocketException {
353        assertFalse(s.isBound());
354        assertFalse(s.isClosed());
355        assertFalse(s.isConnected());
356        assertFalse(s.getBroadcast());
357        assertFalse(s.getReuseAddress());
358        assertNull(s.getInetAddress());
359        assertTrue(s.getLocalAddress().isAnyLocalAddress());
360        assertEquals(s.getLocalPort(), 0);
361        assertNull(s.getLocalSocketAddress());
362        assertEquals(s.getPort(), -1);
363        assertTrue(s.getReceiveBufferSize() >= 8192);
364        assertNull(s.getRemoteSocketAddress());
365        assertFalse(s.getReuseAddress());
366        assertTrue(s.getSendBufferSize() >= 8192);
367        assertEquals(s.getSoTimeout(), 0);
368        assertEquals(s.getTrafficClass(), 0);
369    }
370
371    private void assertSocketAfterConnect(DatagramSocket s)
372            throws SocketException {
373        assertTrue(s.isBound());
374        assertFalse(s.isClosed());
375        assertTrue(s.isConnected());
376        assertFalse(s.getBroadcast());
377        assertFalse(s.getReuseAddress());
378        assertSame(s.getInetAddress(), localAddr1.getAddress());
379        assertEquals(s.getLocalAddress(), localAddr1.getAddress());
380        assertNotNull(s.getLocalSocketAddress());
381        assertEquals(s.getPort(), localAddr1.getPort());
382        assertTrue(s.getReceiveBufferSize() >= 8192);
383        // not same , but equals
384        assertNotSame(s.getRemoteSocketAddress(), (SocketAddress) localAddr1);
385        assertEquals(s.getRemoteSocketAddress(), (SocketAddress) localAddr1);
386        assertFalse(s.getReuseAddress());
387        assertTrue(s.getSendBufferSize() >= 8192);
388        assertEquals(s.getSoTimeout(), 0);
389        assertEquals(s.getTrafficClass(), 0);
390    }
391
392    private void assertSocketActionBeforeConnect(DatagramSocket s)
393            throws IOException {
394        s.connect(localAddr2);
395        assertFalse(this.channel1.isConnected());
396        assertFalse(s.isConnected());
397
398        s.disconnect();
399        assertFalse(this.channel1.isConnected());
400        assertFalse(s.isConnected());
401
402        s.close();
403        assertTrue(s.isClosed());
404        assertFalse(this.channel1.isOpen());
405    }
406
407    private void assertSocketActionAfterConnect(DatagramSocket s)
408            throws IOException {
409        assertEquals(s.getPort(), localAddr1.getPort());
410        s.connect(localAddr2);
411        assertTrue(this.channel1.isConnected());
412        assertTrue(s.isConnected());
413        // not changed
414        assertEquals(s.getPort(), localAddr1.getPort());
415
416        s.disconnect();
417        assertFalse(this.channel1.isConnected());
418        assertFalse(s.isConnected());
419
420        s.close();
421        assertTrue(s.isClosed());
422        assertFalse(this.channel1.isOpen());
423    }
424
425    // -------------------------------------------------------------------
426    // Test for configureBlocking()
427    // -------------------------------------------------------------------
428
429    public void testConfigureBlocking_Read() throws Exception {
430        assertTrue(this.channel1.isBlocking());
431        ByteBuffer buf = ByteBuffer.allocate(CAPACITY_1KB);
432        new Thread() {
433            public void run() {
434                try {
435                    sleep(TIME_UNIT * 5);
436                    channel1.configureBlocking(false);
437                    assertFalse(channel1.isBlocking());
438                    datagramSocket1.close();
439                } catch (Exception e) {
440                    // do nothing
441                }
442            }
443        }.start();
444        SocketAddress addr = channel1.receive(buf);
445        assertNull(addr);
446    }
447
448    // -------------------------------------------------------------------
449    // Test for isConnected()
450    // -------------------------------------------------------------------
451
452    /**
453     * Test method for 'DatagramChannelImpl.isConnected()'
454     *
455     * @throws IOException
456     */
457    public void testIsConnected_WithServer() throws IOException {
458        connectLocalServer();
459        disconnectAfterConnected();
460        this.datagramSocket1.close();
461        this.channel1.close();
462        assertFalse(this.channel1.isConnected());
463    }
464
465    // -------------------------------------------------------------------
466    // Test for connect()
467    // -------------------------------------------------------------------
468
469    /**
470     * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
471     */
472    public void testConnect_BlockWithServer() throws IOException {
473        // blocking mode
474        assertTrue(this.channel1.isBlocking());
475        connectLocalServer();
476        datagramSocket1.close();
477        disconnectAfterConnected();
478    }
479
480    /**
481     * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
482     */
483    public void testConnect_BlockNoServer() throws IOException {
484        connectWithoutServer();
485        disconnectAfterConnected();
486    }
487
488    /**
489     * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
490     *
491     * @throws IOException
492     */
493    public void testConnect_NonBlockWithServer() throws IOException {
494        // Non blocking mode
495        this.channel1.configureBlocking(false);
496        connectLocalServer();
497        datagramSocket1.close();
498        disconnectAfterConnected();
499    }
500
501    /**
502     * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
503     *
504     * @throws IOException
505     */
506    public void testConnect_Null() throws IOException {
507        assertFalse(this.channel1.isConnected());
508        try {
509            this.channel1.connect(null);
510            fail("Should throw an IllegalArgumentException here."); //$NON-NLS-1$
511        } catch (IllegalArgumentException e) {
512            // OK.
513        }
514    }
515
516    /**
517     * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
518     *
519     * @throws IOException
520     */
521    public void testConnect_UnsupportedType() throws IOException {
522        assertFalse(this.channel1.isConnected());
523        class SubSocketAddress extends SocketAddress {
524            private static final long serialVersionUID = 1L;
525
526            public SubSocketAddress() {
527                super();
528            }
529        }
530        SocketAddress newTypeAddress = new SubSocketAddress();
531        try {
532            this.channel1.connect(newTypeAddress);
533            fail("Should throw an UnsupportedAddressTypeException here.");
534        } catch (UnsupportedAddressTypeException e) {
535            // OK.
536        }
537    }
538
539    /**
540     * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
541     *
542     * @throws IOException
543     */
544    public void testConnect_Unresolved() throws IOException {
545        assertFalse(this.channel1.isConnected());
546        InetSocketAddress unresolved = new InetSocketAddress(
547                "unresolved address", 1080);
548        try {
549            this.channel1.connect(unresolved);
550            fail("Should throw an UnresolvedAddressException here."); //$NON-NLS-1$
551        } catch (UnresolvedAddressException e) {
552            // OK.
553        }
554    }
555
556    public void testConnect_EmptyHost() throws Exception {
557        assertFalse(this.channel1.isConnected());
558
559        assertEquals(this.channel1, this.channel1
560                .connect(new InetSocketAddress("", 1081))); //$NON-NLS-1$
561
562    }
563
564    /**
565     * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
566     *
567     * @throws IOException
568     *
569     */
570    public void testConnect_ClosedChannelException() throws IOException {
571        assertFalse(this.channel1.isConnected());
572        this.channel1.close();
573        assertFalse(this.channel1.isOpen());
574        try {
575            this.channel1.connect(localAddr1);
576            fail("Should throw ClosedChannelException."); //$NON-NLS-1$
577        } catch (ClosedChannelException e) {
578            // OK.
579        }
580    }
581
582    /**
583     * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
584     *
585     * @throws IOException
586     *
587     */
588    public void testConnect_IllegalStateException() throws IOException {
589        assertFalse(this.channel1.isConnected());
590        this.channel1.connect(localAddr1);
591        assertTrue(this.channel1.isConnected());
592        // connect after connected.
593        try {
594            this.channel1.connect(localAddr1);
595            fail("Should throw IllegalStateException."); //$NON-NLS-1$
596        } catch (IllegalStateException e) {
597            // OK.
598        }
599    }
600
601    /**
602     * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
603     *
604     * @throws IOException
605     *
606     */
607    public void testConnect_CheckOpenBeforeStatus() throws IOException {
608        assertFalse(this.channel1.isConnected());
609        this.channel1.connect(localAddr1);
610        assertTrue(this.channel1.isConnected());
611        // connect after connected.
612        this.channel1.close();
613        assertFalse(this.channel1.isOpen());
614        // checking open is before checking status.
615        try {
616            this.channel1.connect(localAddr1);
617            fail("Should throw ClosedChannelException."); //$NON-NLS-1$
618        } catch (ClosedChannelException e) {
619            // OK.
620        }
621    }
622
623    private void disconnectAfterConnected() throws IOException {
624        assertTrue(this.channel1.isConnected());
625        this.channel1.disconnect();
626        assertFalse(this.channel1.isConnected());
627    }
628
629    private void disconnectAfterClosed() throws IOException {
630        assertFalse(this.channel1.isOpen());
631        assertFalse(this.channel1.isConnected());
632        this.channel1.disconnect();
633        assertFalse(this.channel1.isConnected());
634    }
635
636    private void connectLocalServer() throws IOException {
637        assertFalse(this.channel1.isConnected());
638        assertTrue(this.datagramSocket1.isBound());
639        assertSame(this.channel1, this.channel1.connect(localAddr1));
640        assertTrue(this.channel1.isConnected());
641    }
642
643    private void connectWithoutServer() throws IOException {
644        assertFalse(this.channel1.isConnected());
645        this.datagramSocket1.close();
646        assertTrue(this.datagramSocket1.isClosed());
647        assertSame(this.channel1, this.channel1.connect(localAddr1));
648        assertTrue(this.channel1.isConnected());
649    }
650
651    // -------------------------------------------------------------------
652    // Test for disconnect()
653    // -------------------------------------------------------------------
654
655    /**
656     * Test method for 'DatagramChannelImpl.disconnect()'
657     *
658     * @throws IOException
659     */
660    public void testDisconnect_BeforeConnect() throws IOException {
661        assertFalse(this.channel1.isConnected());
662        assertEquals(this.channel1, this.channel1.disconnect());
663        assertFalse(this.channel1.isConnected());
664    }
665
666    /**
667     * Test method for 'DatagramChannelImpl.disconnect()'
668     *
669     * @throws IOException
670     */
671    public void testDisconnect_UnconnectedClosed() throws IOException {
672        assertFalse(this.channel1.isConnected());
673        this.channel1.close();
674        assertFalse(this.channel1.isOpen());
675        assertEquals(this.channel1, this.channel1.disconnect());
676        assertFalse(this.channel1.isConnected());
677    }
678
679    /**
680     * Test method for 'DatagramChannelImpl.disconnect()'
681     *
682     * @throws IOException
683     */
684    public void testDisconnect_BlockWithServerChannelClosed()
685            throws IOException {
686        assertTrue(this.channel1.isBlocking());
687        connectLocalServer();
688        // disconnect after channel close
689        this.channel1.close();
690        disconnectAfterClosed();
691    }
692
693    /**
694     * Test method for 'DatagramChannelImpl.disconnect()'
695     *
696     * @throws IOException
697     */
698    public void testDisconnect_NonBlockWithServerChannelClosed()
699            throws IOException {
700        this.channel1.configureBlocking(false);
701        connectLocalServer();
702        // disconnect after channel close
703        this.channel1.close();
704        disconnectAfterClosed();
705    }
706
707    /**
708     * Test method for 'DatagramChannelImpl.disconnect()'
709     *
710     * @throws IOException
711     */
712    public void testDisconnect_BlockWithServerServerClosed() throws IOException {
713        assertTrue(this.channel1.isBlocking());
714        connectLocalServer();
715        // disconnect after server close
716        this.datagramSocket1.close();
717        assertTrue(this.channel1.isOpen());
718        assertTrue(this.channel1.isConnected());
719        disconnectAfterConnected();
720    }
721
722    /**
723     * Test method for 'DatagramChannelImpl.disconnect()'
724     *
725     * @throws IOException
726     */
727    public void testDisconnect_NonBlockWithServerServerClosed()
728            throws IOException {
729        this.channel1.configureBlocking(false);
730        assertFalse(this.channel1.isBlocking());
731        connectLocalServer();
732        // disconnect after server close
733        this.datagramSocket1.close();
734        assertTrue(this.channel1.isOpen());
735        assertTrue(this.channel1.isConnected());
736        disconnectAfterConnected();
737    }
738
739    // -------------------------------------------------------------------
740    // Test for receive(): Behavior Without Server.
741    // -------------------------------------------------------------------
742
743    /**
744     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
745     *
746     * @throws Exception
747     */
748    public void testReceive_UnconnectedNull() throws Exception {
749        assertFalse(this.channel1.isConnected());
750        try {
751            this.channel1.receive(null);
752            fail("Should throw a NPE here."); //$NON-NLS-1$
753        } catch (NullPointerException e) {
754            // OK.
755        }
756    }
757
758    /**
759     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
760     *
761     * @throws Exception
762     */
763    public void testReceive_UnconnectedReadonly() throws Exception {
764        assertFalse(this.channel1.isConnected());
765        ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_NORMAL)
766                .asReadOnlyBuffer();
767        assertTrue(dst.isReadOnly());
768        try {
769            this.channel1.receive(dst);
770            fail("Should throw an IllegalArgumentException here."); //$NON-NLS-1$
771        } catch (IllegalArgumentException e) {
772            // OK.
773        }
774    }
775
776    /**
777     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
778     *
779     * @throws Exception
780     */
781    public void testReceive_UnconnectedBufEmpty() throws Exception {
782        this.channel1.configureBlocking(false);
783        assertFalse(this.channel1.isConnected());
784        ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
785        assertNull(this.channel1.receive(dst));
786    }
787
788    /**
789     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
790     *
791     * @throws Exception
792     */
793    public void testReceive_UnconnectedBufZero() throws Exception {
794        assertFalse(this.channel1.isConnected());
795        ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_ZERO);
796        assertNull(this.channel1.receive(dst));
797    }
798
799    /**
800     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
801     *
802     * @throws Exception
803     */
804    public void testReceive_UnconnectedBufNotEmpty() throws Exception {
805        assertFalse(this.channel1.isConnected());
806        ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
807        // buf is not empty
808        dst.put((byte) 88);
809        assertEquals(dst.position() + CAPACITY_NORMAL - 1, dst.limit());
810        assertNull(this.channel1.receive(dst));
811    }
812
813    /**
814     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
815     *
816     * @throws Exception
817     */
818    public void testReceive_UnconnectedBufFull() throws Exception {
819        assertFalse(this.channel1.isConnected());
820        ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_ONE);
821        // buf is full
822        dst.put((byte) 88);
823        assertEquals(dst.position(), dst.limit());
824        assertNull(this.channel1.receive(dst));
825    }
826
827    /**
828     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
829     *
830     * @throws Exception
831     */
832    public void testReceive_UnconnectedClose() throws Exception {
833        assertFalse(this.channel1.isConnected());
834        ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
835        this.channel1.close();
836        assertFalse(this.channel1.isOpen());
837        try {
838            assertNull(this.channel1.receive(dst));
839            fail("Should throw a ClosedChannelException here."); //$NON-NLS-1$
840        } catch (ClosedChannelException e) {
841            // OK.
842        }
843    }
844
845    /**
846     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
847     *
848     * @throws Exception
849     */
850    public void testReceive_UnconnectedCloseNull() throws Exception {
851        assertFalse(this.channel1.isConnected());
852        this.channel1.close();
853        assertFalse(this.channel1.isOpen());
854        // checking buffer before checking open
855        try {
856            this.channel1.receive(null);
857            fail("Should throw a NPE here."); //$NON-NLS-1$
858        } catch (NullPointerException e) {
859            // OK.
860        }
861    }
862
863    /**
864     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
865     *
866     * @throws Exception
867     */
868    public void testReceive_UnconnectedCloseReadonly() throws Exception {
869        assertFalse(this.channel1.isConnected());
870        ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_NORMAL)
871                .asReadOnlyBuffer();
872        assertTrue(dst.isReadOnly());
873        this.channel1.close();
874        assertFalse(this.channel1.isOpen());
875        try {
876            this.channel1.receive(dst);
877            fail("Should throw an IllegalArgumentException here."); //$NON-NLS-1$
878        } catch (IllegalArgumentException e) {
879            // OK.
880        }
881    }
882
883    /**
884     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
885     *
886     * @throws Exception
887     */
888    public void testReceive_NonBlockNoServerBufEmpty() throws Exception {
889        this.channel1.configureBlocking(false);
890        receiveNonBlockNoServer(CAPACITY_NORMAL);
891    }
892
893    /**
894     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
895     *
896     * @throws Exception
897     */
898    public void testReceive_BlockNoServerNull() throws Exception {
899        assertTrue(this.channel1.isBlocking());
900        receiveNoServerNull();
901    }
902
903    /**
904     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
905     *
906     * @throws Exception
907     */
908    public void testReceive_NonBlockNoServerNull() throws Exception {
909        this.channel1.configureBlocking(false);
910        receiveNoServerNull();
911    }
912
913    /**
914     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
915     *
916     * @throws Exception
917     */
918    public void testReceive_BlockNoServerReadonly() throws Exception {
919        assertTrue(this.channel1.isBlocking());
920        receiveNoServerReadonly();
921    }
922
923    /**
924     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
925     *
926     * @throws Exception
927     */
928    public void testReceive_NonBlockNoServerReadonly() throws Exception {
929        this.channel1.configureBlocking(false);
930        receiveNoServerReadonly();
931    }
932
933    /**
934     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
935     *
936     * @throws Exception
937     */
938    public void testReceive_NonBlockNoServerBufZero() throws Exception {
939        this.channel1.configureBlocking(false);
940        receiveNonBlockNoServer(CAPACITY_ZERO);
941    }
942
943    /**
944     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
945     *
946     * @throws Exception
947     */
948    public void testReceive_NonBlockNoServerBufNotEmpty() throws Exception {
949        this.channel1.configureBlocking(false);
950        connectWithoutServer();
951        ByteBuffer dst = allocateNonEmptyBuf();
952        assertNull(this.channel1.receive(dst));
953    }
954
955
956    /**
957     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
958     *
959     * @throws Exception
960     */
961    public void testReceive_NonBlockNoServerBufFull() throws Exception {
962        this.channel1.configureBlocking(false);
963        connectWithoutServer();
964        ByteBuffer dst = allocateFullBuf();
965        assertNull(this.channel1.receive(dst));
966    }
967
968    /**
969     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
970     *
971     * @throws Exception
972     */
973    public void testReceive_BlockNoServerChannelClose() throws Exception {
974        assertTrue(this.channel1.isBlocking());
975        receiveNoServerChannelClose();
976    }
977
978    /**
979     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
980     *
981     * @throws Exception
982     */
983    public void testReceive_NonBlockNoServerChannelClose() throws Exception {
984        this.channel1.configureBlocking(false);
985        receiveNoServerChannelClose();
986    }
987
988    /**
989     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
990     *
991     * @throws Exception
992     */
993    public void testReceive_BlockNoServerCloseNull() throws Exception {
994        assertTrue(this.channel1.isBlocking());
995        receiveNoServerChannelCloseNull();
996    }
997
998    /**
999     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
1000     *
1001     * @throws Exception
1002     */
1003    public void testReceive_NonBlockNoServerCloseNull() throws Exception {
1004        this.channel1.configureBlocking(false);
1005        receiveNoServerChannelCloseNull();
1006    }
1007
1008    /**
1009     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
1010     *
1011     * @throws Exception
1012     */
1013    public void testReceive_NonBlockNoServerCloseReadonly() throws Exception {
1014        this.channel1.configureBlocking(false);
1015        receiveNoServerChannelCloseReadonly();
1016    }
1017
1018    /**
1019     * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
1020     *
1021     * @throws Exception
1022     */
1023    public void testReceive_BlockNoServerCloseReadonly() throws Exception {
1024        assertTrue(this.channel1.isBlocking());
1025        receiveNoServerChannelCloseReadonly();
1026    }
1027
1028    private void receiveNoServerNull() throws IOException {
1029        connectWithoutServer();
1030        try {
1031            this.channel1.receive(null);
1032            fail("Should throw a NPE here."); //$NON-NLS-1$
1033        } catch (NullPointerException e) {
1034            // OK.
1035        }
1036    }
1037
1038    private void receiveNoServerReadonly() throws IOException {
1039        connectWithoutServer();
1040        ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_NORMAL)
1041                .asReadOnlyBuffer();
1042        assertTrue(dst.isReadOnly());
1043        try {
1044            this.channel1.receive(dst);
1045            fail("Should throw an IllegalArgumentException here."); //$NON-NLS-1$
1046        } catch (IllegalArgumentException e) {
1047            // OK.
1048        }
1049    }
1050
1051    private void receiveNonBlockNoServer(int size) throws IOException {
1052        connectWithoutServer();
1053        ByteBuffer dst = ByteBuffer.allocateDirect(size);
1054        assertNull(this.channel1.receive(dst));
1055    }
1056
1057    private void receiveNoServerChannelClose() throws IOException {
1058        connectWithoutServer();
1059        ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1060        this.channel1.close();
1061        assertFalse(this.channel1.isOpen());
1062        try {
1063            assertNull(this.channel1.receive(dst));
1064            fail("Should throw a ClosedChannelException here."); //$NON-NLS-1$
1065        } catch (ClosedChannelException e) {
1066            // OK.
1067        }
1068    }
1069
1070    private void receiveNoServerChannelCloseNull() throws IOException {
1071        connectWithoutServer();
1072        this.channel1.close();
1073        assertFalse(this.channel1.isOpen());
1074        try {
1075            this.channel1.receive(null);
1076            fail("Should throw a NPE here."); //$NON-NLS-1$
1077        } catch (NullPointerException e) {
1078            // OK.
1079        }
1080    }
1081
1082    private void receiveNoServerChannelCloseReadonly() throws IOException {
1083        connectWithoutServer();
1084        this.channel1.close();
1085        assertFalse(this.channel1.isOpen());
1086        ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_NORMAL)
1087                .asReadOnlyBuffer();
1088        assertTrue(dst.isReadOnly());
1089        try {
1090            this.channel1.receive(dst);
1091            fail("Should throw an IllegalArgumentException here."); //$NON-NLS-1$
1092        } catch (IllegalArgumentException e) {
1093            // OK.
1094        }
1095    }
1096
1097    private ByteBuffer allocateFullBuf() {
1098        ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_ONE);
1099        // buf is full
1100        dst.put((byte) 88);
1101        assertEquals(dst.position(), dst.limit());
1102        return dst;
1103    }
1104
1105    private ByteBuffer allocateNonEmptyBuf() {
1106        ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1107        // buf is not empty
1108        dst.put((byte) 88);
1109        dst.put((byte) 99);
1110        assertEquals(dst.position() + CAPACITY_NORMAL - 2, dst.limit());
1111        return dst;
1112    }
1113
1114    // -------------------------------------------------------------------
1115    // Test for send(): Behavior without server.
1116    // -------------------------------------------------------------------
1117
1118    private void sendDataBlocking(InetSocketAddress addr, ByteBuffer writeBuf)
1119            throws IOException {
1120        InetSocketAddress ipAddr = addr;
1121        assertEquals(CAPACITY_NORMAL, this.channel1.send(writeBuf, ipAddr));
1122        assertTrue(this.channel1.isOpen());
1123        assertTrue(this.channel1.isBlocking());
1124        this.channel1.connect(ipAddr);
1125        assertTrue(this.channel1.isConnected());
1126    }
1127
1128    private void sendDataNonBlocking(InetSocketAddress addr, ByteBuffer writeBuf)
1129            throws IOException {
1130        InetSocketAddress ipAddr = addr;
1131        this.channel1.configureBlocking(false);
1132        assertEquals(CAPACITY_NORMAL, this.channel1.send(writeBuf, ipAddr));
1133        assertTrue(this.channel1.isOpen());
1134        assertFalse(this.channel1.isBlocking());
1135        this.channel1.connect(ipAddr);
1136        assertTrue(this.channel1.isConnected());
1137    }
1138
1139    /*
1140     * Test method for 'DatagramChannelImpl.send(ByteBuffer, SocketAddress)'
1141     */
1142    public void testSend_NoServerBlockingCommon() throws IOException {
1143        ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1144        sendDataBlocking(localAddr1, writeBuf);
1145    }
1146
1147    public void testSend_NoServerNonblockingCommon() throws IOException {
1148        ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1149        sendDataNonBlocking(localAddr1, writeBuf);
1150    }
1151
1152    public void testSend_NoServerTwice() throws IOException {
1153        ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1154        sendDataBlocking(localAddr1, writeBuf);
1155        // can not buffer twice!
1156        assertEquals(0, this.channel1.send(writeBuf, localAddr1));
1157        try {
1158            channel1.send(writeBuf, localAddr2);
1159            fail("Should throw IllegalArgumentException");
1160        } catch (IllegalArgumentException e) {
1161            // correct
1162        }
1163    }
1164
1165    public void testSend_NoServerNonBlockingTwice() throws IOException {
1166        ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1167        sendDataNonBlocking(localAddr1, writeBuf);
1168        // can not buffer twice!
1169        assertEquals(0, this.channel1.send(writeBuf, localAddr1));
1170        try {
1171            channel1.send(writeBuf, localAddr2);
1172            fail("Should throw IllegalArgumentException");
1173        } catch (IllegalArgumentException e) {
1174            // correct
1175        }
1176    }
1177
1178    public void testSend_NoServerBufNull() throws IOException {
1179        try {
1180            sendDataBlocking(localAddr1, null);
1181            fail("Should throw a NPE here.");
1182        } catch (NullPointerException e) {
1183            // correct
1184        }
1185    }
1186
1187    public void testSend_NoServerBufNullTwice() throws IOException {
1188        ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1189        try {
1190            sendDataBlocking(localAddr1, null);
1191            fail("Should throw a NPE here.");
1192        } catch (NullPointerException e) {
1193            // correct
1194        }
1195        sendDataBlocking(localAddr1, writeBuf);
1196        try {
1197            channel1.send(null, localAddr2);
1198            fail("Should throw NPE");
1199        } catch (NullPointerException e) {
1200            // correct
1201        }
1202    }
1203
1204    public void testSend_NoServerAddrNull() throws IOException {
1205        ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1206        try {
1207            sendDataBlocking(null, writeBuf);
1208            fail("Should throw a NPE here.");
1209        } catch (NullPointerException e) {
1210            // correct
1211        }
1212    }
1213
1214    public void testSend_NoServerAddrNullTwice() throws IOException {
1215        ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1216        try {
1217            sendDataBlocking(null, writeBuf);
1218            fail("Should throw a NPE here.");
1219        } catch (NullPointerException e) {
1220            // correct
1221        }
1222        sendDataBlocking(localAddr1, writeBuf);
1223        try {
1224            channel1.send(writeBuf, null);
1225            fail("Should throw NPE");
1226        } catch (NullPointerException e) {
1227            // correct
1228        }
1229    }
1230
1231    // -------------------------------------------------------------------
1232    // Test for receive()and send(): Send and Receive with Real Data
1233    // -------------------------------------------------------------------
1234
1235    public void testReceiveSend_Block_Normal() throws Exception {
1236        this.channel1.socket().bind(localAddr2);
1237        sendByChannel("some normal string in testReceiveSend_Normal",
1238                localAddr2);
1239        receiveByChannel(CAPACITY_NORMAL, localAddr2,
1240                "some normal string in testReceiveSend_Normal");
1241    }
1242
1243    public void testReceiveSend_Block_NotBound() throws Exception {
1244        // not bound
1245        sendByChannel("some normal string in testReceiveSend_Normal",
1246                localAddr2);
1247        ByteBuffer buf = ByteBuffer.allocate(CAPACITY_NORMAL);
1248        assertNull(channel1.receive(buf));
1249        assertFalse(channel1.socket().isBound());
1250    }
1251
1252    public void testReceiveSend_NonBlock_NotBound() throws Exception {
1253        // not bound
1254        this.channel1.configureBlocking(false);
1255        this.channel2.configureBlocking(false);
1256        sendByChannel("some normal string in testReceiveSend_Normal",
1257                localAddr2);
1258        ByteBuffer buf = ByteBuffer.wrap(new byte[CAPACITY_NORMAL]);
1259        assertNull((InetSocketAddress) this.channel1.receive(buf));
1260    }
1261
1262    public void testReceiveSend_Block_Normal_S2C() throws Exception {
1263        this.channel1.socket().bind(localAddr2);
1264        sendByDatagramSocket(
1265                "some normal string in testReceiveSend_Normal_S2C", localAddr2);
1266        receiveByChannel(CAPACITY_NORMAL, localAddr2,
1267                "some normal string in testReceiveSend_Normal_S2C");
1268    }
1269
1270    public void testReceiveSend_Block_Normal_C2S() throws Exception {
1271        this.datagramSocket1 = new DatagramSocket(localAddr2.getPort());
1272        String str1 = "some normal string in testReceiveSend_Normal_C2S";
1273        sendByChannel(str1, localAddr2);
1274        receiveByDatagramSocket(CAPACITY_NORMAL, localAddr2, str1);
1275    }
1276
1277    public void testReceiveSend_NonBlock_Normal_C2S() throws Exception {
1278        this.channel1.configureBlocking(false);
1279        this.channel2.configureBlocking(false);
1280        this.datagramSocket1 = new DatagramSocket(localAddr2.getPort());
1281        String str1 = "some normal string in testReceiveSend_Normal_C2S";
1282        sendByChannel(str1, localAddr2);
1283        receiveByDatagramSocket(CAPACITY_NORMAL, localAddr2, str1);
1284    }
1285
1286    public void testReceiveSend_Normal_S2S() throws Exception {
1287        String msg = "normal string in testReceiveSend_Normal_S2S";
1288        this.datagramSocket1 = new DatagramSocket(testPort);
1289        DatagramPacket rdp = new DatagramPacket(msg.getBytes(), msg.length(),
1290                localAddr2);
1291        datagramSocket2 = new DatagramSocket(localAddr2.getPort());
1292        this.datagramSocket1.send(rdp);
1293        byte[] buf = new byte[CAPACITY_NORMAL];
1294        this.datagramSocket2.setSoTimeout(TIME_UNIT);
1295        rdp = new DatagramPacket(buf, buf.length);
1296        this.datagramSocket2.receive(rdp);
1297        assertEquals(new String(buf, 0, CAPACITY_NORMAL).trim(), msg);
1298    }
1299
1300    public void testReceiveSend_Block_Empty() throws Exception {
1301        this.channel1.socket().bind(localAddr2);
1302        sendByChannel("", localAddr2);
1303        receiveByChannel(CAPACITY_NORMAL, localAddr2, "");
1304    }
1305
1306    public void testReceiveSend_NonBlock_Empty() throws Exception {
1307        this.channel1.configureBlocking(false);
1308        this.channel2.configureBlocking(false);
1309        this.channel1.socket().bind(localAddr2);
1310        sendByChannel("", localAddr2);
1311        receiveByChannel(CAPACITY_NORMAL, localAddr2, "");
1312    }
1313
1314    public void testReceiveSend_Block_Empty_S2C() throws Exception {
1315        this.channel1.socket().bind(localAddr2);
1316        sendByDatagramSocket("", localAddr2);
1317        receiveByChannel(CAPACITY_NORMAL, localAddr2, "");
1318    }
1319
1320    public void testReceiveSend_NonBlock_Empty_S2C() throws Exception {
1321        this.channel1.configureBlocking(false);
1322        this.channel2.configureBlocking(false);
1323        this.channel1.socket().bind(localAddr2);
1324        sendByDatagramSocket("", localAddr2);
1325        receiveByChannel(CAPACITY_NORMAL, localAddr2, "");
1326    }
1327
1328    public void testReceiveSend_Block_Empty_C2S() throws Exception {
1329        this.datagramSocket1 = new DatagramSocket(localAddr2.getPort());
1330        sendByChannel("", localAddr2);
1331        receiveByDatagramSocket(CAPACITY_NORMAL, localAddr2, "");
1332    }
1333
1334    public void testReceiveSend_NonBlock_Empty_C2S() throws Exception {
1335        this.channel1.configureBlocking(false);
1336        this.channel2.configureBlocking(false);
1337        this.datagramSocket1 = new DatagramSocket(localAddr2.getPort());
1338        sendByChannel("", localAddr2);
1339        receiveByDatagramSocket(CAPACITY_NORMAL, localAddr2, "");
1340    }
1341
1342    public void testReceiveSend_Empty_S2S() throws Exception {
1343        String msg = "";
1344        this.datagramSocket1 = new DatagramSocket(testPort);
1345        DatagramPacket rdp = new DatagramPacket(msg.getBytes(), msg.length(),
1346                localAddr2);
1347        datagramSocket2 = new DatagramSocket(localAddr2.getPort());
1348        this.datagramSocket1.send(rdp);
1349        byte[] buf = new byte[CAPACITY_NORMAL];
1350        this.datagramSocket2.setSoTimeout(TIME_UNIT);
1351        rdp = new DatagramPacket(buf, buf.length);
1352        this.datagramSocket2.receive(rdp);
1353        assertEquals(new String(buf, 0, CAPACITY_NORMAL).trim(), msg);
1354    }
1355
1356    public void testReceiveSend_Block_Oversize() throws Exception {
1357        this.channel1.socket().bind(localAddr2);
1358        sendByChannel("0123456789", localAddr2);
1359        receiveByChannel(5, localAddr2, "01234");
1360    }
1361
1362    public void testReceiveSend_Block_Oversize_C2S() throws Exception {
1363        this.datagramSocket1 = new DatagramSocket(localAddr2.getPort());
1364        sendByChannel("0123456789", localAddr2);
1365        receiveByDatagramSocket(5, localAddr2, "01234");
1366    }
1367
1368    public void testReceiveSend_NonBlock_Oversize_C2S() throws Exception {
1369        this.channel1.configureBlocking(false);
1370        this.channel2.configureBlocking(false);
1371        this.datagramSocket1 = new DatagramSocket(localAddr2.getPort());
1372        sendByChannel("0123456789", localAddr2);
1373        receiveByDatagramSocket(5, localAddr2, "01234");
1374    }
1375
1376    public void testReceiveSend_Block_Oversize_S2C() throws Exception {
1377        this.channel1.socket().bind(localAddr2);
1378        sendByDatagramSocket("0123456789", localAddr2);
1379        receiveByChannel(5, localAddr2, "01234");
1380    }
1381
1382    public void testReceiveSend_8K() throws Exception {
1383        StringBuffer str8k = new StringBuffer();
1384        for (int i = 0; i < 8 * CAPACITY_1KB; i++) {
1385            str8k.append('a');
1386        }
1387        String str = str8k.toString();
1388        this.channel1.socket().bind(localAddr2);
1389        sendByChannel(str, localAddr2);
1390        receiveByChannel(8 * CAPACITY_1KB, localAddr2, str);
1391    }
1392
1393    public void testReceiveSend_64K() throws Exception {
1394        StringBuffer str64k = new StringBuffer();
1395        for (int i = 0; i < CAPACITY_64KB; i++) {
1396            str64k.append('a');
1397        }
1398        String str = str64k.toString();
1399        try {
1400            Thread.sleep(TIME_UNIT);
1401            channel2.send(ByteBuffer.wrap(str.getBytes()), localAddr1);
1402            fail("Should throw SocketException!");
1403        } catch (SocketException e) {
1404            //expected
1405        }
1406    }
1407
1408    private void sendByChannel(String data, InetSocketAddress address)
1409            throws Exception {
1410        try {
1411            assertEquals(data.length(), this.channel2.send(ByteBuffer.wrap(data
1412                    .getBytes()), address));
1413        } finally {
1414            this.channel2.close();
1415        }
1416    }
1417
1418    private void sendByDatagramSocket(String data, InetSocketAddress address)
1419            throws Exception {
1420        this.datagramSocket1 = new DatagramSocket(testPort);
1421        DatagramPacket rdp = new DatagramPacket(data.getBytes(), data.length(),
1422                address);
1423        this.datagramSocket1.send(rdp);
1424    }
1425
1426    private void receiveByChannel(int bufSize, InetSocketAddress address,
1427            String expectedString) throws IOException {
1428        try {
1429            ByteBuffer buf = ByteBuffer.wrap(new byte[bufSize]);
1430            InetSocketAddress returnAddr = null;
1431            long startTime = System.currentTimeMillis();
1432            do {
1433                returnAddr = (InetSocketAddress) this.channel1.receive(buf);
1434                // continue loop when channel1 is non-blocking and no data was
1435                // received.
1436                if (channel1.isBlocking() || null != returnAddr) {
1437                    break;
1438                }
1439                // avoid dead loop
1440                assertTimeout(startTime, 10000);
1441            } while (true);
1442            int length = returnAddr.getAddress().getAddress().length;
1443            for (int i = 0; i < length; i++) {
1444                assertEquals(returnAddr.getAddress().getAddress()[i],
1445                        InetAddress.getByName("127.0.0.1").getAddress()[i]);
1446            }
1447            // port is NOT equal
1448            assertFalse(returnAddr.getPort() == address.getPort());
1449            assertEquals(new String(buf.array(), 0, bufSize).trim(),
1450                    expectedString);
1451        } finally {
1452            this.channel1.close();
1453        }
1454    }
1455
1456    /*
1457     * Fails if the difference between current time and start time is greater
1458     * than timeout.
1459     */
1460    private void assertTimeout(long startTime, long timeout) {
1461        long currentTime = System.currentTimeMillis();
1462        if ((currentTime - startTime) > timeout) {
1463            fail("Timeout");
1464        }
1465    }
1466
1467    private void receiveByDatagramSocket(int bufSize,
1468            InetSocketAddress address, String expectedString)
1469            throws IOException {
1470        byte[] buf = new byte[bufSize];
1471        this.datagramSocket1.setSoTimeout(6000);
1472        DatagramPacket rdp = new DatagramPacket(buf, buf.length);
1473        this.datagramSocket1.receive(rdp);
1474        assertEquals(new String(buf, 0, bufSize).trim(), expectedString);
1475    }
1476
1477    public void testRead_NoSecurity() throws Exception {
1478        ByteBuffer buf = ByteBuffer.allocate(CAPACITY_NORMAL);
1479        String strHello = "hello";
1480        localAddr1 = new InetSocketAddress("127.0.0.1", testPort);
1481        this.channel1.socket().bind(localAddr1);
1482        this.channel2.socket().bind(localAddr2);
1483        this.channel1.connect(localAddr2);
1484        this.channel2.send(ByteBuffer.wrap(strHello.getBytes()), localAddr1);
1485        assertEquals(strHello.length(), this.channel1.read(buf));
1486        assertAscii(buf, strHello);
1487    }
1488
1489    public void testReceive_Peek_NoSecurity_Nonblocking() throws Exception {
1490        String strHello = "hello";
1491        localAddr1 = new InetSocketAddress("127.0.0.1", testPort);
1492        this.channel1.socket().bind(localAddr1);
1493        sendByChannel(strHello, localAddr1);
1494        this.channel1.configureBlocking(false);
1495        // for accepted addr, no problem.
1496        ByteBuffer buf = ByteBuffer.allocate(CAPACITY_NORMAL);
1497        InetSocketAddress source = (InetSocketAddress) this.channel1.receive(buf);
1498        assertEquals(localAddr1.getAddress(), source.getAddress());
1499        assertAscii(buf, strHello);
1500    }
1501
1502    private static void assertAscii(ByteBuffer b, String s) {
1503        assertEquals(s.length(), b.position());
1504        for (int i = 0; i < s.length(); ++i) {
1505            assertEquals(s.charAt(i), b.get(i));
1506        }
1507    }
1508
1509    // -------------------------------------------------------------------
1510    // Test for write()
1511    // -------------------------------------------------------------------
1512
1513    private void connectWriteBuf(InetSocketAddress ipAddr, ByteBuffer buf)
1514            throws IOException {
1515        this.channel1.connect(ipAddr);
1516        assertTrue(this.channel1.isConnected());
1517        assertEquals(CAPACITY_NORMAL, this.channel1.write(buf));
1518        assertEquals(0, this.channel1.write(buf));
1519    }
1520
1521    private void noconnectWrite(ByteBuffer buf) throws IOException {
1522        try {
1523            this.channel1.write(buf);
1524            fail("should throw NotYetConnectedException");
1525        } catch (NotYetConnectedException e) {
1526            // correct
1527        }
1528    }
1529
1530    /*
1531     * Test method for 'DatagramChannelImpl.write(ByteBuffer)'
1532     */
1533    public void testWriteByteBuffer_Block() throws IOException {
1534        ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1535        connectWriteBuf(localAddr1, writeBuf);
1536    }
1537
1538    public void testWriteByteBuffer_NonBlock() throws IOException {
1539        ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1540        this.channel1.configureBlocking(false);
1541        connectWriteBuf(localAddr1, writeBuf);
1542    }
1543
1544    public void testWriteByteBuffer_Block_closed() throws IOException {
1545        ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1546        InetSocketAddress ipAddr = localAddr1;
1547        noconnectWrite(writeBuf);
1548        this.channel1.connect(ipAddr);
1549        assertTrue(this.channel1.isConnected());
1550        this.channel1.close();
1551        try {
1552            channel1.write(writeBuf);
1553            fail("should throw ClosedChannelException");
1554        } catch (ClosedChannelException e) {
1555            // correct
1556        }
1557    }
1558
1559    public void testWriteByteBuffer_NonBlock_closed() throws IOException {
1560        ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1561        InetSocketAddress ipAddr = localAddr1;
1562        // non block mode
1563        this.channel1.configureBlocking(false);
1564        noconnectWrite(writeBuf);
1565        this.channel1.connect(ipAddr);
1566        assertTrue(this.channel1.isConnected());
1567        this.channel1.close();
1568        try {
1569            channel1.write(writeBuf);
1570            fail("should throw ClosedChannelException");
1571        } catch (ClosedChannelException e) {
1572            // correct
1573        }
1574    }
1575
1576    public void testWriteByteBuffer_Block_BufNull() throws IOException {
1577        ByteBuffer writeBuf = ByteBuffer.allocateDirect(0);
1578        InetSocketAddress ipAddr = localAddr1;
1579        try {
1580            this.channel1.write((ByteBuffer) null);
1581            fail("Should throw NPE.");
1582        } catch (NullPointerException e) {
1583            // correct
1584        }
1585        this.channel1.connect(ipAddr);
1586        assertTrue(this.channel1.isConnected());
1587        try {
1588            this.channel1.write((ByteBuffer) null);
1589            fail("Should throw NPE.");
1590        } catch (NullPointerException e) {
1591            // correct
1592        }
1593        assertEquals(0, this.channel1.write(writeBuf));
1594        datagramSocket1.close();
1595        try {
1596            this.channel1.write((ByteBuffer) null);
1597            fail("Should throw NPE.");
1598        } catch (NullPointerException e) {
1599            // correct
1600        }
1601    }
1602
1603    public void testWriteByteBuffer_NonBlock_BufNull() throws IOException {
1604        ByteBuffer writeBuf = ByteBuffer.allocateDirect(0);
1605        InetSocketAddress ipAddr = localAddr1;
1606
1607        // non block mode
1608        this.channel1.configureBlocking(false);
1609
1610        try {
1611            this.channel1.write((ByteBuffer) null);
1612            fail("Should throw NPE.");
1613        } catch (NullPointerException e) {
1614            // correct
1615        }
1616        this.channel1.connect(ipAddr);
1617        assertTrue(this.channel1.isConnected());
1618        try {
1619            this.channel1.write((ByteBuffer) null);
1620            fail("Should throw NPE.");
1621        } catch (NullPointerException e) {
1622            // correct
1623        }
1624        assertEquals(0, this.channel1.write(writeBuf));
1625        datagramSocket1.close();
1626        try {
1627            this.channel1.write((ByteBuffer) null);
1628            fail("Should throw NPE.");
1629        } catch (NullPointerException e) {
1630            // correct
1631        }
1632    }
1633
1634    /*
1635     * Test method for 'DatagramChannelImpl.write(ByteBuffer[], int, int)'
1636     */
1637    public void testWriteByteBufferArrayIntInt_Block() throws IOException {
1638        ByteBuffer[] writeBuf = new ByteBuffer[2];
1639        writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1640        writeBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1641        InetSocketAddress ipAddr = localAddr1;
1642        try {
1643            this.channel1.write(writeBuf, 0, 2);
1644            fail("Should throw NotYetConnectedException.");
1645        } catch (NotYetConnectedException e) {
1646            // correct
1647        }
1648        this.channel1.connect(ipAddr);
1649        assertTrue(this.channel1.isConnected());
1650        assertEquals(CAPACITY_NORMAL * 2, this.channel1.write(writeBuf, 0, 2));
1651        // cannot be buffered again!
1652        assertEquals(0, this.channel1.write(writeBuf, 0, 1));
1653
1654    }
1655
1656    public void testWriteByteBufferArrayIntInt_NonBlock() throws IOException {
1657        ByteBuffer[] writeBuf = new ByteBuffer[2];
1658        writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1659        writeBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1660        InetSocketAddress ipAddr = localAddr1;
1661        // non-block mode
1662        this.channel1.configureBlocking(false);
1663        try {
1664            this.channel1.write(writeBuf, 0, 2);
1665            fail("Should throw NotYetConnectedException.");
1666        } catch (NotYetConnectedException e) {
1667            // correct
1668        }
1669        this.channel1.connect(ipAddr);
1670        assertTrue(this.channel1.isConnected());
1671        assertEquals(CAPACITY_NORMAL * 2, this.channel1.write(writeBuf, 0, 2));
1672        // cannot be buffered again!
1673        assertEquals(0, this.channel1.write(writeBuf, 0, 1));
1674
1675    }
1676
1677    public void testWriteByteBufferArrayIntInt_NoConnectIndexBad()
1678            throws IOException {
1679        ByteBuffer[] writeBuf = new ByteBuffer[2];
1680        writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1681        writeBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1682        InetSocketAddress ipAddr = localAddr1;
1683        try {
1684            this.channel1.write(writeBuf, -1, 2);
1685            fail("should throw IndexOutOfBoundsException");
1686        } catch (IndexOutOfBoundsException e) {
1687            // correct
1688        }
1689        try {
1690            this.channel1.write(writeBuf, 0, -1);
1691            fail("should throw IndexOutOfBoundsException");
1692        } catch (IndexOutOfBoundsException e) {
1693            // correct
1694        }
1695        this.channel1.connect(ipAddr);
1696        assertTrue(this.channel1.isConnected());
1697        assertEquals(CAPACITY_NORMAL * 2, this.channel1.write(writeBuf, 0, 2));
1698        // cannot be buffered again!
1699        assertEquals(0, this.channel1.write(writeBuf, 0, 1));
1700    }
1701
1702    public void testWriteByteBufferArrayIntInt_ConnectedIndexBad()
1703            throws IOException {
1704        ByteBuffer[] writeBuf = new ByteBuffer[2];
1705        writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1706        writeBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1707        InetSocketAddress ipAddr = localAddr1;
1708        this.channel1.connect(ipAddr);
1709        assertTrue(this.channel1.isConnected());
1710        try {
1711            this.channel1.write(writeBuf, -1, 2);
1712            fail("should throw IndexOutOfBoundsException");
1713        } catch (IndexOutOfBoundsException e) {
1714            // correct
1715        }
1716        try {
1717            this.channel1.write(writeBuf, 0, -1);
1718            fail("should throw IndexOutOfBoundsException");
1719        } catch (IndexOutOfBoundsException e) {
1720            // correct
1721        }
1722    }
1723
1724    public void testWriteByteBufferArrayIntInt_BufNullNoConnect()
1725            throws IOException {
1726        ByteBuffer[] writeBuf = new ByteBuffer[2];
1727        writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1728        try {
1729            this.channel1.write(null, 0, 2);
1730            fail();
1731        } catch (NullPointerException expected) {
1732        }
1733        try {
1734            this.channel1.write(writeBuf, -1, 2);
1735            fail();
1736        } catch (IndexOutOfBoundsException expected) {
1737        }
1738        try {
1739            this.channel1.write(writeBuf, 0, 3);
1740            fail();
1741        } catch (IndexOutOfBoundsException expected) {
1742        }
1743    }
1744
1745    public void testWriteByteBufferArrayIntInt_BufNullConnect()
1746            throws IOException {
1747        ByteBuffer[] writeBuf = new ByteBuffer[2];
1748        writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1749        InetSocketAddress ipAddr = localAddr1;
1750        this.channel1.connect(ipAddr);
1751        assertTrue(this.channel1.isConnected());
1752        try {
1753            this.channel1.write(null, 0, 2);
1754            fail("should throw NPE");
1755        } catch (NullPointerException e) {
1756            // correct
1757        }
1758        try {
1759            this.channel1.write(writeBuf, 0, 3);
1760            fail("should throw IndexOutOfBoundsException");
1761        } catch (IndexOutOfBoundsException e) {
1762            // correct
1763        }
1764        datagramSocket1.close();
1765        try {
1766            this.channel1.write(null, 0, 2);
1767            fail("should throw NPE");
1768        } catch (NullPointerException e) {
1769            // correct
1770        }
1771    }
1772
1773    // -------------------------------------------------------------------
1774    // Test for read()
1775    // -------------------------------------------------------------------
1776
1777    /*
1778     * Test method for 'DatagramChannelImpl.read(ByteBuffer)'
1779     */
1780    public void testReadByteBuffer() throws IOException {
1781        ByteBuffer readBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1782        try {
1783            this.channel1.read(readBuf);
1784            fail("should throw NotYetConnectedException");
1785        } catch (NotYetConnectedException e) {
1786            // correct
1787        }
1788        this.channel1.connect(localAddr1);
1789        assertTrue(this.channel1.isConnected());
1790        this.channel1.configureBlocking(false);
1791        // note : blocking-mode will make the read process endless!
1792        assertEquals(0, this.channel1.read(readBuf));
1793        this.channel1.close();
1794        try {
1795            this.channel1.read(readBuf);
1796            fail("Should throw ClosedChannelException");
1797        } catch (ClosedChannelException e) {
1798            // OK.
1799        }
1800    }
1801
1802    public void testReadByteBuffer_bufNull() throws IOException {
1803        ByteBuffer readBuf = ByteBuffer.allocateDirect(0);
1804        InetSocketAddress ipAddr = localAddr1;
1805        try {
1806            this.channel1.read(readBuf);
1807            fail("should throw NotYetConnectedException");
1808        } catch (NotYetConnectedException e) {
1809            // correct
1810        }
1811        this.channel1.connect(ipAddr);
1812        assertTrue(this.channel1.isConnected());
1813        try {
1814            channel1.read((ByteBuffer) null);
1815            fail("should throw NPE");
1816        } catch (NullPointerException e) {
1817            // correct
1818        }
1819        this.channel1.configureBlocking(false);
1820        // note : blocking-mode will make the read process endless!
1821        assertEquals(0, this.channel1.read(readBuf));
1822        datagramSocket1.close();
1823    }
1824
1825    /*
1826     * Test method for 'DatagramChannelImpl.read(ByteBuffer[], int, int)'
1827     */
1828    public void testReadByteBufferArrayIntInt() throws IOException {
1829        ByteBuffer[] readBuf = new ByteBuffer[2];
1830        readBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1831        readBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1832        InetSocketAddress ipAddr = localAddr1;
1833        try {
1834            this.channel1.read(readBuf, 0, 2);
1835            fail("should throw NotYetConnectedException");
1836        } catch (NotYetConnectedException e) {
1837            // correct
1838        }
1839        this.channel1.connect(ipAddr);
1840        assertTrue(this.channel1.isConnected());
1841        this.channel1.configureBlocking(false);
1842        // note : blocking-mode will make the read process endless!
1843        assertEquals(0, this.channel1.read(readBuf, 0, 1));
1844        assertEquals(0, this.channel1.read(readBuf, 0, 2));
1845        datagramSocket1.close();
1846    }
1847
1848    public void testReadByteBufferArrayIntInt_exceptions() throws IOException {
1849        //regression test for HARMONY-932
1850        try {
1851            DatagramChannel.open().read(new ByteBuffer[] {}, 2, Integer.MAX_VALUE);
1852            fail();
1853        } catch (IndexOutOfBoundsException expected) {
1854        }
1855        try {
1856            DatagramChannel.open().read(new ByteBuffer[] {}, -1, 0);
1857            fail();
1858        } catch (IndexOutOfBoundsException expected) {
1859        }
1860        try {
1861            DatagramChannel.open().read((ByteBuffer[]) null, 0, 0);
1862            fail();
1863        } catch (NullPointerException expected) {
1864        }
1865    }
1866
1867    public void testReadByteBufferArrayIntInt_BufNull() throws IOException {
1868        ByteBuffer[] readBuf = new ByteBuffer[2];
1869        readBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
1870        InetSocketAddress ipAddr = localAddr1;
1871        try {
1872            this.channel1.read(null, 0, 0);
1873            fail("should throw NPE");
1874        } catch (NullPointerException e) {
1875            // correct
1876        }
1877        this.channel1.connect(ipAddr);
1878        assertTrue(this.channel1.isConnected());
1879        this.channel1.configureBlocking(false);
1880        // note : blocking-mode will make the read process endless!
1881        try {
1882            this.channel1.read(null, 0, 0);
1883            fail("should throw NPE");
1884        } catch (NullPointerException e) {
1885            // correct
1886        }
1887        assertEquals(0, this.channel1.read(readBuf, 0, 1));
1888        try {
1889            this.channel1.read(readBuf, 0, 2);
1890            fail("should throw NPE");
1891        } catch (NullPointerException e) {
1892            // correct
1893        }
1894        try {
1895            this.channel1.read(readBuf, 0, 3);
1896            fail("should throw IndexOutOfBoundsException");
1897        } catch (IndexOutOfBoundsException e) {
1898            // correct
1899        }
1900        datagramSocket1.close();
1901    }
1902
1903    // -------------------------------------------------------------------
1904    // test read and write
1905    // -------------------------------------------------------------------
1906
1907    public void testReadWrite_configureBlock() throws Exception {
1908        byte[] targetArray = new byte[2];
1909        // bind and connect
1910        this.channel1.socket().bind(localAddr2);
1911        this.channel1.connect(localAddr1);
1912        this.channel2.socket().bind(localAddr1);
1913        this.channel2.connect(localAddr2);
1914        ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
1915
1916        new Thread() {
1917            public void run() {
1918                try {
1919                    Thread.sleep(TIME_UNIT);
1920                    channel1.configureBlocking(false);
1921                    channel1.close();
1922                } catch (Exception e) {
1923                    //ignore
1924                }
1925            }
1926        }.start();
1927        try {
1928            this.channel1.read(targetBuf);
1929            fail("should throw AsynchronousCloseException");
1930        } catch (AsynchronousCloseException e) {
1931            // ok
1932        }
1933    }
1934
1935    public void testReadWrite_Block_Zero() throws Exception {
1936        byte[] sourceArray = new byte[0];
1937        byte[] targetArray = new byte[0];
1938        // bind and connect
1939        this.channel1.socket().bind(localAddr2);
1940        this.channel1.connect(localAddr1);
1941        this.channel2.socket().bind(localAddr1);
1942        this.channel2.connect(localAddr2);
1943
1944        // write
1945        ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
1946        assertEquals(0, this.channel1.write(sourceBuf));
1947
1948        // read
1949        ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
1950        int readCount = this.channel2.read(targetBuf);
1951
1952        assertEquals(0, readCount);
1953    }
1954
1955    public void testReadWrite_Block_Normal() throws Exception {
1956        byte[] sourceArray = new byte[CAPACITY_NORMAL];
1957        byte[] targetArray = new byte[CAPACITY_NORMAL];
1958        for (int i = 0; i < sourceArray.length; i++) {
1959            sourceArray[i] = (byte) i;
1960        }
1961
1962        // bind and connect
1963        this.channel1.socket().bind(localAddr2);
1964        this.channel1.connect(localAddr1);
1965        this.channel2.socket().bind(localAddr1);
1966        this.channel2.connect(localAddr2);
1967
1968        readWriteReadData(this.channel1, sourceArray, this.channel2,
1969                targetArray, CAPACITY_NORMAL, "testReadWrite_Block_Normal");
1970    }
1971
1972    public void testReadWrite_Block_Empty() throws Exception {
1973        // empty buf
1974        byte[] sourceArray = "".getBytes();
1975        byte[] targetArray = new byte[CAPACITY_NORMAL];
1976
1977        // bind and connect
1978
1979        this.channel1.socket().bind(localAddr2);
1980        this.channel1.connect(localAddr1);
1981        this.channel2.socket().bind(localAddr1);
1982        this.channel2.connect(localAddr2);
1983
1984        // write
1985        ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
1986        assertEquals(0, this.channel1.write(sourceBuf));
1987
1988        // read
1989        ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
1990        // empty message let the reader blocked
1991        closeBlockedReaderChannel2(targetBuf);
1992    }
1993
1994    public void testReadWrite_changeBlock_Empty() throws Exception {
1995        // empty buf
1996        byte[] sourceArray = "".getBytes();
1997        byte[] targetArray = new byte[CAPACITY_NORMAL];
1998
1999        // bind and connect
2000
2001        this.channel1.socket().bind(localAddr2);
2002        this.channel1.connect(localAddr1);
2003        this.channel2.socket().bind(localAddr1);
2004        this.channel2.connect(localAddr2);
2005
2006        // write
2007        ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
2008        assertEquals(0, this.channel1.write(sourceBuf));
2009
2010        // read
2011        ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
2012        // empty message let the reader blocked
2013        new Thread() {
2014            public void run() {
2015                try {
2016                    Thread.sleep(TIME_UNIT);
2017                    channel2.configureBlocking(false);
2018                    Thread.sleep(TIME_UNIT * 5);
2019                    channel2.close();
2020                } catch (Exception e) {
2021                    // do nothing
2022                }
2023            }
2024        }.start();
2025        try {
2026            assertTrue(this.channel2.isBlocking());
2027            this.channel2.read(targetBuf);
2028            fail("Should throw AsynchronousCloseException");
2029        } catch (AsynchronousCloseException e) {
2030            assertFalse(this.channel2.isBlocking());
2031            // OK.
2032        }
2033    }
2034
2035    public void testReadWrite_Block_8KB() throws Exception {
2036        byte[] sourceArray = new byte[CAPACITY_1KB * 8];
2037        byte[] targetArray = new byte[CAPACITY_1KB * 8];
2038        for (int i = 0; i < sourceArray.length; i++) {
2039            sourceArray[i] = (byte) i;
2040        }
2041
2042        // bind and connect
2043        this.channel1.socket().bind(localAddr2);
2044        this.channel1.connect(localAddr1);
2045        this.channel2.socket().bind(localAddr1);
2046        this.channel2.connect(localAddr2);
2047
2048        readWriteReadData(this.channel1, sourceArray, this.channel2,
2049                targetArray, 8 * CAPACITY_1KB, "testReadWrite_Block_8KB");
2050    }
2051
2052    /*
2053     * sender write the sourceArray whose size is dataSize, and receiver read
2054     * the data into targetArray
2055     */
2056    private void readWriteReadData(DatagramChannel sender, byte[] sourceArray,
2057            DatagramChannel receiver, byte[] targetArray, int dataSize,
2058            String methodName) throws IOException {
2059        // write
2060        ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
2061        assertEquals(dataSize, sender.write(sourceBuf));
2062
2063        // read
2064        ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
2065
2066        int count = 0;
2067        int total = 0;
2068        long beginTime = System.currentTimeMillis();
2069        while (total < dataSize && (count = receiver.read(targetBuf)) != -1) {
2070            total = total + count;
2071            // 3s timeout to avoid dead loop
2072            if (System.currentTimeMillis() - beginTime > 3000){
2073                break;
2074            }
2075        }
2076
2077        assertEquals(dataSize, total);
2078        assertEquals(targetBuf.position(), total);
2079        targetBuf.flip();
2080        targetArray = targetBuf.array();
2081        for (int i = 0; i < targetArray.length; i++) {
2082            assertEquals(targetArray[i], (byte) i);
2083        }
2084    }
2085
2086    public void testReadWrite_Block_64K() throws Exception {
2087        byte[] sourceArray = new byte[CAPACITY_64KB];
2088        for (int i = 0; i < sourceArray.length; i++) {
2089            sourceArray[i] = (byte) i;
2090        }
2091
2092        // bind and connect
2093        this.channel1.socket().bind(localAddr2);
2094        this.channel1.connect(localAddr1);
2095        this.channel2.socket().bind(localAddr1);
2096        this.channel2.connect(localAddr2);
2097
2098        // write
2099        ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
2100        try {
2101            channel1.write(sourceBuf);
2102            fail("Should throw IOException");
2103        } catch (IOException e) {
2104            // too big
2105        }
2106    }
2107
2108    public void testReadWrite_Block_DifferentAddr() throws Exception {
2109        byte[] sourceArray = new byte[CAPACITY_NORMAL];
2110        byte[] targetArray = new byte[CAPACITY_NORMAL];
2111        for (int i = 0; i < sourceArray.length; i++) {
2112            sourceArray[i] = (byte) i;
2113        }
2114
2115        // bind and connect
2116        this.channel1.socket().bind(localAddr2);
2117        this.channel1.connect(localAddr1);
2118        this.channel2.socket().bind(localAddr1);
2119        this.channel2.connect(localAddr1);// the different addr
2120
2121        // write
2122        ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
2123        assertEquals(CAPACITY_NORMAL, this.channel1.write(sourceBuf));
2124
2125        // read
2126        ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
2127        // the wrong connected addr will make the read blocked.
2128        // we close the blocked channel
2129        closeBlockedReaderChannel2(targetBuf);
2130    }
2131
2132    public void testReadWrite_Block_WriterNotBind() throws Exception {
2133        byte[] sourceArray = new byte[CAPACITY_NORMAL];
2134        byte[] targetArray = new byte[CAPACITY_NORMAL];
2135        for (int i = 0; i < sourceArray.length; i++) {
2136            sourceArray[i] = (byte) i;
2137        }
2138
2139        // bind and connect
2140        this.channel1.connect(localAddr1);
2141        this.channel2.socket().bind(localAddr1);
2142        this.channel2.connect(localAddr2);
2143
2144        // write
2145        ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
2146        assertEquals(CAPACITY_NORMAL, this.channel1.write(sourceBuf));
2147
2148        // read
2149        ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
2150        closeBlockedReaderChannel2(targetBuf);
2151    }
2152
2153    public void testReadWrite_Block_WriterBindLater() throws Exception {
2154
2155        byte[] targetArray = new byte[CAPACITY_NORMAL];
2156
2157        // bind and connect
2158        // writer channel1 is bound later
2159        this.channel2.socket().bind(localAddr1);
2160        this.channel2.connect(localAddr2);
2161
2162        // read
2163        ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
2164        new Thread() {
2165            public void run() {
2166                try {
2167                    Thread.sleep(TIME_UNIT);
2168                    // bind later
2169                    byte[] sourceArray = new byte[CAPACITY_NORMAL];
2170                    for (int i = 0; i < sourceArray.length; i++) {
2171                        sourceArray[i] = (byte) i;
2172                    }
2173                    channel1.socket().bind(localAddr2);
2174                    channel1.connect(localAddr1);
2175                    // write later
2176                    ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
2177                    assertEquals(CAPACITY_NORMAL, channel1.write(sourceBuf));
2178                } catch (Exception e) {
2179                    // do nothing
2180                }
2181            }
2182        }.start();
2183
2184        int count = 0;
2185        int total = 0;
2186        long beginTime = System.currentTimeMillis();
2187        while (total < CAPACITY_NORMAL && (count = channel2.read(targetBuf)) != -1) {
2188            total = total + count;
2189            // 3s timeout to avoid dead loop
2190            if (System.currentTimeMillis() - beginTime > 3000){
2191                break;
2192            }
2193        }
2194
2195        assertEquals(CAPACITY_NORMAL, total);
2196        assertEquals(targetBuf.position(), total);
2197        targetBuf.flip();
2198        targetArray = targetBuf.array();
2199        for (int i = 0; i < targetArray.length; i++) {
2200            assertEquals(targetArray[i], (byte) i);
2201        }
2202
2203    }
2204
2205    public void testReadWrite_Block_ReaderNotBind() throws Exception {
2206        byte[] sourceArray = new byte[CAPACITY_NORMAL];
2207        byte[] targetArray = new byte[CAPACITY_NORMAL];
2208        for (int i = 0; i < sourceArray.length; i++) {
2209            sourceArray[i] = (byte) i;
2210        }
2211
2212        // bind and connect
2213        this.channel1.socket().bind(localAddr2);
2214        this.channel1.connect(localAddr1);
2215        // reader channel2 is not bound
2216        this.channel2.connect(localAddr2);
2217
2218        // write
2219        ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
2220        assertEquals(CAPACITY_NORMAL, this.channel1.write(sourceBuf));
2221
2222        // read
2223        ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
2224        closeBlockedReaderChannel2(targetBuf);
2225
2226    }
2227
2228    private void closeBlockedReaderChannel2(ByteBuffer targetBuf)
2229            throws IOException {
2230        new Thread() {
2231            public void run() {
2232                try {
2233                    Thread.sleep(TIME_UNIT);
2234                    channel2.close();
2235                } catch (Exception e) {
2236                    // do nothing
2237                }
2238            }
2239        }.start();
2240        try {
2241            assertTrue(this.channel2.isBlocking());
2242            this.channel2.read(targetBuf);
2243            fail("Should throw AsynchronousCloseException");
2244        } catch (AsynchronousCloseException e) {
2245            // OK.
2246        }
2247    }
2248
2249    // -------------------------------------------------------------------
2250    // Test read and write in non-block mode.
2251    // -------------------------------------------------------------------
2252    public void testReadWrite_NonBlock_Normal() throws Exception {
2253        byte[] sourceArray = new byte[CAPACITY_NORMAL];
2254        byte[] targetArray = new byte[CAPACITY_NORMAL];
2255        for (int i = 0; i < sourceArray.length; i++) {
2256            sourceArray[i] = (byte) i;
2257        }
2258
2259        this.channel1.configureBlocking(false);
2260        this.channel2.configureBlocking(false);
2261
2262        // bind and connect
2263        this.channel1.socket().bind(localAddr2);
2264        this.channel1.connect(localAddr1);
2265        this.channel2.socket().bind(localAddr1);
2266        this.channel2.connect(localAddr2);
2267
2268        readWriteReadData(this.channel1, sourceArray, this.channel2,
2269                targetArray, CAPACITY_NORMAL, "testReadWrite_NonBlock_Normal");
2270    }
2271
2272    public void testReadWrite_NonBlock_8KB() throws Exception {
2273        byte[] sourceArray = new byte[CAPACITY_1KB * 8];
2274        byte[] targetArray = new byte[CAPACITY_1KB * 8];
2275        for (int i = 0; i < sourceArray.length; i++) {
2276            sourceArray[i] = (byte) i;
2277        }
2278
2279        this.channel1.configureBlocking(false);
2280        this.channel2.configureBlocking(false);
2281
2282        // bind and connect
2283        this.channel1.socket().bind(localAddr2);
2284        this.channel1.connect(localAddr1);
2285        this.channel2.socket().bind(localAddr1);
2286        this.channel2.connect(localAddr2);
2287
2288        readWriteReadData(this.channel1, sourceArray, this.channel2,
2289                targetArray, 8 * CAPACITY_1KB, "testReadWrite_NonBlock_8KB");
2290    }
2291
2292    public void testReadWrite_NonBlock_DifferentAddr() throws Exception {
2293        byte[] sourceArray = new byte[CAPACITY_NORMAL];
2294        byte[] targetArray = new byte[CAPACITY_NORMAL];
2295        for (int i = 0; i < sourceArray.length; i++) {
2296            sourceArray[i] = (byte) i;
2297        }
2298
2299        this.channel1.configureBlocking(false);
2300        this.channel2.configureBlocking(false);
2301
2302        // bind and connect
2303        this.channel1.socket().bind(localAddr2);
2304        this.channel1.connect(localAddr1);
2305        this.channel2.socket().bind(localAddr1);
2306        this.channel2.connect(localAddr1);// the different addr
2307
2308        // write
2309        ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
2310        assertEquals(CAPACITY_NORMAL, this.channel1.write(sourceBuf));
2311
2312        // read
2313        ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
2314        assertEquals(0, this.channel2.read(targetBuf));
2315    }
2316
2317    public void testReadWrite_NonBlock_WriterNotBind() throws Exception {
2318        byte[] sourceArray = new byte[CAPACITY_NORMAL];
2319        byte[] targetArray = new byte[CAPACITY_NORMAL];
2320        for (int i = 0; i < sourceArray.length; i++) {
2321            sourceArray[i] = (byte) i;
2322        }
2323
2324        this.channel1.configureBlocking(false);
2325        this.channel2.configureBlocking(false);
2326
2327        // bind and connect
2328        this.channel1.connect(localAddr1);
2329        this.channel2.socket().bind(localAddr1);
2330        this.channel2.connect(localAddr2);
2331
2332        // write
2333        ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
2334        assertEquals(CAPACITY_NORMAL, this.channel1.write(sourceBuf));
2335
2336        // read
2337        ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
2338        assertEquals(0, this.channel2.read(targetBuf));
2339    }
2340
2341    public void testReadWrite_NonBlock_ReaderNotBind() throws Exception {
2342        byte[] sourceArray = new byte[CAPACITY_NORMAL];
2343        byte[] targetArray = new byte[CAPACITY_NORMAL];
2344        for (int i = 0; i < sourceArray.length; i++) {
2345            sourceArray[i] = (byte) i;
2346        }
2347
2348        this.channel1.configureBlocking(false);
2349        this.channel2.configureBlocking(false);
2350
2351        // bind and connect
2352        this.channel1.socket().bind(localAddr2);
2353        this.channel1.connect(localAddr1);
2354        this.channel2.connect(localAddr2);
2355
2356        // write
2357        ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
2358        assertEquals(CAPACITY_NORMAL, this.channel1.write(sourceBuf));
2359
2360        // read
2361        ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
2362        assertEquals(0, this.channel2.read(targetBuf));
2363    }
2364
2365    public void test_write_LBuffer_positioned() throws Exception {
2366        // Regression test for Harmony-683
2367        int position = 16;
2368        DatagramChannel dc = DatagramChannel.open();
2369        byte[] sourceArray = new byte[CAPACITY_NORMAL];
2370        dc.connect(localAddr1);
2371        // write
2372        ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
2373        sourceBuf.position(position);
2374        assertEquals(CAPACITY_NORMAL - position, dc.write(sourceBuf));
2375    }
2376
2377    public void test_send_LBuffer_LSocketAddress_PositionNotZero()
2378            throws Exception {
2379        // regression test for Harmony-701
2380        int CAPACITY_NORMAL = 256;
2381        int position = 16;
2382        DatagramChannel dc = DatagramChannel.open();
2383        byte[] sourceArray = new byte[CAPACITY_NORMAL];
2384        // send ByteBuffer whose position is not zero
2385        ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
2386        sourceBuf.position(position);
2387        int ret = dc.send(sourceBuf, localAddr1);
2388        // assert send (256 - 16) bytes
2389        assertEquals(CAPACITY_NORMAL - position, ret);
2390        // assert the position of ByteBuffer has been set
2391        assertEquals(CAPACITY_NORMAL, sourceBuf.position());
2392    }
2393
2394    /**
2395     * @tests DatagramChannel#read(ByteBuffer[])
2396     */
2397    public void test_read_$LByteBuffer() throws Exception {
2398        // regression test for Harmony-754
2399        channel2.socket().bind(localAddr1);
2400        channel1.socket().bind(localAddr2);
2401        channel1.connect(localAddr1);
2402        channel2.connect(localAddr2);
2403        channel2.write(ByteBuffer.allocate(CAPACITY_NORMAL));
2404
2405        ByteBuffer[] readBuf = new ByteBuffer[2];
2406        readBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
2407        readBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
2408
2409        channel1.configureBlocking(true);
2410        assertEquals(CAPACITY_NORMAL, channel1.read(readBuf));
2411    }
2412
2413    /**
2414     * @tests DatagramChannel#read(ByteBuffer[],int,int)
2415     */
2416    public void test_read_$LByteBufferII() throws Exception {
2417        // regression test for Harmony-754
2418        channel2.socket().bind(localAddr1);
2419        channel1.socket().bind(localAddr2);
2420        channel1.connect(localAddr1);
2421        channel2.connect(localAddr2);
2422        channel2.write(ByteBuffer.allocate(CAPACITY_NORMAL));
2423
2424        ByteBuffer[] readBuf = new ByteBuffer[2];
2425        readBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
2426        readBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
2427
2428        channel1.configureBlocking(true);
2429        assertEquals(CAPACITY_NORMAL, channel1.read(readBuf,0,2));
2430    }
2431
2432    /**
2433     * @tests DatagramChannel#read(ByteBuffer)
2434     */
2435    public void test_read_LByteBuffer_closed_nullBuf() throws Exception {
2436        // regression test for Harmony-754
2437        ByteBuffer c = null;
2438        DatagramChannel channel = DatagramChannel.open();
2439        channel.close();
2440        try{
2441            channel.read(c);
2442            fail("Should throw NullPointerException");
2443        } catch (NullPointerException e){
2444            // expected
2445        }
2446    }
2447
2448    /**
2449     * @tests DatagramChannel#read(ByteBuffer)
2450     */
2451    public void test_read_LByteBuffer_NotConnected_nullBuf() throws Exception {
2452        // regression test for Harmony-754
2453        ByteBuffer c = null;
2454        DatagramChannel channel = DatagramChannel.open();
2455        try{
2456            channel.read(c);
2457            fail("Should throw NullPointerException");
2458        } catch (NullPointerException e){
2459            // expected
2460        }
2461    }
2462
2463    /**
2464     * @tests DatagramChannel#read(ByteBuffer)
2465     */
2466    public void test_read_LByteBuffer_readOnlyBuf() throws Exception {
2467        // regression test for Harmony-754
2468        ByteBuffer c = ByteBuffer.allocate(1);
2469        DatagramChannel channel = DatagramChannel.open();
2470        try{
2471            channel.read(c.asReadOnlyBuffer());
2472            fail("Should throw NotYetConnectedException");
2473        } catch (NotYetConnectedException e){
2474        } catch (IllegalArgumentException e){
2475            // expected
2476        }
2477        channel.connect(localAddr1);
2478        try{
2479            channel.read(c.asReadOnlyBuffer());
2480            fail("Should throw IllegalArgumentException");
2481        } catch (IllegalArgumentException e){
2482            // expected
2483        }
2484    }
2485
2486    /**
2487     * @tests DatagramChannel#send(ByteBuffer, SocketAddress)
2488     */
2489    public void test_send_LByteBuffer_LSocketAddress_closed() throws IOException{
2490        // regression test for Harmony-913
2491        channel1.close();
2492        ByteBuffer buf = ByteBuffer.allocate(CAPACITY_NORMAL);
2493        try {
2494            channel1.send(buf, localAddr1);
2495            fail("Should throw ClosedChannelException");
2496        } catch (ClosedChannelException e) {
2497            //pass
2498        }
2499        try {
2500            channel1.send(null,localAddr1);
2501            fail("Should throw NullPointerException");
2502        } catch (NullPointerException e) {
2503            //pass
2504        }
2505        try {
2506            channel1.send(buf, null);
2507            fail("Should throw ClosedChannelException");
2508        } catch (ClosedChannelException e) {
2509            //pass
2510        }
2511        try {
2512            channel1.send(null, null);
2513            fail("Should throw NullPointerException");
2514        } catch (NullPointerException e) {
2515            //pass
2516        }
2517    }
2518
2519    /**
2520     * @tests DatagramChannel#socket()
2521     */
2522    public void test_socket_IllegalBlockingModeException() throws Exception {
2523        // regression test for Harmony-1036
2524        DatagramChannel channel = DatagramChannel.open();
2525        channel.configureBlocking(false);
2526        DatagramSocket socket = channel.socket();
2527        try {
2528            socket.send(null);
2529            fail("should throw IllegalBlockingModeException");
2530        } catch (IllegalBlockingModeException e) {
2531            // expected
2532        }
2533        try {
2534            socket.receive(null);
2535            fail("should throw IllegalBlockingModeException");
2536        } catch (IllegalBlockingModeException e) {
2537            // expected
2538        }
2539    }
2540
2541    public void test_bounded_harmony6493() throws IOException {
2542        DatagramChannel server = DatagramChannel.open();
2543        InetSocketAddress addr = new InetSocketAddress("localhost", 0);
2544        server.socket().bind(addr);
2545        SocketAddress boundedAddress = server.socket().getLocalSocketAddress();
2546
2547        DatagramChannel client = DatagramChannel.open();
2548        ByteBuffer sent = ByteBuffer.allocate(1024);
2549        sent.put("test".getBytes());
2550        sent.flip();
2551        client.send(sent, boundedAddress);
2552        assertTrue(client.socket().isBound());
2553
2554        server.close();
2555        client.close();
2556    }
2557}
2558