EQ2EMu/EQ2/source/depends/boost_1_72_0/libs/geometry/test/algorithms/distance/distance_ca_pl_ar.cpp

// Boost.Geometry (aka GGL, Generic Geometry Library)
// Unit Test

// Copyright (c) 2014-2018, Oracle and/or its affiliates.

// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle

// Licensed under the Boost Software License version 1.0.
// http://www.boost.org/users/license.html

#include <iostream>

#ifndef BOOST_TEST_MODULE
#define BOOST_TEST_MODULE test_distance_cartesian_pointlike_areal
#endif

#include <boost/test/included/unit_test.hpp>

#include "test_distance_common.hpp"


typedef bg::model::point<double,2,bg::cs::cartesian>  point_type;
typedef bg::model::multi_point<point_type>            multi_point_type;
typedef bg::model::point<double,3,bg::cs::cartesian>  point_type_3d;
typedef bg::model::multi_point<point_type_3d>         multi_point_type_3d;
typedef bg::model::polygon<point_type, false>         polygon_type;
typedef bg::model::multi_polygon<polygon_type>        multi_polygon_type;
typedef bg::model::ring<point_type, false>            ring_type;
typedef bg::model::box<point_type>                    box_type;
typedef bg::model::box<point_type_3d>                 box_type_3d;

namespace services = bg::strategy::distance::services;
typedef bg::default_distance_result<point_type>::type return_type;

typedef bg::strategy::distance::pythagoras<> point_point_strategy;
typedef bg::strategy::distance::projected_point<> point_segment_strategy;
typedef bg::strategy::distance::pythagoras_point_box<> point_box_strategy;

//===========================================================================

template <typename Strategy>
void test_distance_point_polygon(Strategy const& strategy)
{
#ifdef BOOST_GEOMETRY_TEST_DEBUG
    std::cout << std::endl;
    std::cout << "point/polygon distance tests" << std::endl;
#endif
    typedef test_distance_of_geometries<point_type, polygon_type> tester;

    tester::apply("point(0 -20)",
                  "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
                  10, 100, strategy);

    tester::apply("point(12 0)",
                  "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
                  2, 4, strategy);

    tester::apply("point(0 0)",
                  "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
                  0, 0, strategy);

    tester::apply("point(0 0)",
                  "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10),\
                   (-5 -5,-5 5,5 5,5 -5,-5 -5))",
                  5, 25, strategy);

    // polygons with single-point rings
    tester::apply("point(0 0)",
                  "polygon((-5 5))",
                  sqrt(50.0), 50, strategy);

    tester::apply("point(0 0)",
                  "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10),(-5 5))",
                  0, 0, strategy);
}

//===========================================================================

template <typename Strategy>
void test_distance_point_ring(Strategy const& strategy)
{
#ifdef BOOST_GEOMETRY_TEST_DEBUG
    std::cout << std::endl;
    std::cout << "point/ring distance tests" << std::endl;
#endif
    typedef test_distance_of_geometries<point_type, ring_type> tester;

    tester::apply("point(0 -20)",
                  "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
                  10, 100, strategy);

    tester::apply("point(12 0)",
                  "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
                  2, 4, strategy);

    tester::apply("point(0 0)",
                  "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
                  0, 0, strategy);

    // single-point rings
    tester::apply("point(0 0)",
                  "polygon((-10 -10))",
                  sqrt(200.0), 200, strategy);
}

//===========================================================================

template <typename Strategy>
void test_distance_point_multipolygon(Strategy const& strategy)
{
#ifdef BOOST_GEOMETRY_TEST_DEBUG
    std::cout << std::endl;
    std::cout << "point/multipolygon distance tests" << std::endl;
#endif
    typedef test_distance_of_geometries<point_type, multi_polygon_type> tester;

    tester::apply("point(0 -20)",
                  "multipolygon(((-10 -10,10 -10,10 10,-10 10,-10 -10)),\
                   ((0 22,-1 30,2 40,0 22)))",
                  10, 100, strategy);

    tester::apply("point(12 0)",
                  "multipolygon(((-10 -10,10 -10,10 10,-10 10,-10 -10)),\
                   ((20 -1,21 2,30 -10,20 -1)))",
                  2, 4, strategy);

    tester::apply("point(0 0)",
                  "multipolygon(((-10 -10,10 -10,10 10,-10 10,-10 -10)),\
                   ((20 -1,21 2,30 -10,20 -1)))",
                  0, 0, strategy);

    tester::apply("point(0 0)",
                  "multipolygon(((-10 -10,10 -10,10 10,-10 10,-10 -10),\
                   (-5 -5,-5 5,5 5,5 -5,-5 -5)),\
                   ((100 0,101 0,101 1,100 1,100 0)))",
                  5, 25, strategy);
}

