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.xnet.tests.javax.net.ssl;
19
20import javax.net.ssl.SSLEngineResult;
21
22import junit.framework.TestCase;
23
24/**
25 * Tests for SSLEngineResult class
26 */
27public class SSLEngineResultTest extends TestCase {
28
29    /**
30     * Test for <code>SSLEngineResult(SSLEngineResult.Status status,
31     * SSLEngineResult.HandshakeStatus handshakeStatus,
32     * int bytesConsumed,
33     * int bytesProduced) </code> constructor and
34     * <code>getHandshakeStatus()</code>
35     * <code>getStatus()</code>
36     * <code>bytesConsumed()</code>
37     * <code>bytesProduced()</code>
38     * <code>toString()</code>
39     * methods
40     * Assertions:
41     * constructor throws IllegalArgumentException when bytesConsumed
42     * or bytesProduced is negative or when status or handshakeStatus
43     * is null
44     */
45    public void testSSLEngineResultConstructor() {
46
47        int[] neg = { -1, -10, -1000, Integer.MIN_VALUE,
48                (Integer.MIN_VALUE + 1) };
49        int[] pos = { 0, 1, 1000, Integer.MAX_VALUE, (Integer.MAX_VALUE - 1) };
50        try {
51            new SSLEngineResult(null, SSLEngineResult.HandshakeStatus.FINISHED,
52                    1, 1);
53            fail("IllegalArgumentException must be thrown");
54        } catch (IllegalArgumentException e) {
55        }
56        try {
57            new SSLEngineResult(SSLEngineResult.Status.BUFFER_OVERFLOW, null,
58                    1, 1);
59            fail("IllegalArgumentException must be thrown");
60        } catch (IllegalArgumentException e) {
61        }
62        for (int i = 0; i < neg.length; i++) {
63            try {
64                new SSLEngineResult(SSLEngineResult.Status.BUFFER_OVERFLOW,
65                        SSLEngineResult.HandshakeStatus.FINISHED, neg[i], 1);
66                fail("IllegalArgumentException must be thrown");
67            } catch (IllegalArgumentException e) {
68            }
69        }
70        for (int i = 0; i < neg.length; i++) {
71            try {
72                new SSLEngineResult(SSLEngineResult.Status.BUFFER_OVERFLOW,
73                        SSLEngineResult.HandshakeStatus.FINISHED, 1, neg[i]);
74                fail("IllegalArgumentException must be thrown");
75            } catch (IllegalArgumentException e) {
76            }
77        }
78        SSLEngineResult.Status[] enS = SSLEngineResult.Status.values();
79        SSLEngineResult.HandshakeStatus[] enHS = SSLEngineResult.HandshakeStatus
80                .values();
81        SSLEngineResult res;
82        String toS;
83        for (int i = 0; i < enS.length; i++) {
84            for (int j = 0; j < enHS.length; j++) {
85                for (int n = 0; n < pos.length; n++) {
86                    for (int l = 0; l < pos.length; l++) {
87                        res = new SSLEngineResult(enS[i], enHS[j], pos[n],
88                                pos[l]);
89
90                        assertEquals("Incorrect bytesProduced", res
91                                .bytesProduced(), pos[l]);
92                        assertEquals("Incorrect bytesConsumed", res
93                                .bytesConsumed(), pos[n]);
94                        assertEquals("Incorrect HandshakeStatus", res
95                                .getHandshakeStatus(), enHS[j]);
96                        assertEquals("Incorrect Status", res.getStatus(),
97                                enS[i]);
98                        toS = res.toString();
99                        assertNotNull("Result of toSring() method is null", toS);
100                    }
101                }
102            }
103        }
104
105    }
106
107    /**
108     * Test for <code>SSLEngineResult.Status.values()</code> method
109     */
110
111    public void testStatus01() {
112        SSLEngineResult.Status[] enS = SSLEngineResult.Status.values();
113        assertTrue("Incorrect array of Status objects", enS.length > 0);
114        assertTrue("OK object does not define", findEl(enS,
115                SSLEngineResult.Status.OK));
116        assertTrue("CLOSED object does not define", findEl(enS,
117                SSLEngineResult.Status.CLOSED));
118        assertTrue("BUFFER_OVERFLOW object does not define", findEl(enS,
119                SSLEngineResult.Status.BUFFER_OVERFLOW));
120        assertTrue("BUFFER_UNDERFLOW object does not define", findEl(enS,
121                SSLEngineResult.Status.BUFFER_UNDERFLOW));
122    }
123
124    /**
125     * Test for <code>SSLEngineResult.Status.valueOf(String name)</code> method
126     * Assertion:
127     * throws IllegalArgumentException when there is no constan with specified
128     * name
129     */
130
131    public void testStatus02() {
132        String[] invalid = { "", "OK1", "BUFFER_overflow", "BUFFER_UND",
133                "CLOSED_CLOSED", "Bad string for verification valueOf method"
134        };
135        assertEquals(SSLEngineResult.Status.valueOf("BUFFER_OVERFLOW"),
136                SSLEngineResult.Status.BUFFER_OVERFLOW);
137        assertEquals(SSLEngineResult.Status.valueOf("BUFFER_UNDERFLOW"),
138                SSLEngineResult.Status.BUFFER_UNDERFLOW);
139        assertEquals(SSLEngineResult.Status.valueOf("CLOSED"),
140                SSLEngineResult.Status.CLOSED);
141        assertEquals(SSLEngineResult.Status.valueOf("OK"),
142                SSLEngineResult.Status.OK);
143        for (int i = 0; i < invalid.length; i++) {
144            try {
145                SSLEngineResult.Status.valueOf(invalid[i]);
146                fail("IllegalArgumentException must be thrown for name: " + invalid[i]);
147            } catch (IllegalArgumentException e) {
148            }
149        }
150    }
151
152    /**
153     * Test for <code>SSLEngineResult.HandshakeStatus.values()</code> method
154     */
155
156    public void testHandshakeStatus01() {
157        SSLEngineResult.HandshakeStatus[] enHS = SSLEngineResult.HandshakeStatus
158                .values();
159        assertTrue("Incorrect array of HandshakeStatus objects",
160                enHS.length > 0);
161        assertTrue("FINISHED object does not define", findEl(enHS,
162                SSLEngineResult.HandshakeStatus.FINISHED));
163        assertTrue("NEED_UNWRAP object does not define", findEl(enHS,
164                SSLEngineResult.HandshakeStatus.NEED_UNWRAP));
165        assertTrue("NEED_WRAP object does not define", findEl(enHS,
166                SSLEngineResult.HandshakeStatus.NEED_WRAP));
167        assertTrue("NEED_TASK object does not define", findEl(enHS,
168                SSLEngineResult.HandshakeStatus.NEED_TASK));
169        assertTrue("NOT_HANDSHAKING object does not define", findEl(enHS,
170                SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING));
171    }
172
173    /**
174     * Test for <code>SSLEngineResult.HandshakeStatus.valueOf(String name)</code> method
175     * Assertion:
176     * throws IllegalArgumentException when there is no constan with specified
177     * name
178     */
179
180    public void testHandshakeStatus02() {
181        String[] invalid = { "", "FINISHED1", "NEED_task", "NEED_UN",
182                "NEED_WRAP_WRAP", "not_HANDSHAKING", "Bad string for verification valueOf method"
183        };
184        assertEquals(SSLEngineResult.HandshakeStatus.valueOf("NOT_HANDSHAKING"),
185                SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING);
186        assertEquals(SSLEngineResult.HandshakeStatus.valueOf("NEED_WRAP"),
187                SSLEngineResult.HandshakeStatus.NEED_WRAP);
188        assertEquals(SSLEngineResult.HandshakeStatus.valueOf("NEED_UNWRAP"),
189                SSLEngineResult.HandshakeStatus.NEED_UNWRAP);
190        assertEquals(SSLEngineResult.HandshakeStatus.valueOf("FINISHED"),
191                SSLEngineResult.HandshakeStatus.FINISHED);
192        assertEquals(SSLEngineResult.HandshakeStatus.valueOf("NEED_TASK"),
193                SSLEngineResult.HandshakeStatus.NEED_TASK);
194        for (int i = 0; i < invalid.length; i++) {
195            try {
196                SSLEngineResult.HandshakeStatus.valueOf(invalid[i]);
197                fail("IllegalArgumentException must be thrown for name: " + invalid[i]);
198            } catch (IllegalArgumentException e) {
199            }
200        }
201    }
202
203    private boolean findEl(Object[] arr, Object el) {
204        boolean ok = false;
205        for (int i = 0; i < arr.length; i++) {
206            if (arr[i].equals(el)) {
207                ok = true;
208                break;
209            }
210        }
211        return ok;
212    }
213
214}
215