22 */
23
24 /*
25 * @test
26 * @bug 8213418
27 * @summary Ensure correct impl supported socket options
28 * @run testng ImplSupportedOptions
29 */
30
31 import java.io.IOException;
32 import java.io.InputStream;
33 import java.io.OutputStream;
34 import java.net.InetAddress;
35 import java.net.ServerSocket;
36 import java.net.Socket;
37 import java.net.SocketAddress;
38 import java.net.SocketException;
39 import java.net.SocketImpl;
40 import java.net.SocketOption;
41 import java.net.StandardSocketOptions;
42 import java.util.Set;
43 import org.testng.annotations.Test;
44 import static org.testng.Assert.assertEquals;
45 import static org.testng.Assert.assertTrue;
46
47 public class ImplSupportedOptions {
48
49 @Test
50 public void socketSupportedOptions() throws Exception {
51 Socket s = new Socket();
52 Set<?> standardOptions = s.supportedOptions();
53 assertTrue(standardOptions.contains(StandardSocketOptions.SO_LINGER),
54 "Expected SO_LINGER, in:" + standardOptions);
55 assertEquals(standardOptions, s.supportedOptions());
56 assertEquals(standardOptions, s.supportedOptions());
57
58 s = new DummySocket();
59 Set<?> dummyOptions = s.supportedOptions();
60 assertEquals(dummyOptions.size(), 1);
61 assertTrue(dummyOptions.contains(DummySocketImpl.SOCKET_OPT));
62 assertEquals(dummyOptions, s.supportedOptions());
63 assertEquals(dummyOptions, s.supportedOptions());
64
65 s = new Socket();
66 standardOptions = s.supportedOptions();
67 assertTrue(standardOptions.contains(StandardSocketOptions.SO_LINGER),
68 "Expected SO_LINGER, in:" + standardOptions);
69 assertEquals(standardOptions, s.supportedOptions());
70 assertEquals(standardOptions, s.supportedOptions());
71
72 s = new DummySocket();
73 dummyOptions = s.supportedOptions();
74 assertEquals(dummyOptions.size(), 1);
75 assertTrue(dummyOptions.contains(DummySocketImpl.SOCKET_OPT));
76 assertEquals(dummyOptions, s.supportedOptions());
77 assertEquals(dummyOptions, s.supportedOptions());
78 }
79
80 @Test
81 public void serverSocketSupportedOptions() throws Exception {
82 ServerSocket s = new ServerSocket();
83 Set<?> standardOptions = s.supportedOptions();
84 assertTrue(standardOptions.contains(StandardSocketOptions.SO_REUSEADDR),
85 "Expected SO_REUSEADDR, in:" + standardOptions);
86 assertEquals(standardOptions, s.supportedOptions());
87 assertEquals(standardOptions, s.supportedOptions());
88
89 s = new DummyServerSocket();
90 Set<?> dummyOptions = s.supportedOptions();
91 assertEquals(dummyOptions.size(), 1);
92 assertTrue(dummyOptions.contains(DummySocketImpl.SOCKET_OPT));
93 assertEquals(dummyOptions, s.supportedOptions());
94 assertEquals(dummyOptions, s.supportedOptions());
95
96 s = new ServerSocket();
97 standardOptions = s.supportedOptions();
98 assertTrue(standardOptions.contains(StandardSocketOptions.SO_REUSEADDR),
99 "Expected SO_REUSEADDR, in:" + standardOptions);
100 assertEquals(standardOptions, s.supportedOptions());
101 assertEquals(standardOptions, s.supportedOptions());
102
103 s = new DummyServerSocket();
104 dummyOptions = s.supportedOptions();
105 assertEquals(dummyOptions.size(), 1);
106 assertTrue(dummyOptions.contains(DummySocketImpl.SOCKET_OPT));
107 assertEquals(dummyOptions, s.supportedOptions());
108 assertEquals(dummyOptions, s.supportedOptions());
109 }
110
111 static class DummySocket extends Socket {
112 DummySocket() throws IOException {
113 super(new DummySocketImpl());
114 }
115 }
116
117 static class DummyServerSocket extends ServerSocket {
118 DummyServerSocket() throws IOException {
119 super(new DummySocketImpl());
120 }
121 }
122
123 static class DummySocketImpl extends SocketImpl {
124
125 public static final SocketOption<String> SOCKET_OPT =
126 new ImplSocketOption<>("SOCKET_OPT", String.class);
127
128 private static class ImplSocketOption<T> implements SocketOption<T> {
129 private final String name;
130 private final Class<T> type;
131 ImplSocketOption(String name, Class<T> type) {
132 this.name = name;
133 this.type = type;
134 }
135 @Override public String name() { return name; }
136 @Override public Class<T> type() { return type; }
137 @Override public String toString() { return name; }
138 }
139
140 private final Set<SocketOption<?>> SO = Set.of(SOCKET_OPT);
141
142 @Override
143 public Set<SocketOption<?>> supportedOptions() { return SO; }
144
145 // ---
146
147 @Override
148 protected void create(boolean stream) throws IOException { }
149
150 @Override
151 protected void connect(String host, int port) throws IOException { }
152
153 @Override
154 protected void connect(InetAddress address, int port) throws IOException { }
155
156 @Override
157 protected void connect(SocketAddress address, int timeout) throws IOException { }
158
159 @Override
160 protected void bind(InetAddress host, int port) throws IOException { }
161
162 @Override
163 protected void listen(int backlog) throws IOException { }
164
165 @Override
168 @Override
169 protected InputStream getInputStream() throws IOException { return null; }
170
171 @Override
172 protected OutputStream getOutputStream() throws IOException { return null; }
173
174 @Override
175 protected int available() throws IOException { return 0; }
176
177 @Override
178 protected void close() throws IOException { }
179
180 @Override
181 protected void sendUrgentData(int data) throws IOException { }
182
183 @Override
184 public void setOption(int optID, Object value) throws SocketException { }
185
186 @Override
187 public Object getOption(int optID) throws SocketException { return null; }
188 }
189 }
|
22 */
23
24 /*
25 * @test
26 * @bug 8213418
27 * @summary Ensure correct impl supported socket options
28 * @run testng ImplSupportedOptions
29 */
30
31 import java.io.IOException;
32 import java.io.InputStream;
33 import java.io.OutputStream;
34 import java.net.InetAddress;
35 import java.net.ServerSocket;
36 import java.net.Socket;
37 import java.net.SocketAddress;
38 import java.net.SocketException;
39 import java.net.SocketImpl;
40 import java.net.SocketOption;
41 import java.net.StandardSocketOptions;
42 import java.util.HashMap;
43 import java.util.Map;
44 import java.util.Set;
45 import org.testng.annotations.Test;
46 import static org.testng.Assert.assertEquals;
47 import static org.testng.Assert.assertThrows;
48 import static org.testng.Assert.assertTrue;
49
50 public class ImplSupportedOptions {
51
52 static final Class<UnsupportedOperationException> UOE = UnsupportedOperationException.class;
53
54 @Test
55 public void socketSupportedOptions() throws Exception {
56 Socket s1 = new Socket();
57 Set<?> standardOptions = s1.supportedOptions();
58 assertTrue(standardOptions.contains(StandardSocketOptions.SO_LINGER),
59 "Expected SO_LINGER, in:" + standardOptions);
60 assertEquals(standardOptions, s1.supportedOptions());
61 assertEquals(standardOptions, s1.supportedOptions());
62
63 Socket s2 = new DummySocket();
64 Set<?> dummyOptions = s2.supportedOptions();
65 assertEquals(dummyOptions.size(), 2);
66 assertTrue(dummyOptions.contains(StandardDummySocketOptions.SOCKET_OPT));
67 assertTrue(dummyOptions.contains(StandardDummySocketOptions.SOCKET_OPT1));
68 assertEquals(dummyOptions, s2.supportedOptions());
69 assertEquals(dummyOptions, s2.supportedOptions());
70 s2.setOption(StandardDummySocketOptions.SOCKET_OPT, "aValue");
71 assertEquals(s2.getOption(StandardDummySocketOptions.SOCKET_OPT), "aValue");
72 s2.setOption(StandardDummySocketOptions.SOCKET_OPT1, 46);
73 assertEquals((int)s2.getOption(StandardDummySocketOptions.SOCKET_OPT1), 46);
74 assertThrows(UOE, () -> s2.setOption(StandardDummySocketOptions.SERVER_SOCKET_OPT, ""));
75
76 Socket s3 = new Socket();
77 standardOptions = s3.supportedOptions();
78 assertTrue(standardOptions.contains(StandardSocketOptions.SO_LINGER),
79 "Expected SO_LINGER, in:" + standardOptions);
80 assertEquals(standardOptions, s3.supportedOptions());
81 assertEquals(standardOptions, s3.supportedOptions());
82
83 Socket s4 = new DummySocket();
84 dummyOptions = s4.supportedOptions();
85 assertEquals(dummyOptions.size(), 2);
86 assertTrue(dummyOptions.contains(StandardDummySocketOptions.SOCKET_OPT));
87 assertTrue(dummyOptions.contains(StandardDummySocketOptions.SOCKET_OPT1));
88 assertEquals(dummyOptions, s4.supportedOptions());
89 assertEquals(dummyOptions, s4.supportedOptions());
90 s4.setOption(StandardDummySocketOptions.SOCKET_OPT, "bValue");
91 assertEquals(s4.getOption(StandardDummySocketOptions.SOCKET_OPT), "bValue");
92 s4.setOption(StandardDummySocketOptions.SOCKET_OPT1, 47);
93 assertEquals((int)s4.getOption(StandardDummySocketOptions.SOCKET_OPT1), 47);
94 assertThrows(UOE, () -> s4.setOption(StandardDummySocketOptions.SERVER_SOCKET_OPT, ""));
95 }
96
97 @Test
98 public void serverSocketSupportedOptions() throws Exception {
99 ServerSocket s1 = new ServerSocket();
100 Set<?> standardOptions = s1.supportedOptions();
101 assertTrue(standardOptions.contains(StandardSocketOptions.SO_REUSEADDR),
102 "Expected SO_REUSEADDR, in:" + standardOptions);
103 assertEquals(standardOptions, s1.supportedOptions());
104 assertEquals(standardOptions, s1.supportedOptions());
105
106 ServerSocket s2 = new DummyServerSocket();
107 Set<?> dummyOptions = s2.supportedOptions();
108 assertEquals(dummyOptions.size(), 1);
109 assertTrue(dummyOptions.contains(StandardDummySocketOptions.SERVER_SOCKET_OPT));
110 assertEquals(dummyOptions, s2.supportedOptions());
111 assertEquals(dummyOptions, s2.supportedOptions());
112 s2.setOption(StandardDummySocketOptions.SERVER_SOCKET_OPT, "xxyyzz");
113 assertEquals(s2.getOption(StandardDummySocketOptions.SERVER_SOCKET_OPT), "xxyyzz");
114 assertThrows(UOE, () -> s2.setOption(StandardDummySocketOptions.SOCKET_OPT, ""));
115
116 ServerSocket s3 = new ServerSocket();
117 standardOptions = s3.supportedOptions();
118 assertTrue(standardOptions.contains(StandardSocketOptions.SO_REUSEADDR),
119 "Expected SO_REUSEADDR, in:" + standardOptions);
120 assertEquals(standardOptions, s3.supportedOptions());
121 assertEquals(standardOptions, s3.supportedOptions());
122
123 ServerSocket s4 = new DummyServerSocket();
124 dummyOptions = s4.supportedOptions();
125 assertEquals(dummyOptions.size(), 1);
126 assertTrue(dummyOptions.contains(StandardDummySocketOptions.SERVER_SOCKET_OPT));
127 assertEquals(dummyOptions, s4.supportedOptions());
128 assertEquals(dummyOptions, s4.supportedOptions());
129 s4.setOption(StandardDummySocketOptions.SERVER_SOCKET_OPT, "xxyyzz");
130 assertEquals(s4.getOption(StandardDummySocketOptions.SERVER_SOCKET_OPT), "xxyyzz");
131 assertThrows(UOE, () -> s4.setOption(StandardDummySocketOptions.SOCKET_OPT1, 32));
132 }
133
134 public static final class StandardDummySocketOptions {
135 private StandardDummySocketOptions() {}
136
137 public static final SocketOption<String> SOCKET_OPT =
138 new ImplSocketOption<>("SOCKET_OPT", String.class);
139
140 public static final SocketOption<Integer> SOCKET_OPT1 =
141 new ImplSocketOption<>("SOCKET_OPT1", Integer.class);
142
143 public static final SocketOption<String> SERVER_SOCKET_OPT =
144 new ImplSocketOption<>("SERVER_SOCKET_OPT", String.class);
145
146 private static class ImplSocketOption<T> implements SocketOption<T> {
147 private final String name;
148 private final Class<T> type;
149 ImplSocketOption(String name, Class<T> type) {
150 this.name = name;
151 this.type = type;
152 }
153 @Override public String name() { return name; }
154 @Override public Class<T> type() { return type; }
155 @Override public String toString() { return name; }
156 }
157 }
158
159 static class DummySocket extends Socket {
160 DummySocket() throws IOException {
161 super(new DummySocketImpl() {
162 private final Set<SocketOption<?>> SO =
163 Set.of(StandardDummySocketOptions.SOCKET_OPT,
164 StandardDummySocketOptions.SOCKET_OPT1);
165
166 @Override
167 public Set<SocketOption<?>> supportedOptions() {
168 return SO;
169 }
170 });
171 }
172 }
173
174 static class DummyServerSocket extends ServerSocket {
175 DummyServerSocket() throws IOException {
176 super(new DummySocketImpl() {
177 private final Set<SocketOption<?>> SSO =
178 Set.of(StandardDummySocketOptions.SERVER_SOCKET_OPT);
179
180 @Override
181 public Set<SocketOption<?>> supportedOptions() {
182 return SSO;
183 }
184 });
185 }
186 }
187
188 static abstract class DummySocketImpl extends SocketImpl {
189
190 private final Map<SocketOption<?>,Object> optionMap = new HashMap<>();
191
192 @Override
193 protected void create(boolean stream) throws IOException { }
194
195 @Override
196 protected void connect(String host, int port) throws IOException { }
197
198 @Override
199 protected void connect(InetAddress address, int port) throws IOException { }
200
201 @Override
202 protected void connect(SocketAddress address, int timeout) throws IOException { }
203
204 @Override
205 protected void bind(InetAddress host, int port) throws IOException { }
206
207 @Override
208 protected void listen(int backlog) throws IOException { }
209
210 @Override
213 @Override
214 protected InputStream getInputStream() throws IOException { return null; }
215
216 @Override
217 protected OutputStream getOutputStream() throws IOException { return null; }
218
219 @Override
220 protected int available() throws IOException { return 0; }
221
222 @Override
223 protected void close() throws IOException { }
224
225 @Override
226 protected void sendUrgentData(int data) throws IOException { }
227
228 @Override
229 public void setOption(int optID, Object value) throws SocketException { }
230
231 @Override
232 public Object getOption(int optID) throws SocketException { return null; }
233
234 @Override
235 protected <T> void setOption(SocketOption<T> name, T value) throws IOException {
236 if (!supportedOptions().contains(name))
237 throw new UnsupportedOperationException("unsupported option:" + name);
238 optionMap.put(name, value);
239 }
240
241 @Override
242 protected <T> T getOption(SocketOption<T> name) throws IOException {
243 if (!supportedOptions().contains(name))
244 throw new UnsupportedOperationException("unsupported option:" + name);
245
246 return (T)optionMap.get(name);
247 }
248 }
249 }
|