//===========================================================================

template <typename Strategy>
void test_distance_multipoint_polygon(Strategy const& strategy)
{
#ifdef BOOST_GEOMETRY_TEST_DEBUG
    std::cout << std::endl;
    std::cout << "multipoint/polygon distance tests" << std::endl;
#endif
    typedef test_distance_of_geometries<multi_point_type, polygon_type> tester;

    tester::apply("multipoint(0 -20,0 -15)",
                  "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
                  5, 25, strategy);

    tester::apply("multipoint(16 0,12 0)",
                  "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
                  2, 4, strategy);

    tester::apply("multipoint(0 0,5 5,4 4)",
                  "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
                  0, 0, strategy);

    tester::apply("multipoint(0 0,2 0)",
                  "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10),\
                   (-5 -5,-5 5,5 5,5 -5,-5 -5))",
                  3, 9, strategy);

    tester::apply("multipoint(4 4,11 11)",
                  "polygon((0 0,0 10,10 10,10 0,0 0))",
                  0, 0, strategy);
}

//===========================================================================

template <typename Strategy>
void test_distance_multipoint_ring(Strategy const& strategy)
{
#ifdef BOOST_GEOMETRY_TEST_DEBUG
    std::cout << std::endl;
    std::cout << "multipoint/ring distance tests" << std::endl;
#endif
    typedef test_distance_of_geometries<multi_point_type, ring_type> tester;

    tester::apply("multipoint(0 -20,0 -15)",
                  "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
                  5, 25, strategy);

    tester::apply("multipoint(16 0,12 0)",
                  "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
                  2, 4, strategy);

    tester::apply("multipoint(0 0,5 5,4 4)",
                  "polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
                  0, 0, strategy);

    // single-point ring
    tester::apply("multipoint(0 0,5 5,4 4)",
                  "polygon((10 10))",
                  sqrt(50.0), 50, strategy);
}

//===========================================================================

template <typename Strategy>
void test_distance_multipoint_multipolygon(Strategy const& strategy)
{
#ifdef BOOST_GEOMETRY_TEST_DEBUG
    std::cout << std::endl;
    std::cout << "multipoint/multipolygon distance tests" << std::endl;
#endif
    typedef test_distance_of_geometries
        <
            multi_point_type, multi_polygon_type
        > tester;

    tester::apply("multipoint(0 -20,0 -15)",
                  "multipolygon(((-10 -10,10 -10,10 10,-10 10,-10 -10)),\
                   ((0 22,-1 30,2 40,0 22)))",
                  5, 25, strategy);

    tester::apply("multipoint(16 0,12 0)",
                  "multipolygon(((-10 -10,10 -10,10 10,-10 10,-10 -10)),\
                   ((20 -1,21 2,30 -10,20 -1)))",
                  2, 4, strategy);

    tester::apply("multipoint(0 0,4 4,5 5)",
                  "multipolygon(((-10 -10,10 -10,10 10,-10 10,-10 -10)),\
                   ((20 -1,21 2,30 -10,20 -1)))",
                  0, 0, strategy);

    tester::apply("multipoint(0 0,2 0)",
                  "multipolygon(((-10 -10,10 -10,10 10,-10 10,-10 -10),\
                   (-5 -5,-5 5,5 5,5 -5,-5 -5)),\
                   ((100 0,101 0,101 1,100 1,100 0)))",
                  3, 9, strategy);

    tester::apply("MULTIPOINT(19 19,100 100)",
                  "MULTIPOLYGON(((0 0,0 10,10 10,10 0,0 0),\
                  (4 4,4 6,6 6,6 4,4 4)), ((10 10,10 20,20 20,20 10,10 10),\
                  (14 14,14 16,16 16,16 14,14 14)))",
                  0, 0, strategy);
}

//===========================================================================

