--- old/test/jdk/java/net/SocketImpl/ImplSupportedOptions.java	2018-11-13 13:30:27.819195630 +0000
+++ new/test/jdk/java/net/SocketImpl/ImplSupportedOptions.java	2018-11-13 13:30:27.319207050 +0000
@@ -39,92 +39,110 @@
 import java.net.SocketImpl;
 import java.net.SocketOption;
 import java.net.StandardSocketOptions;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Set;
 import org.testng.annotations.Test;
 import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertThrows;
 import static org.testng.Assert.assertTrue;
 
 public class ImplSupportedOptions {
 
+    static final Class<UnsupportedOperationException> UOE = UnsupportedOperationException.class;
+
     @Test
     public void socketSupportedOptions() throws Exception {
-        Socket s = new Socket();
-        Set<?> standardOptions = s.supportedOptions();
+        Socket s1 = new Socket();
+        Set<?> standardOptions = s1.supportedOptions();
         assertTrue(standardOptions.contains(StandardSocketOptions.SO_LINGER),
                    "Expected SO_LINGER, in:" + standardOptions);
-        assertEquals(standardOptions, s.supportedOptions());
-        assertEquals(standardOptions, s.supportedOptions());
+        assertEquals(standardOptions, s1.supportedOptions());
+        assertEquals(standardOptions, s1.supportedOptions());
 
-        s = new DummySocket();
-        Set<?> dummyOptions = s.supportedOptions();
-        assertEquals(dummyOptions.size(), 1);
-        assertTrue(dummyOptions.contains(DummySocketImpl.SOCKET_OPT));
-        assertEquals(dummyOptions, s.supportedOptions());
-        assertEquals(dummyOptions, s.supportedOptions());
+        Socket s2 = new DummySocket();
+        Set<?> dummyOptions = s2.supportedOptions();
+        assertEquals(dummyOptions.size(), 2);
+        assertTrue(dummyOptions.contains(StandardDummySocketOptions.SOCKET_OPT));
+        assertTrue(dummyOptions.contains(StandardDummySocketOptions.SOCKET_OPT1));
+        assertEquals(dummyOptions, s2.supportedOptions());
+        assertEquals(dummyOptions, s2.supportedOptions());
+        s2.setOption(StandardDummySocketOptions.SOCKET_OPT, "aValue");
+        assertEquals(s2.getOption(StandardDummySocketOptions.SOCKET_OPT), "aValue");
+        s2.setOption(StandardDummySocketOptions.SOCKET_OPT1, 46);
+        assertEquals((int)s2.getOption(StandardDummySocketOptions.SOCKET_OPT1), 46);
+        assertThrows(UOE, () -> s2.setOption(StandardDummySocketOptions.SERVER_SOCKET_OPT, ""));
 
-        s = new Socket();
-        standardOptions = s.supportedOptions();
+        Socket s3 = new Socket();
+        standardOptions = s3.supportedOptions();
         assertTrue(standardOptions.contains(StandardSocketOptions.SO_LINGER),
                    "Expected SO_LINGER, in:" + standardOptions);
-        assertEquals(standardOptions, s.supportedOptions());
-        assertEquals(standardOptions, s.supportedOptions());
+        assertEquals(standardOptions, s3.supportedOptions());
+        assertEquals(standardOptions, s3.supportedOptions());
 
-        s = new DummySocket();
-        dummyOptions = s.supportedOptions();
-        assertEquals(dummyOptions.size(), 1);
-        assertTrue(dummyOptions.contains(DummySocketImpl.SOCKET_OPT));
-        assertEquals(dummyOptions, s.supportedOptions());
-        assertEquals(dummyOptions, s.supportedOptions());
+        Socket s4 = new DummySocket();
+        dummyOptions = s4.supportedOptions();
+        assertEquals(dummyOptions.size(), 2);
+        assertTrue(dummyOptions.contains(StandardDummySocketOptions.SOCKET_OPT));
+        assertTrue(dummyOptions.contains(StandardDummySocketOptions.SOCKET_OPT1));
+        assertEquals(dummyOptions, s4.supportedOptions());
+        assertEquals(dummyOptions, s4.supportedOptions());
+        s4.setOption(StandardDummySocketOptions.SOCKET_OPT, "bValue");
+        assertEquals(s4.getOption(StandardDummySocketOptions.SOCKET_OPT), "bValue");
+        s4.setOption(StandardDummySocketOptions.SOCKET_OPT1, 47);
+        assertEquals((int)s4.getOption(StandardDummySocketOptions.SOCKET_OPT1), 47);
+        assertThrows(UOE, () -> s4.setOption(StandardDummySocketOptions.SERVER_SOCKET_OPT, ""));
     }
 
     @Test
     public void serverSocketSupportedOptions() throws Exception {
-        ServerSocket s = new ServerSocket();
-        Set<?> standardOptions = s.supportedOptions();
+        ServerSocket s1 = new ServerSocket();
+        Set<?> standardOptions = s1.supportedOptions();
         assertTrue(standardOptions.contains(StandardSocketOptions.SO_REUSEADDR),
                    "Expected SO_REUSEADDR, in:" + standardOptions);
-        assertEquals(standardOptions, s.supportedOptions());
-        assertEquals(standardOptions, s.supportedOptions());
+        assertEquals(standardOptions, s1.supportedOptions());
+        assertEquals(standardOptions, s1.supportedOptions());
 
-        s = new DummyServerSocket();
-        Set<?> dummyOptions = s.supportedOptions();
+        ServerSocket s2 = new DummyServerSocket();
+        Set<?> dummyOptions = s2.supportedOptions();
         assertEquals(dummyOptions.size(), 1);
-        assertTrue(dummyOptions.contains(DummySocketImpl.SOCKET_OPT));
-        assertEquals(dummyOptions, s.supportedOptions());
-        assertEquals(dummyOptions, s.supportedOptions());
+        assertTrue(dummyOptions.contains(StandardDummySocketOptions.SERVER_SOCKET_OPT));
+        assertEquals(dummyOptions, s2.supportedOptions());
+        assertEquals(dummyOptions, s2.supportedOptions());
+        s2.setOption(StandardDummySocketOptions.SERVER_SOCKET_OPT, "xxyyzz");
+        assertEquals(s2.getOption(StandardDummySocketOptions.SERVER_SOCKET_OPT), "xxyyzz");
+        assertThrows(UOE, () -> s2.setOption(StandardDummySocketOptions.SOCKET_OPT, ""));
 
-        s = new ServerSocket();
-        standardOptions = s.supportedOptions();
+        ServerSocket s3 = new ServerSocket();
+        standardOptions = s3.supportedOptions();
         assertTrue(standardOptions.contains(StandardSocketOptions.SO_REUSEADDR),
                    "Expected SO_REUSEADDR, in:" + standardOptions);
-        assertEquals(standardOptions, s.supportedOptions());
-        assertEquals(standardOptions, s.supportedOptions());
+        assertEquals(standardOptions, s3.supportedOptions());
+        assertEquals(standardOptions, s3.supportedOptions());
 
-        s = new DummyServerSocket();
-        dummyOptions = s.supportedOptions();
+        ServerSocket s4 = new DummyServerSocket();
+        dummyOptions = s4.supportedOptions();
         assertEquals(dummyOptions.size(), 1);
-        assertTrue(dummyOptions.contains(DummySocketImpl.SOCKET_OPT));
-        assertEquals(dummyOptions, s.supportedOptions());
-        assertEquals(dummyOptions, s.supportedOptions());
-    }
-
-    static class DummySocket extends Socket {
-        DummySocket() throws IOException  {
-            super(new DummySocketImpl());
-        }
-    }
-
-    static class DummyServerSocket extends ServerSocket {
-        DummyServerSocket() throws IOException  {
-            super(new DummySocketImpl());
-        }
+        assertTrue(dummyOptions.contains(StandardDummySocketOptions.SERVER_SOCKET_OPT));
+        assertEquals(dummyOptions, s4.supportedOptions());
+        assertEquals(dummyOptions, s4.supportedOptions());
+        s4.setOption(StandardDummySocketOptions.SERVER_SOCKET_OPT, "xxyyzz");
+        assertEquals(s4.getOption(StandardDummySocketOptions.SERVER_SOCKET_OPT), "xxyyzz");
+        assertThrows(UOE, () -> s4.setOption(StandardDummySocketOptions.SOCKET_OPT1, 32));
     }
 
-    static class DummySocketImpl extends SocketImpl {
+    public static final class StandardDummySocketOptions {
+        private StandardDummySocketOptions() {}
 
         public static final SocketOption<String> SOCKET_OPT =
                 new ImplSocketOption<>("SOCKET_OPT", String.class);
 
+        public static final SocketOption<Integer> SOCKET_OPT1 =
+                new ImplSocketOption<>("SOCKET_OPT1", Integer.class);
+
+        public static final SocketOption<String> SERVER_SOCKET_OPT =
+                new ImplSocketOption<>("SERVER_SOCKET_OPT", String.class);
+
         private static class ImplSocketOption<T> implements SocketOption<T> {
             private final String name;
             private final Class<T> type;
@@ -136,13 +154,40 @@
             @Override public Class<T> type() { return type; }
             @Override public String toString() { return name; }
         }
+    }
 
-        private final Set<SocketOption<?>> SO = Set.of(SOCKET_OPT);
+    static class DummySocket extends Socket {
+        DummySocket() throws IOException {
+            super(new DummySocketImpl() {
+                private final Set<SocketOption<?>> SO =
+                        Set.of(StandardDummySocketOptions.SOCKET_OPT,
+                               StandardDummySocketOptions.SOCKET_OPT1);
+
+                @Override
+                public Set<SocketOption<?>> supportedOptions() {
+                    return SO;
+                }
+            });
+        }
+    }
 
-        @Override
-        public Set<SocketOption<?>> supportedOptions() { return SO; }
+    static class DummyServerSocket extends ServerSocket {
+        DummyServerSocket() throws IOException  {
+            super(new DummySocketImpl() {
+                private final Set<SocketOption<?>> SSO =
+                        Set.of(StandardDummySocketOptions.SERVER_SOCKET_OPT);
+
+                @Override
+                public Set<SocketOption<?>> supportedOptions() {
+                    return SSO;
+                }
+            });
+        }
+    }
+
+    static abstract class DummySocketImpl extends SocketImpl {
 
-        // ---
+        private final Map<SocketOption<?>,Object> optionMap = new HashMap<>();
 
         @Override
         protected void create(boolean stream) throws IOException { }
@@ -185,5 +230,20 @@
 
         @Override
         public Object getOption(int optID) throws SocketException { return null; }
+
+        @Override
+        protected <T> void setOption(SocketOption<T> name, T value) throws IOException {
+            if (!supportedOptions().contains(name))
+                throw new UnsupportedOperationException("unsupported option:" + name);
+            optionMap.put(name, value);
+        }
+
+        @Override
+        protected <T> T getOption(SocketOption<T> name) throws IOException {
+            if (!supportedOptions().contains(name))
+                throw new UnsupportedOperationException("unsupported option:" + name);
+
+            return (T)optionMap.get(name);
+        }
     }
 }