< prev index next >

test/java/awt/image/MultiResolutionImageTest.java

Print this page

        

@@ -29,29 +29,27 @@
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.lang.reflect.Method;
 import java.net.URL;
 import javax.imageio.ImageIO;
-import sun.awt.OSInfo;
 import sun.awt.SunHints;
 import java.awt.MediaTracker;
-import java.awt.geom.AffineTransform;
 import java.awt.image.ImageObserver;
-import java.util.Arrays;
-import java.util.List;
 import javax.swing.JPanel;
-import sun.awt.SunToolkit;
+import jdk.testlibrary.Platform;
 import sun.awt.image.MultiResolutionImage;
 
 /**
- * @test
- * @bug 8011059
+ * @test @bug 8011059
  * @author Alexander Scherbatiy
  * @summary [macosx] Make JDK demos look perfect on retina displays
+ * @library /lib/testlibrary/
+ * @build jdk.testlibrary.Platform
+ * @requires (os.family == "mac")
  * @modules java.desktop/sun.awt
  *          java.desktop/sun.awt.image
- * @run main MultiResolutionImageTest CUSTOM
+ *          java.desktop/sun.lwawt.macosx
  * @run main MultiResolutionImageTest TOOLKIT_PREPARE
  * @run main MultiResolutionImageTest TOOLKIT_LOAD
  * @run main MultiResolutionImageTest TOOLKIT
  */
 public class MultiResolutionImageTest {

@@ -68,22 +66,19 @@
         System.out.println("args: " + args.length);
 
         if (args.length == 0) {
             throw new RuntimeException("Not found a test");
         }
-
         String test = args[0];
-
         System.out.println("TEST: " + test);
-        System.out.println("CHECK OS: " + checkOS());
 
-        if ("CUSTOM".equals(test)) {
-            testCustomMultiResolutionImage();
-        } else if (checkOS()) {
+        // To automatically pass the test if the test is not run using JTReg.
+        if (!Platform.isOSX()) {
+            System.out.println("Non-Mac platform detected. Passing the test");
+            return;
+        }
             switch (test) {
-                case "CUSTOM":
-                    break;
                 case "TOOLKIT_PREPARE":
                     testToolkitMultiResolutionImagePrepare();
                     break;
                 case "TOOLKIT_LOAD":
                     testToolkitMultiResolutionImageLoad();

@@ -93,128 +88,11 @@
                     testImageNameTo2xParsing();
                     break;
                 default:
                     throw new RuntimeException("Unknown test: " + test);
             }
-        }
-    }
-
-    static boolean checkOS() {
-        return OSInfo.getOSType() == OSInfo.OSType.MACOSX;
-    }
-
-    public static void testCustomMultiResolutionImage() {
-        testCustomMultiResolutionImage(false);
-        testCustomMultiResolutionImage(true);
-    }
-
-    public static void testCustomMultiResolutionImage(boolean enableImageScaling) {
-
-        Image image = new MultiResolutionBufferedImage();
-
-        // Same image size
-        BufferedImage bufferedImage = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT,
-                BufferedImage.TYPE_INT_RGB);
-        Graphics2D g2d = (Graphics2D) bufferedImage.getGraphics();
-        setImageScalingHint(g2d, enableImageScaling);
-        g2d.drawImage(image, 0, 0, null);
-        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);
-
-        // Twice image size
-        bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT,
-                BufferedImage.TYPE_INT_RGB);
-        g2d = (Graphics2D) bufferedImage.getGraphics();
-        setImageScalingHint(g2d, enableImageScaling);
-        g2d.drawImage(image, 0, 0, 2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);
-        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);
-
-        // Scale 2x
-        bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
-        g2d = (Graphics2D) bufferedImage.getGraphics();
-        setImageScalingHint(g2d, enableImageScaling);
-        g2d.scale(2, 2);
-        g2d.drawImage(image, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);
-        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);
-
-        // Rotate
-        bufferedImage = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT,
-                BufferedImage.TYPE_INT_RGB);
-        g2d = (Graphics2D) bufferedImage.getGraphics();
-        setImageScalingHint(g2d, enableImageScaling);
-        g2d.drawImage(image, 0, 0, null);
-        g2d.rotate(Math.PI / 4);
-        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);
-
-        // Scale 2x and Rotate
-        bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
-        g2d = (Graphics2D) bufferedImage.getGraphics();
-        setImageScalingHint(g2d, enableImageScaling);
-        g2d.scale(-2, 2);
-        g2d.rotate(-Math.PI / 10);
-        g2d.drawImage(image, -IMAGE_WIDTH, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);
-        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);
-
-        // General Transform
-        bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
-        g2d = (Graphics2D) bufferedImage.getGraphics();
-        setImageScalingHint(g2d, enableImageScaling);
-        float delta = 0.05f;
-        float cos = 1 - delta * delta / 2;
-        float sin = 1 + delta;
-        AffineTransform transform = new AffineTransform(2 * cos, 0.1, 0.3, -2 * sin, 10, -5);
-        g2d.setTransform(transform);
-        g2d.drawImage(image, 0, -IMAGE_HEIGHT, IMAGE_WIDTH, IMAGE_HEIGHT, null);
-        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);
-
-        int D = 10;
-        // From Source to small Destination region
-        bufferedImage = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
-        g2d = (Graphics2D) bufferedImage.getGraphics();
-        setImageScalingHint(g2d, enableImageScaling);
-        g2d.drawImage(image, IMAGE_WIDTH / 2, IMAGE_HEIGHT / 2, IMAGE_WIDTH - D, IMAGE_HEIGHT - D,
-                D, D, IMAGE_WIDTH - D, IMAGE_HEIGHT - D, null);
-        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);
-
-        // From Source to large Destination region
-        bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
-        g2d = (Graphics2D) bufferedImage.getGraphics();
-        setImageScalingHint(g2d, enableImageScaling);
-        g2d.drawImage(image, D, D, 2 * IMAGE_WIDTH - D, 2 * IMAGE_HEIGHT - D,
-                IMAGE_WIDTH / 2, IMAGE_HEIGHT / 2, IMAGE_WIDTH - D, IMAGE_HEIGHT - D, null);
-        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);
-    }
-
-    static class MultiResolutionBufferedImage extends BufferedImage
-            implements MultiResolutionImage {
-
-        Image highResolutionImage;
-
-        public MultiResolutionBufferedImage() {
-            super(IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
-            highResolutionImage = new BufferedImage(
-                    2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
-            draw(getGraphics(), 1);
-            draw(highResolutionImage.getGraphics(), 2);
-        }
-
-        void draw(Graphics graphics, float resolution) {
-            Graphics2D g2 = (Graphics2D) graphics;
-            g2.scale(resolution, resolution);
-            g2.setColor((resolution == 1) ? COLOR_1X : COLOR_2X);
-            g2.fillRect(0, 0, IMAGE_WIDTH, IMAGE_HEIGHT);
-        }
-
-        @Override
-        public Image getResolutionVariant(int width, int height) {
-            return ((width <= getWidth() && height <= getHeight()))
-                    ? this : highResolutionImage;
-        }
-
-        @Override
-        public List<Image> getResolutionVariants() {
-            return Arrays.asList(this, highResolutionImage);
-        }
+        System.out.println("Test passed.");
     }
 
     static void testToolkitMultiResolutionImagePrepare() throws Exception {
 
         generateImages();

@@ -222,12 +100,13 @@
         File imageFile = new File(IMAGE_NAME_1X);
         String fileName = imageFile.getAbsolutePath();
 
         Image image = Toolkit.getDefaultToolkit().getImage(fileName);
 
-        SunToolkit toolkit = (SunToolkit) Toolkit.getDefaultToolkit();
-        toolkit.prepareImage(image, IMAGE_WIDTH, IMAGE_HEIGHT, new LoadImageObserver(image));
+        Toolkit toolkit = Toolkit.getDefaultToolkit();
+        toolkit.prepareImage(image, IMAGE_WIDTH, IMAGE_HEIGHT,
+            new LoadImageObserver(image));
 
         testToolkitMultiResolutionImageLoad(image);
     }
 
     static void testToolkitMultiResolutionImageLoad() throws Exception {

@@ -238,11 +117,12 @@
         String fileName = imageFile.getAbsolutePath();
         Image image = Toolkit.getDefaultToolkit().getImage(fileName);
         testToolkitMultiResolutionImageLoad(image);
     }
 
-    static void testToolkitMultiResolutionImageLoad(Image image) throws Exception {
+    static void testToolkitMultiResolutionImageLoad(Image image)
+        throws Exception {
 
         MediaTracker tracker = new MediaTracker(new JPanel());
         tracker.addImage(image, 0);
         tracker.waitForID(0);
         if (tracker.isErrorAny()) {

@@ -265,22 +145,24 @@
         testImageLoaded(resolutionVariant);
     }
 
     static void testImageLoaded(Image image) {
 
-        SunToolkit toolkit = (SunToolkit) Toolkit.getDefaultToolkit();
+        Toolkit toolkit = Toolkit.getDefaultToolkit();
 
-        int flags = toolkit.checkImage(image, IMAGE_WIDTH, IMAGE_WIDTH, new SilentImageObserver());
+        int flags = toolkit.checkImage(image, IMAGE_WIDTH, IMAGE_WIDTH,
+            new SilentImageObserver());
         if ((flags & (ImageObserver.FRAMEBITS | ImageObserver.ALLBITS)) == 0) {
             throw new RuntimeException("Image is not loaded!");
         }
     }
 
     static class SilentImageObserver implements ImageObserver {
 
         @Override
-        public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {
+        public boolean imageUpdate(Image img, int infoflags, int x, int y,
+            int width, int height) {
             throw new RuntimeException("Observer should not be called!");
         }
     }
 
     static class LoadImageObserver implements ImageObserver {

@@ -290,25 +172,29 @@
         public LoadImageObserver(Image image) {
             this.image = image;
         }
 
         @Override
-        public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {
+        public boolean imageUpdate(Image img, int infoflags, int x, int y,
+            int width, int height) {
 
             if (image != img) {
-                throw new RuntimeException("Original image is not passed to the observer");
+                throw new RuntimeException("Original image is not passed "
+                    + "to the observer");
             }
 
             if ((infoflags & ImageObserver.WIDTH) != 0) {
                 if (width != IMAGE_WIDTH) {
-                    throw new RuntimeException("Original width is not passed to the observer");
+                    throw new RuntimeException("Original width is not passed "
+                        + "to the observer");
                 }
             }
 
             if ((infoflags & ImageObserver.HEIGHT) != 0) {
                 if (height != IMAGE_HEIGHT) {
-                    throw new RuntimeException("Original height is not passed to the observer");
+                    throw new RuntimeException("Original height is not passed "
+                        + "to the observer");
                 }
             }
 
             return (infoflags & ALLBITS) == 0;
         }

@@ -333,11 +219,12 @@
         testToolkitImageObserver(image);
         testToolkitMultiResolutionImage(image, false);
         testToolkitMultiResolutionImage(image, true);
     }
 
-    static void testToolkitMultiResolutionImageChache(String fileName, URL url) {
+    static void testToolkitMultiResolutionImageChache(String fileName,
+        URL url) {
 
         Image img1 = Toolkit.getDefaultToolkit().getImage(fileName);
         if (!(img1 instanceof MultiResolutionImage)) {
             throw new RuntimeException("Not a MultiResolutionImage");
         }

@@ -356,26 +243,27 @@
         if (img1 != img2) {
             throw new RuntimeException("Image is not cached");
         }
     }
 
-    static void testToolkitMultiResolutionImage(Image image, boolean enableImageScaling)
-            throws Exception {
+    static void testToolkitMultiResolutionImage(Image image,
+        boolean enableImageScaling) throws Exception {
 
         MediaTracker tracker = new MediaTracker(new JPanel());
         tracker.addImage(image, 0);
         tracker.waitForID(0);
         if (tracker.isErrorAny()) {
             throw new RuntimeException("Error during image loading");
         }
 
-        final BufferedImage bufferedImage1x = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT,
-                BufferedImage.TYPE_INT_RGB);
+        final BufferedImage bufferedImage1x = new BufferedImage(IMAGE_WIDTH,
+            IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
         Graphics2D g1x = (Graphics2D) bufferedImage1x.getGraphics();
         setImageScalingHint(g1x, false);
         g1x.drawImage(image, 0, 0, null);
-        checkColor(bufferedImage1x.getRGB(3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);
+        checkColor(bufferedImage1x.getRGB(3 * IMAGE_WIDTH / 4,
+            3 * IMAGE_HEIGHT / 4), false);
 
         Image resolutionVariant = ((MultiResolutionImage) image).
                 getResolutionVariant(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT);
 
         if (resolutionVariant == null) {

@@ -391,21 +279,26 @@
 
         final BufferedImage bufferedImage2x = new BufferedImage(2 * IMAGE_WIDTH,
                 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
         Graphics2D g2x = (Graphics2D) bufferedImage2x.getGraphics();
         setImageScalingHint(g2x, enableImageScaling);
-        g2x.drawImage(image, 0, 0, 2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);
-        checkColor(bufferedImage2x.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);
+        g2x.drawImage(image, 0, 0, 2 * IMAGE_WIDTH,
+            2 * IMAGE_HEIGHT, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);
+        checkColor(bufferedImage2x.getRGB(3 * IMAGE_WIDTH / 2,
+            3 * IMAGE_HEIGHT / 2), enableImageScaling);
 
         if (!(image instanceof MultiResolutionImage)) {
             throw new RuntimeException("Not a MultiResolutionImage");
         }
 
-        MultiResolutionImage multiResolutionImage = (MultiResolutionImage) image;
+        MultiResolutionImage multiResolutionImage
+            = (MultiResolutionImage) image;
 
-        Image image1x = multiResolutionImage.getResolutionVariant(IMAGE_WIDTH, IMAGE_HEIGHT);
-        Image image2x = multiResolutionImage.getResolutionVariant(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT);
+        Image image1x = multiResolutionImage.getResolutionVariant(
+            IMAGE_WIDTH, IMAGE_HEIGHT);
+        Image image2x = multiResolutionImage.getResolutionVariant(
+            2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT);
 
         if (image1x.getWidth(null) * 2 != image2x.getWidth(null)
                 || image1x.getHeight(null) * 2 != image2x.getHeight(null)) {
             throw new RuntimeException("Wrong resolution variant size");
         }

@@ -414,17 +307,19 @@
     static void testToolkitImageObserver(final Image image) {
 
         ImageObserver observer = new ImageObserver() {
 
             @Override
-            public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {
+            public boolean imageUpdate(Image img, int infoflags, int x, int y,
+                int width, int height) {
 
                 if (img != image) {
                     throw new RuntimeException("Wrong image in observer");
                 }
 
-                if ((infoflags & (ImageObserver.ERROR | ImageObserver.ABORT)) != 0) {
+                if ((infoflags & (ImageObserver.ERROR | ImageObserver.ABORT))
+                    != 0) {
                     throw new RuntimeException("Error during image loading");
                 }
 
                 return (infoflags & ImageObserver.ALLBITS) == 0;
 

@@ -434,15 +329,17 @@
         final BufferedImage bufferedImage2x = new BufferedImage(2 * IMAGE_WIDTH,
                 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
         Graphics2D g2x = (Graphics2D) bufferedImage2x.getGraphics();
         setImageScalingHint(g2x, true);
 
-        g2x.drawImage(image, 0, 0, 2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, observer);
+        g2x.drawImage(image, 0, 0, 2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, 0, 0,
+            IMAGE_WIDTH, IMAGE_HEIGHT, observer);
 
     }
 
-    static void setImageScalingHint(Graphics2D g2d, boolean enableImageScaling) {
+    static void setImageScalingHint(Graphics2D g2d,
+        boolean enableImageScaling) {
         g2d.setRenderingHint(SunHints.KEY_RESOLUTION_VARIANT, enableImageScaling
                 ? SunHints.VALUE_RESOLUTION_VARIANT_ON
                 : SunHints.VALUE_RESOLUTION_VARIANT_OFF);
     }
 

@@ -466,11 +363,12 @@
             generateImage(2);
         }
     }
 
     static void generateImage(int scale) throws Exception {
-        BufferedImage image = new BufferedImage(scale * IMAGE_WIDTH, scale * IMAGE_HEIGHT,
+        BufferedImage image = new BufferedImage(
+            scale * IMAGE_WIDTH, scale * IMAGE_HEIGHT,
                 BufferedImage.TYPE_INT_RGB);
         Graphics g = image.getGraphics();
         g.setColor(scale == 1 ? COLOR_1X : COLOR_2X);
         g.fillRect(0, 0, scale * IMAGE_WIDTH, scale * IMAGE_HEIGHT);
         File file = new File(scale == 1 ? IMAGE_NAME_1X : IMAGE_NAME_2X);

@@ -519,11 +417,12 @@
         Method method = getScalableImageMethod("getScaledImageURL", URL.class);
         return (URL) method.invoke(null, url);
     }
 
     static String getTestScaledImageName(String name) throws Exception {
-        Method method = getScalableImageMethod("getScaledImageName", String.class);
+        Method method = getScalableImageMethod(
+            "getScaledImageName", String.class);
         return (String) method.invoke(null, name);
     }
 
     private static boolean isValidPath(String path) {
         return !path.isEmpty() && !path.endsWith("/") && !path.endsWith(".")

@@ -531,11 +430,13 @@
     }
 
     private static Method getScalableImageMethod(String name,
             Class... parameterTypes) throws Exception {
         Toolkit toolkit = Toolkit.getDefaultToolkit();
-        Method method = toolkit.getClass().getDeclaredMethod(name, parameterTypes);
+        Method method = toolkit.getClass()
+            .
+            getDeclaredMethod(name, parameterTypes);
         method.setAccessible(true);
         return method;
     }
     private static final String[][] TEST_FILE_NAMES;
     private static final URL[][] TEST_URLS;

@@ -602,21 +503,24 @@
                 {new URL("jar:file:/dir/Java2D.jar!/images/image"),
                     new URL("jar:file:/dir/Java2D.jar!/images/image@2x")},
                 {new URL("jar:file:/dir/Java2D.jar!/images/image.ext"),
                     new URL("jar:file:/dir/Java2D.jar!/images/image@2x.ext")},
                 {new URL("jar:file:/aaa.bbb/Java2D.jar!/images/image.ext"),
-                    new URL("jar:file:/aaa.bbb/Java2D.jar!/images/image@2x.ext")},
+                    new URL("jar:file:/aaa.bbb/Java2D.jar!/"
+                    + "images/image@2x.ext")},
                 {new URL("jar:file:/dir/Java2D.jar!/aaa.bbb/image.ext"),
-                    new URL("jar:file:/dir/Java2D.jar!/aaa.bbb/image@2x.ext")},};
+                    new URL("jar:file:/dir/Java2D.jar!/"
+                    + "aaa.bbb/image@2x.ext")},};
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }
 
     static class PreloadedImageObserver implements ImageObserver {
 
         @Override
-        public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {
+        public boolean imageUpdate(Image img, int infoflags, int x, int y,
+            int width, int height) {
             throw new RuntimeException("Image should be already preloaded");
         }
     }
 }
< prev index next >