sis-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From desruisse...@apache.org
Subject svn commit: r1422779 - in /sis/branches/JDK7: sis-referencing/src/test/java/org/apache/sis/geometry/ sis-referencing/src/test/java/org/apache/sis/referencing/ sis-utility/src/test/java/org/apache/sis/math/ sis-utility/src/test/java/org/apache/sis/test/
Date Mon, 17 Dec 2012 07:52:56 GMT
Author: desruisseaux
Date: Mon Dec 17 07:52:55 2012
New Revision: 1422779

URL: http://svn.apache.org/viewvc?rev=1422779&view=rev
Log:
Ported AbstractEnvelopeTest.
Some tests are disabled for now because we need a CRS:84 implementation to enable them.

Added:
    sis/branches/JDK7/sis-referencing/src/test/java/org/apache/sis/geometry/AbstractEnvelopeTest.java   (with props)
    sis/branches/JDK7/sis-referencing/src/test/java/org/apache/sis/referencing/
    sis/branches/JDK7/sis-referencing/src/test/java/org/apache/sis/referencing/Assert.java
      - copied, changed from r1422657, sis/branches/JDK7/sis-utility/src/test/java/org/apache/sis/test/Assert.java
Modified:
    sis/branches/JDK7/sis-utility/src/test/java/org/apache/sis/math/MathFunctionsTest.java
    sis/branches/JDK7/sis-utility/src/test/java/org/apache/sis/test/Assert.java