template <typename Strategy>
void test_distance_point_box_2d(Strategy const& strategy)
{
#ifdef BOOST_GEOMETRY_TEST_DEBUG
    std::cout << std::endl;
    std::cout << "2D point/box distance tests" << std::endl;
#endif
    typedef test_distance_of_geometries<box_type, point_type> tester;

    // point inside box
    tester::apply("box(-1 -1,1 1)",
                  "point(0 0)", 0, 0, strategy);

    // points on box corners
    tester::apply("box(-1 -1,1 1)",
                  "point(-1 -1)", 0, 0, strategy);
    tester::apply("box(-1 -1,1 1)",
                  "point(-1 1)", 0, 0, strategy);
    tester::apply("box(-1 -1,1 1)",
                  "point(1 -1)", 0, 0, strategy);
    tester::apply("box(-1 -1,1 1)",
                  "point(1 1)", 0, 0, strategy);

    // points on box boundary edges
    tester::apply("box(-1 -1,1 1)",
                  "point(0 -1)", 0, 0, strategy);
    tester::apply("box(-1 -1,1 1)",
                  "point(-1 0)", 0, 0, strategy);
    tester::apply("box(-1 -1,1 1)",
                  "point(1 0)", 0, 0, strategy);
    tester::apply("box(-1 -1,1 1)",
                  "point(0 1)", 0, 0, strategy);

    // points outside box
    tester::apply("box(-1 -1,1 1)",
                  "point(0 4)", 3, 9, strategy);
    tester::apply("box(-1 -1,1 1)",
                  "point(0.5 4)", 3, 9, strategy);
    tester::apply("box(-1 -1,1 1)",
                  "point(-0.5 5)", 4, 16, strategy);
    tester::apply("box(-1 -1,1 1)",
                  "point(3 0.25)", 2, 4, strategy);
    tester::apply("box(-1 -1,1 1)",
                  "point(-3 -0.25)", 2, 4, strategy);
    tester::apply("box(-1 -1,1 1)",
                  "point(3 5)", sqrt(20.0), 20, strategy);
    tester::apply("box(-1 -1,1 1)",
                  "point(-5 -4)", 5, 25, strategy);
    tester::apply("box(-1 -1,1 1)",
                  "point(2 -2)", sqrt(2.0), 2, strategy);
    tester::apply("box(-1 -1,1 1)",
                  "point(-3 4)", sqrt(13.0), 13, strategy);
}

//===========================================================================

template <typename Strategy>
void test_distance_point_box_different_point_types(Strategy const& strategy)
{
#ifdef BOOST_GEOMETRY_TEST_DEBUG
    std::cout << std::endl;
    std::cout << "2D point/box distance tests with different points"
              << std::endl;
#endif
    typedef point_type double_point;
    typedef box_type double_box;
    typedef bg::model::point<int,2,bg::cs::cartesian> int_point;
    typedef bg::model::box<int_point> int_box;

    test_distance_of_geometries
        <
            int_point, int_box
        >::apply("point(0 0)",
                 "box(1 1, 2 2)",
                 sqrt(2.0), 2, strategy);

    test_distance_of_geometries
        <
            double_point, int_box
        >::apply("point(0.5 0)",
                 "box(1 -1,2 1)",
                 0.5, 0.25, strategy);

    test_distance_of_geometries
        <
            double_point, double_box
        >::apply("point(1.5 0)",
                 "box(1 -1,2 1)",
                 0, 0, strategy);

    test_distance_of_geometries
        <
            double_point, int_box
        >::apply("point(1.5 0)",
                 "box(1 -1,2 1)",
                 0, 0, strategy);

    test_distance_of_geometries
        <
            int_point, double_box
        >::apply("point(1 0)",
                 "box(0.5 -1,1.5 1)",
                 0, 0, strategy);

    test_distance_of_geometries
        <
            int_point, double_box
        >::apply("point(0 0)",
                 "box(0.5, -1,1.5, 1)",
                 0.5, 0.25, strategy);
}

//===========================================================================

