1 /*

     2  * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 import java.awt.Color;

    25 import java.awt.Graphics;

    26 import java.awt.Graphics2D;

    27 import java.awt.Image;

    28 import java.awt.Toolkit;

    29 import java.awt.image.BufferedImage;

    30 import java.io.File;

    31 import java.lang.reflect.Method;

    32 import java.net.URL;

    33 import javax.imageio.ImageIO;

    34 import sun.awt.OSInfo;

    35 import sun.awt.SunHints;

    36 import java.awt.MediaTracker;

    37 import java.awt.geom.AffineTransform;

    38 import java.awt.image.ImageObserver;

    39 import java.util.Arrays;

    40 import java.util.List;

    41 import javax.swing.JPanel;

    42 import sun.awt.SunToolkit;

    43 import sun.awt.image.MultiResolutionImage;

    44 

    45 /**

    46  * @test

    47  * @bug 8011059

    48  * @author Alexander Scherbatiy

    49  * @summary [macosx] Make JDK demos look perfect on retina displays

    50  * @run main MultiResolutionImageTest CUSTOM

    51  * @run main MultiResolutionImageTest TOOLKIT_PREPARE

    52  * @run main MultiResolutionImageTest TOOLKIT_LOAD

    53  * @run main MultiResolutionImageTest TOOLKIT

    54  */

    55 public class MultiResolutionImageTest {

    56 

    57     private static final int IMAGE_WIDTH = 300;

    58     private static final int IMAGE_HEIGHT = 200;

    59     private static final Color COLOR_1X = Color.GREEN;

    60     private static final Color COLOR_2X = Color.BLUE;

    61     private static final String IMAGE_NAME_1X = "image.png";

    62     private static final String IMAGE_NAME_2X = "image@2x.png";

    63 

    64     public static void main(String[] args) throws Exception {

    65 

    66         System.out.println("args: " + args.length);

    67 

    68         if (args.length == 0) {

    69             throw new RuntimeException("Not found a test");

    70         }

    71 

    72         String test = args[0];

    73 

    74         System.out.println("TEST: " + test);

    75         System.out.println("CHECK OS: " + checkOS());

    76 

    77         if ("CUSTOM".equals(test)) {

    78             testCustomMultiResolutionImage();

    79         } else if (checkOS()) {

    80             switch (test) {

    81                 case "CUSTOM":

    82                     break;

    83                 case "TOOLKIT_PREPARE":

    84                     testToolkitMultiResolutionImagePrepare();

    85                     break;

    86                 case "TOOLKIT_LOAD":

    87                     testToolkitMultiResolutionImageLoad();

    88                     break;

    89                 case "TOOLKIT":

    90                     testToolkitMultiResolutionImage();

    91                     testImageNameTo2xParsing();

    92                     break;

    93                 default:

    94                     throw new RuntimeException("Unknown test: " + test);

    95             }

    96         }

    97     }

    98 

    99     static boolean checkOS() {

   100         return OSInfo.getOSType() == OSInfo.OSType.MACOSX;

   101     }

   102 

   103     public static void testCustomMultiResolutionImage() {

   104         testCustomMultiResolutionImage(false);

   105         testCustomMultiResolutionImage(true);

   106     }

   107 

   108     public static void testCustomMultiResolutionImage(boolean enableImageScaling) {

   109 

   110         Image image = new MultiResolutionBufferedImage();

   111 

   112         // Same image size

   113         BufferedImage bufferedImage = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT,

   114                 BufferedImage.TYPE_INT_RGB);

   115         Graphics2D g2d = (Graphics2D) bufferedImage.getGraphics();

   116         setImageScalingHint(g2d, enableImageScaling);

   117         g2d.drawImage(image, 0, 0, null);

   118         checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);

   119 

   120         // Twice image size

   121         bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT,

   122                 BufferedImage.TYPE_INT_RGB);

   123         g2d = (Graphics2D) bufferedImage.getGraphics();

   124         setImageScalingHint(g2d, enableImageScaling);

   125         g2d.drawImage(image, 0, 0, 2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);

   126         checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);

   127 

   128         // Scale 2x

   129         bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

   130         g2d = (Graphics2D) bufferedImage.getGraphics();

   131         setImageScalingHint(g2d, enableImageScaling);

   132         g2d.scale(2, 2);

   133         g2d.drawImage(image, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);

   134         checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);

   135 

   136         // Rotate

   137         bufferedImage = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT,

   138                 BufferedImage.TYPE_INT_RGB);

   139         g2d = (Graphics2D) bufferedImage.getGraphics();

   140         setImageScalingHint(g2d, enableImageScaling);

   141         g2d.drawImage(image, 0, 0, null);

   142         g2d.rotate(Math.PI / 4);

   143         checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);

   144 

   145         // Scale 2x and Rotate

   146         bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

   147         g2d = (Graphics2D) bufferedImage.getGraphics();

   148         setImageScalingHint(g2d, enableImageScaling);

   149         g2d.scale(-2, 2);

   150         g2d.rotate(-Math.PI / 10);

   151         g2d.drawImage(image, -IMAGE_WIDTH, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);

   152         checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);

   153 

   154         // General Transform

   155         bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

   156         g2d = (Graphics2D) bufferedImage.getGraphics();

   157         setImageScalingHint(g2d, enableImageScaling);

   158         float delta = 0.05f;

   159         float cos = 1 - delta * delta / 2;

   160         float sin = 1 + delta;

   161         AffineTransform transform = new AffineTransform(2 * cos, 0.1, 0.3, -2 * sin, 10, -5);

   162         g2d.setTransform(transform);

   163         g2d.drawImage(image, 0, -IMAGE_HEIGHT, IMAGE_WIDTH, IMAGE_HEIGHT, null);

   164         checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);

   165 

   166         int D = 10;

   167         // From Source to small Destination region

   168         bufferedImage = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

   169         g2d = (Graphics2D) bufferedImage.getGraphics();

   170         setImageScalingHint(g2d, enableImageScaling);

   171         g2d.drawImage(image, IMAGE_WIDTH / 2, IMAGE_HEIGHT / 2, IMAGE_WIDTH - D, IMAGE_HEIGHT - D,

   172                 D, D, IMAGE_WIDTH - D, IMAGE_HEIGHT - D, null);

   173         checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);

   174 

   175         // From Source to large Destination region

   176         bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

   177         g2d = (Graphics2D) bufferedImage.getGraphics();

   178         setImageScalingHint(g2d, enableImageScaling);

   179         g2d.drawImage(image, D, D, 2 * IMAGE_WIDTH - D, 2 * IMAGE_HEIGHT - D,

   180                 IMAGE_WIDTH / 2, IMAGE_HEIGHT / 2, IMAGE_WIDTH - D, IMAGE_HEIGHT - D, null);

   181         checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);

   182     }

   183 

   184     static class MultiResolutionBufferedImage extends BufferedImage

   185             implements MultiResolutionImage {

   186 

   187         Image highResolutionImage;

   188 

   189         public MultiResolutionBufferedImage() {

   190             super(IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

   191             highResolutionImage = new BufferedImage(

   192                     2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

   193             draw(getGraphics(), 1);

   194             draw(highResolutionImage.getGraphics(), 2);

   195         }

   196 

   197         void draw(Graphics graphics, float resolution) {

   198             Graphics2D g2 = (Graphics2D) graphics;

   199             g2.scale(resolution, resolution);

   200             g2.setColor((resolution == 1) ? COLOR_1X : COLOR_2X);

   201             g2.fillRect(0, 0, IMAGE_WIDTH, IMAGE_HEIGHT);

   202         }

   203 

   204         @Override

   205         public Image getResolutionVariant(int width, int height) {

   206             return ((width <= getWidth() && height <= getHeight()))

   207                     ? this : highResolutionImage;

   208         }

   209 

   210         @Override

   211         public List<Image> getResolutionVariants() {

   212             return Arrays.asList(this, highResolutionImage);

   213         }

   214     }

   215 

   216     static void testToolkitMultiResolutionImagePrepare() throws Exception {

   217 

   218         generateImages();

   219 

   220         File imageFile = new File(IMAGE_NAME_1X);

   221         String fileName = imageFile.getAbsolutePath();

   222 

   223         Image image = Toolkit.getDefaultToolkit().getImage(fileName);

   224 

   225         SunToolkit toolkit = (SunToolkit) Toolkit.getDefaultToolkit();

   226         toolkit.prepareImage(image, IMAGE_WIDTH, IMAGE_HEIGHT, new LoadImageObserver(image));

   227 

   228         testToolkitMultiResolutionImageLoad(image);

   229     }

   230 

   231     static void testToolkitMultiResolutionImageLoad() throws Exception {

   232 

   233         generateImages();

   234 

   235         File imageFile = new File(IMAGE_NAME_1X);

   236         String fileName = imageFile.getAbsolutePath();

   237         Image image = Toolkit.getDefaultToolkit().getImage(fileName);

   238         testToolkitMultiResolutionImageLoad(image);

   239     }

   240 

   241     static void testToolkitMultiResolutionImageLoad(Image image) throws Exception {

   242 

   243         MediaTracker tracker = new MediaTracker(new JPanel());

   244         tracker.addImage(image, 0);

   245         tracker.waitForID(0);

   246         if (tracker.isErrorAny()) {

   247             throw new RuntimeException("Error during image loading");

   248         }

   249         tracker.removeImage(image, 0);

   250 

   251         testImageLoaded(image);

   252 

   253         int w = image.getWidth(null);

   254         int h = image.getHeight(null);

   255 

   256         Image resolutionVariant = ((MultiResolutionImage) image)

   257                 .getResolutionVariant(2 * w, 2 * h);

   258 

   259         if (image == resolutionVariant) {

   260             throw new RuntimeException("Resolution variant is not loaded");

   261         }

   262 

   263         testImageLoaded(resolutionVariant);

   264     }

   265 

   266     static void testImageLoaded(Image image) {

   267 

   268         SunToolkit toolkit = (SunToolkit) Toolkit.getDefaultToolkit();

   269 

   270         int flags = toolkit.checkImage(image, IMAGE_WIDTH, IMAGE_WIDTH, new SilentImageObserver());

   271         if ((flags & (ImageObserver.FRAMEBITS | ImageObserver.ALLBITS)) == 0) {

   272             throw new RuntimeException("Image is not loaded!");

   273         }

   274     }

   275 

   276     static class SilentImageObserver implements ImageObserver {

   277 

   278         @Override

   279         public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {

   280             throw new RuntimeException("Observer should not be called!");

   281         }

   282     }

   283 

   284     static class LoadImageObserver implements ImageObserver {

   285 

   286         Image image;

   287 

   288         public LoadImageObserver(Image image) {

   289             this.image = image;

   290         }

   291 

   292         @Override

   293         public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {

   294 

   295             if (image != img) {

   296                 throw new RuntimeException("Original image is not passed to the observer");

   297             }

   298 

   299             if ((infoflags & ImageObserver.WIDTH) != 0) {

   300                 if (width != IMAGE_WIDTH) {

   301                     throw new RuntimeException("Original width is not passed to the observer");

   302                 }

   303             }

   304 

   305             if ((infoflags & ImageObserver.HEIGHT) != 0) {

   306                 if (height != IMAGE_HEIGHT) {

   307                     throw new RuntimeException("Original height is not passed to the observer");

   308                 }

   309             }

   310 

   311             return (infoflags & ALLBITS) == 0;

   312         }

   313 

   314     }

   315 

   316     static void testToolkitMultiResolutionImage() throws Exception {

   317 

   318         generateImages();

   319 

   320         File imageFile = new File(IMAGE_NAME_1X);

   321         String fileName = imageFile.getAbsolutePath();

   322         URL url = imageFile.toURI().toURL();

   323         testToolkitMultiResolutionImageChache(fileName, url);

   324 

   325         Image image = Toolkit.getDefaultToolkit().getImage(fileName);

   326         testToolkitImageObserver(image);

   327         testToolkitMultiResolutionImage(image, false);

   328         testToolkitMultiResolutionImage(image, true);

   329 

   330         image = Toolkit.getDefaultToolkit().getImage(url);

   331         testToolkitImageObserver(image);

   332         testToolkitMultiResolutionImage(image, false);

   333         testToolkitMultiResolutionImage(image, true);

   334     }

   335 

   336     static void testToolkitMultiResolutionImageChache(String fileName, URL url) {

   337 

   338         Image img1 = Toolkit.getDefaultToolkit().getImage(fileName);

   339         if (!(img1 instanceof MultiResolutionImage)) {

   340             throw new RuntimeException("Not a MultiResolutionImage");

   341         }

   342 

   343         Image img2 = Toolkit.getDefaultToolkit().getImage(fileName);

   344         if (img1 != img2) {

   345             throw new RuntimeException("Image is not cached");

   346         }

   347 

   348         img1 = Toolkit.getDefaultToolkit().getImage(url);

   349         if (!(img1 instanceof MultiResolutionImage)) {

   350             throw new RuntimeException("Not a MultiResolutionImage");

   351         }

   352 

   353         img2 = Toolkit.getDefaultToolkit().getImage(url);

   354         if (img1 != img2) {

   355             throw new RuntimeException("Image is not cached");

   356         }

   357     }

   358 

   359     static void testToolkitMultiResolutionImage(Image image, boolean enableImageScaling)

   360             throws Exception {

   361 

   362         MediaTracker tracker = new MediaTracker(new JPanel());

   363         tracker.addImage(image, 0);

   364         tracker.waitForID(0);

   365         if (tracker.isErrorAny()) {

   366             throw new RuntimeException("Error during image loading");

   367         }

   368 

   369         final BufferedImage bufferedImage1x = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT,

   370                 BufferedImage.TYPE_INT_RGB);

   371         Graphics2D g1x = (Graphics2D) bufferedImage1x.getGraphics();

   372         setImageScalingHint(g1x, false);

   373         g1x.drawImage(image, 0, 0, null);

   374         checkColor(bufferedImage1x.getRGB(3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);

   375 

   376         Image resolutionVariant = ((MultiResolutionImage) image).

   377                 getResolutionVariant(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT);

   378 

   379         if (resolutionVariant == null) {

   380             throw new RuntimeException("Resolution variant is null");

   381         }

   382 

   383         MediaTracker tracker2x = new MediaTracker(new JPanel());

   384         tracker2x.addImage(resolutionVariant, 0);

   385         tracker2x.waitForID(0);

   386         if (tracker2x.isErrorAny()) {

   387             throw new RuntimeException("Error during scalable image loading");

   388         }

   389 

   390         final BufferedImage bufferedImage2x = new BufferedImage(2 * IMAGE_WIDTH,

   391                 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

   392         Graphics2D g2x = (Graphics2D) bufferedImage2x.getGraphics();

   393         setImageScalingHint(g2x, enableImageScaling);

   394         g2x.drawImage(image, 0, 0, 2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);

   395         checkColor(bufferedImage2x.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);

   396 

   397         if (!(image instanceof MultiResolutionImage)) {

   398             throw new RuntimeException("Not a MultiResolutionImage");

   399         }

   400 

   401         MultiResolutionImage multiResolutionImage = (MultiResolutionImage) image;

   402 

   403         Image image1x = multiResolutionImage.getResolutionVariant(IMAGE_WIDTH, IMAGE_HEIGHT);

   404         Image image2x = multiResolutionImage.getResolutionVariant(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT);

   405 

   406         if (image1x.getWidth(null) * 2 != image2x.getWidth(null)

   407                 || image1x.getHeight(null) * 2 != image2x.getHeight(null)) {

   408             throw new RuntimeException("Wrong resolution variant size");

   409         }

   410     }

   411 

   412     static void testToolkitImageObserver(final Image image) {

   413 

   414         ImageObserver observer = new ImageObserver() {

   415 

   416             @Override

   417             public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {

   418 

   419                 if (img != image) {

   420                     throw new RuntimeException("Wrong image in observer");

   421                 }

   422 

   423                 if ((infoflags & (ImageObserver.ERROR | ImageObserver.ABORT)) != 0) {

   424                     throw new RuntimeException("Error during image loading");

   425                 }

   426 

   427                 return (infoflags & ImageObserver.ALLBITS) == 0;

   428 

   429             }

   430         };

   431 

   432         final BufferedImage bufferedImage2x = new BufferedImage(2 * IMAGE_WIDTH,

   433                 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

   434         Graphics2D g2x = (Graphics2D) bufferedImage2x.getGraphics();

   435         setImageScalingHint(g2x, true);

   436 

   437         g2x.drawImage(image, 0, 0, 2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, observer);

   438 

   439     }

   440 

   441     static void setImageScalingHint(Graphics2D g2d, boolean enableImageScaling) {

   442         g2d.setRenderingHint(SunHints.KEY_RESOLUTION_VARIANT, enableImageScaling

   443                 ? SunHints.VALUE_RESOLUTION_VARIANT_ON

   444                 : SunHints.VALUE_RESOLUTION_VARIANT_OFF);

   445     }

   446 

   447     static void checkColor(int rgb, boolean isImageScaled) {

   448 

   449         if (!isImageScaled && COLOR_1X.getRGB() != rgb) {

   450             throw new RuntimeException("Wrong 1x color: " + new Color(rgb));

   451         }

   452 

   453         if (isImageScaled && COLOR_2X.getRGB() != rgb) {

   454             throw new RuntimeException("Wrong 2x color" + new Color(rgb));

   455         }

   456     }

   457 

   458     static void generateImages() throws Exception {

   459         if (!new File(IMAGE_NAME_1X).exists()) {

   460             generateImage(1);

   461         }

   462 

   463         if (!new File(IMAGE_NAME_2X).exists()) {

   464             generateImage(2);

   465         }

   466     }

   467 

   468     static void generateImage(int scale) throws Exception {

   469         BufferedImage image = new BufferedImage(scale * IMAGE_WIDTH, scale * IMAGE_HEIGHT,

   470                 BufferedImage.TYPE_INT_RGB);

   471         Graphics g = image.getGraphics();

   472         g.setColor(scale == 1 ? COLOR_1X : COLOR_2X);

   473         g.fillRect(0, 0, scale * IMAGE_WIDTH, scale * IMAGE_HEIGHT);

   474         File file = new File(scale == 1 ? IMAGE_NAME_1X : IMAGE_NAME_2X);

   475         ImageIO.write(image, "png", file);

   476     }

   477 

   478     static void testImageNameTo2xParsing() throws Exception {

   479 

   480         for (String[] testNames : TEST_FILE_NAMES) {

   481             String testName = testNames[0];

   482             String goldenName = testNames[1];

   483             String resultName = getTestScaledImageName(testName);

   484 

   485             if (!isValidPath(testName) && resultName == null) {

   486                 continue;

   487             }

   488 

   489             if (goldenName.equals(resultName)) {

   490                 continue;

   491             }

   492 

   493             throw new RuntimeException("Test name " + testName

   494                     + ", result name: " + resultName);

   495         }

   496 

   497         for (URL[] testURLs : TEST_URLS) {

   498             URL testURL = testURLs[0];

   499             URL goldenURL = testURLs[1];

   500             URL resultURL = getTestScaledImageURL(testURL);

   501 

   502             if (!isValidPath(testURL.getPath()) && resultURL == null) {

   503                 continue;

   504             }

   505 

   506             if (goldenURL.equals(resultURL)) {

   507                 continue;

   508             }

   509 

   510             throw new RuntimeException("Test url: " + testURL

   511                     + ", result url: " + resultURL);

   512         }

   513 

   514     }

   515 

   516     static URL getTestScaledImageURL(URL url) throws Exception {

   517         Method method = getScalableImageMethod("getScaledImageURL", URL.class);

   518         return (URL) method.invoke(null, url);

   519     }

   520 

   521     static String getTestScaledImageName(String name) throws Exception {

   522         Method method = getScalableImageMethod("getScaledImageName", String.class);

   523         return (String) method.invoke(null, name);

   524     }

   525 

   526     private static boolean isValidPath(String path) {

   527         return !path.isEmpty() && !path.endsWith("/") && !path.endsWith(".")

   528                 && !path.contains("@2x");

   529     }

   530 

   531     private static Method getScalableImageMethod(String name,

   532             Class... parameterTypes) throws Exception {

   533         Toolkit toolkit = Toolkit.getDefaultToolkit();

   534         Method method = toolkit.getClass().getDeclaredMethod(name, parameterTypes);

   535         method.setAccessible(true);

   536         return method;

   537     }

   538     private static final String[][] TEST_FILE_NAMES;

   539     private static final URL[][] TEST_URLS;

   540 

   541     static {

   542         TEST_FILE_NAMES = new String[][]{

   543             {"", null},

   544             {".", null},

   545             {"..", null},

   546             {"/", null},

   547             {"/.", null},

   548             {"dir/", null},

   549             {"dir/.", null},

   550             {"aaa@2x.png", null},

   551             {"/dir/aaa@2x.png", null},

   552             {"image", "image@2x"},

   553             {"image.ext", "image@2x.ext"},

   554             {"image.aaa.ext", "image.aaa@2x.ext"},

   555             {"dir/image", "dir/image@2x"},

   556             {"dir/image.ext", "dir/image@2x.ext"},

   557             {"dir/image.aaa.ext", "dir/image.aaa@2x.ext"},

   558             {"dir/aaa.bbb/image", "dir/aaa.bbb/image@2x"},

   559             {"dir/aaa.bbb/image.ext", "dir/aaa.bbb/image@2x.ext"},

   560             {"dir/aaa.bbb/image.ccc.ext", "dir/aaa.bbb/image.ccc@2x.ext"},

   561             {"/dir/image", "/dir/image@2x"},

   562             {"/dir/image.ext", "/dir/image@2x.ext"},

   563             {"/dir/image.aaa.ext", "/dir/image.aaa@2x.ext"},

   564             {"/dir/aaa.bbb/image", "/dir/aaa.bbb/image@2x"},

   565             {"/dir/aaa.bbb/image.ext", "/dir/aaa.bbb/image@2x.ext"},

   566             {"/dir/aaa.bbb/image.ccc.ext", "/dir/aaa.bbb/image.ccc@2x.ext"}

   567         };

   568         try {

   569             TEST_URLS = new URL[][]{

   570                 // file

   571                 {new URL("file:/aaa"), new URL("file:/aaa@2x")},

   572                 {new URL("file:/aaa.ext"), new URL("file:/aaa@2x.ext")},

   573                 {new URL("file:/aaa.bbb.ext"), new URL("file:/aaa.bbb@2x.ext")},

   574                 {new URL("file:/ccc/aaa.bbb.ext"),

   575                     new URL("file:/ccc/aaa.bbb@2x.ext")},

   576                 {new URL("file:/ccc.ddd/aaa.bbb.ext"),

   577                     new URL("file:/ccc.ddd/aaa.bbb@2x.ext")},

   578                 {new URL("file:///~/image"), new URL("file:///~/image@2x")},

   579                 {new URL("file:///~/image.ext"),

   580                     new URL("file:///~/image@2x.ext")},

   581                 // http

   582                 {new URL("http://www.test.com"), null},

   583                 {new URL("http://www.test.com/"), null},

   584                 {new URL("http://www.test.com///"), null},

   585                 {new URL("http://www.test.com/image"),

   586                     new URL("http://www.test.com/image@2x")},

   587                 {new URL("http://www.test.com/image.ext"),

   588                     new URL("http://www.test.com/image@2x.ext")},

   589                 {new URL("http://www.test.com/dir/image"),

   590                     new URL("http://www.test.com/dir/image@2x")},

   591                 {new URL("http://www.test.com:80/dir/image.aaa.ext"),

   592                     new URL("http://www.test.com:80/dir/image.aaa@2x.ext")},

   593                 {new URL("http://www.test.com:8080/dir/image.aaa.ext"),

   594                     new URL("http://www.test.com:8080/dir/image.aaa@2x.ext")},

   595                 // jar

   596                 {new URL("jar:file:/dir/Java2D.jar!/image"),

   597                     new URL("jar:file:/dir/Java2D.jar!/image@2x")},

   598                 {new URL("jar:file:/dir/Java2D.jar!/image.aaa.ext"),

   599                     new URL("jar:file:/dir/Java2D.jar!/image.aaa@2x.ext")},

   600                 {new URL("jar:file:/dir/Java2D.jar!/images/image"),

   601                     new URL("jar:file:/dir/Java2D.jar!/images/image@2x")},

   602                 {new URL("jar:file:/dir/Java2D.jar!/images/image.ext"),

   603                     new URL("jar:file:/dir/Java2D.jar!/images/image@2x.ext")},

   604                 {new URL("jar:file:/aaa.bbb/Java2D.jar!/images/image.ext"),

   605                     new URL("jar:file:/aaa.bbb/Java2D.jar!/images/image@2x.ext")},

   606                 {new URL("jar:file:/dir/Java2D.jar!/aaa.bbb/image.ext"),

   607                     new URL("jar:file:/dir/Java2D.jar!/aaa.bbb/image@2x.ext")},};

   608         } catch (Exception e) {

   609             throw new RuntimeException(e);

   610         }

   611     }

   612 

   613     static class PreloadedImageObserver implements ImageObserver {

   614 

   615         @Override

   616         public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {

   617             throw new RuntimeException("Image should be already preloaded");

   618         }

   619     }

   620 }