Added: sis/branches/JDK7/sis-referencing/src/test/java/org/apache/sis/geometry/AbstractEnvelopeTest.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK7/sis-referencing/src/test/java/org/apache/sis/geometry/AbstractEnvelopeTest.java?rev=1422779&view=auto
==============================================================================
--- sis/branches/JDK7/sis-referencing/src/test/java/org/apache/sis/geometry/AbstractEnvelopeTest.java (added)
+++ sis/branches/JDK7/sis-referencing/src/test/java/org/apache/sis/geometry/AbstractEnvelopeTest.java Mon Dec 17 07:52:55 2012
@@ -0,0 +1,385 @@
+/*
+ * 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.geometry;
+
+import java.awt.geom.Rectangle2D;
+import org.opengis.geometry.Envelope;
+import org.opengis.geometry.DirectPosition;
+import org.apache.sis.test.DependsOn;
+import org.apache.sis.test.TestCase;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static java.lang.Double.NaN;
+import static org.apache.sis.referencing.Assert.*;
+
+
+/**
+ * Tests the methods defined in the {@link AbstractEnvelope} class.
+ * Various implementations are used for each test.
+ *
+ * @author  Martin Desruisseaux (IRD, Geomatys)
+ * @since   0.3 (derived from geotk-3.20)
+ * @version 0.3
+ * @module
+ */
+@DependsOn(GeneralDirectPositionTest.class)
+public final strictfp class AbstractEnvelopeTest extends TestCase {
+    /**
+     * Tolerance threshold for strict floating point comparisons.
+     */
+    private static final double STRICT = 0;
+
+    /**
+     * Enumeration of implementations to be tested.
+     * The {@code LAST} constant is for stopping the loops.
+     */
+    private static final int GENERAL=0, IMMUTABLE=1, RECTANGLE=2, LAST=3;
+
+    /**
+     * Creates an envelope of the given type. The type shall be one of the
+     * {@link #GENERAL}, {@link #IMMUTABLE} or {@link #RECTANGLE} constants.
+     */
+    private static Envelope create(final int type,
+            final double xmin, final double xmax,
+            final double ymin, final double ymax)
+    {
+        switch (type) {
+            case GENERAL: {
+                final GeneralEnvelope envelope = new GeneralEnvelope(2);
+                envelope.setRange(0, xmin, xmax);
+                envelope.setRange(1, ymin, ymax);
+                return envelope;
+            }
+            case IMMUTABLE: {
+                // TODO return new ImmutableEnvelope(xmin, xmax, ymin, ymax, null);
+            }
+            case RECTANGLE: {
+                return new Envelope2D(xmin, ymin, xmax - xmin, ymax - ymin, null);
+            }
+            default: throw new IllegalArgumentException(String.valueOf(type));
+        }
+    }
+
+    /**
+     * Tests the simple case (no anti-meridian crossing).
+     *
+     * {@preformat text
+     *     ┌─────────────┐
+     *     │  ┌───────┐  │
+     *     │  └───────┘  │
+     *     └─────────────┘
+     * }
+     */
+    @Test
+    public void testSimpleEnvelope() {
+        final DirectPosition2D inside  = new DirectPosition2D( 3, 32);
+        final DirectPosition2D outside = new DirectPosition2D(-5, 32);
+        final Envelope2D contained = (Envelope2D) create(RECTANGLE, -2, 10, 35, 40);
+        final Envelope2D intersect = (Envelope2D) create(RECTANGLE, -2, 16, 35, 40);
+        final Envelope2D disjoint  = (Envelope2D) create(RECTANGLE, 14, 16, 35, 40);
+        for (int type=0; type<LAST; type++) {
+            final String label = "Type " + type;
+            final Envelope envelope = create(type, -4, 12, 30, 50);
+            assertEquals(label, 30, envelope.getMinimum(1), STRICT);
+            assertEquals(label, 50, envelope.getMaximum(1), STRICT);
+            assertEquals(label, 40, envelope.getMedian (1), STRICT);
+            assertEquals(label, 20, envelope.getSpan   (1), STRICT);
+            assertEquals(label, -4, envelope.getMinimum(0), STRICT);
+            assertEquals(label, 12, envelope.getMaximum(0), STRICT);
+            assertEquals(label,  4, envelope.getMedian (0), STRICT);
+            assertEquals(label, 16, envelope.getSpan   (0), STRICT);
+            if (envelope instanceof AbstractEnvelope) {
+                final AbstractEnvelope ext = (AbstractEnvelope) envelope;
+                assertTrue (label, ext.contains  (inside));
+                assertFalse(label, ext.contains  (outside));
+                assertFalse(label, ext.contains  (intersect, false));
+                assertTrue (label, ext.intersects(intersect, false));
+                assertDisjoint(ext, disjoint);
+                assertContains(ext, contained);
+            }
+            if (envelope instanceof Rectangle2D) {
+                final Rectangle2D ext = (Rectangle2D) envelope;
+                assertTrue (label, ext.contains  (inside));
+                assertFalse(label, ext.contains  (outside));
+                assertFalse(label, ext.contains  (intersect));
+                assertTrue (label, ext.intersects(intersect));
+                assertDisjoint(ext, disjoint);
+                assertContains(ext, contained);
+            }
+        }
+    }
+
+    /**
+     * Tests a case crossing the anti-meridian.
+     *
+     * {@preformat text
+     *      ─────┐  ┌─────────              ─────┐      ┌─────
+     *           │  │  ┌────┐       or      ──┐  │      │  ┌──
+     *           │  │  └────┘               ──┘  │      │  └──
+     *      ─────┘  └─────────              ─────┘      └─────
+     * }
+     */
+    @Test
+    @Ignore("The tested envelope needs to be associated to CRS:84")
+    public void testCrossingAntiMeridian() {
+        final DirectPosition2D inside  = new DirectPosition2D(18, 32);
+        final DirectPosition2D outside = new DirectPosition2D( 3, 32);
+        final Envelope2D contained  = (Envelope2D) create(RECTANGLE, 14, 16, 35, 40);
+        final Envelope2D intersect  = (Envelope2D) create(RECTANGLE, -2, 16, 35, 40);
+        final Envelope2D disjoint   = (Envelope2D) create(RECTANGLE, -2, 10, 35, 40);
+        final Envelope2D spanning   = (Envelope2D) create(RECTANGLE, 16, -8, 35, 40);
+        for (int type=0; type<LAST; type++) {
+            final String label = "Type " + type;
+            final Envelope envelope = create(type, 12, -4, 30, 50);
+            final DirectPosition lower = envelope.getLowerCorner();
+            final DirectPosition upper = envelope.getUpperCorner();
+            assertEquals(label,   30, envelope.getMinimum (1), STRICT);
+            assertEquals(label,   50, envelope.getMaximum (1), STRICT);
+            assertEquals(label,   40, envelope.getMedian  (1), STRICT);
+            assertEquals(label,   20, envelope.getSpan    (1), STRICT);
+            assertEquals(label,   12, lower   .getOrdinate(0), STRICT);
+            assertEquals(label, -180, envelope.getMinimum (0), STRICT);
+            assertEquals(label,   -4, upper   .getOrdinate(0), STRICT);
+            assertEquals(label, +180, envelope.getMaximum (0), STRICT);
+            assertEquals(label, -176, envelope.getMedian  (0), STRICT);
+            assertEquals(label,  344, envelope.getSpan    (0), STRICT); // 360° - testSimpleEnvelope()
+            if (envelope instanceof AbstractEnvelope) {
+                final AbstractEnvelope ext = (AbstractEnvelope) envelope;
+                assertTrue (label, ext.contains  (inside));
+                assertFalse(label, ext.contains  (outside));
+                assertFalse(label, ext.contains  (intersect, false));
+                assertTrue (label, ext.intersects(intersect, false));
+                assertDisjoint(ext, disjoint);
+                assertContains(ext, contained);
+                assertContains(ext, spanning);
+            }
+            if (envelope instanceof Rectangle2D) {
+                final Rectangle2D ext = (Rectangle2D) envelope;
+                assertTrue (label, ext.contains  (inside));
+                assertFalse(label, ext.contains  (outside));
+                assertFalse(label, ext.contains  (intersect));
+                assertTrue (label, ext.intersects(intersect));
+                assertDisjoint(ext, disjoint);
+                assertContains(ext, contained);
+                assertContains(ext, spanning);
+            }
+        }
+    }
+
+    /**
+     * Tests a the anti-meridian case with a larger empty space
+     * on the left side.
+     *
+     * {@preformat text
+     *      ───┐    ┌─────────              ───┐      ┌─────
+     *         │    │  ┌────┐       or      ───┼──┐   │  ┌──
+     *         │    │  └────┘               ───┼──┘   │  └──
+     *      ───┘    └─────────              ───┘      └─────
+     * }
+     */
+    @Test
+    @Ignore("The tested envelope needs to be associated to CRS:84")
+    public void testCrossingAntiMeridianTwice() {
+        final DirectPosition2D inside  = new DirectPosition2D(18, 32);
+        final DirectPosition2D outside = new DirectPosition2D( 3, 32);
+        final Envelope2D contained  = (Envelope2D) create(RECTANGLE, 14, 16, 35, 40);
+        final Envelope2D intersect  = (Envelope2D) create(RECTANGLE, -2, 16, 35, 40);
+        final Envelope2D disjoint   = (Envelope2D) create(RECTANGLE, -2, 10, 35, 40);
+        final Envelope2D spanning   = (Envelope2D) create(RECTANGLE, 16, -8, 35, 40);
+        for (int type=0; type<LAST; type++) {
+            final String label = "Type " + type;
+            final Envelope envelope = create(type, 12, -364, 30, 50);
+            final DirectPosition lower = envelope.getLowerCorner();
+            final DirectPosition upper = envelope.getUpperCorner();
+            assertEquals(label,   30, envelope.getMinimum (1), STRICT);
+            assertEquals(label,   50, envelope.getMaximum (1), STRICT);
+            assertEquals(label,   40, envelope.getMedian  (1), STRICT);
+            assertEquals(label,   20, envelope.getSpan    (1), STRICT);
+            assertEquals(label,   12, lower   .getOrdinate(0), STRICT);
+            assertEquals(label, -180, envelope.getMinimum (0), STRICT);
+            assertEquals(label, -364, upper   .getOrdinate(0), STRICT);
+            assertEquals(label, +180, envelope.getMaximum (0), STRICT);
+            assertEquals(label,    4, envelope.getMedian  (0), STRICT); // Note the alternance with the previous test methods.
+            assertEquals(label,  NaN, envelope.getSpan    (0), STRICT); // testCrossingAntiMeridian() + 360°.
+            if (envelope instanceof AbstractEnvelope) {
+                final AbstractEnvelope ext = (AbstractEnvelope) envelope;
+                assertTrue (label, ext.contains  (inside));
+                assertFalse(label, ext.contains  (outside));
+                assertFalse(label, ext.contains  (intersect, false));
+                assertTrue (label, ext.intersects(intersect, false));
+                assertFalse(label, ext.contains  (spanning,  false));
+                assertTrue (label, ext.intersects(spanning,  false));
+                assertDisjoint(ext, disjoint);
+                assertContains(ext, contained);
+            }
+            if (envelope instanceof Rectangle2D) {
+                final Rectangle2D ext = (Rectangle2D) envelope;
+                assertTrue (label, ext.contains  (inside));
+                assertFalse(label, ext.contains  (outside));
+                assertFalse(label, ext.contains  (intersect));
+                assertTrue (label, ext.intersects(intersect));
+                assertFalse(label, ext.contains  (spanning));
+                assertTrue (label, ext.intersects(spanning));
+                assertDisjoint(ext, disjoint);
+                assertContains(ext, contained);
+            }
+        }
+    }
+
+    /**
+     * Tests a the anti-meridian case with a larger empty space
+     * on the left and right sides.
+     */
+    @Test
+    @Ignore("The tested envelope needs to be associated to CRS:84")
+    public void testCrossingAntiMeridianThreeTimes() {
+        final DirectPosition2D wasInside = new DirectPosition2D(18, 32);
+        final DirectPosition2D outside   = new DirectPosition2D( 3, 32);
+        final Envelope2D wasContained = (Envelope2D) create(RECTANGLE, 14, 16, 35, 40);
+        final Envelope2D wasIntersect = (Envelope2D) create(RECTANGLE, -2, 16, 35, 40);
+        final Envelope2D disjoint     = (Envelope2D) create(RECTANGLE, -2, 10, 35, 40);
+        final Envelope2D spanning     = (Envelope2D) create(RECTANGLE, 16, -8, 35, 40);
+        for (int type=0; type<LAST; type++) {
+            final String label = "Type " + type;
+            final Envelope envelope = create(type, 372, -364, 30, 50);
+            final DirectPosition lower = envelope.getLowerCorner();
+            final DirectPosition upper = envelope.getUpperCorner();
+            assertEquals(label,   30, envelope.getMinimum (1), STRICT);
+            assertEquals(label,   50, envelope.getMaximum (1), STRICT);
+            assertEquals(label,   40, envelope.getMedian  (1), STRICT);
+            assertEquals(label,   20, envelope.getSpan    (1), STRICT);
+            assertEquals(label,  372, lower   .getOrdinate(0), STRICT);
+            assertEquals(label, -180, envelope.getMinimum (0), STRICT);
+            assertEquals(label, -364, upper   .getOrdinate(0), STRICT);
+            assertEquals(label, +180, envelope.getMaximum (0), STRICT);
+            assertEquals(label, -176, envelope.getMedian  (0), STRICT); // Note the alternance with the previous test methods.
+            assertEquals(label,  NaN, envelope.getSpan    (0), STRICT); // testCrossingAntiMeridianTwice() + 360°.
+            if (envelope instanceof AbstractEnvelope) {
+                final AbstractEnvelope ext = (AbstractEnvelope) envelope;
+                assertFalse(label, ext.contains  (wasInside));
+                assertFalse(label, ext.contains  (outside));
+                assertFalse(label, ext.contains  (spanning,  false));
+                assertTrue (label, ext.intersects(spanning,  false));
+                assertDisjoint(ext, wasIntersect);
+                assertDisjoint(ext, disjoint);
+                assertDisjoint(ext, wasContained);
+            }
+            if (envelope instanceof Rectangle2D) {
+                final Rectangle2D ext = (Rectangle2D) envelope;
+                assertFalse(label, ext.contains  (wasInside));
+                assertFalse(label, ext.contains  (outside));
+                assertFalse(label, ext.contains  (spanning));
+                assertTrue (label, ext.intersects(spanning));
+                assertDisjoint(ext, wasIntersect);
+                assertDisjoint(ext, disjoint);
+                assertDisjoint(ext, wasContained);
+            }
+        }
+    }
+
+    /**
+     * Tests an empty envelope from -0 to 0°
+     */
+    @Test
+    public void testRange0() {
+        final DirectPosition2D wasInside = new DirectPosition2D(18, 32);
+        final DirectPosition2D outside   = new DirectPosition2D( 3, 32);
+        final Envelope2D wasContained = (Envelope2D) create(RECTANGLE, 14, 16, 35, 40);
+        final Envelope2D intersect    = (Envelope2D) create(RECTANGLE, -2, 16, 35, 40);
+        final Envelope2D spanning     = (Envelope2D) create(RECTANGLE, 16, -8, 35, 40);
+        for (int type=0; type<LAST; type++) {
+            final String label = "Type " + type;
+            final Envelope envelope = create(type, -0.0, 0.0, 30, 50);
+            assertEquals(label,   30, envelope.getMinimum(1), STRICT);
+            assertEquals(label,   50, envelope.getMaximum(1), STRICT);
+            assertEquals(label,   40, envelope.getMedian (1), STRICT);
+            assertEquals(label,   20, envelope.getSpan   (1), STRICT);
+            assertEquals(label, -0.0, envelope.getMinimum(0), STRICT);
+            assertEquals(label,  0.0, envelope.getMaximum(0), STRICT);
+            assertEquals(label,    0, envelope.getMedian (0), STRICT);
+            assertEquals(label,    0, envelope.getSpan   (0), STRICT);
+            if (envelope instanceof AbstractEnvelope) {
+                final AbstractEnvelope ext = (AbstractEnvelope) envelope;
+                assertFalse(label, ext.contains  (wasInside));
+                assertFalse(label, ext.contains  (outside));
+                assertFalse(label, ext.contains  (intersect, false));
+                assertTrue (label, ext.intersects(intersect, false));
+                assertFalse(label, ext.contains  (spanning,  false));
+                assertFalse(label, ext.intersects(spanning,  false));
+                assertFalse(label, ext.intersects(spanning,  false));
+                assertDisjoint(ext, wasContained);
+            }
+            if (envelope instanceof Rectangle2D) {
+                final Rectangle2D ext = (Rectangle2D) envelope;
+                assertFalse(label, ext.contains  (wasInside));
+                assertFalse(label, ext.contains  (outside));
+                assertFalse(label, ext.contains  (intersect));
+                assertTrue (label, ext.intersects(intersect));
+                assertFalse(label, ext.contains  (spanning));
+                assertFalse(label, ext.intersects(spanning));
+                assertFalse(label, ext.intersects(spanning));
+                assertDisjoint(ext, wasContained);
+            }
+        }
+    }
+
+    /**
+     * Tests a case crossing the anti-meridian crossing, from 0° to -0°.
+     */
+    @Test
+    @Ignore("The tested envelope needs to be associated to CRS:84")
+    public void testRange360() {
+        final DirectPosition2D inside     = new DirectPosition2D(18, 32);
+        final DirectPosition2D wasOutside = new DirectPosition2D( 3, 32);
+        final Envelope2D contained = (Envelope2D) create(RECTANGLE, 14, 16, 35, 40);
+        final Envelope2D intersect = (Envelope2D) create(RECTANGLE, -2, 16, 35, 40);
+        final Envelope2D spanning  = (Envelope2D) create(RECTANGLE, 16, -8, 35, 40);
+        for (int type=0; type<LAST; type++) {
+            final String label = "Type " + type;
+            final Envelope envelope = create(type, 0.0, -0.0, 30, 50);
+            final DirectPosition lower = envelope.getLowerCorner();
+            final DirectPosition upper = envelope.getUpperCorner();
+            assertEquals(label,   30, envelope.getMinimum (1), STRICT);
+            assertEquals(label,   50, envelope.getMaximum (1), STRICT);
+            assertEquals(label,   40, envelope.getMedian  (1), STRICT);
+            assertEquals(label,   20, envelope.getSpan    (1), STRICT);
+            assertEquals(label,  0.0, lower   .getOrdinate(0), STRICT);
+            assertEquals(label, -180, envelope.getMinimum (0), STRICT);
+            assertEquals(label, -0.0, upper   .getOrdinate(0), STRICT);
+            assertEquals(label, +180, envelope.getMaximum (0), STRICT);
+            assertEquals(label,  180, envelope.getMedian  (0), STRICT);
+            assertEquals(label,  360, envelope.getSpan    (0), STRICT);
+            if (envelope instanceof AbstractEnvelope) {
+                final AbstractEnvelope ext = (AbstractEnvelope) envelope;
+                assertTrue(label, ext.contains(inside));
+                assertTrue(label, ext.contains(wasOutside));
+                assertTrue(label, ext.intersects(intersect, false));
+                assertContains(ext, contained);
+                assertContains(ext, spanning);
+            }
+            if (envelope instanceof Rectangle2D) {
+                final Rectangle2D ext = (Rectangle2D) envelope;
+                assertTrue(label, ext.contains(inside));
+                assertTrue(label, ext.contains(wasOutside));
+                assertTrue(label, ext.intersects(intersect));
+                assertContains(ext, contained);
+                assertContains(ext, spanning);
+            }
+        }
+    }
+}

