Subversion Repositories hibernate-spatial

/*

 * $Id: TestSpatialFunctions.java 193 2010-03-26 15:56:02Z maesenka $

 *

 * This file is part of Hibernate Spatial, an extension to the

 * hibernate ORM solution for geographic data.

 *

 * Copyright © 2007-2010 Geovise BVBA

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * For more information, visit: http://www.hibernatespatial.org/

 */

package org.hibernatespatial.testsuite;

import com.vividsolutions.jts.geom.Geometry;

import org.hibernate.Query;

import org.hibernate.Session;

import org.hibernate.Transaction;

import org.hibernate.type.CustomType;

import org.hibernatespatial.GeometryUserType;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import java.sql.SQLException;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import static junit.framework.Assert.assertTrue;

import static org.junit.Assert.*;

/**

 * @author Karel Maesen, Geovise BVBA

 */

public class TestSpatialFunctions extends SpatialFunctionalTestCase {

    private static Logger LOGGER = LoggerFactory.getLogger(TestSpatialFunctions.class);

    public TestSpatialFunctions(String string) {

        super(string);

    }

    public void prepareTest(){

        super.prepareTest();

        try {

            dataSourceUtils.insertTestData(testData);

        } catch (SQLException e) {

            throw new RuntimeException(e);

        }

    }

    public void test_dimension() throws SQLException {

        Map<Integer, Integer> dbexpected = expectationsFactory.getDimension();

        String hql = "SELECT id, dimension(geom) FROM GeomEntity";

        retrieveHQLResultsAndCompare(dbexpected, hql);

    }

    public void test_astext() throws SQLException {

        Map<Integer, String> dbexpected = expectationsFactory.getAsText();

        String hql = "SELECT id, astext(geom) from GeomEntity";

        retrieveHQLResultsAndCompare(dbexpected, hql);

    }

    public void test_asbinary() throws SQLException {

        Map<Integer, byte[]> dbexpected = expectationsFactory.getAsBinary();

        String hql = "SELECT id, asbinary(geom) from GeomEntity";

        retrieveHQLResultsAndCompare(dbexpected, hql);

    }

    public void test_geometrytype() throws SQLException {

        Map<Integer, String> dbexpected = expectationsFactory.getGeometryType();

        String hql = "SELECT id, geometrytype(geom) from GeomEntity";

        retrieveHQLResultsAndCompare(dbexpected, hql);

    }

    public void test_srid() throws SQLException {

        Map<Integer, Integer> dbexpected = expectationsFactory.getSrid();

        String hql = "SELECT id, srid(geom) from GeomEntity";

        retrieveHQLResultsAndCompare(dbexpected, hql);

    }

    public void test_issimple() throws SQLException {

        Map<Integer, Boolean> dbexpected = expectationsFactory.getIsSimple();

        String hql = "SELECT id, issimple(geom) from GeomEntity";

        retrieveHQLResultsAndCompare(dbexpected, hql);

    }

    public void test_isempty() throws SQLException {

        Map<Integer, Boolean> dbexpected = expectationsFactory.getIsEmpty();

        String hql = "SELECT id, isEmpty(geom) from GeomEntity";

        retrieveHQLResultsAndCompare(dbexpected, hql);

    }

    public void test_boundary() throws SQLException {

        Map<Integer, Geometry> dbexpected = expectationsFactory.getBoundary();

        String hql = "SELECT id, boundary(geom) from GeomEntity";

        retrieveHQLResultsAndCompare(dbexpected, hql);

    }

    public void test_envelope() throws SQLException {

        Map<Integer, Geometry> dbexpected = expectationsFactory.getEnvelope();

        String hql = "SELECT id, envelope(geom) from GeomEntity";

        retrieveHQLResultsAndCompare(dbexpected, hql);

    }

    public void test_within() throws SQLException {

        Map<Integer, Boolean> dbexpected = expectationsFactory.getWithin(expectationsFactory.getTestPolygon());

        String hql = "SELECT id, within(geom, :filter) from GeomEntity where within(geom, :filter) = true and srid(geom) = 4326";

        Map<String, Object> params = createQueryParams("filter", expectationsFactory.getTestPolygon());

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

    }

    private Map<String, Object> createQueryParams(String filterParamName, Object value) {

        Map<String, Object> params = new HashMap<String, Object>();

        params.put(filterParamName, value);

        return params;

    }

