[Boost-commit] svn:boost r56874 - in sandbox/ggl/formal_review_request/libs/ggl/test: . core

Subject: [Boost-commit] svn:boost r56874 - in sandbox/ggl/formal_review_request/libs/ggl/test: . core
From: barend.gehrels_at_[hidden]
Date: 2009-10-15 13:01:31

Author: barendgehrels
Date: 2009-10-15 13:01:29 EDT (Thu, 15 Oct 2009)
New Revision: 56874
URL: http://svn.boost.org/trac/boost/changeset/56874

Log:
Added testsuite for core
Added:
   sandbox/ggl/formal_review_request/libs/ggl/test/
   sandbox/ggl/formal_review_request/libs/ggl/test/Jamroot   (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/test/core/
   sandbox/ggl/formal_review_request/libs/ggl/test/core/Jamfile   (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/test/core/access.cpp   (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/test/core/coordinate_dimension.cpp   (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/test/core/coordinate_system.cpp   (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/test/core/coordinate_type.cpp   (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/test/core/geometry_id.cpp   (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/test/core/point_type.cpp   (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/test/core/radian_access.cpp   (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/test/core/reverse_dispatch.cpp   (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/test/core/ring.cpp   (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/test/core/tag.cpp   (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/test/core/topological_dimension.cpp   (contents, props changed)

Added: sandbox/ggl/formal_review_request/libs/ggl/test/Jamroot
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/test/Jamroot	2009-10-15 13:01:29 EDT (Thu, 15 Oct 2009)
@@ -0,0 +1,17 @@
+# Generic Geometry Library unit tests
+#
+# Copyright Bruno Lalande 2008
+# Copyright Barend Gehrels, Geodan Holding B.V. Amsterdam, the Netherlands.
+# Use, modification and distribution is subject to the Boost Software License,
+# Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+project 
+    : requirements
+        <include>../../../boost
+        <include>.
+        <toolset>gcc:<cxxflags>-pedantic
+    ;
+
+import testing ;
+

Added: sandbox/ggl/formal_review_request/libs/ggl/test/core/Jamfile
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/test/core/Jamfile	2009-10-15 13:01:29 EDT (Thu, 15 Oct 2009)
@@ -0,0 +1,21 @@
+# Generic Geometry Library unit tests
+#
+# Copyright Bruno Lalande 2008
+# Copyright Barend Gehrels, Geodan Holding B.V. Amsterdam, the Netherlands.
+# Use, modification and distribution is subject to the Boost Software License,
+# Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+run access.cpp ;
+run coordinate_dimension.cpp ;
+run coordinate_system.cpp ;
+run coordinate_type.cpp ;
+run geometry_id.cpp ;
+run point_type.cpp ;
+run radian_access.cpp ;
+run reverse_dispatch.cpp ;
+run ring.cpp ;
+run tag.cpp ;
+run topological_dimension.cpp ;
+
+

Added: sandbox/ggl/formal_review_request/libs/ggl/test/core/access.cpp
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/test/core/access.cpp	2009-10-15 13:01:29 EDT (Thu, 15 Oct 2009)
@@ -0,0 +1,126 @@
+// Generic Geometry Library test file
+//
+// Copyright Barend Gehrels, 1995-2009, Geodan Holding B.V. Amsterdam, the Netherlands.
+// Copyright Bruno Lalande 2008, 2009
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/test/floating_point_comparison.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <ggl/core/access.hpp>
+
+
+#include <ggl/core/coordinate_type.hpp>
+#include <ggl/algorithms/make.hpp>
+
+#include <ggl/geometries/adapted/c_array_cartesian.hpp>
+#include <ggl/geometries/adapted/tuple_cartesian.hpp>
+
+
+#include <ggl/core/cs.hpp>
+#include <ggl/geometries/point.hpp>
+#include <ggl/geometries/nsphere.hpp>
+#include <ggl/geometries/segment.hpp>
+#include <ggl/geometries/box.hpp>
+
+
+
+template <typename G>
+void test_get_set()
+{
+    typedef typename ggl::coordinate_type<G>::type coordinate_type;
+
+    G g;
+    ggl::set<0>(g, coordinate_type(1));
+    ggl::set<1>(g, coordinate_type(2));
+
+    coordinate_type x = ggl::get<0>(g);
+    coordinate_type y = ggl::get<1>(g);
+
+    BOOST_CHECK_CLOSE(double(x), 1.0, 0.0001);
+    BOOST_CHECK_CLOSE(double(y), 2.0, 0.0001);
+}
+
+template <typename G>
+void test_indexed_get_set(G& g)
+{
+    ggl::set<0, 0>(g, 1);
+    ggl::set<0, 1>(g, 2);
+    ggl::set<1, 0>(g, 3);
+    ggl::set<1, 1>(g, 4);
+
+    typedef typename ggl::coordinate_type<G>::type coordinate_type;
+    coordinate_type x1 = ggl::get<0, 0>(g);
+    coordinate_type y1 = ggl::get<0, 1>(g);
+    coordinate_type x2 = ggl::get<1, 0>(g);
+    coordinate_type y2 = ggl::get<1, 1>(g);
+
+    BOOST_CHECK_CLOSE(double(x1), 1.0, 0.0001);
+    BOOST_CHECK_CLOSE(double(y1), 2.0, 0.0001);
+    BOOST_CHECK_CLOSE(double(x2), 3.0, 0.0001);
+    BOOST_CHECK_CLOSE(double(y2), 4.0, 0.0001);
+}
+
+template <typename G, typename T>
+void test_indexed_get(G const& g, T a, T b, T c, T d)
+{
+    T x1 = ggl::get<0, 0>(g);
+    T y1 = ggl::get<0, 1>(g);
+    T x2 = ggl::get<1, 0>(g);
+    T y2 = ggl::get<1, 1>(g);
+
+    BOOST_CHECK_CLOSE(double(x1), double(a), 0.0001);
+    BOOST_CHECK_CLOSE(double(y1), double(b), 0.0001);
+    BOOST_CHECK_CLOSE(double(x2), double(c), 0.0001);
+    BOOST_CHECK_CLOSE(double(y2), double(d), 0.0001);
+}
+
+template <typename P>
+void test_all()
+{
+    typedef typename ggl::coordinate_type<P>::type coordinate_type;
+
+    // POINT, setting coordinate
+    test_get_set<P>();
+
+    // N-SPHERE, setting sphere center
+    test_get_set<ggl::nsphere<P, double> >();
+
+    // BOX, setting left/right/top/bottom
+    ggl::box<P> b;
+    test_indexed_get_set(b);
+
+    // SEGMENT (in GGL not having default constructor; however that is not a requirement)
+    P p1 = ggl::make_zero<P>();
+    P p2 = ggl::make_zero<P>();
+    ggl::segment<P> s(p1, p2);
+    test_indexed_get_set(s);
+
+    // CONST SEGMENT
+    ggl::set<0>(p1, 1); // we don't use assign because dim in {2,3}
+    ggl::set<1>(p1, 2);
+    ggl::set<0>(p2, 3);
+    ggl::set<1>(p2, 4);
+    ggl::segment<const P> cs(p1, p2);
+    test_indexed_get(cs,
+        coordinate_type(1), coordinate_type(2),
+        coordinate_type(3), coordinate_type(4));
+}
+
+
+int test_main(int, char* [])
+{
+    test_get_set<int[2]>();
+    test_get_set<float[2]>();
+    test_get_set<double[2]>();
+
+    test_get_set<double[3]>();
+
+    test_all<ggl::point<int, 2, ggl::cs::cartesian> >();
+    test_all<ggl::point<float, 2, ggl::cs::cartesian> >();
+    test_all<ggl::point<double, 2, ggl::cs::cartesian> >();
+
+    return 0;
+}

Added: sandbox/ggl/formal_review_request/libs/ggl/test/core/coordinate_dimension.cpp
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/test/core/coordinate_dimension.cpp	2009-10-15 13:01:29 EDT (Thu, 15 Oct 2009)
@@ -0,0 +1,69 @@
+// Generic Geometry Library test file
+//
+// Copyright Barend Gehrels, 1995-2009, Geodan Holding B.V. Amsterdam, the Netherlands.
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/concept/assert.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <ggl/core/coordinate_dimension.hpp>
+
+
+#include <ggl/geometries/geometries.hpp>
+
+#include <ggl/geometries/adapted/c_array_cartesian.hpp>
+#include <ggl/geometries/adapted/tuple_cartesian.hpp>
+
+#include <ggl/geometries/adapted/boost_array_as_linestring.hpp>
+#include <ggl/geometries/adapted/std_as_linestring.hpp>
+
+#include <vector>
+#include <deque>
+
+
+template <typename G, std::size_t Expected>
+void test_geometry()
+{
+    BOOST_CHECK_EQUAL(ggl::dimension<G>::type::value, Expected);
+}
+
+template <typename P, size_t D>
+void test_all()
+{
+    test_geometry<P, D>();
+    test_geometry<const P, D>();
+    test_geometry<ggl::linestring<P> , D>();
+    test_geometry<ggl::linear_ring<P> , D>();
+    test_geometry<ggl::polygon<P> , D>();
+    test_geometry<ggl::box<P> , D>();
+    test_geometry<ggl::segment<P> , D>();
+    test_geometry<ggl::segment<const P> , D>();
+    test_geometry<ggl::nsphere<P, double> , D>();
+
+    test_geometry<std::vector<P>, D>();
+    test_geometry<std::deque<P>, D>();
+
+    test_geometry<boost::array<P, 5>, D>();
+}
+
+int test_main(int, char* [])
+{
+    test_geometry<int[2], 2>();
+    test_geometry<float[2], 2>();
+    test_geometry<double[2], 2>();
+
+    test_geometry<int[3], 3>();
+    test_geometry<float[3], 3>();
+    test_geometry<double[3], 3>();
+
+    test_geometry<boost::tuple<double, double>, 2>();
+    test_geometry<boost::tuple<double, double, double>, 3>();
+
+    test_all<ggl::point<int, 2, ggl::cs::cartesian>, 2 >();
+    test_all<ggl::point<float, 2, ggl::cs::cartesian>, 2 >();
+    test_all<ggl::point<double, 2, ggl::cs::cartesian>, 2 >();
+
+    return 0;
+}

Added: sandbox/ggl/formal_review_request/libs/ggl/test/core/coordinate_system.cpp
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/test/core/coordinate_system.cpp	2009-10-15 13:01:29 EDT (Thu, 15 Oct 2009)
@@ -0,0 +1,96 @@
+// Generic Geometry Library test file
+//
+// Copyright Barend Gehrels, 1995-2009, Geodan Holding B.V. Amsterdam, the Netherlands.
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/concept/assert.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <ggl/core/coordinate_system.hpp>
+
+
+#include <ggl/geometries/geometries.hpp>
+
+#include <ggl/geometries/adapted/c_array_cartesian.hpp>
+#include <ggl/geometries/adapted/tuple_cartesian.hpp>
+
+#include <ggl/geometries/adapted/boost_array_as_linestring.hpp>
+#include <ggl/geometries/adapted/std_as_linestring.hpp>
+
+#include <vector>
+#include <deque>
+
+
+template <typename G, typename Expected>
+void test_geometry()
+{
+    BOOST_CHECK_EQUAL(typeid(typename ggl::coordinate_system<G>::type).name(),
+        typeid(Expected).name());
+}
+
+template <typename P, typename Expected>
+void test_all()
+{
+    test_geometry<P, Expected>();
+    test_geometry<const P, Expected>();
+    test_geometry<ggl::linestring<P> , Expected>();
+    test_geometry<ggl::linear_ring<P> , Expected>();
+    test_geometry<ggl::polygon<P> , Expected>();
+    test_geometry<ggl::box<P> , Expected>();
+    test_geometry<ggl::segment<P> , Expected>();
+    test_geometry<ggl::segment<const P> , Expected>();
+    test_geometry<ggl::nsphere<P, double> , Expected>();
+
+    test_geometry<std::vector<P>, Expected>();
+    test_geometry<std::deque<P>, Expected>();
+
+    test_geometry<boost::array<P, 5>, Expected>();
+}
+
+int test_main(int, char* [])
+{
+    // Because of the included headerfiles, there are always cartesian
+    test_geometry<int[2], ggl::cs::cartesian>();
+    test_geometry<float[2], ggl::cs::cartesian>();
+    test_geometry<double[2], ggl::cs::cartesian>();
+
+    test_geometry<int[3], ggl::cs::cartesian>();
+    test_geometry<float[3], ggl::cs::cartesian>();
+    test_geometry<double[3], ggl::cs::cartesian>();
+
+    // Because of the included headerfiles, there are always cartesian
+    test_geometry<boost::tuple<double, double>, ggl::cs::cartesian>();
+    test_geometry<boost::tuple<double, double, double>, ggl::cs::cartesian>();
+
+
+    // Test cartesian
+    test_all<ggl::point<int, 2, ggl::cs::cartesian>, ggl::cs::cartesian>();
+    test_all<ggl::point<float, 2, ggl::cs::cartesian>, ggl::cs::cartesian>();
+    test_all<ggl::point<double, 2, ggl::cs::cartesian>, ggl::cs::cartesian>();
+
+    // Test spherical
+    test_all<ggl::point<int, 2, ggl::cs::spherical<ggl::degree> >,
+            ggl::cs::spherical<ggl::degree> >();
+    test_all<ggl::point<float, 2, ggl::cs::spherical<ggl::degree> >,
+            ggl::cs::spherical<ggl::degree> >();
+    test_all<ggl::point<double, 2, ggl::cs::spherical<ggl::degree> >,
+            ggl::cs::spherical<ggl::degree> >();
+
+    test_all<ggl::point<int, 2, ggl::cs::spherical<ggl::radian> >,
+                ggl::cs::spherical<ggl::radian> >();
+    test_all<ggl::point<float, 2, ggl::cs::spherical<ggl::radian> >,
+                ggl::cs::spherical<ggl::radian> >();
+    test_all<ggl::point<double, 2, ggl::cs::spherical<ggl::radian> >,
+                ggl::cs::spherical<ggl::radian> >();
+
+    // Test other
+    test_all<ggl::point<double, 2, ggl::cs::polar<ggl::degree> >,
+            ggl::cs::polar<ggl::degree> >();
+
+    test_all<ggl::point<double, 2, ggl::cs::geographic<ggl::degree> >,
+            ggl::cs::geographic<ggl::degree> >();
+
+    return 0;
+}

Added: sandbox/ggl/formal_review_request/libs/ggl/test/core/coordinate_type.cpp
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/test/core/coordinate_type.cpp	2009-10-15 13:01:29 EDT (Thu, 15 Oct 2009)
@@ -0,0 +1,73 @@
+// Generic Geometry Library test file
+//
+// Copyright Barend Gehrels, 1995-2009, Geodan Holding B.V. Amsterdam, the Netherlands.
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/concept/assert.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <ggl/core/coordinate_type.hpp>
+
+
+#include <ggl/geometries/geometries.hpp>
+
+#include <ggl/geometries/adapted/c_array_cartesian.hpp>
+#include <ggl/geometries/adapted/tuple_cartesian.hpp>
+
+#include <ggl/geometries/adapted/boost_array_as_linestring.hpp>
+#include <ggl/geometries/adapted/std_as_linestring.hpp>
+
+#include <vector>
+#include <deque>
+
+
+template <typename G, typename Expected>
+void test_geometry()
+{
+    BOOST_CHECK_EQUAL(typeid(typename ggl::coordinate_type<G>::type).name(),
+        typeid(Expected).name());
+}
+
+template <typename P, typename Expected>
+void test_all()
+{
+    test_geometry<P, Expected>();
+    test_geometry<const P, Expected>();
+    test_geometry<ggl::linestring<P> , Expected>();
+    test_geometry<ggl::linear_ring<P> , Expected>();
+    test_geometry<ggl::polygon<P> , Expected>();
+    test_geometry<ggl::box<P> , Expected>();
+    test_geometry<ggl::segment<P> , Expected>();
+    test_geometry<ggl::segment<const P> , Expected>();
+    test_geometry<ggl::nsphere<P, double> , Expected>();
+
+    test_geometry<std::vector<P>, Expected>();
+    test_geometry<std::deque<P>, Expected>();
+
+    test_geometry<boost::array<P, 5>, Expected>();
+}
+
+int test_main(int, char* [])
+{
+    test_geometry<int[2], int>();
+    test_geometry<float[2], float>();
+    test_geometry<double[2], double>();
+
+    test_geometry<int[3], int>();
+    test_geometry<float[3], float>();
+    test_geometry<double[3], double>();
+
+    test_geometry<boost::tuple<float, float>, float>();
+    test_geometry<boost::tuple<double, double>, double>();
+    test_geometry<boost::tuple<long double, long double>, long double>();
+    test_geometry<boost::tuple<double, double, double>, double>();
+
+    test_all<ggl::point<int, 2, ggl::cs::cartesian>, int>();
+    test_all<ggl::point<float, 2, ggl::cs::cartesian>, float>();
+    test_all<ggl::point<double, 2, ggl::cs::cartesian>, double>();
+    test_all<ggl::point<long double, 2, ggl::cs::cartesian>, long double>();
+
+    return 0;
+}

Added: sandbox/ggl/formal_review_request/libs/ggl/test/core/geometry_id.cpp
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/test/core/geometry_id.cpp	2009-10-15 13:01:29 EDT (Thu, 15 Oct 2009)
@@ -0,0 +1,68 @@
+// Generic Geometry Library test file
+//
+// Copyright Barend Gehrels, 1995-2009, Geodan Holding B.V. Amsterdam, the Netherlands.
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/concept/assert.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <ggl/core/geometry_id.hpp>
+
+#include <ggl/geometries/geometries.hpp>
+
+#include <ggl/geometries/adapted/c_array_cartesian.hpp>
+#include <ggl/geometries/adapted/tuple_cartesian.hpp>
+
+#include <ggl/geometries/adapted/boost_array_as_linestring.hpp>
+#include <ggl/geometries/adapted/std_as_linestring.hpp>
+
+#include <vector>
+#include <deque>
+
+
+template <typename G, std::size_t Expected>
+void test_geometry()
+{
+    BOOST_CHECK_EQUAL(ggl::geometry_id<G>::type::value, Expected);
+}
+
+template <typename P>
+void test_all()
+{
+    test_geometry<P, 1>();
+    test_geometry<const P, 1>();
+    test_geometry<ggl::linestring<P> , 2>();
+    test_geometry<ggl::linear_ring<P> , 93>();
+    test_geometry<ggl::polygon<P> , 3>();
+    test_geometry<ggl::box<P> , 94>();
+    test_geometry<ggl::segment<P> , 92>();
+    test_geometry<ggl::segment<const P> , 92>();
+    test_geometry<ggl::nsphere<P, double> , 91>();
+
+    test_geometry<std::vector<P>, 2>();
+    test_geometry<std::deque<P>, 2>();
+
+    test_geometry<boost::array<P, 5>, 2>();
+}
+
+int test_main(int, char* [])
+{
+    test_geometry<int[2], 1>();
+    test_geometry<float[2], 1>();
+    test_geometry<double[2], 1>();
+
+    test_geometry<int[3], 1>();
+    test_geometry<float[3], 1>();
+    test_geometry<double[3], 1>();
+
+    test_geometry<boost::tuple<double, double>, 1>();
+    test_geometry<boost::tuple<double, double, double>, 1>();
+
+    test_all<ggl::point<int, 2, ggl::cs::cartesian> >();
+    test_all<ggl::point<float, 2, ggl::cs::cartesian> >();
+    test_all<ggl::point<double, 2, ggl::cs::cartesian> >();
+
+    return 0;
+}

Added: sandbox/ggl/formal_review_request/libs/ggl/test/core/point_type.cpp
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/test/core/point_type.cpp	2009-10-15 13:01:29 EDT (Thu, 15 Oct 2009)
@@ -0,0 +1,72 @@
+// Generic Geometry Library test file
+//
+// Copyright Barend Gehrels, 1995-2009, Geodan Holding B.V. Amsterdam, the Netherlands.
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/concept/assert.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+
+#include <ggl/core/tag.hpp>
+
+#include <ggl/geometries/geometries.hpp>
+
+#include <ggl/geometries/adapted/c_array_cartesian.hpp>
+#include <ggl/geometries/adapted/tuple_cartesian.hpp>
+
+#include <ggl/geometries/adapted/boost_array_as_linestring.hpp>
+#include <ggl/geometries/adapted/std_as_linestring.hpp>
+
+#include <vector>
+#include <deque>
+
+
+template <typename G, typename Expected>
+void test_geometry()
+{
+    BOOST_CHECK_EQUAL(typeid(typename ggl::point_type<G>::type).name(),
+        typeid(Expected).name());
+}
+
+template <typename P>
+void test_all()
+{
+    test_geometry<P, P>();
+    test_geometry<const P, P>();
+    test_geometry<ggl::linestring<P> , P>();
+    test_geometry<ggl::linear_ring<P> , P>();
+    test_geometry<ggl::polygon<P> , P>();
+    test_geometry<ggl::box<P> , P>();
+    test_geometry<ggl::segment<P> , P>();
+    test_geometry<ggl::segment<const P> , P>();
+    test_geometry<ggl::nsphere<P, double> , P>();
+
+    test_geometry<std::vector<P>, P>();
+    test_geometry<std::deque<P>, P>();
+
+    test_geometry<boost::array<P, 5>, P>();
+}
+
+int test_main(int, char* [])
+{
+    test_geometry<int[2], int[2]>();
+    test_geometry<float[2], float[2]>();
+    test_geometry<double[2], double[2]>();
+
+    test_geometry<int[3], int[3]>();
+    test_geometry<float[3], float[3]>();
+    test_geometry<double[3], double[3]>();
+
+    test_geometry<boost::tuple<double, double>,
+                boost::tuple<double, double> >();
+    test_geometry<boost::tuple<double, double, double>,
+                boost::tuple<double, double, double> >();
+
+    test_all<ggl::point<int, 2, ggl::cs::cartesian> >();
+    test_all<ggl::point<float, 2, ggl::cs::cartesian> >();
+    test_all<ggl::point<double, 2, ggl::cs::cartesian> >();
+
+    return 0;
+}

Added: sandbox/ggl/formal_review_request/libs/ggl/test/core/radian_access.cpp
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/test/core/radian_access.cpp	2009-10-15 13:01:29 EDT (Thu, 15 Oct 2009)
@@ -0,0 +1,81 @@
+// Generic Geometry Library test file
+//
+// Copyright Barend Gehrels, 1995-2009, Geodan Holding B.V. Amsterdam, the Netherlands.
+// Copyright Bruno Lalande 2008, 2009
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/test/floating_point_comparison.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+
+#include <ggl/core/coordinate_type.hpp>
+#include <ggl/core/radian_access.hpp>
+
+#include <ggl/core/cs.hpp>
+#include <ggl/geometries/point.hpp>
+
+
+template <typename P, typename T>
+void test_get(T const& c1, T const& c2,
+    T const& e1, T const& e2)
+{
+    typedef typename ggl::coordinate_type<P>::type coordinate_type;
+
+    P p;
+    ggl::set<0>(p, coordinate_type(c1));
+    ggl::set<1>(p, coordinate_type(c2));
+
+    coordinate_type g1 = ggl::get_as_radian<0>(p);
+    coordinate_type g2 = ggl::get_as_radian<1>(p);
+
+    BOOST_CHECK_CLOSE(double(g1), double(e1), 0.0001);
+    BOOST_CHECK_CLOSE(double(g2), double(e2), 0.0001);
+}
+
+
+template <typename P, typename T>
+void test_set(T const& c1, T const& c2,
+    T const& e1, T const& e2)
+{
+    typedef typename ggl::coordinate_type<P>::type coordinate_type;
+
+    P p;
+    ggl::set_from_radian<0>(p, coordinate_type(c1));
+    ggl::set_from_radian<1>(p, coordinate_type(c2));
+
+    coordinate_type g1 = ggl::get<0>(p);
+    coordinate_type g2 = ggl::get<1>(p);
+
+    BOOST_CHECK_CLOSE(double(g1), double(e1), 0.0001);
+    BOOST_CHECK_CLOSE(double(g2), double(e2), 0.0001);
+}
+
+
+template <typename T>
+void test()
+{
+    double d2r = 3.1415926535897932384626433832795 / 180.0;
+
+    test_get<ggl::point<T, 2, ggl::cs::spherical<ggl::degree> > >
+        (1.0, 2.0, 1.0 * d2r, 2.0 * d2r);
+
+    test_get<ggl::point<T, 2, ggl::cs::spherical<ggl::radian> > >
+        (1.0, 2.0, 1.0, 2.0);
+
+    test_set<ggl::point<T, 2, ggl::cs::spherical<ggl::radian> > >
+        (1.0, 2.0, 1.0, 2.0);
+    test_set<ggl::point<T, 2, ggl::cs::spherical<ggl::degree> > >
+        (1.0 * d2r, 2.0 * d2r, 1.0, 2.0);
+
+}
+
+
+int test_main(int, char* [])
+{
+    //test<float>();
+    test<double>();
+
+    return 0;
+}

Added: sandbox/ggl/formal_review_request/libs/ggl/test/core/reverse_dispatch.cpp
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/test/core/reverse_dispatch.cpp	2009-10-15 13:01:29 EDT (Thu, 15 Oct 2009)
@@ -0,0 +1,60 @@
+// Generic Geometry Library test file
+//
+// Copyright Barend Gehrels, 1995-2009, Geodan Holding B.V. Amsterdam, the Netherlands.
+// Copyright Bruno Lalande 2008, 2009
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <iostream>
+
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <ggl/core/reverse_dispatch.hpp>
+
+#include <ggl/geometries/geometries.hpp>
+
+
+
+template <typename Geometry1, typename Geometry2, bool Expected>
+void test_reversed()
+{
+    BOOST_CHECK_EQUAL((ggl::reverse_dispatch<Geometry1, Geometry2>::type::value),
+                Expected);
+}
+
+
+template <typename P>
+void test_all()
+{
+
+    test_reversed<P, P, false>();
+    test_reversed<P, ggl::linestring<P>, false>();
+    test_reversed<ggl::linestring<P>, P, true>();
+    test_reversed<ggl::linear_ring<P>, P, true>();
+    test_reversed<ggl::linestring<P>, ggl::linear_ring<P>, false>();
+    test_reversed<ggl::linear_ring<P>, ggl::linestring<P>, true>();
+}
+
+template <typename P1, typename P2>
+void test_mixed()
+{
+    test_reversed<P1, P2, false>();
+}
+
+
+int test_main(int, char* [])
+{
+    test_all<ggl::point<int, 2, ggl::cs::cartesian> >();
+    test_mixed
+        <
+            ggl::point<int, 2, ggl::cs::cartesian>,
+            ggl::point<int, 2, ggl::cs::spherical<ggl::degree> >
+        >();
+    test_mixed
+        <
+            ggl::point<int, 2, ggl::cs::spherical<ggl::degree> >,
+            ggl::point<int, 2, ggl::cs::spherical<ggl::radian> >
+        >();
+    return 0;
+}

Added: sandbox/ggl/formal_review_request/libs/ggl/test/core/ring.cpp
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/test/core/ring.cpp	2009-10-15 13:01:29 EDT (Thu, 15 Oct 2009)
@@ -0,0 +1,68 @@
+// Generic Geometry Library test file
+//
+// Copyright Barend Gehrels, 1995-2009, Geodan Holding B.V. Amsterdam, the Netherlands.
+// Copyright Bruno Lalande 2008, 2009
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <iostream>
+
+#include <boost/test/included/test_exec_monitor.hpp>
+
+// To be tested:
+#include <ggl/core/ring_type.hpp>
+#include <ggl/core/exterior_ring.hpp>
+#include <ggl/core/interior_rings.hpp>
+
+// For geometries:
+#include <ggl/core/cs.hpp>
+#include <ggl/geometries/point.hpp>
+#include <ggl/geometries/polygon.hpp>
+
+
+#include <ggl/extensions/gis/io/wkt/read_wkt.hpp>
+
+
+
+
+template <typename P>
+void test_ring(std::string const& wkt,
+    int expected_main_count,
+    int expected_interior_ring_count,
+    int expected_first_interior_count)
+{
+    typedef ggl::polygon<P> the_polygon;
+    typedef typename ggl::ring_type<the_polygon>::type the_ring;
+    typedef typename ggl::interior_type<the_polygon>::type the_interior;
+
+    the_polygon poly;
+    read_wkt(wkt, poly);
+
+    the_ring ext = ggl::exterior_ring(poly);
+    the_interior rings = ggl::interior_rings(poly);
+
+    BOOST_CHECK_EQUAL(ggl::num_interior_rings(poly), expected_interior_ring_count);
+    BOOST_CHECK_EQUAL(boost::size(rings), expected_interior_ring_count);
+    BOOST_CHECK_EQUAL(boost::size(ext), expected_main_count);
+    if (boost::size(rings) > 0)
+    {
+        BOOST_CHECK_EQUAL(boost::size(rings.front()), expected_first_interior_count);
+    }
+}
+
+
+template <typename P>
+void test_all()
+{
+    test_ring<P>("POLYGON((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1))", 5, 1, 5);
+    test_ring<P>("POLYGON((0 0,0 3,3 3,3 0,0 0),(1 1,2 2,2 1,1 1),(1 1,1 2,2 2,1 1))", 5, 2, 4);
+    test_ring<P>("POLYGON((0 0,0 3,3 3,3 0,0 0))", 5, 0, 0);
+}
+
+
+int test_main(int, char* [])
+{
+    test_all<ggl::point<double, 2, ggl::cs::cartesian> >();
+    return 0;
+}

Added: sandbox/ggl/formal_review_request/libs/ggl/test/core/tag.cpp
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/test/core/tag.cpp	2009-10-15 13:01:29 EDT (Thu, 15 Oct 2009)
@@ -0,0 +1,69 @@
+// Generic Geometry Library test file
+//
+// Copyright Barend Gehrels, 1995-2009, Geodan Holding B.V. Amsterdam, the Netherlands.
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/concept/assert.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <ggl/core/tag.hpp>
+
+#include <ggl/geometries/geometries.hpp>
+
+#include <ggl/geometries/adapted/c_array_cartesian.hpp>
+#include <ggl/geometries/adapted/tuple_cartesian.hpp>
+
+#include <ggl/geometries/adapted/boost_array_as_linestring.hpp>
+#include <ggl/geometries/adapted/std_as_linestring.hpp>
+
+#include <vector>
+#include <deque>
+
+
+template <typename G, typename Expected>
+void test_geometry()
+{
+    BOOST_CHECK_EQUAL(typeid(typename ggl::tag<G>::type).name(),
+        typeid(Expected).name());
+}
+
+template <typename P, size_t D>
+void test_all()
+{
+    test_geometry<P, ggl::point_tag>();
+    test_geometry<const P, ggl::point_tag>();
+    test_geometry<ggl::linestring<P> , ggl::linestring_tag>();
+    test_geometry<ggl::linear_ring<P> , ggl::ring_tag>();
+    test_geometry<ggl::polygon<P> , ggl::polygon_tag>();
+    test_geometry<ggl::box<P> , ggl::box_tag>();
+    test_geometry<ggl::segment<P> , ggl::segment_tag>();
+    test_geometry<ggl::segment<const P> , ggl::segment_tag>();
+    test_geometry<ggl::nsphere<P, double> , ggl::nsphere_tag>();
+
+    test_geometry<std::vector<P>, ggl::linestring_tag>();
+    test_geometry<std::deque<P>, ggl::linestring_tag>();
+
+    test_geometry<boost::array<P, 5>, ggl::linestring_tag>();
+}
+
+int test_main(int, char* [])
+{
+    test_geometry<int[2], ggl::point_tag>();
+    test_geometry<float[2], ggl::point_tag>();
+    test_geometry<double[2], ggl::point_tag>();
+
+    test_geometry<int[3], ggl::point_tag>();
+    test_geometry<float[3], ggl::point_tag>();
+    test_geometry<double[3], ggl::point_tag>();
+
+    test_geometry<boost::tuple<double, double>, ggl::point_tag>();
+    test_geometry<boost::tuple<double, double, double>, ggl::point_tag>();
+
+    test_all<ggl::point<int, 2, ggl::cs::cartesian>, 2 >();
+    test_all<ggl::point<float, 2, ggl::cs::cartesian>, 2 >();
+    test_all<ggl::point<double, 2, ggl::cs::cartesian>, 2 >();
+
+    return 0;
+}

Added: sandbox/ggl/formal_review_request/libs/ggl/test/core/topological_dimension.cpp
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/test/core/topological_dimension.cpp	2009-10-15 13:01:29 EDT (Thu, 15 Oct 2009)
@@ -0,0 +1,68 @@
+// Generic Geometry Library test file
+//
+// Copyright Barend Gehrels, 1995-2009, Geodan Holding B.V. Amsterdam, the Netherlands.
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/concept/assert.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <ggl/core/topological_dimension.hpp>
+
+#include <ggl/geometries/geometries.hpp>
+
+#include <ggl/geometries/adapted/c_array_cartesian.hpp>
+#include <ggl/geometries/adapted/tuple_cartesian.hpp>
+
+#include <ggl/geometries/adapted/boost_array_as_linestring.hpp>
+#include <ggl/geometries/adapted/std_as_linestring.hpp>
+
+#include <vector>
+#include <deque>
+
+
+template <typename G, std::size_t Expected>
+void test_geometry()
+{
+    BOOST_CHECK_EQUAL(ggl::topological_dimension<G>::type::value, Expected);
+}
+
+template <typename P>
+void test_all()
+{
+    test_geometry<P, 0>();
+    test_geometry<const P, 0>();
+    test_geometry<ggl::linestring<P> , 1>();
+    test_geometry<ggl::linear_ring<P> , 2>(); // being discussed
+    test_geometry<ggl::polygon<P> , 2>();
+    test_geometry<ggl::box<P> , 2>();
+    test_geometry<ggl::segment<P> , 1>();
+    test_geometry<ggl::segment<const P> , 1>();
+    test_geometry<ggl::nsphere<P, double> , 2>(); // being discussed
+
+    test_geometry<std::vector<P>, 1>();
+    test_geometry<std::deque<P>, 1>();
+
+    test_geometry<boost::array<P, 5>, 1>();
+}
+
+int test_main(int, char* [])
+{
+    test_geometry<int[2], 0>();
+    test_geometry<float[2], 0>();
+    test_geometry<double[2], 0>();
+
+    test_geometry<int[3], 0>();
+    test_geometry<float[3], 0>();
+    test_geometry<double[3], 0>();
+
+    test_geometry<boost::tuple<double, double>, 0>();
+    test_geometry<boost::tuple<double, double, double>, 0>();
+
+    test_all<ggl::point<int, 2, ggl::cs::cartesian> >();
+    test_all<ggl::point<float, 2, ggl::cs::cartesian> >();
+    test_all<ggl::point<double, 2, ggl::cs::cartesian> >();
+
+    return 0;
+}