< prev index next >

test/lib/jdk/test/lib/OSVersion.java

Print this page
rev 51542 : 8210039: move OSInfo to top level testlibrary
Reviewed-by: duke

@@ -21,196 +21,87 @@
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 
-package jdk.testlibrary;
+package jdk.test.lib;
 
-import java.security.PrivilegedAction;
-import java.util.HashMap;
-import java.util.Map;
+import java.util.Arrays;
 import java.io.BufferedReader;
 import java.io.FileReader;
-import java.io.InputStreamReader;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
-import static jdk.testlibrary.OSInfo.OSType.*;
+public final class OSVersion implements Comparable<OSVersion> {
+    public static final OSVersion WINDOWS_95 = new OSVersion(4, 0);
+    public static final OSVersion WINDOWS_98 = new OSVersion(4, 10);
+    public static final OSVersion WINDOWS_ME = new OSVersion(4, 90);
+    public static final OSVersion WINDOWS_2000 = new OSVersion(5, 0);
+    public static final OSVersion WINDOWS_XP = new OSVersion(5, 1);
+    public static final OSVersion WINDOWS_2003 = new OSVersion(5, 2);
+    public static final OSVersion WINDOWS_VISTA = new OSVersion(6, 0);
 
-/**
- * @author Pavel Porvatov
- * copied to testlibrary by yan
- */
-public class OSInfo {
-    public static enum OSType {
-        WINDOWS,
-        LINUX,
-        SOLARIS,
-        MACOSX,
-        UNKNOWN
-    }
-
-    /*
-       The map windowsVersionMap must contain all windows version constants except WINDOWS_UNKNOWN,
-       and so the method getWindowsVersion() will return the constant for known OS.
-       It allows compare objects by "==" instead of "equals".
-     */
-    public static final WindowsVersion WINDOWS_UNKNOWN = new WindowsVersion(-1, -1);
-    public static final WindowsVersion WINDOWS_95 = new WindowsVersion(4, 0);
-    public static final WindowsVersion WINDOWS_98 = new WindowsVersion(4, 10);
-    public static final WindowsVersion WINDOWS_ME = new WindowsVersion(4, 90);
-    public static final WindowsVersion WINDOWS_2000 = new WindowsVersion(5, 0);
-    public static final WindowsVersion WINDOWS_XP = new WindowsVersion(5, 1);
-    public static final WindowsVersion WINDOWS_2003 = new WindowsVersion(5, 2);
-    public static final WindowsVersion WINDOWS_VISTA = new WindowsVersion(6, 0);
-
-    private static final String OS_NAME = "os.name";
-    private static final String OS_VERSION = "os.version";
-
-    private final static Map<String, WindowsVersion> windowsVersionMap = new HashMap<String, OSInfo.WindowsVersion>();
-
-    static {
-        windowsVersionMap.put(WINDOWS_95.toString(), WINDOWS_95);
-        windowsVersionMap.put(WINDOWS_98.toString(), WINDOWS_98);
-        windowsVersionMap.put(WINDOWS_ME.toString(), WINDOWS_ME);
-        windowsVersionMap.put(WINDOWS_2000.toString(), WINDOWS_2000);
-        windowsVersionMap.put(WINDOWS_XP.toString(), WINDOWS_XP);
-        windowsVersionMap.put(WINDOWS_2003.toString(), WINDOWS_2003);
-        windowsVersionMap.put(WINDOWS_VISTA.toString(), WINDOWS_VISTA);
-    }
-
-    private static final PrivilegedAction<OSType> osTypeAction = new PrivilegedAction<OSType>() {
-        public OSType run() {
-            return getOSType();
-        }
-    };
-
-    private OSInfo() {
-        // Don't allow to create instances
-    }
-
-    /**
-     * Returns type of operating system.
-     */
-    public static OSType getOSType() throws SecurityException {
-        String osName = System.getProperty(OS_NAME);
+    private final int[] versionTokens;
 
-        if (osName != null) {
-            if (osName.contains("Windows")) {
-                return WINDOWS;
+    public static OSVersion current() {
+        if (Platform.isSolaris()) {
+            return new OSVersion(getSolarisVersion());
             }
-
-            if (osName.contains("Linux")) {
-                return LINUX;
-            }
-
-            if (osName.contains("Solaris") || osName.contains("SunOS")) {
-                return SOLARIS;
+        return new OSVersion(Platform.getOsVersion());
             }
 
-            if (osName.contains("OS X")) {
-                return MACOSX;
+    public OSVersion(int major, int minor) {
+        versionTokens = new int[] {major, minor};
             }
 
-            // determine another OS here
+    public OSVersion(String version) {
+        Pattern onlyDigits = Pattern.compile("^\\d+$");
+        this.versionTokens = Arrays.stream(version.split("-")[0].split("\\."))
+                                   .filter(onlyDigits.asPredicate())
+                                   .mapToInt(Integer::parseInt)
+                                   .toArray();
         }
 
-        return UNKNOWN;
-    }
-
-    public static PrivilegedAction<OSType> getOSTypeAction() {
-        return osTypeAction;
-    }
-
-    public static WindowsVersion getWindowsVersion() throws SecurityException {
-        String osVersion = System.getProperty(OS_VERSION);
-
-        if (osVersion == null) {
-            return WINDOWS_UNKNOWN;
-        }
-
-        synchronized (windowsVersionMap) {
-            WindowsVersion result = windowsVersionMap.get(osVersion);
-
-            if (result == null) {
-                // Try parse version and put object into windowsVersionMap
-                String[] arr = osVersion.split("\\.");
-
-                if (arr.length == 2) {
+    private static String getSolarisVersion() {
                     try {
-                        result = new WindowsVersion(Integer.parseInt(arr[0]), Integer.parseInt(arr[1]));
-                    } catch (NumberFormatException e) {
-                        return WINDOWS_UNKNOWN;
-                    }
-                } else {
-                    return WINDOWS_UNKNOWN;
-                }
-
-                windowsVersionMap.put(osVersion, result);
-            }
-
-            return result;
-        }
-    }
-
-    public static double getSolarisVersion() {
-        try {
-            OutputAnalyzer output = ProcessTools.executeProcess("uname", "-v");
-            System.out.println("'uname -v' finished with code "
-                    + output.getExitValue());
-            return Double.parseDouble(output.getOutput());
-        } catch (Exception e) {
+            return Utils.distro();
+        } catch (Throwable e) {
             System.out.println("First attempt failed with: " + e.getMessage());
         }
 
-        //Try to get Solaris version from /etc/release
+        // Try to get Solaris version from /etc/release
         try (BufferedReader in =
                      new BufferedReader(new FileReader("/etc/release"))) {
-            String line = in.readLine().trim().split(" ")[2];
-            return Double.parseDouble(line);
+            return in.readLine().trim().split(" ")[2];
         } catch (Exception e) {
             System.out.println("Second attempt failed with: " + e.getMessage());
         }
 
         throw new RuntimeException("Unable to get Solaris version");
     }
 
-    public static class WindowsVersion implements Comparable<WindowsVersion> {
-        private final int major;
-
-        private final int minor;
-
-        private WindowsVersion(int major, int minor) {
-            this.major = major;
-            this.minor = minor;
-        }
-
-        public int getMajor() {
-            return major;
-        }
-
-        public int getMinor() {
-            return minor;
-        }
-
-        public int compareTo(WindowsVersion o) {
-            int result = major - o.getMajor();
-
-            if (result == 0) {
-                result = minor - o.getMinor();
+    @Override
+    public int compareTo(OSVersion o) {
+        return Arrays.compare(this.versionTokens, o.versionTokens);
             }
 
-            return result;
+    @Override
+    public int hashCode() {
+        return Arrays.hashCode(versionTokens);
         }
 
-        public boolean equals(Object obj) {
-            return obj instanceof WindowsVersion && compareTo((WindowsVersion) obj) == 0;
-        }
-
-        public int hashCode() {
-            return 31 * major + minor;
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        OSVersion osVersion = (OSVersion) o;
+        return Arrays.equals(versionTokens, osVersion.versionTokens);
         }
 
+    @Override
         public String toString() {
-            return major + "." + minor;
-        }
+        return Arrays.stream(versionTokens)
+                     .mapToObj(String::valueOf)
+                     .collect(Collectors.joining("."));
     }
 }
 
< prev index next >