    public void test_equals() throws SQLException {

        Map<Integer, Boolean> dbexpected = expectationsFactory.getEquals(expectationsFactory.getTestPolygon());

        String hql = "SELECT id, equals(geom, :filter) from GeomEntity where equals(geom, :filter) = true and srid(geom) = 4326";

        Map<String, Object> params = createQueryParams("filter", expectationsFactory.getTestPolygon());

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

    }

    public void test_crosses() throws SQLException {

        Map<Integer, Boolean> dbexpected = expectationsFactory.getCrosses(expectationsFactory.getTestPolygon());

        String hql = "SELECT id, crosses(geom, :filter) from GeomEntity where crosses(geom, :filter) = true and srid(geom) = 4326";

        Map<String, Object> params = createQueryParams("filter", expectationsFactory.getTestPolygon());

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

    }

    public void test_contains() throws SQLException {

        Map<Integer, Boolean> dbexpected = expectationsFactory.getContains(expectationsFactory.getTestPolygon());

        String hql = "SELECT id, contains(geom, :filter) from GeomEntity where contains(geom, :filter) = true and srid(geom) = 4326";

        Map<String, Object> params = createQueryParams("filter", expectationsFactory.getTestPolygon());

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

    }

    public void test_disjoint() throws SQLException {

        Map<Integer, Boolean> dbexpected = expectationsFactory.getDisjoint(expectationsFactory.getTestPolygon());

        String hql = "SELECT id, disjoint(geom, :filter) from GeomEntity where disjoint(geom, :filter) = true and srid(geom) = 4326";

        Map<String, Object> params = createQueryParams("filter", expectationsFactory.getTestPolygon());

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

    }

    public void test_intersects() throws SQLException {

        Map<Integer, Boolean> dbexpected = expectationsFactory.getIntersects(expectationsFactory.getTestPolygon());

        String hql = "SELECT id, intersects(geom, :filter) from GeomEntity where intersects(geom, :filter) = true and srid(geom) = 4326";

        Map<String, Object> params = createQueryParams("filter", expectationsFactory.getTestPolygon());

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

    }

    public void test_overlaps() throws SQLException {

        Map<Integer, Boolean> dbexpected = expectationsFactory.getOverlaps(expectationsFactory.getTestPolygon());

        String hql = "SELECT id, overlaps(geom, :filter) from GeomEntity where overlaps(geom, :filter) = true and srid(geom) = 4326";

        Map<String, Object> params = createQueryParams("filter", expectationsFactory.getTestPolygon());

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

    }

    public void test_touches() throws SQLException {

        String hql = "SELECT id, touches(geom, :filter) from GeomEntity where touches(geom, :filter) = true and srid(geom) = 4326";

        Map<Integer, Boolean> dbexpected = expectationsFactory.getTouches(expectationsFactory.getTestPolygon());

        Map<String, Object> params = createQueryParams("filter", expectationsFactory.getTestPolygon());

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

    }

    public void test_relate() throws SQLException {

        String matrix = "T*T***T**";

        Map<Integer, Boolean> dbexpected = expectationsFactory.getRelate(expectationsFactory.getTestPolygon(), matrix);

        String hql = "SELECT id, relate(geom, :filter, :matrix) from GeomEntity where relate(geom, :filter, :matrix) = true and srid(geom) = 4326";

        Map<String, Object> params = createQueryParams("filter", expectationsFactory.getTestPolygon());

        params.put("matrix", matrix);

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

        matrix = "FF*FF****";

        dbexpected = expectationsFactory.getRelate(expectationsFactory.getTestPolygon(), matrix);

        params.put("matrix", matrix);

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

    }

    public void test_distance() throws SQLException {

        Map<Integer, Double> dbexpected = expectationsFactory.getDistance(expectationsFactory.getTestPolygon());

        String hql = "SELECT id, distance(geom, :filter) from GeomEntity where srid(geom) = 4326";

        Map<String, Object> params = createQueryParams("filter", expectationsFactory.getTestPolygon());

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

    }

    public void test_buffer() throws SQLException {

        Map<Integer, Geometry> dbexpected = expectationsFactory.getBuffer(Double.valueOf(1.0));

        String hql = "SELECT id, buffer(geom, :distance) from GeomEntity where srid(geom) = 4326";

        Map<String, Object> params = createQueryParams("distance", Double.valueOf(1.0));

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

    }

    public void test_convexhull() throws SQLException {

        Map<Integer, Geometry> dbexpected = expectationsFactory.getConvexHull(expectationsFactory.getTestPolygon());

        String hql = "SELECT id, convexhull(geomunion(geom, :polygon)) from GeomEntity where srid(geom) = 4326";

        Map<String, Object> params = createQueryParams("polygon", expectationsFactory.getTestPolygon());

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

    }

