sis-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From desruisse...@apache.org
Subject svn commit: r1576309 - /sis/branches/JDK7/storage/sis-storage/src/test/java/org/apache/sis/internal/storage/ImageInputStreamComparator.java
Date Tue, 11 Mar 2014 12:32:31 GMT
Author: desruisseaux
Date: Tue Mar 11 12:32:31 2014
New Revision: 1576309

URL: http://svn.apache.org/r1576309
Log:
Added a debugging tool.

Added:
    sis/branches/JDK7/storage/sis-storage/src/test/java/org/apache/sis/internal/storage/ImageInputStreamComparator.java
  (with props)

Added: sis/branches/JDK7/storage/sis-storage/src/test/java/org/apache/sis/internal/storage/ImageInputStreamComparator.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK7/storage/sis-storage/src/test/java/org/apache/sis/internal/storage/ImageInputStreamComparator.java?rev=1576309&view=auto
==============================================================================
--- sis/branches/JDK7/storage/sis-storage/src/test/java/org/apache/sis/internal/storage/ImageInputStreamComparator.java
(added)
+++ sis/branches/JDK7/storage/sis-storage/src/test/java/org/apache/sis/internal/storage/ImageInputStreamComparator.java
[UTF-8] Tue Mar 11 12:32:31 2014
@@ -0,0 +1,427 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.sis.internal.storage;
+
+import java.util.Arrays;
+import java.io.IOException;
+import java.nio.ByteOrder;
+import javax.imageio.stream.IIOByteBuffer;
+import javax.imageio.stream.ImageInputStream;
+
+import static org.junit.Assert.*;
+
+
+/**
+ * Compares the result of two {@link ImageInputStream} instances. This class is used for
comparing
+ * {@link ChannelImageInputStream} with the JDK implementation, where the JDK's one is used
as the
+ * reference implementation.
+ *
+ * <p><b>This class is provided for debugging purpose only.</b> This class
can not be used in test
+ * suite because it checks for identical behavior between the two input streams, which is
usually
+ * a too strong requirement. For example two streams may read a different amount of bytes
in a call
+ * to {@link #read(byte[])} and still be compliant with their contract.</p>
+ *
+ * @author  Rémi Maréchal (Geomatys)
+ * @author  Martin Desruisseaux (Geomatys)
+ * @since   0.4
+ * @version 0.4
+ * @module
+ */
+public class ImageInputStreamComparator implements ImageInputStream {
+    /**
+     * The reference implementation ("expected") and the tested ("actual") input streams.
+     */
+    private final ImageInputStream expected, actual;
+
+    /**
+     * Creates a new comparator for the given input streams.
+     *
+     * @param expected The stream used as a reference implementation.
+     * @param actual   The stream to compare against the reference implementation.
+     */
+    public ImageInputStreamComparator(final ImageInputStream expected, final ImageInputStream
actual) {
+        this.expected = expected;
+        this.actual   = actual;
+    }
+
+    /**
+     * Forwards the call to the two streams.
+     *
+     * @param byteOrder The byte order to set.
+     */
+    @Override
+    public void setByteOrder(final ByteOrder byteOrder) {
+        expected.setByteOrder(byteOrder);
+        actual  .setByteOrder(byteOrder);
+    }
+
+    /**
+     * Forwards the call to the two streams and ensures that they return identical results.
+     *
+     * @return The result of the forwarded call.
+     */
+    @Override
+    public ByteOrder getByteOrder() {
+        final ByteOrder r = expected.getByteOrder();
+        assertEquals(r, actual.getByteOrder());
+        return r;
+    }
+
+    /**
+     * Forwards the call to the two streams and ensures that they return identical results.
+     *
+     * @return The result of the forwarded call.
+     * @throws IOException if any of the two streams failed to perform the operation.
+     */
+    @Override
+    public int read() throws IOException {
+        final int r = expected.read();
+        assertEquals(r, actual.read());
+        return r;
+    }
+
+    /**
+     * Forwards the call to the two streams and ensures that they return identical results,
+     * <strong>without tolerance for normally allowed differences</strong>.
+     * This method requires that the two streams read an identical amount of bytes,
+     * despite the method contract allowing a different amount of bytes to be read.
+     *
+     * @param  dest The destination array where to store the bytes read.
+     * @return The result of the forwarded call.
+     * @throws IOException if any of the two streams failed to perform the operation.
+     */
+    @Override
+    public int read(final byte[] dest) throws IOException {
+        final byte[] copy = dest.clone();
+        final int r = expected.read(dest);
+        assertEquals(r, actual.read(copy));
+        assertArrayEquals(dest, copy);
+        return r;
+    }
+
+    @Override
+    public int read(final byte[] dest, final int offset, final int length) throws IOException
{
+        final byte[] copy = dest.clone();
+        final int r = expected.read(dest, offset, length);
+        assertEquals(r, actual.read(copy, offset, length));
+        final boolean subRange = (offset != 0) || (length != dest.length);
+        assertArrayEquals(subRange ? Arrays.copyOfRange(dest, offset, offset + length) :
dest,
+                          subRange ? Arrays.copyOfRange(copy, offset, offset + length) :
copy);
+        return r;
+    }
+
+    @Override
+    public void readBytes(final IIOByteBuffer dest, final int n) throws IOException {
+        final IIOByteBuffer copy = new IIOByteBuffer(dest.getData().clone(), dest.getOffset(),
dest.getLength());
+        expected.readBytes(dest, n);
+        actual  .readBytes(copy,   n);
+        final int offset = dest.getOffset();
+        final int length = dest.getLength();
+        assertEquals("offset", offset, copy.getOffset());
+        assertEquals("length", length, copy.getLength());
+        assertArrayEquals(Arrays.copyOfRange(dest.getData(), offset, offset + length),
+                          Arrays.copyOfRange(copy.getData(), offset, offset + length));
+    }
+
+    @Override
+    public boolean readBoolean() throws IOException {
+        final boolean r = expected.readBoolean();
+        assertEquals(r, actual.readBoolean());
+        return r;
+    }
+
+    @Override
+    public byte readByte() throws IOException {
+        final byte r = expected.readByte();
+        assertEquals(r, actual.readByte());
+        return r;
+    }
+
+    @Override
+    public int readUnsignedByte() throws IOException {
+        final int r = expected.readUnsignedByte();
+        assertEquals(r, actual.readUnsignedByte());
+        return r;
+    }
+
+    @Override
+    public short readShort() throws IOException {
+        final short r = expected.readShort();
+        assertEquals(r, actual.readShort());
+        return r;
+    }
+
+    @Override
+    public int readUnsignedShort() throws IOException {
+        final int r = expected.readUnsignedShort();
+        assertEquals(r, actual.readUnsignedShort());
+        return r;
+    }
+
+    @Override
+    public char readChar() throws IOException {
+        final char r = expected.readChar();
+        assertEquals(r, actual.readChar());
+        return r;
+    }
+
+    @Override
+    public int readInt() throws IOException {
+        final int r = expected.readInt();
+        assertEquals(r, actual.readInt());
+        return r;
+    }
+
+    @Override
+    public long readUnsignedInt() throws IOException {
+        final long r = expected.readUnsignedInt();
+        assertEquals(r, actual.readUnsignedInt());
+        return r;
+    }
+
+    @Override
+    public long readLong() throws IOException {
+        final long r = expected.readLong();
+        assertEquals(r, actual.readLong());
+        return r;
+    }
+
+    @Override
+    public float readFloat() throws IOException {
+        final float r = expected.readFloat();
+        assertEquals(r, actual.readFloat(), 0f);
+        return r;
+    }
+
+    @Override
+    public double readDouble() throws IOException {
+        final double r = expected.readDouble();
+        assertEquals(r, actual.readDouble(), 0d);
+        return r;
+    }
+
+    @Override
+    public String readLine() throws IOException {
+        final String r = expected.readLine();
+        assertEquals(r, actual.readLine());
+        return r;
+    }
+
+    @Override
+    public String readUTF() throws IOException {
+        final String r = expected.readUTF();
+        assertEquals(r, actual.readUTF());
+        return r;
+    }
+
+    @Override
+    public void readFully(final byte[] dest) throws IOException {
+        final byte[] copy = dest.clone();
+        expected.readFully(dest);
+        actual.readFully(copy);
+        assertArrayEquals(dest, copy);
+    }
+
+    @Override
+    public void readFully(final byte[] dest, final int offset, final int length) throws IOException
{
+        final byte[] copy = dest.clone();
+        expected.readFully(dest, offset, length);
+        actual  .readFully(copy, offset, length);
+        final boolean subRange = (offset != 0) || (length != dest.length);
+        assertArrayEquals(subRange ? Arrays.copyOfRange(dest, offset, offset + length) :
dest,
+                          subRange ? Arrays.copyOfRange(copy, offset, offset + length) :
copy);
+    }
+
+    @Override
+    public void readFully(final short[] dest, final int offset, final int length) throws
IOException {
+        final short[] copy = dest.clone();
+        expected.readFully(dest, offset, length);
+        actual  .readFully(copy, offset, length);
+        final boolean subRange = (offset != 0) || (length != dest.length);
+        assertArrayEquals(subRange ? Arrays.copyOfRange(dest, offset, offset + length) :
dest,
+                          subRange ? Arrays.copyOfRange(copy, offset, offset + length) :
copy);
+    }
+
+    @Override
+    public void readFully(final char[] dest, final int offset, final int length) throws IOException
{
+        final char[] copy = dest.clone();
+        expected.readFully(dest, offset, length);
+        actual  .readFully(copy, offset, length);
+        final boolean subRange = (offset != 0) || (length != dest.length);
+        assertArrayEquals(subRange ? Arrays.copyOfRange(dest, offset, offset + length) :
dest,
+                          subRange ? Arrays.copyOfRange(copy, offset, offset + length) :
copy);
+    }
+
+    @Override
+    public void readFully(final int[] dest, final int offset, final int length) throws IOException
{
+        final int[] copy = dest.clone();
+        expected.readFully(dest, offset, length);
+        actual  .readFully(copy, offset, length);
+        final boolean subRange = (offset != 0) || (length != dest.length);
+        assertArrayEquals(subRange ? Arrays.copyOfRange(dest, offset, offset + length) :
dest,
+                          subRange ? Arrays.copyOfRange(copy, offset, offset + length) :
copy);
+    }
+
+    @Override
+    public void readFully(final long[] dest, final int offset, final int length) throws IOException
{
+        final long[] copy = dest.clone();
+        expected.readFully(dest, offset, length);
+        actual  .readFully(copy, offset, length);
+        final boolean subRange = (offset != 0) || (length != dest.length);
+        assertArrayEquals(subRange ? Arrays.copyOfRange(dest, offset, offset + length) :
dest,
+                          subRange ? Arrays.copyOfRange(copy, offset, offset + length) :
copy);
+    }
+
+    @Override
+    public void readFully(final float[] dest, final int offset, final int length) throws
IOException {
+        final float[] copy = dest.clone();
+        expected.readFully(dest, offset, length);
+        actual  .readFully(copy, offset, length);
+        final boolean subRange = (offset != 0) || (length != dest.length);
+        assertArrayEquals(subRange ? Arrays.copyOfRange(dest, offset, offset + length) :
dest,
+                          subRange ? Arrays.copyOfRange(copy, offset, offset + length) :
copy, 0f);
+    }
+
+    @Override
+    public void readFully(final double[] dest, final int offset, final int length) throws
IOException {
+        final double[] copy = dest.clone();
+        expected.readFully(dest, offset, length);
+        actual  .readFully(copy, offset, length);
+        final boolean subRange = (offset != 0) || (length != dest.length);
+        assertArrayEquals(subRange ? Arrays.copyOfRange(dest, offset, offset + length) :
dest,
+                          subRange ? Arrays.copyOfRange(copy, offset, offset + length) :
copy, 0d);
+    }
+
+    @Override
+    public long getStreamPosition() throws IOException {
+        final long r = expected.getStreamPosition();
+        assertEquals(r, actual.getStreamPosition());
+        return r;
+    }
+
+    @Override
+    public int getBitOffset() throws IOException {
+        final int r = expected.getBitOffset();
+        assertEquals(r, actual.getBitOffset());
+        return r;
+    }
+
+    @Override
+    public void setBitOffset(int bitOffset) throws IOException {
+        expected.setBitOffset(bitOffset);
+        actual  .setBitOffset(bitOffset);
+    }
+
+    @Override
+    public int readBit() throws IOException {
+        final int r = expected.readBit();
+        assertEquals(r, actual.readBit());
+        return r;
+    }
+
+    @Override
+    public long readBits(final int numBits) throws IOException {
+        final long r = expected.readBits(numBits);
+        assertEquals(r, actual.readBits(numBits));
+        return r;
+    }
+
+    @Override
+    public long length() throws IOException {
+        final long r = expected.length();
+        assertEquals(r, actual.length());
+        return r;
+    }
+
+    @Override
+    public int skipBytes(final int n) throws IOException {
+        final int r = expected.skipBytes(n);
+        assertEquals(r, actual.skipBytes(n));
+        return r;
+    }
+
+    @Override
+    public long skipBytes(long n) throws IOException {
+        final long r = expected.skipBytes(n);
+        assertEquals(r, actual.skipBytes(n));
+        return r;
+    }
+
+    @Override
+    public void seek(long pos) throws IOException {
+        expected.seek(pos);
+        actual  .seek(pos);
+    }
+
+    @Override
+    public void mark() {
+        expected.mark();
+        actual  .mark();
+    }
+
+    @Override
+    public void reset() throws IOException {
+        expected.reset();
+        actual  .reset();
+    }
+
+    @Override
+    public void flushBefore(final long position) throws IOException {
+        expected.flushBefore(position);
+        actual  .flushBefore(position);
+    }
+
+    @Override
+    public void flush() throws IOException {
+        expected.flush();
+        actual  .flush();
+    }
+
+    @Override
+    public long getFlushedPosition() {
+        final long r = expected.getFlushedPosition();
+        assertEquals(r, actual.getFlushedPosition());
+        return r;
+    }
+
+    @Override
+    public boolean isCached() {
+        final boolean r = expected.isCached();
+        assertEquals(r, actual.isCached());
+        return r;
+    }
+
+    @Override
+    public boolean isCachedMemory() {
+        final boolean r = expected.isCachedMemory();
+        assertEquals(r, actual.isCachedMemory());
+        return r;
+    }
+
+    @Override
+    public boolean isCachedFile() {
+        final boolean r =  expected.isCachedFile();
+        assertEquals(r, actual.isCachedFile());
+        return r;
+    }
+
+    @Override
+    public void close() throws IOException {
+        expected.close();
+        actual  .close();
+    }
+}

Propchange: sis/branches/JDK7/storage/sis-storage/src/test/java/org/apache/sis/internal/storage/ImageInputStreamComparator.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: sis/branches/JDK7/storage/sis-storage/src/test/java/org/apache/sis/internal/storage/ImageInputStreamComparator.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain;charset=UTF-8



Mime
View raw message