Propchange: sis/branches/JDK7/sis-referencing/src/test/java/org/apache/sis/geometry/AbstractEnvelopeTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: sis/branches/JDK7/sis-referencing/src/test/java/org/apache/sis/geometry/AbstractEnvelopeTest.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Copied: sis/branches/JDK7/sis-referencing/src/test/java/org/apache/sis/referencing/Assert.java (from r1422657, sis/branches/JDK7/sis-utility/src/test/java/org/apache/sis/test/Assert.java)
URL: http://svn.apache.org/viewvc/sis/branches/JDK7/sis-referencing/src/test/java/org/apache/sis/referencing/Assert.java?p2=sis/branches/JDK7/sis-referencing/src/test/java/org/apache/sis/referencing/Assert.java&p1=sis/branches/JDK7/sis-utility/src/test/java/org/apache/sis/test/Assert.java&r1=1422657&r2=1422779&rev=1422779&view=diff
==============================================================================
--- sis/branches/JDK7/sis-utility/src/test/java/org/apache/sis/test/Assert.java (original)
+++ sis/branches/JDK7/sis-referencing/src/test/java/org/apache/sis/referencing/Assert.java Mon Dec 17 07:52:55 2012
@@ -14,41 +14,34 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.apache.sis.test;
+package org.apache.sis.referencing;
 