    public void test_intersection() throws SQLException {

        Map<Integer, Geometry> dbexpected = expectationsFactory.getIntersection(expectationsFactory.getTestPolygon());

        String hql = "SELECT id, intersection(geom, :polygon) from GeomEntity where srid(geom) = 4326";

        Map<String, Object> params = createQueryParams("polygon", expectationsFactory.getTestPolygon());

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

    }

    public void test_difference() throws SQLException {

        Map<Integer, Geometry> dbexpected = expectationsFactory.getDifference(expectationsFactory.getTestPolygon());

        String hql = "SELECT id, difference(geom, :polygon) from GeomEntity where srid(geom) = 4326";

        Map<String, Object> params = createQueryParams("polygon", expectationsFactory.getTestPolygon());

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

    }

    public void test_symdifference() throws SQLException {

        Map<Integer, Geometry> dbexpected = expectationsFactory.getSymDifference(expectationsFactory.getTestPolygon());

        String hql = "SELECT id, symdifference(geom, :polygon) from GeomEntity where srid(geom) = 4326";

        Map<String, Object> params = createQueryParams("polygon", expectationsFactory.getTestPolygon());

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

    }

    public void test_geomunion() throws SQLException {

        Map<Integer, Geometry> dbexpected = expectationsFactory.getGeomUnion(expectationsFactory.getTestPolygon());

        String hql = "SELECT id, geomunion(geom, :polygon) from GeomEntity where srid(geom) = 4326";

        Map<String, Object> params = createQueryParams("polygon", expectationsFactory.getTestPolygon());

        retrieveHQLResultsAndCompare(dbexpected, hql, params);

    }

    public <T> void retrieveHQLResultsAndCompare(Map<Integer, T> dbexpected, String hql) {

        Map<Integer, T> hsreceived = new HashMap<Integer, T>();

        doInSession(hql, hsreceived, null);

        compare(dbexpected, hsreceived);

    }

    protected <T> void retrieveHQLResultsAndCompare(Map<Integer, T> dbexpected, String hql, Map<String, Object> params) {

        Map<Integer, T> hsreceived = new HashMap<Integer, T>();

        doInSession(hql, hsreceived, params);

        compare(dbexpected, hsreceived);

    }

    protected <T> void compare(Map<Integer, T> expected, Map<Integer, T> received) {

        for (Integer id : expected.keySet()) {

            LOGGER.debug("Case :" + id);

            LOGGER.debug("expected: " + expected.get(id));

            LOGGER.debug("received: " + received.get(id));

            compare(id, expected.get(id), received.get(id));

        }

    }

    protected void compare(Integer id, Object expected, Object received) {

        assertTrue(expected != null && received != null);

        if (expected instanceof byte[]) {

            assertArrayEquals("Failure on testsuite-suite for case " + id, (byte[]) expected, (byte[]) received);

        } else if (expected instanceof Geometry) {

            if (!(received instanceof Geometry))

                fail("Expected a Geometry, but received an object of type " + received.getClass().getCanonicalName());

            assertTrue("Failure on testsuite-suite for case " + id, geometryEquality.test((Geometry) expected, (Geometry) received));

        } else {

            if (expected instanceof Long) {

                assertEquals("Failure on testsuite-suite for case " + id, ((Long) expected).intValue(), received);

            } else {

                assertEquals("Failure on testsuite-suite for case " + id, expected, received);

            }

        }

    }

    private <T> void doInSession(String hql, Map<Integer, T> result, Map<String, Object> params) {

        Session session = null;

        Transaction tx = null;

        try {

            session = openSession();

            tx = session.beginTransaction();

            Query query = session.createQuery(hql);

            setParameters(params, query);

            addQueryResults(result, query);

        } finally {

            if (tx != null) tx.rollback();

            if (session != null) session.close();

        }

    }

    private <T> void addQueryResults(Map<Integer, T> result, Query query) {

        List<Object[]> rows = (List<Object[]>) query.list();

        if (rows.size() == 0) {

            LOGGER.warn("No results returned for query!!");

        }

        for (Object[] row : rows) {

            Integer id = (Integer) row[0];

            T val = (T) row[1];

            result.put(id, val);

        }

    }

    private void setParameters(Map<String, Object> params, Query query) {

        if (params == null) return;

        for (String param : params.keySet()) {

            Object value = params.get(param);

            if (value instanceof Geometry) {

                query.setParameter(param, value, new CustomType(new GeometryUserType()));

            } else {

                query.setParameter(param, value);

            }

        }

    }

}