template <typename Strategy>
void test_distance_point_box_3d(Strategy const& strategy)
{
#ifdef BOOST_GEOMETRY_TEST_DEBUG
    std::cout << std::endl;
    std::cout << "3D point/box distance tests" << std::endl;
#endif
    typedef test_distance_of_geometries<box_type_3d, point_type_3d> tester;

    // point inside box
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 0 0)", 0, 0, strategy);

    // points on box corners
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-1 -1 -1)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-1 -1 1)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-1 1 -1)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-1 1 1)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(1 -1 -1)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(1 -1 1)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(1 1 -1)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(1 1 1)", 0, 0, strategy);

    // points on box boundary edges
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 -1 -1)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 -1 1)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 1 -1)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 1 1)", 0, 0, strategy);

    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-1 0 -1)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-1 0 1)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(1 0 -1)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(1 0 1)", 0, 0, strategy);

    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-1 -1 0)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-1 1 0)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(1 -1 0)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(1 1 0)", 0, 0, strategy);

    // point on box faces
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 0 -1)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 0 1)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 -1 0)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 1 0)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-1 0 0)", 0, 0, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(1 0 0)", 0, 0, strategy);

    // points outside box -- closer to box corners
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-2 -3 -4)", sqrt(14.0), 14, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-2 -3 3)", 3, 9, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-2 5 -2)", sqrt(18.0), 18, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-2 5 3)", sqrt(21.0), 21, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(4 -6 -3)", sqrt(38.0), 38, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(4 -6 4)", sqrt(43.0), 43, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(4 7 -2)", sqrt(46.0), 46, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(4 7 8)", sqrt(94.0), 94, strategy);


    // points closer to box facets
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 0 10)", 9, 81, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 0 -5)", 4, 16, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 7 0)", 6, 36, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 -6 0)", 5, 25, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(4 0 0)", 3, 9, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-3 0 0)", 2, 4, strategy);

    // points closer to box edges
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 -4 -5)", 5, 25, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 -3 6)", sqrt(29.0), 29, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 2 -7)", sqrt(37.0), 37, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(0 8 7)", sqrt(85.0), 85, strategy);

    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-4 0 -4)", sqrt(18.0), 18, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-3 0 5)", sqrt(20.0), 20, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(2 0 -6)", sqrt(26.0), 26, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(8 0 6)", sqrt(74.0), 74, strategy);

    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-5 -5 0)", sqrt(32.0), 32, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(-4 6 0)", sqrt(34.0), 34, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(3 -7 0)", sqrt(40.0), 40, strategy);
    tester::apply("box(-1 -1 -1,1 1 1)",
                  "point(9 7 0)", 10, 100, strategy);
}

//===========================================================================

template <typename Strategy>
void test_distance_multipoint_box_2d(Strategy const& strategy)
{
#ifdef BOOST_GEOMETRY_TEST_DEBUG
    std::cout << std::endl;
    std::cout << "2D multipoint/box distance tests" << std::endl;
#endif
    typedef test_distance_of_geometries<box_type, multi_point_type> tester;

    // at least one point inside the box
    tester::apply("box(0 0,10 10)",
                  "multipoint(0 0,-1 -1,20 20)",
                  0, 0, strategy);

    tester::apply("box(0 0,10 10)",
                  "multipoint(1 1,-1 -1,20 20)",
                  0, 0, strategy);

    tester::apply("box(0 0,10 10)",
                  "multipoint(1 1,2 2,3 3)",
                  0, 0, strategy);

    // all points outside the box
    tester::apply("box(0 0,10 10)",
                  "multipoint(-1 -1,20 20)",
                  sqrt(2.0), 2, strategy);

    tester::apply("box(0 0,10 10)",
                  "multipoint(5 13, 50 50)",
                  3, 9, strategy);
}

//===========================================================================

template <typename Strategy>
void test_distance_multipoint_box_3d(Strategy const& strategy)
{
#ifdef BOOST_GEOMETRY_TEST_DEBUG
    std::cout << std::endl;
    std::cout << "3D multipoint/box distance tests" << std::endl;
#endif
    typedef test_distance_of_geometries
        <
            box_type_3d, multi_point_type_3d
        > tester;

    // at least one point inside the box
    tester::apply("box(0 0 0,10 10 10)",
                  "multipoint(0 0 0,-1 -1 -1,20 20 20)",
                  0, 0, strategy);

    tester::apply("box(0 0 0,10 10 10)",
                  "multipoint(1 1 1,-1 -1 -1,20 20 20)",
                  0, 0, strategy);

    tester::apply("box(0 0 0,10 10 10)",
                  "multipoint(1 1 1,2 2 2,3 3 3)",
                  0, 0, strategy);

    // all points outside the box
    tester::apply("box(0 0 0,10 10 10)",
                  "multipoint(-1 -1 -1,20 20 20)",
                  sqrt(3.0), 3, strategy);

    tester::apply("box(0 0 0,10 10 10)",
                  "multipoint(5 5 13,50 50 50)",
                  3, 9, strategy);
}