-import java.util.Set;
-import java.util.Map;
-import java.util.Arrays;
-import java.util.Enumeration;
-import java.util.LinkedHashSet;
-import java.util.LinkedHashMap;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RectangularShape;
-import java.awt.image.RenderedImage;
-import javax.swing.tree.TreeNode;
-import javax.xml.parsers.ParserConfigurationException;
-import org.xml.sax.SAXException;
+import java.awt.geom.AffineTransform;
+import javax.measure.unit.Unit;
+import org.opengis.geometry.Envelope;
+import org.opengis.parameter.GeneralParameterValue;
+import org.opengis.parameter.ParameterDescriptor;
+import org.opengis.parameter.ParameterValue;
+import org.opengis.parameter.ParameterValueGroup;
+import org.opengis.referencing.operation.Matrix;
+import org.apache.sis.geometry.AbstractEnvelope;
+import org.apache.sis.geometry.GeneralDirectPosition;
 
-import org.apache.sis.util.CharSequences;
-
-// Related to JDK7
-import java.util.Objects;
+import static java.lang.StrictMath.*;
 
 
 /**
- * Assertion methods used by the SIS project in addition of the JUnit and GeoAPI assertions.
+ * Assertion methods used by the {@code sis-referencing} module in addition of the ones inherited
+ * from other modules and libraries.
  *
  * @author  Martin Desruisseaux (Geomatys)
  * @since   0.3 (derived from geotk-3.00)
  * @version 0.3
  * @module
  */
