Add ImageTypeDetector's stream overload

DEVSIX-5172

Author: ars18wrw

io/src/main/java/com/itextpdf/io/image/ImageTypeDetector.java

@@ -49,7 +49,8 @@ private ImageTypeDetector() {
     }
 
     /**
-     * Detect image type by magic bytes given the byte array source
+     * Detect image type by magic bytes given the byte array source.
+     *
      * @param source image bytes
      * @return detected image type, see{@link ImageType}. Returns {@link ImageType#NONE} if image type is unknown
      */
@@ -59,7 +60,8 @@ public static ImageType detectImageType(byte[] source) {
     }
 
     /**
-     * Detect image type by magic bytes given the source URL
+     * Detect image type by magic bytes given the source URL.
+     *
      * @param source image URL
      * @return detected image type, see{@link ImageType}. Returns {@link ImageType#NONE} if image type is unknown
      */
@@ -68,6 +70,17 @@ public static ImageType detectImageType(URL source) {
         return detectImageTypeByHeader(header);
     }
 
+    /**
+     * Detect image type by magic bytes given the input stream.
+     *
+     * @param stream image stream
+     * @return detected image type, see{@link ImageType}. Returns {@link ImageType#NONE} if image type is unknown
+     */
+    public static ImageType detectImageType(InputStream stream) {
+        byte[] header = readImageType(stream);
+        return detectImageTypeByHeader(header);
+    }
+
     private static ImageType detectImageTypeByHeader(byte[] header) {
         if (imageTypeIs(header, gif)) {
             return ImageType.GIF;
@@ -99,6 +112,14 @@ private static boolean imageTypeIs(byte[] imageType, byte[] compareWith) {
 
     private static byte[] readImageType(URL source) {
         try (InputStream stream = UrlUtil.openStream(source)) {
+            return readImageType(stream);
+        } catch (java.io.IOException e) {
+            throw new IOException(IOException.IoException, e);
+        }
+    }
+
+    private static byte[] readImageType(InputStream stream) {
+        try {
             byte[] bytes = new byte[8];
             stream.read(bytes);
             return bytes;

io/src/test/java/com/itextpdf/io/image/ImageTypeDetectorTest.java

@@ -22,49 +22,145 @@ This file is part of the iText (R) project.
  */
 package com.itextpdf.io.image;
 
+import com.itextpdf.io.util.StreamUtil;
 import com.itextpdf.io.util.UrlUtil;
 import com.itextpdf.test.ExtendedITextTest;
 import com.itextpdf.test.annotations.type.UnitTest;
 
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
 import java.net.MalformedURLException;
 import java.net.URL;
 import org.junit.Assert;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
+import org.junit.rules.ExpectedException;
 
 @Category(UnitTest.class)
 public class ImageTypeDetectorTest extends ExtendedITextTest {
 
     private static final String SOURCE_FOLDER = "./src/test/resources/com/itextpdf/io/image/ImageTypeDetectorTest/";
     private static final String IMAGE_NAME = "image";
 
+    @Rule
+    public ExpectedException junitExpectedException = ExpectedException.none();
+
+    @Test
+    public void testUrlUnknown() throws MalformedURLException {
+        testURL(UrlUtil.toURL(SOURCE_FOLDER + IMAGE_NAME + ".txt"), ImageType.NONE);
+    }
+
+    @Test
+    public void testUrlGif() throws MalformedURLException {
+        testURL(UrlUtil.toURL(SOURCE_FOLDER + IMAGE_NAME + ".gif"), ImageType.GIF);
+    }
+
+    @Test
+    public void testUrlJpeg() throws MalformedURLException {
+        testURL(UrlUtil.toURL(SOURCE_FOLDER + IMAGE_NAME + ".jpg"), ImageType.JPEG);
+    }
+
+    @Test
+    public void testUrlTiff() throws MalformedURLException {
+        testURL(UrlUtil.toURL(SOURCE_FOLDER + IMAGE_NAME + ".tiff"), ImageType.TIFF);
+    }
+
+    @Test
+    public void testUrlWmf() throws MalformedURLException {
+        testURL(UrlUtil.toURL(SOURCE_FOLDER + IMAGE_NAME + ".wmf"), ImageType.WMF);
+    }
+
+    @Test
+    public void testNullUrl() throws MalformedURLException {
+        junitExpectedException.expect(com.itextpdf.io.IOException.class);
+
+        ImageTypeDetector.detectImageType(UrlUtil.toURL("not existing path"));
+
+        Assert.fail("This line is not expected to be triggered: "
+                + "an exception should have been thrown");
+    }
+
+    @Test
+    public void testStreamUnknown() throws FileNotFoundException {
+        testStream(new FileInputStream(SOURCE_FOLDER + IMAGE_NAME + ".txt"), ImageType.NONE);
+    }
+
+    @Test
+    public void testStreamGif() throws FileNotFoundException {
+        testStream(new FileInputStream(SOURCE_FOLDER + IMAGE_NAME + ".gif"), ImageType.GIF);
+    }
+
+    @Test
+    public void testStreamJpeg() throws FileNotFoundException {
+        testStream(new FileInputStream(SOURCE_FOLDER + IMAGE_NAME + ".jpg"), ImageType.JPEG);
+    }
+
+    @Test
+    public void testStreamTiff() throws FileNotFoundException {
+        testStream(new FileInputStream(SOURCE_FOLDER + IMAGE_NAME + ".tiff"), ImageType.TIFF);
+    }
+
     @Test
-    public void testUnknown() throws MalformedURLException {
-        test(UrlUtil.toURL(SOURCE_FOLDER + IMAGE_NAME + ".txt"), ImageType.NONE);
+    public void testStreamWmf() throws FileNotFoundException {
+        testStream(new FileInputStream(SOURCE_FOLDER + IMAGE_NAME + ".wmf"), ImageType.WMF);
     }
 
     @Test
-    public void testGif() throws MalformedURLException {
-        test(UrlUtil.toURL(SOURCE_FOLDER + IMAGE_NAME + ".gif"), ImageType.GIF);
+    public void testStreamClosed() throws IOException {
+        // A common exception is expected instead of com.itextpdf.io.IOException, because in .NET
+        // the thrown exception is different
+        junitExpectedException.expect(Exception.class);
+
+        InputStream stream = new FileInputStream(SOURCE_FOLDER + IMAGE_NAME + ".wmf");
+        stream.close();
+        ImageTypeDetector.detectImageType(stream);
+
+        Assert.fail("This line is not expected to be triggered: "
+                + "an exception should have been thrown");
+    }
+
+    @Test
+    public void testBytesUnknown() throws IOException {
+        testBytes(StreamUtil.inputStreamToArray(new FileInputStream(SOURCE_FOLDER + IMAGE_NAME + ".txt")),
+                ImageType.NONE);
     }
 
     @Test
-    public void testJpeg() throws MalformedURLException {
-        test(UrlUtil.toURL(SOURCE_FOLDER + IMAGE_NAME + ".jpg"), ImageType.JPEG);
+    public void testBytesGif() throws IOException {
+        testBytes(StreamUtil.inputStreamToArray(new FileInputStream(SOURCE_FOLDER + IMAGE_NAME + ".gif")),
+                ImageType.GIF);
     }
 
     @Test
-    public void testTiff() throws MalformedURLException {
-        test(UrlUtil.toURL(SOURCE_FOLDER + IMAGE_NAME + ".tiff"), ImageType.TIFF);
+    public void testBytesJpeg() throws IOException {
+        testBytes(StreamUtil.inputStreamToArray(new FileInputStream(SOURCE_FOLDER + IMAGE_NAME + ".jpg")),
+                ImageType.JPEG);
     }
 
     @Test
-    public void testWmf() throws MalformedURLException {
-        test(UrlUtil.toURL(SOURCE_FOLDER + IMAGE_NAME + ".wmf"), ImageType.WMF);
+    public void testBytesTiff() throws IOException {
+        testBytes(StreamUtil.inputStreamToArray(new FileInputStream(SOURCE_FOLDER + IMAGE_NAME + ".tiff")),
+                ImageType.TIFF);
     }
 
-    private void test(URL location, ImageType expectedType) {
+    @Test
+    public void testBytesWmf() throws IOException {
+        testBytes(StreamUtil.inputStreamToArray(new FileInputStream(SOURCE_FOLDER + IMAGE_NAME + ".wmf")),
+                ImageType.WMF);
+    }
+
+    private static void testURL(URL location, ImageType expectedType) {
         Assert.assertEquals(expectedType, ImageTypeDetector.detectImageType(location));
     }
 
+    private static void testStream(InputStream stream, ImageType expectedType) {
+        Assert.assertEquals(expectedType, ImageTypeDetector.detectImageType(stream));
+    }
+
+    private static void testBytes(byte[] bytes, ImageType expectedType) {
+        Assert.assertEquals(expectedType, ImageTypeDetector.detectImageType(bytes));
+    }
 }