//===========================================================================

template <typename Point, typename Strategy>
void test_more_empty_input_pointlike_areal(Strategy const& strategy)
{
#ifdef BOOST_GEOMETRY_TEST_DEBUG
    std::cout << std::endl;
    std::cout << "testing on empty inputs... " << std::flush;
#endif
    bg::model::multi_point<Point> multipoint_empty;
    bg::model::polygon<Point> polygon_empty;
    bg::model::multi_polygon<bg::model::polygon<Point> > multipolygon_empty;
    bg::model::ring<Point> ring_empty;

    Point point = from_wkt<Point>("point(0 0)");
    bg::model::polygon<Point> polygon =
        from_wkt<bg::model::polygon<Point> >("polygon((0 0,1 0,0 1))");
    bg::model::ring<Point> ring =
        from_wkt<bg::model::ring<Point> >("polygon((0 0,1 0,0 1))");

    // 1st geometry is empty
    test_empty_input(multipoint_empty, polygon, strategy);
    test_empty_input(multipoint_empty, ring, strategy);

    // 2nd geometry is empty
    test_empty_input(point, polygon_empty, strategy);
    test_empty_input(point, multipolygon_empty, strategy);
    test_empty_input(point, ring_empty, strategy);

    // both geometries are empty
    test_empty_input(multipoint_empty, polygon_empty, strategy);
    test_empty_input(multipoint_empty, multipolygon_empty, strategy);
    test_empty_input(multipoint_empty, ring_empty, strategy);

#ifdef BOOST_GEOMETRY_TEST_DEBUG
    std::cout << "done!" << std::endl;
#endif
}

//===========================================================================

BOOST_AUTO_TEST_CASE( test_all_pointlike_polygon )
{
    test_distance_point_polygon(point_point_strategy()); // back-compatibility
    test_distance_point_polygon(point_segment_strategy());
}

BOOST_AUTO_TEST_CASE( test_all_point_multipolygon )
{
    test_distance_point_multipolygon(point_point_strategy()); // back-compatibility
    test_distance_point_multipolygon(point_segment_strategy());
}

BOOST_AUTO_TEST_CASE( test_all_point_ring )
{
    test_distance_point_ring(point_point_strategy()); // back-compatibility
    test_distance_point_ring(point_segment_strategy());
}

BOOST_AUTO_TEST_CASE( test_all_multipoint_polygon )
{
    test_distance_multipoint_polygon(point_point_strategy()); // back-compatibility
    test_distance_multipoint_polygon(point_segment_strategy());
}

BOOST_AUTO_TEST_CASE( test_all_multipoint_multipolygon )
{
    test_distance_multipoint_multipolygon(point_point_strategy()); // back-compatibility
    test_distance_multipoint_multipolygon(point_segment_strategy());
}

BOOST_AUTO_TEST_CASE( test_all_multipoint_ring )
{
    test_distance_multipoint_ring(point_segment_strategy());
}

BOOST_AUTO_TEST_CASE( test_all_point_box_2d )
{
    point_box_strategy pb_strategy;

    test_distance_point_box_2d(pb_strategy);
    test_distance_point_box_different_point_types(pb_strategy);
}

BOOST_AUTO_TEST_CASE( test_all_point_box_3d )
{
    test_distance_point_box_3d(point_box_strategy());
}

BOOST_AUTO_TEST_CASE( test_all_multipoint_box_2d )
{
    test_distance_multipoint_box_2d(point_box_strategy());
}

BOOST_AUTO_TEST_CASE( test_all_multipoint_box_3d )
{
    test_distance_multipoint_box_3d(point_box_strategy());
}

BOOST_AUTO_TEST_CASE( test_all_empty_input_pointlike_areal )
{
    test_more_empty_input_pointlike_areal
        <
            point_type
        >(point_segment_strategy());
}