tests/unit/utility.h

   1 // $Id$
   2 //
   3 // GEOS Unit Test utilities, extension of TUT Framework namespace
   4 //
   5 #ifndef GEOS_TUT_UTILITY_H_INCLUDED
   6 #define GEOS_TUT_UTILITY_H_INCLUDED
   7
   8 // tut
   9 #include <tut.hpp>
  10 // geos
  11 #include <geos/geom/Geometry.h>
  12 #include <geos/geom/GeometryCollection.h>
  13 #include <geos/geom/Coordinate.h>
  14 #include <geos/geom/CoordinateArraySequence.h>
  15 #include <geos/geom/CoordinateArraySequenceFactory.h>
  16 #include <geos/geom/CoordinateSequenceFactory.h>
  17 #include <geos/geom/Dimension.h>
  18 #include <geos/geom/Point.h>
  19 #include <geos/geom/Polygon.h>
  20 #include <geos/geom/LinearRing.h>
  21 #include <geos/geom/LineString.h>
  22 #include <geos/geom/MultiPoint.h>
  23 #include <geos/geom/MultiLineString.h>
  24 #include <geos/geom/MultiPolygon.h>
  25 #include <geos/geom/PrecisionModel.h>
  26 #include <geos/geom/GeometryFactory.h>
  27 #include <geos/geom/prep/PreparedGeometry.h>
  28 #include <geos/io/WKTReader.h>
  29 // std
  30 #include <memory>
  31 #include <cstdlib>
  32 #include <cassert>
  33 #include <string>
  34 #include <vector>
  35
  36 namespace tut
  37 {
  38
  39 //
  40 // Helper typedefs
  41 //
  42 typedef geos::geom::Coordinate* CoordinatePtr;
  43 typedef geos::geom::Coordinate const* CoordinateCPtr;
  44
  45 typedef geos::geom::CoordinateSequence* CoordSeqPtr;
  46 typedef geos::geom::CoordinateSequence const* CoordSeqCPtr;
  47
  48 typedef geos::geom::CoordinateArraySequence* CoordArrayPtr;
  49 typedef geos::geom::CoordinateArraySequence const* CoordArrayCPtr;
  50
  51 typedef geos::geom::Geometry* GeometryPtr;
  52 typedef geos::geom::Geometry const* GeometryCPtr;
  53
  54 typedef geos::geom::Point* PointPtr;
  55 typedef geos::geom::Point const* PointCPtr;
  56 typedef geos::geom::LinearRing* LinearRingPtr;
  57 typedef geos::geom::LinearRing const* LinearRingCPtr;
  58 typedef geos::geom::LineString* LineStringPtr;
  59 typedef geos::geom::LineString const* LineStringCPtr;
  60 typedef geos::geom::Polygon* PolygonPtr;
  61 typedef geos::geom::Polygon const* PolygonCPtr;
  62
  63 typedef geos::geom::GeometryCollection* GeometryColPtr;
  64 typedef geos::geom::GeometryCollection const* GeometryColCPtr;
  65
  66 typedef geos::geom::MultiPoint* MultiPointPtr;
  67 typedef geos::geom::MultiPoint const* MultiPointCPtr;
  68 typedef geos::geom::MultiLineString* MultiLineStringPtr;
  69 typedef geos::geom::MultiLineString const* MultiLineStringCPtr;
  70 typedef geos::geom::MultiPolygon* MultiPolygonPtr;
  71 typedef geos::geom::MultiPolygon const* MultiPolygonCPtr;
  72
  73 // prepared geometries always returend as const
  74 typedef geos::geom::prep::PreparedGeometry const* PreparedGeometryPtr;
  75
  76 //
  77 // Type cast helper utilities
  78 //
  79
  80 template<typename Type, typename InstanceType>
  81 inline bool isInstanceOf(InstanceType const* instance)
  82 {
  83     assert(0 != instance);
  84     return (0 != dynamic_cast<Type const*>(instance) );
  85 }
  86
  87 template<typename Type, typename InstanceType>
  88 inline Type const* instanceOf(InstanceType const* instance)
  89 {
  90     assert(0 != instance);
  91     return dynamic_cast<Type const*>(instance);
  92 }
  93
  94 template <typename Dst, typename Src>
  95 std::auto_ptr<Dst> dynamic_cast_auto_ptr(std::auto_ptr<Src>& ptr)
  96 {
  97     Dst* res = dynamic_cast<Dst*>(ptr.get());
  98     if (0 != res)
  99     {
 100         ptr.release();
 101     }
 102     return std::auto_ptr<Dst>(res);
 103 }
 104
 105 template <typename Dst, typename Src>
 106 std::auto_ptr<Dst> static_cast_auto_ptr(std::auto_ptr<Src>& ptr)
 107 {
 108     return std::auto_ptr<Dst>(static_cast<Dst*>(ptr.release()));
 109 }
 110
 111 //
 112 // Geometries structure comparators
 113 //
 114
 115 template <typename T1, typename T2>
 116 inline void ensure_equals_geometry(T1 const* lhs, T2 const* rhs)
 117 {
 118     assert(0 != lhs);
 119     assert(0 != rhs);
 120
 121     assert(!"DIFFERENT TYPES ARE NOT OF THE SAME STRUCTURE");
 122 }
 123
 124 template <typename T>
 125 inline void ensure_equals_geometry(T const* lhs, T const* rhs)
 126 {
 127     assert(0 != lhs);
 128     assert(0 != rhs);
 129
 130     using geos::geom::Polygon;
 131     using geos::geom::GeometryCollection;
 132
 133     ensure_equals("is-valid do not match",
 134                   lhs->isValid(), rhs->isValid());
 135
 136     ensure_equals("is-empty do not match",
 137                   lhs->isEmpty(), rhs->isEmpty());
 138
 139     if (!isInstanceOf<GeometryCollection>(lhs)
 140          && !isInstanceOf<GeometryCollection>(rhs))
 141     {
 142         ensure_equals("is-simple do not match",
 143                       lhs->isSimple(), rhs->isSimple());
 144     }
 145
 146     ensure_equals("type do not match",
 147                   lhs->getGeometryType(), rhs->getGeometryType());
 148
 149     ensure_equals("type id do not match",
 150                   lhs->getGeometryTypeId(), rhs->getGeometryTypeId());
 151
 152     ensure_equals("dimension do not match",
 153                   lhs->getDimension(), rhs->getDimension());
 154
 155     ensure_equals("boundary dimension do not match",
 156                   lhs->getBoundaryDimension(), rhs->getBoundaryDimension());
 157
 158     // NOTE - mloskot: Intentionally disabled, so simplified geometry
 159     // can be compared to its original
 160     //ensure_equals("number of points do not match",
 161     //              lhs->getNumPoints(), rhs->getNumPoints());
 162
 163     // Dispatch to run more specific testes
 164     if (isInstanceOf<Polygon>(lhs)
 165         && isInstanceOf<Polygon>(rhs))
 166     {
 167         ensure_equals_geometry(instanceOf<Polygon>(lhs),
 168                         instanceOf<Polygon>(rhs));
 169     }
 170     else if (isInstanceOf<GeometryCollection>(lhs)
 171              && isInstanceOf<GeometryCollection>(rhs))
 172     {
 173         ensure_equals_geometry(instanceOf<GeometryCollection>(lhs),
 174                         instanceOf<GeometryCollection>(rhs));
 175     }
 176 }
 177
 178 template <>
 179 inline void ensure_equals_geometry(geos::geom::Polygon const* lhs,
 180                                    geos::geom::Polygon const* rhs)
 181 {
 182     assert(0 != lhs);
 183     assert(0 != rhs);
 184
 185     ensure_equals("number of interior ring do not match",
 186                   lhs->getNumInteriorRing(), rhs->getNumInteriorRing());
 187 }
 188
 189 template <>
 190 inline void ensure_equals_geometry(geos::geom::GeometryCollection const* lhs,
 191                                    geos::geom::GeometryCollection const* rhs)
 192 {
 193     assert(0 != lhs);
 194     assert(0 != rhs);
 195
 196     using geos::geom::Geometry;
 197
 198     ensure_equals("number of geometries do not match",
 199                   lhs->getNumGeometries(), rhs->getNumGeometries());
 200
 201     for (std::size_t i = 0, n = lhs->getNumGeometries(); i < n; ++i)
 202     {
 203         Geometry const* g1 = lhs->getGeometryN(i);
 204         Geometry const* g2 = rhs->getGeometryN(i);
 205         ensure_equals_geometry(g1, g2); // breaks on failure
 206     }
 207 }
 208
 209 template <>
 210 inline void ensure_equals_geometry(geos::geom::Geometry const* lhs,
 211                                    geos::geom::prep::PreparedGeometry const* rhs)
 212 {
 213     assert(0 != lhs);
 214     assert(0 != rhs);
 215
 216     geos::geom::Geometry const& pg = rhs->getGeometry();
 217     ensure_equals_geometry(lhs, &pg);
 218 }
 219
 220 //
 221 // Utility functions
 222 //
 223
 224 // Decodes hex-encoded WKB/EWKB to raw binary.
 225 struct wkb_hex_decoder
 226 {
 227     typedef std::vector<unsigned char> binary_type;
 228
 229     // bytes [out] - buffer for binary output
 230     static void decode(std::string const& hexstr, binary_type& bytes)
 231     {
 232         bytes.clear();
 233         for(std::string::size_type i = 0; i < hexstr.size() / 2; ++i)
 234         {
 235             std::istringstream iss(hexstr.substr(i * 2, 2));
 236             unsigned int n;
 237             iss >> std::hex >> n;
 238             bytes.push_back(static_cast<unsigned char>(n));
 239         }
 240     }
 241 };
 242
 243
 244 } // namespace tut
 245
 246 #endif // #ifndef GEOS_TUT_UTILITY_H_INCLUDED
 247