-public strictfp class Assert extends org.opengis.test.Assert {
+public strictfp class Assert extends org.apache.sis.test.Assert {
     /**
      * For subclass constructor only.
      */
@@ -56,194 +49,112 @@ public strictfp class Assert extends org
     }
 
     /**
-     * Asserts that two strings are equal, ignoring the differences in EOL characters.
-     * The comparisons is performed one a line-by-line basis. For each line, leading
-     * and trailing spaces are ignored in order to make the comparison independent of
-     * indentation.
-     *
-     * @param expected The expected string.
-     * @param actual   The actual string.
-     */
-    public static void assertMultilinesEquals(final CharSequence expected, final CharSequence actual) {
-        assertArrayEquals(CharSequences.split(expected, '\n'), CharSequences.split(actual, '\n'));
-    }
-
-    /**
-     * Asserts that two strings are equal, ignoring the differences in EOL characters.
-     * The comparisons is performed one a line-by-line basis. For each line, leading
-     * and trailing spaces are ignored in order to make the comparison independent of
-     * indentation.
-     *
-     * @param message  The message to print in case of failure, or {@code null} if none.
-     * @param expected The expected string.
-     * @param actual   The actual string.
-     */
-    public static void assertMultilinesEquals(final String message, final CharSequence expected, final CharSequence actual) {
-        assertArrayEquals(message, CharSequences.split(expected, '\n'), CharSequences.split(actual, '\n'));
-    }
-
-    /**
-     * Asserts that the given set contains the same elements.
-     * In case of failure, this method lists the missing or unexpected elements.
-     *
-     * @param expected The expected set, or {@code null}.
-     * @param actual   The actual set, or {@code null}.
+     * Asserts that the given parameter values are equal to the expected ones within
+     * a positive delta. Only the elements in the given descriptor are compared, and
+     * the comparisons are done in the units declared in the descriptor.
+     *
+     * @param expected  The expected parameter values.
+     * @param actual    The actual parameter values.
+     * @param tolerance The tolerance threshold for comparison of numerical values.
      */
-    public static void assertSetEquals(final Set<?> expected, final Set<?> actual) {
-        if (expected != null && actual != null && !expected.isEmpty()) {
-            final Set<Object> r = new LinkedHashSet<>(expected);
-            assertTrue("The two sets are disjoint.",                 r.removeAll(actual));
-            assertTrue("The set is missing elements: " + r,          r.isEmpty());
-            assertTrue("The set unexpectedly became empty.",         r.addAll(actual));
-            assertTrue("The two sets are disjoint.",                 r.removeAll(expected));
-            assertTrue("The set contains unexpected elements: " + r, r.isEmpty());
-        }
-        assertEquals("Set.equals(Object) failed:", expected, actual);
-    }
-
-    /**
-     * Asserts that the given map contains the same entries.
-     * In case of failure, this method lists the missing or unexpected entries.
-     *
-     * @param expected The expected map, or {@code null}.
-     * @param actual   The actual map, or {@code null}.
-     */
-    public static void assertMapEquals(final Map<?,?> expected, final Map<?,?> actual) {
-        if (expected != null && actual != null && !expected.isEmpty()) {
-            final Map<Object,Object> r = new LinkedHashMap<>(expected);
-            for (final Map.Entry<?,?> entry : actual.entrySet()) {
-                final Object key = entry.getKey();
-                if (!r.containsKey(key)) {
-                    fail("Unexpected entry for key " + key);
-                }
-                final Object ve = r.remove(key);
-                final Object va = entry.getValue();
-                if (!Objects.equals(ve, va)) {
-                    fail("Wrong value for key " + key + ": expected " + ve + " but got " + va);
-                }
-            }
-            if (!r.isEmpty()) {
-                fail("The map is missing entries: " + r);
-            }
-            r.putAll(actual);
-            for (final Map.Entry<?,?> entry : expected.entrySet()) {
-                final Object key = entry.getKey();
-                if (!r.containsKey(key)) {
-                    fail("Missing an entry for key " + key);
-                }
-                final Object ve = entry.getValue();
-                final Object va = r.remove(key);
-                if (!Objects.equals(ve, va)) {
-                    fail("Wrong value for key " + key + ": expected " + ve + " but got " + va);
-                }
+    public static void assertParameterEquals(final ParameterValueGroup expected,
+            final ParameterValueGroup actual, final double tolerance)
+    {
+        for (final GeneralParameterValue candidate : expected.values()) {
+            if (!(candidate instanceof ParameterValue<?>)) {
+                throw new UnsupportedOperationException("Not yet implemented.");
             }
-            if (!r.isEmpty()) {
-                fail("The map contains unexpected elements:" + r);
+            final ParameterValue<?> value = (ParameterValue<?>) candidate;
+            final ParameterDescriptor<?> descriptor = value.getDescriptor();
+            final String   name       = descriptor.getName().getCode();
+            final Unit<?>  unit       = descriptor.getUnit();
+            final Class<?> valueClass = descriptor.getValueClass();
+            final ParameterValue<?> e = expected.parameter(name);
+            final ParameterValue<?> a = actual  .parameter(name);
+            if (unit != null) {
+                final double f = e.doubleValue(unit);
+                assertEquals(name, f, a.doubleValue(unit), tolerance);
+            } else if (valueClass == Float.class || valueClass == Double.class) {
+                final double f = e.doubleValue();
+                assertEquals(name, f, a.doubleValue(), tolerance);
+            } else {
+                assertEquals(name, e.getValue(), a.getValue());
             }
         }
-        assertEquals("Map.equals(Object) failed:", expected, actual);
     }
 
     /**
-     * Ensures that a tree is equals to an other tree.
-     * This method invokes itself recursively for every child nodes.
-     *
-     * @param  expected The expected tree, or {@code null}.
-     * @param  actual   The tree to compare with the expected one, or {@code null}.
-     * @return The number of nodes.
+     * Asserts that the given matrix is diagonal, and that all elements on the diagonal are equal
+     * to the given values. The matrix doesn't need to be square. The last row is handled especially
+     * if the {@code affine} argument is {@code true}.
+     *
+     * @param expected  The values which are expected on the diagonal. If the length of this array
+     *                  is less than the matrix size, then the last element in the array is repeated
+     *                  for all remaining diagonal elements.
+     * @param affine    If {@code true}, then the last row is expected to contains the value 1
+     *                  in the last column, and all other columns set to 0.
+     * @param matrix    The matrix to test.
+     * @param tolerance The tolerance threshold while comparing floating point values.
      */
-    public static int assertTreeEquals(final TreeNode expected, final TreeNode actual) {
-        if (expected == null) {
-            assertNull(actual);
-            return 0;
-        }
-        int n = 1;
-        assertNotNull(actual);
-        assertEquals("isLeaf()",            expected.isLeaf(),            actual.isLeaf());
-        assertEquals("getAllowsChildren()", expected.getAllowsChildren(), actual.getAllowsChildren());
-        assertEquals("getChildCount()",     expected.getChildCount(),     actual.getChildCount());
-        @SuppressWarnings("unchecked") final Enumeration<? extends TreeNode> ec = expected.children();
-        @SuppressWarnings("unchecked") final Enumeration<? extends TreeNode> ac = actual  .children();
-
-        int childIndex = 0;
-        while (ec.hasMoreElements()) {
-            assertTrue("hasMoreElements()", ac.hasMoreElements());
-            final TreeNode nextExpected = ec.nextElement();
-            final TreeNode nextActual   = ac.nextElement();
-            final String message = "getChildAt(" + childIndex + ')';
-            assertSame(message, nextExpected, expected.getChildAt(childIndex));
-            assertSame(message, nextActual,   actual  .getChildAt(childIndex));
-            assertSame("getParent()", expected, nextExpected.getParent());
-            assertSame("getParent()", actual,   nextActual  .getParent());
-            assertSame("getIndex(TreeNode)", childIndex, expected.getIndex(nextExpected));
-            assertSame("getIndex(TreeNode)", childIndex, actual  .getIndex(nextActual));
-            n += assertTreeEquals(nextExpected, nextActual);
-            childIndex++;
+    public static void assertDiagonalEquals(final double[] expected, final boolean affine,
+            final Matrix matrix, final double tolerance)
+    {
+        final int numRows = matrix.getNumRow();
+        final int numCols = matrix.getNumCol();
+        final StringBuilder buffer = new StringBuilder("matrix(");
+        final int bufferBase = buffer.length();
+        for (int j=0; j<numRows; j++) {
+            for (int i=0; i<numCols; i++) {
+                final double e;
+                if (affine && j == numRows-1) {
+                    e = (i == numCols-1) ? 1 : 0;
+                } else if (i == j) {
+                    e = expected[min(expected.length-1, i)];
+                } else {
+                    e = 0;
+                }
+                buffer.setLength(bufferBase);
+                assertEquals(buffer.append(j).append(',').append(i).append(')').toString(),
+                        e, matrix.getElement(j, i), tolerance);
+            }
         }
-        assertFalse("hasMoreElements()", ac.hasMoreElements());
-        assertEquals("toString()", expected.toString(), actual.toString());
-        return n;
     }
 
     /**
-     * Parses two XML tree as DOM documents, and compares the nodes.
-     * The inputs given to this method can be any of the following types:
-     *
-     * <ul>
-     *   <li>{@link org.w3c.dom.Node}: used directly without further processing.</li>
-     *   <li>{@link java.io.File}, {@link java.net.URL} or {@link java.net.URI}: the
-     *       stream is opened and parsed as a XML document.</li>
-     *   <li>{@link String}: The string content is parsed directly as a XML document.
-     *       Encoding <strong>must</strong> be UTF-8 (no other encoding is supported
-     *       by current implementation of this method).</li>
-     * </ul>
-     *
-     * This method will ignore comments and the optional attributes given in arguments.
+     * Compares two affine transforms for equality.
      *
-     * @param  expected The expected XML document.
-     * @param  actual   The XML document to compare.
-     * @param  ignoredAttributes The fully-qualified names of attributes to ignore
-     *         (typically {@code "xmlns:*"} and {@code "xsi:schemaLocation"}).
-     *
-     * @see XMLComparator
-     */
-    public static void assertXmlEquals(final Object expected, final Object actual,
-            final String... ignoredAttributes)
-    {
-        assertXmlEquals(expected, actual, 0, ignoredAttributes);
+     * @param expected  The expected affine transform.
+     * @param actual    The actual affine transform.
+     * @param tolerance The tolerance threshold.
+     */
+    public static void assertTransformEquals(final AffineTransform expected, final AffineTransform actual, final double tolerance) {
+        assertEquals("scaleX",     expected.getScaleX(),     actual.getScaleX(),     tolerance);
+        assertEquals("scaleY",     expected.getScaleY(),     actual.getScaleY(),     tolerance);
+        assertEquals("shearX",     expected.getShearX(),     actual.getShearX(),     tolerance);
+        assertEquals("shearY",     expected.getShearY(),     actual.getShearY(),     tolerance);
+        assertEquals("translateX", expected.getTranslateX(), actual.getTranslateX(), tolerance);
+        assertEquals("translateY", expected.getTranslateY(), actual.getTranslateY(), tolerance);
     }
 
     /**
-     * Parses two XML tree as DOM documents, and compares the nodes with the given tolerance
-     * threshold for numerical values. The inputs given to this method can be any of the types
-     * documented {@linkplain #assertXmlEquals(Object, Object, String[]) above}. This method
-     * will ignore comments and the optional attributes given in arguments.
-     *
-     * @param  expected  The expected XML document.
-     * @param  actual    The XML document to compare.
-     * @param  tolerance The tolerance threshold for comparison of numerical values.
-     * @param  ignoredAttributes The fully-qualified names of attributes to ignore
-     *         (typically {@code "xmlns:*"} and {@code "xsi:schemaLocation"}).
+     * Asserts that two rectangles have the same location and the same size.
      *
-     * @see XMLComparator
+     * @param expected The expected rectangle.
+     * @param actual   The rectangle to compare with the expected one.
+     * @param tolx     The tolerance threshold on location along the <var>x</var> axis.
+     * @param toly     The tolerance threshold on location along the <var>y</var> axis.
      */
-    public static void assertXmlEquals(final Object expected, final Object actual,
-            final double tolerance, final String... ignoredAttributes)
+    public static void assertRectangleEquals(final RectangularShape expected,
+            final RectangularShape actual, final double tolx, final double toly)
     {
-        final XMLComparator comparator;
-        try {
-            comparator = new XMLComparator(expected, actual);
-        } catch (IOException | ParserConfigurationException | SAXException e) {
-            // We don't throw directly those exceptions since failing to parse the XML file can
-            // be considered as part of test failures and the JUnit exception for such failures
-            // is AssertionError. Having no checked exception in "assert" methods allow us to
-            // declare the checked exceptions only for the library code being tested.
-            throw new AssertionError(e);
-        }
-        comparator.tolerance = tolerance;
-        comparator.ignoreComments = true;
-        comparator.ignoredAttributes.addAll(Arrays.asList(ignoredAttributes));
-        comparator.compare();
+        assertEquals("Min X",    expected.getMinX(),    actual.getMinX(),    tolx);
+        assertEquals("Min Y",    expected.getMinY(),    actual.getMinY(),    toly);
+        assertEquals("Max X",    expected.getMaxX(),    actual.getMaxX(),    tolx);
+        assertEquals("Max Y",    expected.getMaxY(),    actual.getMaxY(),    toly);
+        assertEquals("Center X", expected.getCenterX(), actual.getCenterX(), tolx);
+        assertEquals("Center Y", expected.getCenterY(), actual.getCenterY(), toly);
+        assertEquals("Width",    expected.getWidth(),   actual.getWidth(),   tolx*2);
+        assertEquals("Height",   expected.getHeight(),  actual.getHeight(),  toly*2);
     }
 
     /**
@@ -269,6 +180,33 @@ public strictfp class Assert extends org
     }
 
     /**
+     * Tests if the given {@code outer} envelope contains the given {@code inner} envelope.
+     * This method will also verify class consistency by invoking the {@code intersects}
+     * method, and by interchanging the arguments.
+     *
+     * @param outer The envelope which is expected to contains the given inner envelope.
+     * @param inner The envelope which should be contained by the outer envelope.
+     */
+    public static void assertContains(final AbstractEnvelope outer, final Envelope inner) {
+        assertTrue("outer.contains(inner)",   outer.contains  (inner, true));
+        assertTrue("outer.contains(inner)",   outer.contains  (inner, false));
+        assertTrue("outer.intersects(inner)", outer.intersects(inner, true));
+        assertTrue("outer.intersects(inner)", outer.intersects(inner, false));
+        if (inner instanceof AbstractEnvelope) {
+            final AbstractEnvelope ai = (AbstractEnvelope) inner;
+            assertTrue ("inner.intersects(outer)", ai.intersects(outer, true));
+            assertTrue ("inner.intersects(outer)", ai.intersects(outer, false));
+            assertFalse("inner.contains(outer)",   ai.contains  (outer, true));
+            assertFalse("inner.contains(outer)",   ai.contains  (outer, false));
+        }
+        final GeneralDirectPosition median = new GeneralDirectPosition(inner.getDimension());
+        for (int i=median.getDimension(); --i>=0;) {
+            median.setOrdinate(i, inner.getMedian(i));
+        }
+        assertTrue("outer.contains(median)", outer.contains(median));
+    }
+
+    /**
      * Tests if the given {@code r1} shape is disjoint with the given {@code r2} rectangle.
      * This method will also verify class consistency by invoking the {@code contains}
      * method, and by interchanging the arguments.
@@ -305,75 +243,43 @@ public strictfp class Assert extends org
     }
 
     /**
-     * Asserts that two rectangles have the same location and the same size.
-     *
-     * @param expected The expected rectangle.
-     * @param actual   The rectangle to compare with the expected one.
-     * @param tolx     The tolerance threshold on location along the <var>x</var> axis.
-     * @param toly     The tolerance threshold on location along the <var>y</var> axis.
-     */
-    public static void assertRectangleEquals(final RectangularShape expected,
-            final RectangularShape actual, final double tolx, final double toly)
-    {
-        assertEquals("Min X",    expected.getMinX(),    actual.getMinX(),    tolx);
-        assertEquals("Min Y",    expected.getMinY(),    actual.getMinY(),    toly);
-        assertEquals("Max X",    expected.getMaxX(),    actual.getMaxX(),    tolx);
-        assertEquals("Max Y",    expected.getMaxY(),    actual.getMaxY(),    toly);
-        assertEquals("Center X", expected.getCenterX(), actual.getCenterX(), tolx);
-        assertEquals("Center Y", expected.getCenterY(), actual.getCenterY(), toly);
-        assertEquals("Width",    expected.getWidth(),   actual.getWidth(),   tolx*2);
-        assertEquals("Height",   expected.getHeight(),  actual.getHeight(),  toly*2);
-    }
-
-    /**
-     * Asserts that two images have the same origin and the same size.
-     *
-     * @param expected The image having the expected size.
-     * @param actual   The image to compare with the expected one.
-     */
-    public static void assertBoundEquals(final RenderedImage expected, final RenderedImage actual) {
-        assertEquals("Min X",  expected.getMinX(),   actual.getMinX());
-        assertEquals("Min Y",  expected.getMinY(),   actual.getMinY());
-        assertEquals("Width",  expected.getWidth(),  actual.getWidth());
-        assertEquals("Height", expected.getHeight(), actual.getHeight());
-    }
-
-    /**
-     * Serializes the given object in memory, deserialize it and ensures that the deserialized
-     * object is equals to the original one. This method doesn't write anything to the disk.
-     *
-     * <p>If the serialization fails, then this method thrown an {@link AssertionError}
-     * as do the other JUnit assertion methods.</p>
-     *
-     * @param  <T> The type of the object to serialize.
-     * @param  object The object to serialize.
-     * @return The deserialized object.
-     */
-    public static <T> T assertSerializedEquals(final T object) {
-        final Object deserialized;
-        try {
-            final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
-            try (ObjectOutputStream out = new ObjectOutputStream(buffer)) {
-                out.writeObject(object);
-            }
-            // Now reads the object we just serialized.
-            final byte[] data = buffer.toByteArray();
-            try (ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(data))) {
-                try {
-                    deserialized = in.readObject();
-                } catch (ClassNotFoundException e) {
-                    throw new AssertionError(e);
+     * Tests if the given {@code e1} envelope is disjoint with the given {@code e2} envelope.
+     * This method will also verify class consistency by invoking the {@code contains} method,
+     * and by interchanging the arguments.
+     *
+     * @param e1 The first envelope to test.
+     * @param e2 The second envelope to test.
+     */
+    public static void assertDisjoint(final AbstractEnvelope e1, final Envelope e2) {
+        assertFalse("e1.intersects(e2)", e1.intersects(e2, false));
+        assertFalse("e1.intersects(e2)", e1.intersects(e2, true));
+        assertFalse("e1.contains(e2)",   e1.contains  (e2, false));
+        assertFalse("e1.contains(e2)",   e1.contains  (e2, true));
+        if (e2 instanceof AbstractEnvelope) {
+            final AbstractEnvelope ae = (AbstractEnvelope) e2;
+            assertFalse("e2.intersects(e1)", ae.intersects(e1, false));
+            assertFalse("e2.intersects(e1)", ae.intersects(e1, true));
+            assertFalse("e2.contains(e1)",   ae.contains  (e1, false));
+            assertFalse("e2.contains(e1)",   ae.contains  (e1, true));
+        }
+        final int dimension = e1.getDimension();
+        final int numCases = (int) round(pow(3, dimension));
+        final GeneralDirectPosition pos = new GeneralDirectPosition(dimension);
+        for (int index=0; index<numCases; index++) {
+            int n = index;
+            for (int i=0; i<dimension; i++) {
+                final double ordinate;
+                switch (n % 3) {
+                    case 0: ordinate = e2.getMinimum(i); break;
+                    case 1: ordinate = e2.getMedian (i); break;
+                    case 2: ordinate = e2.getMaximum(i); break;
+                    default: throw new AssertionError(i);
                 }
+                pos.setOrdinate(i, ordinate);
+                n /= 3;
             }
-        } catch (IOException e) {
-            throw new AssertionError(e.toString(), e);
+            assertEquals(0, n); // Opportunist check of this assert method.
+            assertFalse("e1.contains(" + pos + ')', e1.contains(pos));
         }
-        // Compares with the original object and returns it.
-        @SuppressWarnings("unchecked")
-        final Class<? extends T> type = (Class<? extends T>) object.getClass();
-        assertEquals("Deserialized object not equal to the original one.", object, deserialized);
-        assertEquals("Deserialized object has a different hash code.",
-                object.hashCode(), deserialized.hashCode());
-        return type.cast(deserialized);
     }
 }

Modified: sis/branches/JDK7/sis-utility/src/test/java/org/apache/sis/math/MathFunctionsTest.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK7/sis-utility/src/test/java/org/apache/sis/math/MathFunctionsTest.java?rev=1422779&r1=1422778&r2=1422779&view=diff
==============================================================================
--- sis/branches/JDK7/sis-utility/src/test/java/org/apache/sis/math/MathFunctionsTest.java (original)
+++ sis/branches/JDK7/sis-utility/src/test/java/org/apache/sis/math/MathFunctionsTest.java Mon Dec 17 07:52:55 2012
@@ -153,7 +153,7 @@ public final strictfp class MathFunction
             final double y = atanh(x);
             switch (i) {
                 case -10: assertEquals(Double.NEGATIVE_INFINITY, y, EPS); break;
-                default:  assertEquals(x, Math.tanh(y),             EPS); break;
+                default:  assertEquals(x, StrictMath.tanh(y),       EPS); break;
                 case +10: assertEquals(Double.POSITIVE_INFINITY, y, EPS); break;
             }
         }

Modified: sis/branches/JDK7/sis-utility/src/test/java/org/apache/sis/test/Assert.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK7/sis-utility/src/test/java/org/apache/sis/test/Assert.java?rev=1422779&r1=1422778&r2=1422779&view=diff
==============================================================================
--- sis/branches/JDK7/sis-utility/src/test/java/org/apache/sis/test/Assert.java (original)
+++ sis/branches/JDK7/sis-utility/src/test/java/org/apache/sis/test/Assert.java Mon Dec 17 07:52:55 2012
@@ -27,14 +27,12 @@ import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
-import java.awt.geom.Rectangle2D;
-import java.awt.geom.RectangularShape;
-import java.awt.image.RenderedImage;
 import javax.swing.tree.TreeNode;
 import javax.xml.parsers.ParserConfigurationException;
 import org.xml.sax.SAXException;
-
+import org.apache.sis.util.Utilities;
 import org.apache.sis.util.CharSequences;
+import org.apache.sis.util.ComparisonMode;
 
 // Related to JDK7
 import java.util.Objects;
@@ -56,6 +54,52 @@ public strictfp class Assert extends org
     }
 
     /**
+     * Asserts that the two given objects are not equal.
+     * This method tests all {@link ComparisonMode} except {@code DEBUG}.
+     *
+     * @param o1  The first object.
+     * @param o2  The second object.
+     */
+    public static void assertNotDeepEquals(final Object o1, final Object o2) {
+        assertNotSame("same", o1, o2);
+        assertFalse("equals",                      Objects  .equals    (o1, o2));
+        assertFalse("deepEquals",                  Objects  .deepEquals(o1, o2));
+        assertFalse("deepEquals(STRICT)",          Utilities.deepEquals(o1, o2, ComparisonMode.STRICT));
+        assertFalse("deepEquals(BY_CONTRACT)",     Utilities.deepEquals(o1, o2, ComparisonMode.BY_CONTRACT));
+        assertFalse("deepEquals(IGNORE_METADATA)", Utilities.deepEquals(o1, o2, ComparisonMode.IGNORE_METADATA));
+        assertFalse("deepEquals(APPROXIMATIVE)",   Utilities.deepEquals(o1, o2, ComparisonMode.APPROXIMATIVE));
+    }
+
+    /**
+     * Asserts that the two given objects are approximatively equal, while slightly different.
+     * More specifically, this method asserts that the given objects are equal according the
+     * {@link ComparisonMode#APPROXIMATIVE} criterion, but not equal according the
+     * {@link ComparisonMode#IGNORE_METADATA} criterion.
+     *
+     * @param expected  The expected object.
+     * @param actual    The actual object.
+     */
+    public static void assertAlmostEquals(final Object expected, final Object actual) {
+        assertFalse("Shall not be strictly equals",          Utilities.deepEquals(expected, actual, ComparisonMode.STRICT));
+        assertFalse("Shall be slightly different",           Utilities.deepEquals(expected, actual, ComparisonMode.IGNORE_METADATA));
+        assertTrue ("Shall be approximatively equals",       Utilities.deepEquals(expected, actual, ComparisonMode.DEBUG));
+        assertTrue ("DEBUG inconsistent with APPROXIMATIVE", Utilities.deepEquals(expected, actual, ComparisonMode.APPROXIMATIVE));
+    }
+
+    /**
+     * Asserts that the two given objects are equal ignoring metadata.
+     * See {@link ComparisonMode#IGNORE_METADATA} for more information.
+     *
+     * @param expected  The expected object.
+     * @param actual    The actual object.
+     */
+    public static void assertEqualsIgnoreMetadata(final Object expected, final Object actual) {
+        assertTrue("Shall be approximatively equals",       Utilities.deepEquals(expected, actual, ComparisonMode.DEBUG));
+        assertTrue("DEBUG inconsistent with APPROXIMATIVE", Utilities.deepEquals(expected, actual, ComparisonMode.APPROXIMATIVE));
+        assertTrue("Shall be equals, ignoring metadata",    Utilities.deepEquals(expected, actual, ComparisonMode.IGNORE_METADATA));
+    }
+
+    /**
      * Asserts that two strings are equal, ignoring the differences in EOL characters.
      * The comparisons is performed one a line-by-line basis. For each line, leading
      * and trailing spaces are ignored in order to make the comparison independent of
@@ -247,98 +291,6 @@ public strictfp class Assert extends org
     }
 
     /**
-     * Tests if the given {@code outer} shape contains the given {@code inner} rectangle.
-     * This method will also verify class consistency by invoking the {@code intersects}
-     * method, and by interchanging the arguments.
-     *
-     * <p>This method can be used for testing the {@code outer} implementation -
-     * it should not be needed for standard JDK implementations.</p>
-     *
-     * @param outer The shape which is expected to contains the given rectangle.
-     * @param inner The rectangle which should be contained by the shape.
-     */
-    public static void assertContains(final RectangularShape outer, final Rectangle2D inner) {
-        assertTrue("outer.contains(inner)",   outer.contains  (inner));
-        assertTrue("outer.intersects(inner)", outer.intersects(inner));
-        if (outer instanceof Rectangle2D) {
-            assertTrue ("inner.intersects(outer)", inner.intersects((Rectangle2D) outer));
-            assertFalse("inner.contains(outer)",   inner.contains  ((Rectangle2D) outer));
-        }
-        assertTrue("outer.contains(centerX, centerY)",
-                outer.contains(inner.getCenterX(), inner.getCenterY()));
-    }
-
-    /**
-     * Tests if the given {@code r1} shape is disjoint with the given {@code r2} rectangle.
-     * This method will also verify class consistency by invoking the {@code contains}
-     * method, and by interchanging the arguments.
-     *
-     * <p>This method can be used for testing the {@code r1} implementation - it should not
-     * be needed for standard implementations.</p>
-     *
-     * @param r1 The first shape to test.
-     * @param r2 The second rectangle to test.
-     */
-    public static void assertDisjoint(final RectangularShape r1, final Rectangle2D r2) {
-        assertFalse("r1.intersects(r2)", r1.intersects(r2));
-        assertFalse("r1.contains(r2)",   r1.contains(r2));
-        if (r1 instanceof Rectangle2D) {
-            assertFalse("r2.intersects(r1)", r2.intersects((Rectangle2D) r1));
-            assertFalse("r2.contains(r1)",   r2.contains  ((Rectangle2D) r1));
-        }
-        for (int i=0; i<9; i++) {
-            final double x, y;
-            switch (i % 3) {
-                case 0: x = r2.getMinX();    break;
-                case 1: x = r2.getCenterX(); break;
-                case 2: x = r2.getMaxX();    break;
-                default: throw new AssertionError(i);
-            }
-            switch (i / 3) {
-                case 0: y = r2.getMinY();    break;
-                case 1: y = r2.getCenterY(); break;
-                case 2: y = r2.getMaxY();    break;
-                default: throw new AssertionError(i);
-            }
-            assertFalse("r1.contains(" + x + ", " + y + ')', r1.contains(x, y));
-        }
-    }
-
-    /**
-     * Asserts that two rectangles have the same location and the same size.
-     *
-     * @param expected The expected rectangle.
-     * @param actual   The rectangle to compare with the expected one.
-     * @param tolx     The tolerance threshold on location along the <var>x</var> axis.
-     * @param toly     The tolerance threshold on location along the <var>y</var> axis.
-     */
-    public static void assertRectangleEquals(final RectangularShape expected,
-            final RectangularShape actual, final double tolx, final double toly)
-    {
-        assertEquals("Min X",    expected.getMinX(),    actual.getMinX(),    tolx);
-        assertEquals("Min Y",    expected.getMinY(),    actual.getMinY(),    toly);
-        assertEquals("Max X",    expected.getMaxX(),    actual.getMaxX(),    tolx);
-        assertEquals("Max Y",    expected.getMaxY(),    actual.getMaxY(),    toly);
-        assertEquals("Center X", expected.getCenterX(), actual.getCenterX(), tolx);
-        assertEquals("Center Y", expected.getCenterY(), actual.getCenterY(), toly);
-        assertEquals("Width",    expected.getWidth(),   actual.getWidth(),   tolx*2);
-        assertEquals("Height",   expected.getHeight(),  actual.getHeight(),  toly*2);
-    }
-
-    /**
-     * Asserts that two images have the same origin and the same size.
-     *
-     * @param expected The image having the expected size.
-     * @param actual   The image to compare with the expected one.
-     */
-    public static void assertBoundEquals(final RenderedImage expected, final RenderedImage actual) {
-        assertEquals("Min X",  expected.getMinX(),   actual.getMinX());
-        assertEquals("Min Y",  expected.getMinY(),   actual.getMinY());
-        assertEquals("Width",  expected.getWidth(),  actual.getWidth());
-        assertEquals("Height", expected.getHeight(), actual.getHeight());
-    }
-
-    /**
      * Serializes the given object in memory, deserialize it and ensures that the deserialized
      * object is equals to the original one. This method doesn't write anything to the disk.
      *



Mime
View raw message