diff --git a/src/db/unit_tests/dbEdgePairTests.cc b/src/db/unit_tests/dbEdgePairTests.cc
index 251bc15be..cd24fc074 100644
--- a/src/db/unit_tests/dbEdgePairTests.cc
+++ b/src/db/unit_tests/dbEdgePairTests.cc
@@ -20,8 +20,6 @@
 
 */
 
-
-
 #include "dbEdgePair.h"
 #include "dbHash.h"
 #include "tlUnitTest.h"
diff --git a/src/db/unit_tests/dbEdgePairsTests.cc b/src/db/unit_tests/dbEdgePairsTests.cc
index 6d7f01d5b..e20d543ee 100644
--- a/src/db/unit_tests/dbEdgePairsTests.cc
+++ b/src/db/unit_tests/dbEdgePairsTests.cc
@@ -26,6 +26,7 @@
 #include "dbEdgePairs.h"
 #include "dbEdges.h"
 #include "dbRegion.h"
+#include "dbTestSupport.h"
 
 TEST(1) 
 {
@@ -87,27 +88,27 @@ TEST(2)
   ep.insert (db::EdgePair (db::Edge (db::Point (10, 20), db::Point (110, 120)), db::Edge (db::Point (-10, -20), db::Point (90, 80))));
   ep.insert (db::EdgePair (db::Edge (db::Point (10, 20), db::Point (110, 120)), db::Edge (db::Point (90, 80), db::Point (-10, -20))));
 
-  EXPECT_EQ (ep.to_string (), "(10,20;110,120)/(-10,-20;90,80);(10,20;110,120)/(90,80;-10,-20)");
+  EXPECT_EQ (db::compare (ep, "(10,20;110,120)/(-10,-20;90,80);(10,20;110,120)/(90,80;-10,-20)"), true);
 
   db::EdgePairs ee;
   std::string s = ep.to_string ();
   tl::Extractor ex (s.c_str ());
   EXPECT_EQ (ex.try_read (ee), true);
-  EXPECT_EQ (ee.to_string (), "(10,20;110,120)/(-10,-20;90,80);(10,20;110,120)/(90,80;-10,-20)");
+  EXPECT_EQ (db::compare (ee, "(10,20;110,120)/(-10,-20;90,80);(10,20;110,120)/(90,80;-10,-20)"), true);
 
   db::Edges e;
   ep.edges (e);
-  EXPECT_EQ (e.to_string (), "(10,20;110,120);(-10,-20;90,80);(10,20;110,120);(90,80;-10,-20)");
+  EXPECT_EQ (db::compare (e, "(10,20;110,120);(-10,-20;90,80);(10,20;110,120);(90,80;-10,-20)"), true);
   e.clear ();
   ep.first_edges (e);
-  EXPECT_EQ (e.to_string (), "(10,20;110,120);(10,20;110,120)");
+  EXPECT_EQ (db::compare (e, "(10,20;110,120);(10,20;110,120)"), true);
   e.clear ();
   ep.second_edges (e);
-  EXPECT_EQ (e.to_string (), "(-10,-20;90,80);(90,80;-10,-20)");
+  EXPECT_EQ (db::compare (e, "(-10,-20;90,80);(90,80;-10,-20)"), true);
 
   db::Region r;
   ep.polygons (r);
-  EXPECT_EQ (r.to_string (), "(-10,-20;10,20;110,120;90,80);(-10,-20;10,20;110,120;90,80)");
+  EXPECT_EQ (db::compare (r, "(-10,-20;10,20;110,120;90,80);(-10,-20;10,20;110,120;90,80)"), true);
 }
 
 struct EPTestFilter
@@ -157,5 +158,5 @@ TEST(4)
   ep.insert_into_as_polygons (&ly, top_cell, l1, 1);
 
   db::Region r (db::RecursiveShapeIterator (ly, ly.cell (top_cell), l1));
-  EXPECT_EQ (r.to_string (), "(-10,-21;9,20;50,51;91,80);(-10,-21;9,20;110,121;91,80)");
+  EXPECT_EQ (db::compare (r, "(-10,-21;9,20;50,51;91,80);(-10,-21;9,20;110,121;91,80)"), true);
 }
diff --git a/src/db/unit_tests/dbEdgesTests.cc b/src/db/unit_tests/dbEdgesTests.cc
index c5e141076..15740ccde 100644
--- a/src/db/unit_tests/dbEdgesTests.cc
+++ b/src/db/unit_tests/dbEdgesTests.cc
@@ -27,10 +27,11 @@
 #include "dbEdgesUtils.h"
 #include "dbPolygonTools.h"
 #include "dbRegion.h"
+#include "dbTestSupport.h"
 
 #include <cstdlib>
 
-TEST(1) 
+TEST(1)
 {
   db::Edges r;
   EXPECT_EQ (r.to_string (), "");
@@ -49,8 +50,8 @@ TEST(1)
   EXPECT_EQ (r != r, false);
   EXPECT_EQ (r == r, true);
   EXPECT_EQ (r < r, false);
-  EXPECT_EQ (r.to_string (), "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0)");
-  EXPECT_EQ (r.transformed (db::Trans (db::Vector (1, 2))).to_string (), "(1,2;1,202);(1,202;101,202);(101,202;101,2);(101,2;1,2)");
+  EXPECT_EQ (db::compare (r, "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0)"), true);
+  EXPECT_EQ (db::compare (r.transformed (db::Trans (db::Vector (1, 2))), "(1,2;1,202);(1,202;101,202);(101,202;101,2);(101,2;1,2)"), true);
   EXPECT_EQ (r.bbox ().to_string (), "(0,0;100,200)");
   EXPECT_EQ (r.transformed (db::Trans (db::Vector (1, 2))).bbox ().to_string (), "(1,2;101,202)");
   EXPECT_EQ (r.empty (), false);
@@ -59,27 +60,27 @@ TEST(1)
 
   db::Edges r1 = r;
   db::Edges r2;
-  EXPECT_EQ (r1.to_string (), "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0)");
-  EXPECT_EQ (r1.merged ().to_string (), "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0)");
+  EXPECT_EQ (db::compare (r1, "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0)"), true);
+  EXPECT_EQ (db::compare (r1.merged (), "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0)"), true);
   EXPECT_EQ (r2.to_string (), "");
   EXPECT_EQ (r1.bbox ().to_string (), "(0,0;100,200)");
   EXPECT_EQ (r2.bbox ().to_string (), "()");
   r1.swap (r2);
   EXPECT_EQ (r1.to_string (), "");
-  EXPECT_EQ (r2.to_string (), "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0)");
+  EXPECT_EQ (db::compare (r2, "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0)"), true);
   EXPECT_EQ (r1.bbox ().to_string (), "()");
   EXPECT_EQ (r2.bbox ().to_string (), "(0,0;100,200)");
 
-  EXPECT_EQ ((r | db::Edges (db::Box (db::Point (10, 0), db::Point (110, 200)))).to_string (), "(0,0;0,200);(100,200;100,0);(10,0;10,200);(0,200;110,200);(110,200;110,0);(110,0;0,0)");
-  EXPECT_EQ ((r + db::Edges (db::Box (db::Point (10, 0), db::Point (110, 200)))).to_string (), "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0);(10,0;10,200);(10,200;110,200);(110,200;110,0);(110,0;10,0)");
+  EXPECT_EQ (db::compare ((r | db::Edges (db::Box (db::Point (10, 0), db::Point (110, 200)))), "(0,0;0,200);(100,200;100,0);(10,0;10,200);(0,200;110,200);(110,200;110,0);(110,0;0,0)"), true);
+  EXPECT_EQ (db::compare ((r + db::Edges (db::Box (db::Point (10, 0), db::Point (110, 200)))), "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0);(10,0;10,200);(10,200;110,200);(110,200;110,0);(110,0;10,0)"), true);
 
   db::Edges rr = r;
   rr |= db::Edges (db::Box (db::Point (10, 0), db::Point (110, 200)));
   EXPECT_EQ (rr.is_merged (), true);
-  EXPECT_EQ (rr.to_string (), "(0,0;0,200);(100,200;100,0);(10,0;10,200);(0,200;110,200);(110,200;110,0);(110,0;0,0)");
+  EXPECT_EQ (db::compare (rr, "(0,0;0,200);(100,200;100,0);(10,0;10,200);(0,200;110,200);(110,200;110,0);(110,0;0,0)"), true);
 
   r += db::Edges (db::Box (db::Point (10, 0), db::Point (110, 200)));
-  EXPECT_EQ (r.to_string (), "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0);(10,0;10,200);(10,200;110,200);(110,200;110,0);(110,0;10,0)");
+  EXPECT_EQ (db::compare (r, "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0);(10,0;10,200);(10,200;110,200);(110,200;110,0);(110,0;10,0)"), true);
   EXPECT_EQ (r.is_merged (), false);
   EXPECT_EQ (r.count (), size_t (8));
   EXPECT_EQ (r.hier_count (), size_t (8));
@@ -94,7 +95,7 @@ TEST(1)
   EXPECT_EQ (r.length (db::Box (db::Point (-10, -10), db::Point (0, 50))), db::Edges::length_type (0));
   EXPECT_EQ (r.length (db::Box (db::Point (0, 0), db::Point (50, 50))), db::Edges::length_type (150));
   r.merge ();
-  EXPECT_EQ (r.to_string (), "(0,0;0,200);(100,200;100,0);(10,0;10,200);(0,200;110,200);(110,200;110,0);(110,0;0,0)");
+  EXPECT_EQ (db::compare (r, "(0,0;0,200);(100,200;100,0);(10,0;10,200);(0,200;110,200);(110,200;110,0);(110,0;0,0)"), true);
   EXPECT_EQ (r.bbox ().to_string (), "(0,0;110,200)");
   EXPECT_EQ (r.is_merged (), true);
   EXPECT_EQ (r.empty (), false);
@@ -118,24 +119,24 @@ TEST(2)
   db::Edges r2;
   r2.insert (db::Box (db::Point (0, 10), db::Point (100, 210)));
 
-  EXPECT_EQ ((r & r1).to_string (), "(10,200;100,200);(100,0;10,0)");
-  EXPECT_EQ ((r & r2).to_string (), "(0,10;0,200);(100,200;100,10)");
+  EXPECT_EQ (db::compare ((r & r1), "(10,200;100,200);(100,0;10,0)"), true);
+  EXPECT_EQ (db::compare ((r & r2), "(0,10;0,200);(100,200;100,10)"), true);
   db::Edges o1 = r;
   o1 &= r1;
   EXPECT_EQ (o1.is_merged (), true);
-  EXPECT_EQ (o1.to_string (), "(10,200;100,200);(100,0;10,0)");
+  EXPECT_EQ (db::compare (o1, "(10,200;100,200);(100,0;10,0)"), true);
 
-  EXPECT_EQ ((r - r1).to_string (), "(0,0;0,200);(100,200;100,0);(0,200;10,200);(10,0;0,0)");
+  EXPECT_EQ (db::compare ((r - r1), "(0,0;0,200);(100,200;100,0);(0,200;10,200);(10,0;0,0)"), true);
   db::Edges o2 = r;
   o2 -= r1;
   EXPECT_EQ (o2.is_merged (), true);
-  EXPECT_EQ (o2.to_string (), "(0,0;0,200);(100,200;100,0);(0,200;10,200);(10,0;0,0)");
+  EXPECT_EQ (db::compare (o2, "(0,0;0,200);(100,200;100,0);(0,200;10,200);(10,0;0,0)"), true);
 
-  EXPECT_EQ ((r ^ r1).to_string (), "(0,0;0,200);(100,200;100,0);(10,0;10,200);(0,200;10,200);(100,200;110,200);(110,200;110,0);(110,0;100,0);(10,0;0,0)");
+  EXPECT_EQ (db::compare ((r ^ r1), "(0,0;0,200);(100,200;100,0);(10,0;10,200);(0,200;10,200);(100,200;110,200);(110,200;110,0);(110,0;100,0);(10,0;0,0)"), true);
   db::Edges o3 = r;
   o3 ^= r1;
   EXPECT_EQ (o3.is_merged (), true);
-  EXPECT_EQ (o3.to_string (), "(0,0;0,200);(100,200;100,0);(10,0;10,200);(0,200;10,200);(100,200;110,200);(110,200;110,0);(110,0;100,0);(10,0;0,0)");
+  EXPECT_EQ (db::compare (o3, "(0,0;0,200);(100,200;100,0);(10,0;10,200);(0,200;10,200);(100,200;110,200);(110,200;110,0);(110,0;100,0);(10,0;0,0)"), true);
 
   r.clear ();
   r.insert (db::Box (db::Point (1000, 0), db::Point (6000, 4000)));
@@ -157,11 +158,11 @@ TEST(3)
   rr.insert (db::Edge (db::Point (10, 1), db::Point (60, 6)));
   rr.insert (db::Edge (db::Point (50, 5), db::Point (70, 7)));
 
-  EXPECT_EQ (r.merged ().to_string (), "(0,0;150,15);(200,20;230,23)");
+  EXPECT_EQ (db::compare (r.merged (), "(0,0;150,15);(200,20;230,23)"), true);
   EXPECT_EQ (rr.merged ().to_string (), "(10,1;70,7)");
-  EXPECT_EQ ((r ^ rr).to_string (), "(200,20;230,23);(0,0;10,1);(70,7;150,15)");
-  EXPECT_EQ ((rr ^ r).to_string (), "(0,0;10,1);(70,7;150,15);(200,20;230,23)");
-  EXPECT_EQ ((r - rr).to_string (), "(200,20;230,23);(0,0;10,1);(70,7;150,15)");
+  EXPECT_EQ (db::compare ((r ^ rr), "(200,20;230,23);(0,0;10,1);(70,7;150,15)"), true);
+  EXPECT_EQ (db::compare ((rr ^ r), "(0,0;10,1);(70,7;150,15);(200,20;230,23)"), true);
+  EXPECT_EQ (db::compare ((r - rr), "(200,20;230,23);(0,0;10,1);(70,7;150,15)"), true);
   EXPECT_EQ ((rr - r).to_string (), "");
   EXPECT_EQ ((r & rr).to_string (), "(10,1;70,7)");
   EXPECT_EQ ((rr & r).to_string (), "(10,1;70,7)");
@@ -181,39 +182,39 @@ TEST(4)
     db::EdgeLengthFilter f1 (100, 101, false);
     db::Edges rr = r;
     rr.filter (f1);
-    EXPECT_EQ (rr.to_string (), "(0,200;100,200);(100,0;0,0);(300,0;200,0)");
+    EXPECT_EQ (db::compare (rr, "(0,200;100,200);(100,0;0,0);(300,0;200,0)"), true);
   }
   {
     db::EdgeLengthFilter f1 (201, 1000, false);
     db::Edges rr = r;
     rr.filter (f1);
-    EXPECT_EQ (rr.to_string (), "(200,0;250,200);(250,200;300,0);(200,0;250,-200);(250,-200;300,0)");
+    EXPECT_EQ (db::compare (rr, "(200,0;250,200);(250,200;300,0);(200,0;250,-200);(250,-200;300,0)"), true);
   }
   {
     db::EdgeLengthFilter f1 (201, 1000, true);
     db::Edges rr = r;
     rr.filter (f1);
-    EXPECT_EQ (rr.to_string (), "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0);(300,0;200,0)");
+    EXPECT_EQ (db::compare (rr, "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0);(300,0;200,0)"), true);
   }
   {
     db::EdgeOrientationFilter f1 (0.0, false);
-    EXPECT_EQ (r.filtered (f1).to_string (), "(0,200;100,200);(100,0;0,0);(300,0;200,0)");
+    EXPECT_EQ (db::compare (r.filtered (f1), "(0,200;100,200);(100,0;0,0);(300,0;200,0)"), true);
   }
   {
     db::EdgeOrientationFilter f1 (50.0, true, 80.0, false, false);
-    EXPECT_EQ (r.filtered (f1).to_string (), "(200,0;250,200);(250,-200;300,0)");
+    EXPECT_EQ (db::compare (r.filtered (f1), "(200,0;250,200);(250,-200;300,0)"), true);
   }
   {
     db::EdgeOrientationFilter f1 (50.0, true, 80.0, false, true);
-    EXPECT_EQ (r.filtered (f1).to_string (), "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0);(250,200;300,0);(300,0;200,0);(200,0;250,-200)");
+    EXPECT_EQ (db::compare (r.filtered (f1), "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0);(250,200;300,0);(300,0;200,0);(200,0;250,-200)"), true);
   }
   {
     db::EdgeOrientationFilter f1 (0.0, true, 1.0, false, false);
-    EXPECT_EQ (r.filtered (f1).to_string (), "(0,200;100,200);(100,0;0,0);(300,0;200,0)");
+    EXPECT_EQ (db::compare (r.filtered (f1), "(0,200;100,200);(100,0;0,0);(300,0;200,0)"), true);
   }
   {
     db::EdgeOrientationFilter f1 (-1.0, true, 1.0, false, false);
-    EXPECT_EQ (r.filtered (f1).to_string (), "(0,200;100,200);(100,0;0,0);(300,0;200,0)");
+    EXPECT_EQ (db::compare (r.filtered (f1), "(0,200;100,200);(100,0;0,0);(300,0;200,0)"), true);
   }
   {
     db::EdgeOrientationFilter f1 (-1.0, true, 0.0, false, false);
@@ -221,11 +222,11 @@ TEST(4)
   }
   {
     db::EdgeOrientationFilter f1 (-1.0, true, 0.0, true, false);
-    EXPECT_EQ (r.filtered (f1).to_string (), "(0,200;100,200);(100,0;0,0);(300,0;200,0)");
+    EXPECT_EQ (db::compare (r.filtered (f1), "(0,200;100,200);(100,0;0,0);(300,0;200,0)"), true);
   }
   {
     db::EdgeOrientationFilter f1 (0.0, true, 1.0, true, false);
-    EXPECT_EQ (r.filtered (f1).to_string (), "(0,200;100,200);(100,0;0,0);(300,0;200,0)");
+    EXPECT_EQ (db::compare (r.filtered (f1), "(0,200;100,200);(100,0;0,0);(300,0;200,0)"), true);
   }
   {
     db::EdgeOrientationFilter f1 (0.0, false, 1.0, true, false);
@@ -233,15 +234,15 @@ TEST(4)
   }
   {
     db::EdgeOrientationFilter f1 (90.0, false);
-    EXPECT_EQ (r.filtered (f1).to_string (), "(0,0;0,200);(100,200;100,0)");
+    EXPECT_EQ (db::compare (r.filtered (f1), "(0,0;0,200);(100,200;100,0)"), true);
   }
   {
     db::EdgeOrientationFilter f1 (90.0, true, 91.0, false, false);
-    EXPECT_EQ (r.filtered (f1).to_string (), "(0,0;0,200);(100,200;100,0)");
+    EXPECT_EQ (db::compare (r.filtered (f1), "(0,0;0,200);(100,200;100,0)"), true);
   }
   {
     db::EdgeOrientationFilter f1 (89.0, true, 91.0, false, false);
-    EXPECT_EQ (r.filtered (f1).to_string (), "(0,0;0,200);(100,200;100,0)");
+    EXPECT_EQ (db::compare (r.filtered (f1), "(0,0;0,200);(100,200;100,0)"), true);
   }
   {
     db::EdgeOrientationFilter f1 (89.0, true, 90.0, false, false);
@@ -253,18 +254,18 @@ TEST(5)
 {
   db::Edges r;
   r.insert (db::Polygon (db::Box (db::Point (0, 0), db::Point (100, 200))));
-  EXPECT_EQ (r.to_string (), "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0)");
+  EXPECT_EQ (db::compare (r, "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0)"), true);
   r.clear ();
   r.insert (db::SimplePolygon (db::Box (db::Point (0, 0), db::Point (100, 200))));
-  EXPECT_EQ (r.to_string (), "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0)");
+  EXPECT_EQ (db::compare (r, "(0,0;0,200);(0,200;100,200);(100,200;100,0);(100,0;0,0)"), true);
   r.transform (db::ICplxTrans (2.5));
-  EXPECT_EQ (r.to_string (), "(0,0;0,500);(0,500;250,500);(250,500;250,0);(250,0;0,0)");
+  EXPECT_EQ (db::compare (r, "(0,0;0,500);(0,500;250,500);(250,500;250,0);(250,0;0,0)"), true);
 
   db::Edges rr;
   std::string s = r.to_string ();
   tl::Extractor ex (s.c_str ());
   EXPECT_EQ (ex.try_read (rr), true);
-  EXPECT_EQ (rr.to_string (), "(0,0;0,500);(0,500;250,500);(250,500;250,0);(250,0;0,0)");
+  EXPECT_EQ (db::compare (rr, "(0,0;0,500);(0,500;250,500);(250,500;250,0);(250,0;0,0)"), true);
 }
 
 TEST(6) 
@@ -277,31 +278,31 @@ TEST(6)
 
   db::Region r;
   e.extended (r, 0, 0, 20, 0, false);
-  EXPECT_EQ (r.to_string (), "(-20,0;-20,200;0,200;0,0);(0,200;0,220;100,220;100,200);(200,0;181,5;231,205;250,200);(300,0;250,200;269,205;319,5)");
+  EXPECT_EQ (db::compare (r, "(-20,0;-20,200;0,200;0,0);(0,200;0,220;100,220;100,200);(200,0;181,5;231,205;250,200);(300,0;250,200;269,205;319,5)"), true);
 
   r.clear ();
   e.extended (r, 0, 0, 20, 0, true);
-  EXPECT_EQ (r.to_string (), "(-20,0;-20,220;100,220;100,200;0,200;0,0);(200,0;181,5;235,224;265,224;319,5;300,0;250,200)");
+  EXPECT_EQ (db::compare (r, "(-20,0;-20,220;100,220;100,200;0,200;0,0);(200,0;181,5;235,224;265,224;319,5;300,0;250,200)"), true);
 
   r.clear ();
   e.extended (r, 0, 0, 0, 10, false);
-  EXPECT_EQ (r.to_string (), "(0,0;0,200;10,200;10,0);(0,190;0,200;100,200;100,190);(210,-2;200,0;250,200;260,198);(290,-2;240,198;250,200;300,0)");
+  EXPECT_EQ (db::compare (r, "(0,0;0,200;10,200;10,0);(0,190;0,200;100,200;100,190);(210,-2;200,0;250,200;260,198);(290,-2;240,198;250,200;300,0)"), true);
 
   r.clear ();
   e.extended (r, 0, 0, 0, 10, true);
-  EXPECT_EQ (r.to_string (), "(0,0;0,200;100,200;100,190;10,190;10,0);(210,-2;200,0;250,200;300,0;290,-2;250,159)");
+  EXPECT_EQ (db::compare (r, "(0,0;0,200;100,200;100,190;10,190;10,0);(210,-2;200,0;250,200;300,0;290,-2;250,159)"), true);
 
   r.clear ();
   e.extended (r, 10, 20, 0, 10, true);
-  EXPECT_EQ (r.to_string (), "(0,-10;0,200;120,200;120,190;10,190;10,-10);(295,-22;250,159;207,-12;198,-10;250,200;305,-19)");
+  EXPECT_EQ (db::compare (r, "(0,-10;0,200;120,200;120,190;10,190;10,-10);(295,-22;250,159;207,-12;198,-10;250,200;305,-19)"), true);
 
   r.clear ();
   e.extended (r, 10, 20, 0, 10, false);
-  EXPECT_EQ (r.to_string (), "(0,-10;0,220;10,220;10,-10);(-10,190;-10,200;120,200;120,190);(207,-12;198,-10;255,219;265,217);(295,-22;238,207;248,210;305,-19)");
+  EXPECT_EQ (db::compare (r, "(0,-10;0,220;10,220;10,-10);(-10,190;-10,200;120,200;120,190);(207,-12;198,-10;255,219;265,217);(295,-22;238,207;248,210;305,-19)"), true);
 
   r.clear ();
   e.extended (r, 10, 20, 20, -10, false);
-  EXPECT_EQ (r.to_string (), "(-20,-10;-20,220;-10,220;-10,-10);(-10,210;-10,220;120,220;120,210);(188,-7;178,-5;235,224;245,222);(315,-17;257,212;267,215;324,-15)");
+  EXPECT_EQ (db::compare (r, "(-20,-10;-20,220;-10,220;-10,-10);(-10,210;-10,220;120,220;120,210);(188,-7;178,-5;235,224;245,222);(315,-17;257,212;267,215;324,-15)"), true);
 
   /* This is not working properly yet:
    * Apparently db::Path is not able to produce the right inner corner.
@@ -315,7 +316,7 @@ TEST(6)
 
   r.clear ();
   e.extended (r, 10, 20, 0, 10, false);
-  EXPECT_EQ (r.to_string (), "(0,-10;0,220;10,220;10,-10);(-10,190;-10,200;120,200;120,190);(90,-20;90,210;100,210;100,-20);(-20,0;-20,10;110,10;110,0)");
+  EXPECT_EQ (db::compare (r, "(0,-10;0,220;10,220;10,-10);(-10,190;-10,200;120,200;120,190);(90,-20;90,210;100,210;100,-20);(-20,0;-20,10;110,10;110,0)"), true);
 
   r.clear ();
   e.extended (r, 10, 20, 0, 10, true);
@@ -338,7 +339,7 @@ TEST(6b)
 
   db::Region r;
   e.extended (r, 0, 0, 20, 0, true);
-  EXPECT_EQ (r.to_string (), "(0,-200;0,0;20,0;20,-180;100,-180;100,-200);(250,-200;200,0;219,5;250,-118;281,5;300,0)");
+  EXPECT_EQ (db::compare (r, "(0,-200;0,0;20,0;20,-180;100,-180;100,-200);(250,-200;200,0;219,5;250,-118;281,5;300,0)"), true);
 }
 
 TEST(6c)
@@ -356,7 +357,7 @@ TEST(6c)
 
   db::Region r;
   e.extended (r, 0, 0, 20, 0, true);
-  EXPECT_EQ (r.to_string (), "(0,-200;0,0;20,0;20,-180;100,-180;100,-200);(0,-200;0,-100;20,-100;20,-180;200,-180;200,-200);(250,-200;200,0;219,5;250,-118;281,5;300,0);(250,-200;232,-191;332,9;350,0)");
+  EXPECT_EQ (db::compare (r, "(0,-200;0,0;20,0;20,-180;100,-180;100,-200);(0,-200;0,-100;20,-100;20,-180;200,-180;200,-200);(250,-200;200,0;219,5;250,-118;281,5;300,0);(250,-200;232,-191;332,9;350,0)"), true);
 }
 
 TEST(7)
@@ -365,20 +366,20 @@ TEST(7)
   e.insert (db::Edge (db::Point (0, 0), db::Point (0, 200)));
   e.insert (db::Edge (db::Point (250, 200), db::Point (300, 0)));
 
-  EXPECT_EQ (e.start_segments (10, 0).to_string (), "(0,0;0,10);(250,200;252,190)");
-  EXPECT_EQ (e.start_segments (10, 0.25).to_string (), "(0,0;0,50);(250,200;263,150)");
-  EXPECT_EQ (e.start_segments (0, 1.0).to_string (), "(0,0;0,200);(250,200;300,0)");
-  EXPECT_EQ (e.start_segments (0, 0).to_string (), "(0,0;0,0);(250,200;250,200)");
+  EXPECT_EQ (db::compare (e.start_segments (10, 0), "(0,0;0,10);(250,200;252,190)"), true);
+  EXPECT_EQ (db::compare (e.start_segments (10, 0.25), "(0,0;0,50);(250,200;263,150)"), true);
+  EXPECT_EQ (db::compare (e.start_segments (0, 1.0), "(0,0;0,200);(250,200;300,0)"), true);
+  EXPECT_EQ (db::compare (e.start_segments (0, 0), "(0,0;0,0);(250,200;250,200)"), true);
 
-  EXPECT_EQ (e.end_segments (10, 0).to_string (), "(0,190;0,200);(298,10;300,0)");
-  EXPECT_EQ (e.end_segments (10, 0.25).to_string (), "(0,150;0,200);(288,50;300,0)");
-  EXPECT_EQ (e.end_segments (0, 1.0).to_string (), "(0,0;0,200);(250,200;300,0)");
-  EXPECT_EQ (e.end_segments (0, 0).to_string (), "(0,200;0,200);(300,0;300,0)");
+  EXPECT_EQ (db::compare (e.end_segments (10, 0), "(0,190;0,200);(298,10;300,0)"), true);
+  EXPECT_EQ (db::compare (e.end_segments (10, 0.25), "(0,150;0,200);(288,50;300,0)"), true);
+  EXPECT_EQ (db::compare (e.end_segments (0, 1.0), "(0,0;0,200);(250,200;300,0)"), true);
+  EXPECT_EQ (db::compare (e.end_segments (0, 0), "(0,200;0,200);(300,0;300,0)"), true);
 
-  EXPECT_EQ (e.centers (10, 0).to_string (), "(0,95;0,105);(274,105;276,95)");
-  EXPECT_EQ (e.centers (10, 0.25).to_string (), "(0,75;0,125);(269,125;281,75)");
-  EXPECT_EQ (e.centers (0, 1.0).to_string (), "(0,0;0,200);(250,200;300,0)");
-  EXPECT_EQ (e.centers (0, 0).to_string (), "(0,100;0,100);(275,100;275,100)");
+  EXPECT_EQ (db::compare (e.centers (10, 0), "(0,95;0,105);(274,105;276,95)"), true);
+  EXPECT_EQ (db::compare (e.centers (10, 0.25), "(0,75;0,125);(269,125;281,75)"), true);
+  EXPECT_EQ (db::compare (e.centers (0, 1.0), "(0,0;0,200);(250,200;300,0)"), true);
+  EXPECT_EQ (db::compare (e.centers (0, 0), "(0,100;0,100);(275,100;275,100)"), true);
 }
 
 TEST(8) 
@@ -409,7 +410,7 @@ TEST(8)
   e2.insert (db::Edge (db::Point (-100, -1), db::Point (100, -1)));
 
   EXPECT_EQ (e.selected_interacting (e2).to_string (), "");
-  EXPECT_EQ (e.selected_not_interacting (e2).to_string (), "(0,0;0,200);(250,200;300,0)");
+  EXPECT_EQ (db::compare (e.selected_not_interacting (e2), "(0,0;0,200);(250,200;300,0)"), true);
 
   e2.clear ();
   e2.insert (db::Edge (db::Point (-100, 0), db::Point (100, 0)));
@@ -566,14 +567,14 @@ TEST(11)
   db::Box bb[3] = { db::Box (db::Point (0, 0), db::Point (10, 10)), db::Box (), db::Box (db::Point (20, 20), db::Point (40, 50)) };
   db::Region r (bb + 0, bb + 3);
 
-  EXPECT_EQ (r.edges ().width_check (15).to_string (), "(0,0;0,10)/(10,10;10,0);(0,10;10,10)/(10,0;0,0)");
+  EXPECT_EQ (db::compare (r.edges ().width_check (15), "(0,0;0,10)/(10,10;10,0);(0,10;10,10)/(10,0;0,0)"), true);
   EXPECT_EQ (r.edges ().width_check (5).to_string (), "");
-  EXPECT_EQ (r.edges ().width_check (5, db::EdgesCheckOptions (false, db::Euclidian, 91)).to_string (), "(0,5;0,10)/(0,10;5,10);(0,0;0,5)/(5,0;0,0);(5,10;10,10)/(10,10;10,5);(10,5;10,0)/(10,0;5,0);(20,45;20,50)/(20,50;25,50);(20,20;20,25)/(25,20;20,20);(35,50;40,50)/(40,50;40,45);(40,25;40,20)/(40,20;35,20)");
-  EXPECT_EQ (r.edges ().space_check (15, db::EdgesCheckOptions (false, db::Euclidian, 91)).to_string (), "(9,10;10,10)/(20,20;20,21);(9,10;10,10)/(21,20;20,20);(10,10;10,9)/(20,20;20,21);(10,10;10,9)/(21,20;20,20)");
-  EXPECT_EQ (r.edges ().space_check (15, db::EdgesCheckOptions (false, db::Square, 91)).to_string (), "(5,10;10,10)/(20,20;20,25);(5,10;10,10)/(25,20;20,20);(10,10;10,5)/(20,20;20,25);(10,10;10,5)/(25,20;20,20)");
-  EXPECT_EQ (r.edges ().space_check (15).to_string (), "(9,10;10,10)/(21,20;20,20);(10,10;10,9)/(20,20;20,21)");
-  EXPECT_EQ (r.edges ().space_check (15, db::EdgesCheckOptions (true)).to_string (), "(0,10;10,10)/(40,20;20,20);(10,10;10,0)/(20,20;20,50)");
-  EXPECT_EQ (r.edges ().space_check (15, db::EdgesCheckOptions (false, db::Square)).to_string (), "(5,10;10,10)/(25,20;20,20);(10,10;10,5)/(20,20;20,25)");
+  EXPECT_EQ (db::compare (r.edges ().width_check (5, db::EdgesCheckOptions (false, db::Euclidian, 91)), "(0,5;0,10)/(0,10;5,10);(0,0;0,5)/(5,0;0,0);(5,10;10,10)/(10,10;10,5);(10,5;10,0)/(10,0;5,0);(20,45;20,50)/(20,50;25,50);(20,20;20,25)/(25,20;20,20);(35,50;40,50)/(40,50;40,45);(40,25;40,20)/(40,20;35,20)"), true);
+  EXPECT_EQ (db::compare (r.edges ().space_check (15, db::EdgesCheckOptions (false, db::Euclidian, 91)), "(9,10;10,10)/(20,20;20,21);(9,10;10,10)/(21,20;20,20);(10,10;10,9)/(20,20;20,21);(10,10;10,9)/(21,20;20,20)"), true);
+  EXPECT_EQ (db::compare (r.edges ().space_check (15, db::EdgesCheckOptions (false, db::Square, 91)), "(5,10;10,10)/(20,20;20,25);(5,10;10,10)/(25,20;20,20);(10,10;10,5)/(20,20;20,25);(10,10;10,5)/(25,20;20,20)"), true);
+  EXPECT_EQ (db::compare (r.edges ().space_check (15), "(9,10;10,10)/(21,20;20,20);(10,10;10,9)/(20,20;20,21)"), true);
+  EXPECT_EQ (db::compare (r.edges ().space_check (15, db::EdgesCheckOptions (true)), "(0,10;10,10)/(40,20;20,20);(10,10;10,0)/(20,20;20,50)"), true);
+  EXPECT_EQ (db::compare (r.edges ().space_check (15, db::EdgesCheckOptions (false, db::Square)), "(5,10;10,10)/(25,20;20,20);(10,10;10,5)/(20,20;20,25)"), true);
 }
 
 TEST(12) 
@@ -586,22 +587,22 @@ TEST(12)
 
   EXPECT_EQ (a.edges ().inside_check (b.edges (), 15).to_string (), "(10,20;10,30)/(0,9;0,41)");
   EXPECT_EQ (a.edges ().inside_check (b.edges (), 15, db::EdgesCheckOptions (true)).to_string (), "(10,20;10,30)/(0,0;0,100)");
-  EXPECT_EQ (a.edges ().inside_check (b.edges (), 15, db::EdgesCheckOptions (false, db::Euclidian, 91)).to_string (), "(10,20;10,30)/(0,9;0,41);(10,30;15,30)/(0,30;0,41);(15,20;10,20)/(0,9;0,20)");
+  EXPECT_EQ (db::compare (a.edges ().inside_check (b.edges (), 15, db::EdgesCheckOptions (false, db::Euclidian, 91)), "(10,20;10,30)/(0,9;0,41);(10,30;15,30)/(0,30;0,41);(15,20;10,20)/(0,9;0,20)"), true);
   EXPECT_EQ (b.edges ().enclosing_check (a.edges (), 15).to_string (), "(0,9;0,41)/(10,20;10,30)");
   EXPECT_EQ (b.edges ().enclosing_check (a.edges (), 15, db::EdgesCheckOptions (true)).to_string (), "(0,0;0,100)/(10,20;10,30)");
-  EXPECT_EQ (b.edges ().enclosing_check (a.edges (), 15, db::EdgesCheckOptions (false, db::Euclidian, 91)).to_string (), "(0,9;0,41)/(10,20;10,30);(0,30;0,41)/(10,30;15,30);(0,9;0,20)/(15,20;10,20)");
+  EXPECT_EQ (db::compare (b.edges ().enclosing_check (a.edges (), 15, db::EdgesCheckOptions (false, db::Euclidian, 91)), "(0,9;0,41)/(10,20;10,30);(0,30;0,41)/(10,30;15,30);(0,9;0,20)/(15,20;10,20)"), true);
 
   b.clear ();
   b.insert (db::Box (db::Point (30, 0), db::Point (100, 100)));
   EXPECT_EQ (b.separation_check (a, 15).to_string (), "(30,9;30,41)/(20,30;20,20)");
   EXPECT_EQ (b.separation_check (a, 15, true).to_string (), "(30,0;30,100)/(20,30;20,20)");
-  EXPECT_EQ (b.separation_check (a, 15, db::RegionCheckOptions (false, db::Euclidian, 91)).to_string (), "(30,30;30,41)/(15,30;20,30);(30,9;30,41)/(20,30;20,20);(30,9;30,20)/(20,20;15,20)");
+  EXPECT_EQ (db::compare (b.separation_check (a, 15, db::RegionCheckOptions (false, db::Euclidian, 91)), "(30,30;30,41)/(15,30;20,30);(30,9;30,41)/(20,30;20,20);(30,9;30,20)/(20,20;15,20)"), true);
 
   b.clear ();
   b.insert (db::Box (db::Point (15, 0), db::Point (100, 100)));
   EXPECT_EQ (b.overlap_check (a, 15).to_string (), "(15,6;15,44)/(20,30;20,20)");
   EXPECT_EQ (b.overlap_check (a, 15, true).to_string (), "(15,0;15,100)/(20,30;20,20)");
-  EXPECT_EQ (b.overlap_check (a, 15, db::RegionCheckOptions (false, db::Euclidian, 91)).to_string (), "(15,15;15,30)/(15,30;20,30);(15,6;15,44)/(20,30;20,20);(15,20;15,35)/(20,20;15,20)");
+  EXPECT_EQ (db::compare (b.overlap_check (a, 15, db::RegionCheckOptions (false, db::Euclidian, 91)), "(15,15;15,30)/(15,30;20,30);(15,6;15,44)/(20,30;20,20);(15,20;15,35)/(20,20;15,20)"), true);
 }
 
 TEST(20)
@@ -643,14 +644,14 @@ TEST(20)
   {
     db::Edges r1 (db::RecursiveShapeIterator (ly, ly.cell (top), l2, db::Box (60, 10, 90, 50)), false);
     EXPECT_EQ (r1.has_valid_edges (), false);
-    EXPECT_EQ (r1.to_string (), "(60,10;60,20);(60,20;70,20);(70,20;70,10);(70,10;60,10);(80,40;80,70);(110,40;80,40)");
+    EXPECT_EQ (db::compare (r1, "(60,10;60,20);(60,20;70,20);(70,20;70,10);(70,10;60,10);(80,40;80,70);(110,40;80,40)"), true);
     EXPECT_EQ (r1.has_valid_edges (), false);
   }
 
   {
     db::Edges r1 (db::RecursiveShapeIterator (ly, ly.cell (top), l2, db::Box (60, 10, 90, 50)), db::ICplxTrans (2.0), false);
     EXPECT_EQ (r1.has_valid_edges (), false);
-    EXPECT_EQ (r1.to_string (), "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20);(160,80;160,140);(220,80;160,80)");
+    EXPECT_EQ (db::compare (r1, "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20);(160,80;160,140);(220,80;160,80)"), true);
     EXPECT_EQ (r1.has_valid_edges (), false);
     EXPECT_EQ (r1.length (), db::Edges::length_type (200));
     EXPECT_EQ (r1.has_valid_edges (), false);
@@ -662,7 +663,7 @@ TEST(20)
     db::EdgeLengthFilter f0 (0, 50, false);
     db::Edges rr = r1.filtered (f0);
     EXPECT_EQ (rr.has_valid_edges (), true);
-    EXPECT_EQ (rr.to_string (), "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20)");
+    EXPECT_EQ (db::compare (rr, "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20)"), true);
 
     db::Edges r2 = r1;
     EXPECT_EQ (r2.has_valid_edges (), false);
@@ -673,7 +674,7 @@ TEST(20)
     EXPECT_EQ (r2.empty (), false);
     r2.filter (f0);
     EXPECT_EQ (r2.has_valid_edges (), true);
-    EXPECT_EQ (r2.to_string (), "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20)");
+    EXPECT_EQ (db::compare (r2, "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20)"), true);
     EXPECT_EQ (r2.count (), size_t (4));
     EXPECT_EQ (r2.hier_count (), size_t (4));
     EXPECT_EQ (r2.empty (), false);
@@ -681,24 +682,24 @@ TEST(20)
 
     r1.insert (db::Box (0, 0, 10, 20));
     EXPECT_EQ (r1.has_valid_edges (), true);
-    EXPECT_EQ (r1.to_string (), "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20);(160,80;160,140);(220,80;160,80);(0,0;0,20);(0,20;10,20);(10,20;10,0);(10,0;0,0)");
+    EXPECT_EQ (db::compare (r1, "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20);(160,80;160,140);(220,80;160,80);(0,0;0,20);(0,20;10,20);(10,20;10,0);(10,0;0,0)"), true);
     EXPECT_EQ (r1.to_string (2), "(120,20;120,40);(120,40;140,40)...");
     EXPECT_EQ (r1.count (), size_t (10));
     EXPECT_EQ (r1.hier_count (), size_t (10));
     EXPECT_EQ (r1.length (), db::Edges::length_type (260));
 
     rr = r1.filtered (f0);
-    EXPECT_EQ (rr.to_string (), "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20);(0,0;0,20);(0,20;10,20);(10,20;10,0);(10,0;0,0)");
-    EXPECT_EQ (r1.to_string (), "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20);(160,80;160,140);(220,80;160,80);(0,0;0,20);(0,20;10,20);(10,20;10,0);(10,0;0,0)");
+    EXPECT_EQ (db::compare (rr, "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20);(0,0;0,20);(0,20;10,20);(10,20;10,0);(10,0;0,0)"), true);
+    EXPECT_EQ (db::compare (r1, "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20);(160,80;160,140);(220,80;160,80);(0,0;0,20);(0,20;10,20);(10,20;10,0);(10,0;0,0)"), true);
 
     r1.filter (f0);
-    EXPECT_EQ (r1.to_string (), "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20);(0,0;0,20);(0,20;10,20);(10,20;10,0);(10,0;0,0)");
+    EXPECT_EQ (db::compare (r1, "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20);(0,0;0,20);(0,20;10,20);(10,20;10,0);(10,0;0,0)"), true);
   }
 
   {
     db::Edges r1 (db::RecursiveShapeIterator (ly, ly.cell (top), l2, db::Box (60, 10, 70, 50)), db::ICplxTrans (2.0), false);
     EXPECT_EQ (r1.has_valid_edges (), false);
-    EXPECT_EQ (r1.to_string (), "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20)");
+    EXPECT_EQ (db::compare (r1, "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20)"), true);
     EXPECT_EQ (r1.has_valid_edges (), false);
     EXPECT_EQ (r1.count (), size_t (4));
     EXPECT_EQ (r1.hier_count (), size_t (4));
@@ -706,10 +707,10 @@ TEST(20)
 
     db::Edges r2 = r1;
 
-    EXPECT_EQ (r1.transformed (db::ICplxTrans (0.5)).to_string (), "(60,10;60,20);(60,20;70,20);(70,20;70,10);(70,10;60,10)");
+    EXPECT_EQ (db::compare (r1.transformed (db::ICplxTrans (0.5)), "(60,10;60,20);(60,20;70,20);(70,20;70,10);(70,10;60,10)"), true);
     r1.transform (db::ICplxTrans (0.5));
     EXPECT_EQ (r1.has_valid_edges (), true);
-    EXPECT_EQ (r1.to_string (), "(60,10;60,20);(60,20;70,20);(70,20;70,10);(70,10;60,10)");
+    EXPECT_EQ (db::compare (r1, "(60,10;60,20);(60,20;70,20);(70,20;70,10);(70,10;60,10)"), true);
 
     r1.clear ();
     EXPECT_EQ (r1.has_valid_edges (), true);
@@ -718,10 +719,10 @@ TEST(20)
     EXPECT_EQ (r1.empty (), true);
     EXPECT_EQ (r1.length (), db::Edges::length_type (0));
 
-    EXPECT_EQ (r2.to_string (), "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20)");
+    EXPECT_EQ (db::compare (r2, "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20)"), true);
     r1.swap (r2);
 
-    EXPECT_EQ (r1.to_string (), "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20)");
+    EXPECT_EQ (db::compare (r1, "(120,20;120,40);(120,40;140,40);(140,40;140,20);(140,20;120,20)"), true);
     EXPECT_EQ (r1.has_valid_edges (), false);
     EXPECT_EQ (r2.has_valid_edges (), true);
     EXPECT_EQ (r2.count (), size_t (0));
@@ -742,17 +743,17 @@ TEST(20)
 
   {
     db::Edges r1 (db::RecursiveShapeIterator (ly, ly.cell (top), l2), false);
-    EXPECT_EQ (r1.width_check (20).to_string (), "(60,10;60,20)/(70,20;70,10);(60,20;70,20)/(70,10;60,10)");
-    EXPECT_EQ (r1.width_check (50).to_string (), "(60,10;60,20)/(70,20;70,10);(60,20;70,20)/(70,10;60,10);(60,20;70,20)/(40,10;11,10);(70,10;60,10)/(20,40;40,40);(10,10;10,40)/(40,40;40,10);(10,40;40,40)/(40,10;10,10);(80,70;140,70)/(140,40;80,40)");
-    EXPECT_EQ (r1.width_check (50, db::EdgesCheckOptions (true)).to_string (), "(60,10;60,20)/(70,20;70,10);(60,20;70,20)/(70,10;60,10);(60,20;70,20)/(40,10;10,10);(70,10;60,10)/(10,40;40,40);(10,10;10,40)/(40,40;40,10);(10,40;40,40)/(40,10;10,10);(80,70;140,70)/(140,40;80,40)");
-    EXPECT_EQ (r1.width_check (50, db::EdgesCheckOptions (false, db::Projection)).to_string (), "(60,10;60,20)/(70,20;70,10);(60,20;70,20)/(70,10;60,10);(10,10;10,40)/(40,40;40,10);(10,40;40,40)/(40,10;10,10);(80,70;140,70)/(140,40;80,40)");
-    EXPECT_EQ (r1.width_check (50, db::EdgesCheckOptions (false, db::Euclidian, 90, 1)).to_string (), "(60,10;60,20)/(70,20;70,10);(60,20;70,20)/(70,10;60,10);(10,10;10,40)/(40,40;40,10);(10,40;40,40)/(40,10;10,10);(80,70;140,70)/(140,40;80,40)");
+    EXPECT_EQ (db::compare (r1.width_check (20), "(60,10;60,20)/(70,20;70,10);(60,20;70,20)/(70,10;60,10)"), true);
+    EXPECT_EQ (db::compare (r1.width_check (50), "(60,10;60,20)/(70,20;70,10);(60,20;70,20)/(70,10;60,10);(60,20;70,20)/(40,10;11,10);(70,10;60,10)/(20,40;40,40);(10,10;10,40)/(40,40;40,10);(10,40;40,40)/(40,10;10,10);(80,70;140,70)/(140,40;80,40)"), true);
+    EXPECT_EQ (db::compare (r1.width_check (50, db::EdgesCheckOptions (true)), "(60,10;60,20)/(70,20;70,10);(60,20;70,20)/(70,10;60,10);(60,20;70,20)/(40,10;10,10);(70,10;60,10)/(10,40;40,40);(10,10;10,40)/(40,40;40,10);(10,40;40,40)/(40,10;10,10);(80,70;140,70)/(140,40;80,40)"), true);
+    EXPECT_EQ (db::compare (r1.width_check (50, db::EdgesCheckOptions (false, db::Projection)), "(60,10;60,20)/(70,20;70,10);(60,20;70,20)/(70,10;60,10);(10,10;10,40)/(40,40;40,10);(10,40;40,40)/(40,10;10,10);(80,70;140,70)/(140,40;80,40)"), true);
+    EXPECT_EQ (db::compare (r1.width_check (50, db::EdgesCheckOptions (false, db::Euclidian, 90, 1)), "(60,10;60,20)/(70,20;70,10);(60,20;70,20)/(70,10;60,10);(10,10;10,40)/(40,40;40,10);(10,40;40,40)/(40,10;10,10);(80,70;140,70)/(140,40;80,40)"), true);
   }
 
   {
     db::Edges r1 (db::RecursiveShapeIterator (ly, ly.cell (top), l2), false);
     EXPECT_EQ (r1.has_valid_edges (), false);
-    EXPECT_EQ (r1.space_check (30).to_string (), "(60,10;60,20)/(40,40;40,10);(60,20;70,20)/(92,40;80,40);(70,20;70,12)/(80,40;80,48)");
+    EXPECT_EQ (db::compare (r1.space_check (30), "(60,10;60,20)/(40,40;40,10);(60,20;70,20)/(92,40;80,40);(70,20;70,12)/(80,40;80,48)"), true);
     EXPECT_EQ (r1.space_check (2).to_string (), "");
   }
 
@@ -761,9 +762,9 @@ TEST(20)
     EXPECT_EQ (r1.has_valid_edges (), false);
     db::Edges r2 (db::RecursiveShapeIterator (ly, ly.cell (top), l2), false);
     EXPECT_EQ (r2.has_valid_edges (), false);
-    EXPECT_EQ (r1.separation_check (r2, 20).to_string (), "(50,0;50,30)/(40,40;40,10);(63,30;80,30)/(97,40;80,40);(50,40;50,57)/(40,40;40,23);(80,70;80,40)/(80,40;80,70)");
-    EXPECT_EQ (r1.separation_check (r2, 20, db::EdgesCheckOptions (false, db::Projection)).to_string (), "(50,10;50,30)/(40,30;40,10);(80,70;80,40)/(80,40;80,70)");
-    EXPECT_EQ (r1.separation_check (r2, 20, db::EdgesCheckOptions (false, db::Euclidian, 90, 1)).to_string (), "(50,0;50,30)/(40,40;40,10);(80,70;80,40)/(80,40;80,70)");
+    EXPECT_EQ (db::compare (r1.separation_check (r2, 20), "(50,0;50,30)/(40,40;40,10);(63,30;80,30)/(97,40;80,40);(50,40;50,57)/(40,40;40,23);(80,70;80,40)/(80,40;80,70)"), true);
+    EXPECT_EQ (db::compare (r1.separation_check (r2, 20, db::EdgesCheckOptions (false, db::Projection)), "(50,10;50,30)/(40,30;40,10);(80,70;80,40)/(80,40;80,70)"), true);
+    EXPECT_EQ (db::compare (r1.separation_check (r2, 20, db::EdgesCheckOptions (false, db::Euclidian, 90, 1)), "(50,0;50,30)/(40,40;40,10);(80,70;80,40)/(80,40;80,70)"), true);
   }
 
   {
@@ -788,7 +789,7 @@ TEST(20)
 
     db::Edges r2dup = r2;
     r2.select_interacting (rr1);
-    EXPECT_EQ (r2.to_string (), "(60,10;60,20);(60,20;70,20);(70,20;70,10);(70,10;60,10);(10,10;10,40);(40,10;10,10);(80,40;80,70);(80,70;140,70);(140,40;80,40)");
+    EXPECT_EQ (db::compare (r2, "(60,10;60,20);(60,20;70,20);(70,20;70,10);(70,10;60,10);(10,10;10,40);(40,10;10,10);(80,40;80,70);(80,70;140,70);(140,40;80,40)"), true);
     r2 = r2dup;
     r2.select_not_interacting (rr1);
     EXPECT_EQ (r2.to_string (100), "(10,40;40,40);(40,40;40,10);(140,70;140,40)");
@@ -796,7 +797,7 @@ TEST(20)
     r2 = db::Edges (db::RecursiveShapeIterator (ly, ly.cell (top), l2), false);
     EXPECT_EQ (r2.has_valid_edges (), false);
     r2.select_interacting (r1);
-    EXPECT_EQ (r2.to_string (), "(10,10;10,40);(40,10;10,10);(80,40;80,70);(80,70;140,70);(140,40;80,40)");
+    EXPECT_EQ (db::compare (r2, "(10,10;10,40);(40,10;10,10);(80,40;80,70);(80,70;140,70);(140,40;80,40)"), true);
   }
 }
 
@@ -818,16 +819,16 @@ TEST(21)
   ee.select_inside_part (r);
   EXPECT_EQ (ee.to_string (), "(0,100;100,100)");
 
-  EXPECT_EQ ((e - r).to_string (), "(-100,100;0,100);(100,100;200,100)");
-  EXPECT_EQ (e.outside_part (r).to_string (), "(-100,100;0,100);(100,100;200,100)");
+  EXPECT_EQ (db::compare ((e - r), "(-100,100;0,100);(100,100;200,100)"), true);
+  EXPECT_EQ (db::compare (e.outside_part (r), "(-100,100;0,100);(100,100;200,100)"), true);
 
   ee = e;
   ee -= r;
-  EXPECT_EQ (ee.to_string (), "(-100,100;0,100);(100,100;200,100)");
+  EXPECT_EQ (db::compare (ee, "(-100,100;0,100);(100,100;200,100)"), true);
 
   ee = e;
   ee.select_outside_part (r);
-  EXPECT_EQ (ee.to_string (), "(-100,100;0,100);(100,100;200,100)");
+  EXPECT_EQ (db::compare (ee, "(-100,100;0,100);(100,100;200,100)"), true);
 
   e.clear ();
   e.insert (db::Edge (-100, 0, 200, 0));
@@ -842,16 +843,16 @@ TEST(21)
   ee.select_inside_part (r);
   EXPECT_EQ (ee.to_string (), "");
 
-  EXPECT_EQ ((e - r).to_string (), "(-100,0;0,0);(100,0;200,0)");
-  EXPECT_EQ (e.outside_part (r).to_string (), "(-100,0;0,0);(0,0;100,0);(100,0;200,0)");
+  EXPECT_EQ (db::compare ((e - r), "(-100,0;0,0);(100,0;200,0)"), true);
+  EXPECT_EQ (db::compare (e.outside_part (r), "(-100,0;0,0);(0,0;100,0);(100,0;200,0)"), true);
 
   ee = e;
   ee -= r;
-  EXPECT_EQ (ee.to_string (), "(-100,0;0,0);(100,0;200,0)");
+  EXPECT_EQ (db::compare (ee, "(-100,0;0,0);(100,0;200,0)"), true);
 
   ee = e;
   ee.select_outside_part (r);
-  EXPECT_EQ (ee.to_string (), "(-100,0;0,0);(0,0;100,0);(100,0;200,0)");
+  EXPECT_EQ (db::compare (ee, "(-100,0;0,0);(0,0;100,0);(100,0;200,0)"), true);
 }
 
 TEST(22)
@@ -872,8 +873,8 @@ TEST(22)
   ee.insert (db::Edge (4000,0,4000,-2000));
   ee.insert (db::Edge (4000,-2000,-2000,-2000));
 
-  EXPECT_EQ ((e & ee).to_string (), "(400,0;-2000,0);(500,-174;400,0);(1000,0;900,-173);(4000,0;1000,0)");
-  EXPECT_EQ (e.intersections (ee).to_string (), "(400,0;-2000,0);(500,-174;400,0);(1000,0;900,-173);(4000,0;1000,0)");
+  EXPECT_EQ (db::compare ((e & ee), "(400,0;-2000,0);(500,-174;400,0);(1000,0;900,-173);(4000,0;1000,0)"), true);
+  EXPECT_EQ (db::compare (e.intersections (ee), "(400,0;-2000,0);(500,-174;400,0);(1000,0;900,-173);(4000,0;1000,0)"), true);
 
   //  Edge/edge intersections
   ee.clear ();
@@ -882,7 +883,7 @@ TEST(22)
   ee.insert (db::Edge (-50, 50, 50, 50));
   ee.insert (db::Edge (-50, 100, 50, 100));
   EXPECT_EQ ((e & ee).to_string (), "");  //  AND does not report intersection points
-  EXPECT_EQ (e.intersections (ee).to_string (), "(0,50;0,50);(0,100;0,100)");
+  EXPECT_EQ (db::compare (e.intersections (ee), "(0,50;0,50);(0,100;0,100)"), true);
 
   //  Edge is intersected by pair with connection point on this line
   ee.clear ();
@@ -893,7 +894,7 @@ TEST(22)
   ee.insert (db::Edge (-50, 100, 0, 100));
   ee.insert (db::Edge (0, 100, 50, 100));
   EXPECT_EQ ((e & ee).to_string (), "");  //  AND does not report intersection points
-  EXPECT_EQ (e.intersections (ee).to_string (), "(0,50;0,50);(0,60;0,60);(0,100;0,100)");
+  EXPECT_EQ (db::compare (e.intersections (ee), "(0,50;0,50);(0,60;0,60);(0,100;0,100)"), true);
 
   //  Coincident edges are crossed by another one
   ee.clear ();
@@ -903,7 +904,7 @@ TEST(22)
   ee.insert (db::Edge (-50, 100, 50, 100));
   ee.insert (db::Edge (-50, 200, 50, 200));
   EXPECT_EQ ((e & ee).to_string (), "(0,0;0,150)");
-  EXPECT_EQ (e.intersections (ee).to_string (), "(0,0;0,150);(0,200;0,200)");
+  EXPECT_EQ (db::compare (e.intersections (ee), "(0,0;0,150);(0,200;0,200)"), true);
 }
 
 TEST(23)
@@ -951,12 +952,12 @@ TEST(100)
   r.insert (db::Box (1000, -1000, 2000, 0));
   r.insert (db::Box (1000, 1000, 2000, 2000));
 
-  EXPECT_EQ ((e - r).to_string (), "(0,0;0,1000);(1000,0;0,0);(3000,0;2000,0);(3000,1000;3000,0);(0,1000;1000,1000);(2000,1000;3000,1000)");
+  EXPECT_EQ (db::compare ((e - r), "(0,0;0,1000);(1000,0;0,0);(3000,0;2000,0);(3000,1000;3000,0);(0,1000;1000,1000);(2000,1000;3000,1000)"), true);
 
   r.clear ();
   r.insert (db::Box (1000, -1000, 2000, 2000));
 
-  EXPECT_EQ ((e - r).to_string (), "(0,0;0,1000);(1000,0;0,0);(3000,0;2000,0);(3000,1000;3000,0);(0,1000;1000,1000);(2000,1000;3000,1000)");
+  EXPECT_EQ (db::compare ((e - r), "(0,0;0,1000);(1000,0;0,0);(3000,0;2000,0);(3000,1000;3000,0);(0,1000;1000,1000);(2000,1000;3000,1000)"), true);
 
   e.clear ();
   e.insert (db::Edge (0, 0, 100, 1000));
@@ -968,12 +969,12 @@ TEST(100)
   r.insert (db::Box (1000, -1000, 2000, 0));
   r.insert (db::Box (1000, 1000, 2000, 2000));
 
-  EXPECT_EQ ((e - r).to_string (), "(0,0;100,1000);(1000,0;0,0);(3000,0;2000,0);(3100,1000;3000,0);(100,1000;1000,1000);(2000,1000;3100,1000)");
+  EXPECT_EQ (db::compare ((e - r), "(0,0;100,1000);(1000,0;0,0);(3000,0;2000,0);(3100,1000;3000,0);(100,1000;1000,1000);(2000,1000;3100,1000)"), true);
 
   r.clear ();
   r.insert (db::Box (1000, -1000, 2000, 2000));
 
-  EXPECT_EQ ((e - r).to_string (), "(0,0;100,1000);(1000,0;0,0);(3000,0;2000,0);(3100,1000;3000,0);(100,1000;1000,1000);(2000,1000;3100,1000)");
+  EXPECT_EQ (db::compare ((e - r), "(0,0;100,1000);(1000,0;0,0);(3000,0;2000,0);(3100,1000;3000,0);(100,1000;1000,1000);(2000,1000;3100,1000)"), true);
 
   e.clear ();
   e.insert (db::Edge (0, 0, 1000, 0));
@@ -985,11 +986,11 @@ TEST(100)
   r.insert (db::Box (-1000, 1000, 0, 2000));
   r.insert (db::Box (1000, 1000, 2000, 2000));
 
-  EXPECT_EQ ((e - r).to_string (), "(0,1000;0,0);(0,0;1000,0);(1000,0;1000,1000);(0,3000;0,2000);(1000,2000;1000,3000);(1000,3000;0,3000)");
+  EXPECT_EQ (db::compare ((e - r), "(0,1000;0,0);(0,0;1000,0);(1000,0;1000,1000);(0,3000;0,2000);(1000,2000;1000,3000);(1000,3000;0,3000)"), true);
 
   r.clear ();
   r.insert (db::Box (-1000, 1000, 2000, 2000));
 
-  EXPECT_EQ ((e - r).to_string (), "(0,1000;0,0);(0,0;1000,0);(1000,0;1000,1000);(0,3000;0,2000);(1000,2000;1000,3000);(1000,3000;0,3000)");
+  EXPECT_EQ (db::compare ((e - r), "(0,1000;0,0);(0,0;1000,0);(1000,0;1000,1000);(0,3000;0,2000);(1000,2000;1000,3000);(1000,3000;0,3000)"), true);
 }
 
diff --git a/src/db/unit_tests/dbRegionTests.cc b/src/db/unit_tests/dbRegionTests.cc
index 892a1d051..6926aec7a 100644
--- a/src/db/unit_tests/dbRegionTests.cc
+++ b/src/db/unit_tests/dbRegionTests.cc
@@ -38,11 +38,11 @@
 TEST(1)
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r, ""), true);
+  EXPECT_EQ (r.to_string (), "");
   EXPECT_EQ (r == db::Region (), true);
   EXPECT_EQ (r < db::Region (), false);
   EXPECT_EQ (r != db::Region (), false);
-  EXPECT_EQ (db::compare (r.bbox (), "()"), true);
+  EXPECT_EQ (r.bbox ().to_string (), "()");
   EXPECT_EQ (r.empty (), true);
   EXPECT_EQ (r.is_box (), false);
   EXPECT_EQ (r.is_merged (), true);
@@ -55,9 +55,9 @@ TEST(1)
   EXPECT_EQ (r != r, false);
   EXPECT_EQ (r == r, true);
   EXPECT_EQ (r < r, false);
-  EXPECT_EQ (db::compare (r, "(0,0;0,200;100,200;100,0)"), true);
-  EXPECT_EQ (db::compare (r.transformed (db::Trans (db::Vector (1, 2))), "(1,2;1,202;101,202;101,2)"), true);
-  EXPECT_EQ (db::compare (r.bbox (), "(0,0;100,200)"), true);
+  EXPECT_EQ (r.to_string (), "(0,0;0,200;100,200;100,0)");
+  EXPECT_EQ (r.transformed (db::Trans (db::Vector (1, 2))).to_string (), "(1,2;1,202;101,202;101,2)");
+  EXPECT_EQ (r.bbox ().to_string (), "(0,0;100,200)");
   EXPECT_EQ (r.empty (), false);
   EXPECT_EQ (r.is_merged (), true);
   EXPECT_EQ (r.is_box (), true);
@@ -65,7 +65,7 @@ TEST(1)
 
   db::Region rr = r;
   rr.insert (db::Box (db::Point (10, 10), db::Point (110, 30)));
-  EXPECT_EQ (db::compare (rr.bbox (), "(0,0;110,200)"), true);
+  EXPECT_EQ (rr.bbox ().to_string (), "(0,0;110,200)");
   EXPECT_EQ (db::compare (rr, "(0,0;0,200;100,200;100,0);(10,10;10,30;110,30;110,10)"), true);
   EXPECT_EQ (rr.empty (), false);
   EXPECT_EQ (rr.is_merged (), false);
@@ -74,20 +74,20 @@ TEST(1)
 
   db::Region r1 = r;
   db::Region r2;
-  EXPECT_EQ (db::compare (r1, "(0,0;0,200;100,200;100,0)"), true);
-  EXPECT_EQ (db::compare (r2, ""), true);
-  EXPECT_EQ (db::compare (r1.bbox (), "(0,0;100,200)"), true);
-  EXPECT_EQ (db::compare (r2.bbox (), "()"), true);
+  EXPECT_EQ (r1.to_string (), "(0,0;0,200;100,200;100,0)");
+  EXPECT_EQ (r2.to_string (), "");
+  EXPECT_EQ (r1.bbox ().to_string (), "(0,0;100,200)");
+  EXPECT_EQ (r2.bbox ().to_string (), "()");
   r1.swap (r2);
-  EXPECT_EQ (db::compare (r1, ""), true);
-  EXPECT_EQ (db::compare (r2, "(0,0;0,200;100,200;100,0)"), true);
-  EXPECT_EQ (db::compare (r1.bbox (), "()"), true);
-  EXPECT_EQ (db::compare (r2.bbox (), "(0,0;100,200)"), true);
+  EXPECT_EQ (r1.to_string (), "");
+  EXPECT_EQ (r2.to_string (), "(0,0;0,200;100,200;100,0)");
+  EXPECT_EQ (r1.bbox ().to_string (), "()");
+  EXPECT_EQ (r2.bbox ().to_string (), "(0,0;100,200)");
 
   EXPECT_EQ (db::compare ((r + db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))), "(0,0;0,200;100,200;100,0);(10,20;10,220;110,220;110,20)"), true);
-  EXPECT_EQ (db::compare ((r + db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))).merged (), "(0,0;0,200;10,200;10,220;110,220;110,20;100,20;100,0)"), true);
-  EXPECT_EQ (db::compare ((r + db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))).merged (false, 1), "(10,20;10,200;100,200;100,20)"), true);
-  EXPECT_EQ (db::compare ((r | db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))), "(0,0;0,200;10,200;10,220;110,220;110,20;100,20;100,0)"), true);
+  EXPECT_EQ ((r + db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))).merged ().to_string (), "(0,0;0,200;10,200;10,220;110,220;110,20;100,20;100,0)");
+  EXPECT_EQ ((r + db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))).merged (false, 1).to_string (), "(10,20;10,200;100,200;100,20)");
+  EXPECT_EQ ((r | db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))).to_string (), "(0,0;0,200;10,200;10,220;110,220;110,20;100,20;100,0)");
 
   r += db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)));
   EXPECT_EQ (r.is_box (), false);
@@ -119,8 +119,8 @@ TEST(1)
   EXPECT_EQ (r.perimeter (db::Box (db::Point (-10, -10), db::Point (0, 50))), db::Region::perimeter_type (0));
   EXPECT_EQ (r.perimeter (db::Box (db::Point (0, 0), db::Point (50, 50))), db::Region::perimeter_type (100));
   r.merge ();
-  EXPECT_EQ (db::compare (r, "(0,0;0,200;10,200;10,220;110,220;110,20;100,20;100,0)"), true);
-  EXPECT_EQ (db::compare (r.bbox (), "(0,0;110,220)"), true);
+  EXPECT_EQ (r.to_string (), "(0,0;0,200;10,200;10,220;110,220;110,20;100,20;100,0)");
+  EXPECT_EQ (r.bbox ().to_string (), "(0,0;110,220)");
   EXPECT_EQ (r.is_merged (), true);
   EXPECT_EQ (r.is_box (), false);
   EXPECT_EQ (r.empty (), false);
@@ -135,7 +135,7 @@ TEST(1)
 
   r.insert (db::Box (db::Point (0, 0), db::Point (50, 50)));
   r.insert (db::Box (db::Point (50, 50), db::Point (100, 100)));
-  EXPECT_EQ (db::compare (r.merged (false), "(0,0;0,50;50,50;50,100;100,100;100,50;50,50;50,0)"), true);
+  EXPECT_EQ (r.merged (false).to_string (), "(0,0;0,50;50,50;50,100;100,100;100,50;50,50;50,0)");
   EXPECT_EQ (db::compare (r.merged (true), "(0,0;0,50;50,50;50,0);(50,50;50,100;100,100;100,50)"), true);
 
   r.set_merged_semantics (false);
@@ -162,13 +162,13 @@ TEST(2)
   r.insert (db::Box (db::Point (0, 0), db::Point (100, 200)));
   EXPECT_EQ (r.is_box (), true);
 
-  EXPECT_EQ (db::compare ((r & db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))), "(10,20;10,200;100,200;100,20)"), true);
+  EXPECT_EQ ((r & db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))).to_string (), "(10,20;10,200;100,200;100,20)");
 
   r &= db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)));
   EXPECT_EQ (r.is_box (), true);
   EXPECT_EQ (r.empty (), false);
   EXPECT_EQ (r.is_merged (), true);
-  EXPECT_EQ (db::compare (r, "(10,20;10,200;100,200;100,20)"), true);
+  EXPECT_EQ (r.to_string (), "(10,20;10,200;100,200;100,20)");
 
   r.insert (db::Box (db::Point (-50, -50), db::Point (50, 50)));
   EXPECT_EQ (r.is_box (), false);
@@ -197,25 +197,25 @@ TEST(3)
   rr.insert (db::Box (db::Point (10, 20), db::Point (110, 220)));
   EXPECT_EQ (rr.is_box (), false);
 
-  EXPECT_EQ (db::compare ((r & rr), "(10,20;10,220;110,220;110,20)"), true);
-  EXPECT_EQ (db::compare ((rr & r), "(10,20;10,220;110,220;110,20)"), true);
-  EXPECT_EQ (db::compare ((r & db::Region ()), ""), true);
+  EXPECT_EQ ((r & rr).to_string (), "(10,20;10,220;110,220;110,20)");
+  EXPECT_EQ ((rr & r).to_string (), "(10,20;10,220;110,220;110,20)");
+  EXPECT_EQ ((r & db::Region ()).to_string (), "");
   EXPECT_EQ ((r & db::Region ()).empty (), true);
-  EXPECT_EQ (db::compare ((db::Region () & r), ""), true);
+  EXPECT_EQ ((db::Region () & r).to_string (), "");
   EXPECT_EQ ((db::Region () & r).empty (), true);
 
-  EXPECT_EQ (db::compare (r.andnot(rr).first, "(10,20;10,220;110,220;110,20)"), true);
-  EXPECT_EQ (db::compare (rr.andnot(r).first, "(10,20;10,220;110,220;110,20)"), true);
-  EXPECT_EQ (db::compare (r.andnot(db::Region ()).first, ""), true);
+  EXPECT_EQ (r.andnot(rr).first.to_string (), "(10,20;10,220;110,220;110,20)");
+  EXPECT_EQ (rr.andnot(r).first.to_string (), "(10,20;10,220;110,220;110,20)");
+  EXPECT_EQ (r.andnot(db::Region ()).first.to_string (), "");
   EXPECT_EQ (r.andnot(db::Region ()).first.empty (), true);
-  EXPECT_EQ (db::compare (db::Region ().andnot(r).first, ""), true);
+  EXPECT_EQ (db::Region ().andnot(r).first.to_string (), "");
   EXPECT_EQ (db::Region ().andnot(r).first.empty (), true);
 
   r &= rr;
   EXPECT_EQ (r.is_box (), true);
   EXPECT_EQ (r.empty (), false);
   EXPECT_EQ (r.is_merged (), true);
-  EXPECT_EQ (db::compare (r, "(10,20;10,220;110,220;110,20)"), true);
+  EXPECT_EQ (r.to_string (), "(10,20;10,220;110,220;110,20)");
 }
 
 TEST(4) 
@@ -225,7 +225,7 @@ TEST(4)
   EXPECT_EQ (r.is_box (), true);
 
   r.set_min_coherence (false);
-  EXPECT_EQ (db::compare ((r ^ db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))), "(0,0;0,200;10,200;10,220;110,220;110,20;100,20;100,0/10,20;100,20;100,200;10,200)"), true);
+  EXPECT_EQ ((r ^ db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))).to_string (), "(0,0;0,200;10,200;10,220;110,220;110,20;100,20;100,0/10,20;100,20;100,200;10,200)");
 
   r.set_min_coherence (true);
   EXPECT_EQ (db::compare ((r ^ db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))), "(0,0;0,200;10,200;10,20;100,20;100,0);(100,20;100,200;10,200;10,220;110,220;110,20)"), true);
@@ -244,7 +244,7 @@ TEST(5)
   r.insert (db::Box (db::Point (-100, -100), db::Point (200, 400)));
   EXPECT_EQ (r.is_box (), false);
 
-  EXPECT_EQ (db::compare ((r ^ db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))), "(-100,-100;-100,400;200,400;200,-100/10,20;110,20;110,220;10,220)"), true);
+  EXPECT_EQ ((r ^ db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))).to_string (), "(-100,-100;-100,400;200,400;200,-100/10,20;110,20;110,220;10,220)");
   EXPECT_EQ (db::compare ((r ^ db::Region ()), "(0,0;0,200;100,200;100,0);(-100,-100;-100,400;200,400;200,-100)"), true);
   EXPECT_EQ ((r ^ db::Region ()).empty (), false);
   EXPECT_EQ ((r ^ db::Region ()).is_merged (), false);
@@ -256,16 +256,16 @@ TEST(5)
   EXPECT_EQ (r.is_box (), false);
   EXPECT_EQ (r.empty (), false);
   EXPECT_EQ (r.is_merged (), true);
-  EXPECT_EQ (db::compare (r, "(-100,-100;-100,400;200,400;200,-100/10,20;110,20;110,220;10,220)"), true);
+  EXPECT_EQ (r.to_string (), "(-100,-100;-100,400;200,400;200,-100/10,20;110,20;110,220;10,220)");
 
   db::Region rr;
   std::string s = r.to_string ();
   tl::Extractor ex (s.c_str ());
   EXPECT_EQ (ex.try_read (rr), true);
-  EXPECT_EQ (db::compare (rr, "(-100,-100;-100,400;200,400;200,-100/10,20;110,20;110,220;10,220)"), true);
+  EXPECT_EQ (rr.to_string (), "(-100,-100;-100,400;200,400;200,-100/10,20;110,20;110,220;10,220)");
 
-  EXPECT_EQ (db::compare (r.holes (), "(10,20;10,220;110,220;110,20)"), true);
-  EXPECT_EQ (db::compare (r.hulls (), "(-100,-100;-100,400;200,400;200,-100)"), true);
+  EXPECT_EQ (r.holes ().to_string (), "(10,20;10,220;110,220;110,20)");
+  EXPECT_EQ (r.hulls ().to_string (), "(-100,-100;-100,400;200,400;200,-100)");
 }
 
 TEST(6) 
@@ -274,13 +274,13 @@ TEST(6)
   r.insert (db::Box (db::Point (0, 0), db::Point (100, 200)));
   EXPECT_EQ (r.is_box (), true);
 
-  EXPECT_EQ (db::compare ((r - db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))), "(0,0;0,200;10,200;10,20;100,20;100,0)"), true);
+  EXPECT_EQ ((r - db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))).to_string (), "(0,0;0,200;10,200;10,20;100,20;100,0)");
 
   r -= db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)));
   EXPECT_EQ (r.is_box (), false);
   EXPECT_EQ (r.empty (), false);
   EXPECT_EQ (r.is_merged (), true);
-  EXPECT_EQ (db::compare (r, "(0,0;0,200;10,200;10,20;100,20;100,0)"), true);
+  EXPECT_EQ (r.to_string (), "(0,0;0,200;10,200;10,20;100,20;100,0)");
 }
 
 TEST(7) 
@@ -290,19 +290,19 @@ TEST(7)
   r.insert (db::Box (db::Point (-100, -100), db::Point (200, 400)));
   EXPECT_EQ (r.is_box (), false);
 
-  EXPECT_EQ (db::compare ((r - db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))), "(-100,-100;-100,400;200,400;200,-100/10,20;110,20;110,220;10,220)"), true);
+  EXPECT_EQ ((r - db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))).to_string (), "(-100,-100;-100,400;200,400;200,-100/10,20;110,20;110,220;10,220)");
   EXPECT_EQ (db::compare ((r - db::Region ()), "(0,0;0,200;100,200;100,0);(-100,-100;-100,400;200,400;200,-100)"), true);
   EXPECT_EQ ((r - db::Region ()).empty (), false);
   EXPECT_EQ ((r - db::Region ()).is_merged (), false);
-  EXPECT_EQ (db::compare ((db::Region () - r), ""), true);
+  EXPECT_EQ ((db::Region () - r).to_string (), "");
   EXPECT_EQ ((db::Region () - r).empty (), true);
   EXPECT_EQ ((db::Region () - r).is_merged (), true);
 
-  EXPECT_EQ (db::compare (r.andnot(db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))).second, "(-100,-100;-100,400;200,400;200,-100/10,20;110,20;110,220;10,220)"), true);
+  EXPECT_EQ (r.andnot(db::Region (db::Box (db::Point (10, 20), db::Point (110, 220)))).second.to_string (), "(-100,-100;-100,400;200,400;200,-100/10,20;110,20;110,220;10,220)");
   EXPECT_EQ (db::compare (r.andnot(db::Region ()).second, "(0,0;0,200;100,200;100,0);(-100,-100;-100,400;200,400;200,-100)"), true);
   EXPECT_EQ (r.andnot(db::Region ()).second.empty (), false);
   EXPECT_EQ (r.andnot(db::Region ()).second.is_merged (), false);
-  EXPECT_EQ (db::compare (db::Region ().andnot(r).second, ""), true);
+  EXPECT_EQ (db::Region ().andnot(r).second.to_string (), "");
   EXPECT_EQ (db::Region ().andnot(r).second.empty (), true);
   EXPECT_EQ (db::Region ().andnot(r).second.is_merged (), true);
 
@@ -310,7 +310,7 @@ TEST(7)
   EXPECT_EQ (r.is_box (), false);
   EXPECT_EQ (r.empty (), false);
   EXPECT_EQ (r.is_merged (), true);
-  EXPECT_EQ (db::compare (r, "(-100,-100;-100,400;200,400;200,-100/10,20;110,20;110,220;10,220)"), true);
+  EXPECT_EQ (r.to_string (), "(-100,-100;-100,400;200,400;200,-100/10,20;110,20;110,220;10,220)");
 }
 
 TEST(8) 
@@ -319,17 +319,17 @@ TEST(8)
   r.insert (db::Box (db::Point (0, 0), db::Point (100, 200)));
   EXPECT_EQ (r.is_box (), true);
 
-  EXPECT_EQ (db::compare (r.sized (10), "(-10,-10;-10,210;110,210;110,-10)"), true);
+  EXPECT_EQ (r.sized (10).to_string (), "(-10,-10;-10,210;110,210;110,-10)");
   EXPECT_EQ (r.sized (10).is_box (), true);
   EXPECT_EQ (r.sized (10).is_merged (), true);
-  EXPECT_EQ (db::compare (r.sized (db::Coord (10), db::Coord (20)), "(-10,-20;-10,220;110,220;110,-20)"), true);
+  EXPECT_EQ (r.sized (db::Coord (10), db::Coord (20)).to_string (), "(-10,-20;-10,220;110,220;110,-20)");
   EXPECT_EQ (r.sized (db::Coord (10), db::Coord (20)).is_box (), true);
   EXPECT_EQ (r.sized (db::Coord (10), db::Coord (20)).is_merged (), true);
 
   r.size (10);
-  EXPECT_EQ (db::compare (r, "(-10,-10;-10,210;110,210;110,-10)"), true);
+  EXPECT_EQ (r.to_string (), "(-10,-10;-10,210;110,210;110,-10)");
   r.size (db::Coord (10), db::Coord (20));
-  EXPECT_EQ (db::compare (r, "(-20,-30;-20,230;120,230;120,-30)"), true);
+  EXPECT_EQ (r.to_string (), "(-20,-30;-20,230;120,230;120,-30)");
 }
 
 TEST(9) 
@@ -337,10 +337,10 @@ TEST(9)
   db::Region r;
   r.insert (db::Box (db::Point (0, 0), db::Point (100, 200)));
   r.insert (db::Box (db::Point (-100, -100), db::Point (200, 400)));
-  EXPECT_EQ (db::compare (r.sized (10), "(-110,-110;-110,410;210,410;210,-110)"), true);
+  EXPECT_EQ (r.sized (10).to_string (), "(-110,-110;-110,410;210,410;210,-110)");
   EXPECT_EQ (r.sized (10).is_box (), true);
   EXPECT_EQ (r.sized (10).is_merged (), false);
-  EXPECT_EQ (db::compare (r.sized (db::Coord (10), db::Coord (20)), "(-110,-120;-110,420;210,420;210,-120)"), true);
+  EXPECT_EQ (r.sized (db::Coord (10), db::Coord (20)).to_string (), "(-110,-120;-110,420;210,420;210,-120)");
   EXPECT_EQ (r.sized (db::Coord (10), db::Coord (20)).is_box (), true);
   EXPECT_EQ (r.sized (db::Coord (10), db::Coord (20)).is_merged (), false);
 }
@@ -348,80 +348,80 @@ TEST(9)
 TEST(10a) 
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))).to_string (), "");
   r.insert (db::Box (db::Point (0, 0), db::Point (100, 200)));
   r.insert (db::Box (db::Point (-100, -100), db::Point (0, 0)));
   r.set_merged_semantics (false);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))), "(0,0;0,200;100,200;100,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))), "(-100,-100;-100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.selected_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))).to_string (), "(0,0;0,200;100,200;100,0)");
+  EXPECT_EQ (r.selected_not_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))).to_string (), "(-100,-100;-100,0;0,0;0,-100)");
   EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (-20, -20), db::Point (30, 30)))), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (-200, -200), db::Point (-190, -190)))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Region (db::Box (db::Point (-200, -200), db::Point (-190, -190)))).to_string (), "");
   db::Region rr = r;
   r.select_interacting (db::Region (db::Box (db::Point (-20, -20), db::Point (-10, -10))));
-  EXPECT_EQ (db::compare (r, "(-100,-100;-100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.to_string (), "(-100,-100;-100,0;0,0;0,-100)");
   rr.select_not_interacting (db::Region (db::Box (db::Point (-20, -20), db::Point (-10, -10))));
-  EXPECT_EQ (db::compare (rr, "(0,0;0,200;100,200;100,0)"), true);
+  EXPECT_EQ (rr.to_string (), "(0,0;0,200;100,200;100,0)");
 
   r.clear ();
   r.insert(db::Box (db::Point (1000, 0), db::Point (6000, 4000)));
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (0, 4000), db::Point (2000, 6000)))), "(1000,0;1000,4000;6000,4000;6000,0)"), true);
-  EXPECT_EQ (db::compare (db::Region (db::Box (db::Point (0, 4000), db::Point (2000, 6000))).selected_interacting (r), "(0,4000;0,6000;2000,6000;2000,4000)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (0, 4000), db::Point (1000, 6000)))), "(1000,0;1000,4000;6000,4000;6000,0)"), true);
-  EXPECT_EQ (db::compare (db::Region (db::Box (db::Point (0, 4000), db::Point (1000, 6000))).selected_interacting (r), "(0,4000;0,6000;1000,6000;1000,4000)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (0, 4001), db::Point (2000, 6000)))), ""), true);
-  EXPECT_EQ (db::compare (db::Region (db::Box (db::Point (0, 4001), db::Point (2000, 6000))).selected_interacting (r), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (0, 3999), db::Point (1000, 6000)))), "(1000,0;1000,4000;6000,4000;6000,0)"), true);
-  EXPECT_EQ (db::compare (db::Region (db::Box (db::Point (0, 3999), db::Point (1000, 6000))).selected_interacting (r), "(0,3999;0,6000;1000,6000;1000,3999)"), true);
-  EXPECT_EQ (db::compare (r.selected_overlapping (db::Region (db::Box (db::Point (0, 4000), db::Point (2000, 6000)))), ""), true);
-  EXPECT_EQ (db::compare (db::Region (db::Box (db::Point (0, 4000), db::Point (2000, 6000))).selected_overlapping (r), ""), true);
-  EXPECT_EQ (db::compare (r.selected_overlapping (db::Region (db::Box (db::Point (0, 4000), db::Point (1000, 6000)))), ""), true);
-  EXPECT_EQ (db::compare (db::Region (db::Box (db::Point (0, 4000), db::Point (1000, 6000))).selected_overlapping (r), ""), true);
-  EXPECT_EQ (db::compare (r.selected_overlapping (db::Region (db::Box (db::Point (0, 4001), db::Point (2000, 6000)))), ""), true);
-  EXPECT_EQ (db::compare (db::Region (db::Box (db::Point (0, 4001), db::Point (2000, 6000))).selected_overlapping (r), ""), true);
-  EXPECT_EQ (db::compare (r.selected_overlapping (db::Region (db::Box (db::Point (0, 3999), db::Point (1001, 6000)))), "(1000,0;1000,4000;6000,4000;6000,0)"), true);
-  EXPECT_EQ (db::compare (db::Region (db::Box (db::Point (0, 3999), db::Point (1001, 6000))).selected_overlapping (r), "(0,3999;0,6000;1001,6000;1001,3999)"), true);
+  EXPECT_EQ (r.selected_interacting (db::Region (db::Box (db::Point (0, 4000), db::Point (2000, 6000)))).to_string (), "(1000,0;1000,4000;6000,4000;6000,0)");
+  EXPECT_EQ (db::Region (db::Box (db::Point (0, 4000), db::Point (2000, 6000))).selected_interacting (r).to_string (), "(0,4000;0,6000;2000,6000;2000,4000)");
+  EXPECT_EQ (r.selected_interacting (db::Region (db::Box (db::Point (0, 4000), db::Point (1000, 6000)))).to_string (), "(1000,0;1000,4000;6000,4000;6000,0)");
+  EXPECT_EQ (db::Region (db::Box (db::Point (0, 4000), db::Point (1000, 6000))).selected_interacting (r).to_string (), "(0,4000;0,6000;1000,6000;1000,4000)");
+  EXPECT_EQ (r.selected_interacting (db::Region (db::Box (db::Point (0, 4001), db::Point (2000, 6000)))).to_string (), "");
+  EXPECT_EQ (db::Region (db::Box (db::Point (0, 4001), db::Point (2000, 6000))).selected_interacting (r).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (db::Region (db::Box (db::Point (0, 3999), db::Point (1000, 6000)))).to_string (), "(1000,0;1000,4000;6000,4000;6000,0)");
+  EXPECT_EQ (db::Region (db::Box (db::Point (0, 3999), db::Point (1000, 6000))).selected_interacting (r).to_string (), "(0,3999;0,6000;1000,6000;1000,3999)");
+  EXPECT_EQ (r.selected_overlapping (db::Region (db::Box (db::Point (0, 4000), db::Point (2000, 6000)))).to_string (), "");
+  EXPECT_EQ (db::Region (db::Box (db::Point (0, 4000), db::Point (2000, 6000))).selected_overlapping (r).to_string (), "");
+  EXPECT_EQ (r.selected_overlapping (db::Region (db::Box (db::Point (0, 4000), db::Point (1000, 6000)))).to_string (), "");
+  EXPECT_EQ (db::Region (db::Box (db::Point (0, 4000), db::Point (1000, 6000))).selected_overlapping (r).to_string (), "");
+  EXPECT_EQ (r.selected_overlapping (db::Region (db::Box (db::Point (0, 4001), db::Point (2000, 6000)))).to_string (), "");
+  EXPECT_EQ (db::Region (db::Box (db::Point (0, 4001), db::Point (2000, 6000))).selected_overlapping (r).to_string (), "");
+  EXPECT_EQ (r.selected_overlapping (db::Region (db::Box (db::Point (0, 3999), db::Point (1001, 6000)))).to_string (), "(1000,0;1000,4000;6000,4000;6000,0)");
+  EXPECT_EQ (db::Region (db::Box (db::Point (0, 3999), db::Point (1001, 6000))).selected_overlapping (r).to_string (), "(0,3999;0,6000;1001,6000;1001,3999)");
 }
 
 TEST(10b) 
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))).to_string (), "");
   r.insert (db::Box (db::Point (0, 0), db::Point (100, 200)));
   r.insert (db::Box (db::Point (-100, -100), db::Point (0, 0)));
   r.set_merged_semantics (true);
   r.set_min_coherence (true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))), "(0,0;0,200;100,200;100,0)"), true);
+  EXPECT_EQ (r.selected_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))).to_string (), "(0,0;0,200;100,200;100,0)");
   EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (-20, -20), db::Point (30, 30)))), "(-100,-100;-100,0;0,0;0,-100);(0,0;0,200;100,200;100,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (-200, -200), db::Point (-190, -190)))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Region (db::Box (db::Point (-200, -200), db::Point (-190, -190)))).to_string (), "");
   r.select_interacting (db::Region (db::Box (db::Point (-20, -20), db::Point (-10, -10))));
-  EXPECT_EQ (db::compare (r, "(-100,-100;-100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.to_string (), "(-100,-100;-100,0;0,0;0,-100)");
 }
 
 TEST(10c) 
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))).to_string (), "");
   r.insert (db::Box (db::Point (0, 0), db::Point (100, 200)));
   r.insert (db::Box (db::Point (-100, -100), db::Point (0, 0)));
   r.set_merged_semantics (true);
   r.set_min_coherence (false);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (-20, -20), db::Point (30, 30)))), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (-200, -200), db::Point (-190, -190)))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (db::Region (db::Box (db::Point (-20, -20), db::Point (30, 30)))).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (db::Region (db::Box (db::Point (-200, -200), db::Point (-190, -190)))).to_string (), "");
   r.select_interacting (db::Region (db::Box (db::Point (-20, -20), db::Point (-10, -10))));
-  EXPECT_EQ (db::compare (r, "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
 }
 
 TEST(11)
 {
   db::Box bb[3] = { db::Box (db::Point (0, 0), db::Point (10, 10)), db::Box (), db::Box (db::Point (20, 20), db::Point (40, 50)) };
   EXPECT_EQ (db::compare (db::Region (bb + 0, bb + 3), "(0,0;0,10;10,10;10,0);(20,20;20,50;40,50;40,20)"), true);
-  EXPECT_EQ (db::compare (db::Region (db::Polygon (db::Box (db::Point (0, 0), db::Point (10, 10)))), "(0,0;0,10;10,10;10,0)"), true);
-  EXPECT_EQ (db::compare (db::Region (db::Polygon ()), ""), true);
-  EXPECT_EQ (db::compare (db::Region (db::Box ()), ""), true);
+  EXPECT_EQ (db::Region (db::Polygon (db::Box (db::Point (0, 0), db::Point (10, 10)))).to_string (), "(0,0;0,10;10,10;10,0)");
+  EXPECT_EQ (db::Region (db::Polygon ()).to_string (), "");
+  EXPECT_EQ (db::Region (db::Box ()).to_string (), "");
 
   db::Point pts[2] = { db::Point (0, 0), db::Point (0, 20) };
-  EXPECT_EQ (db::compare (db::Region (db::Path (pts + 0, pts + 2, 10)), "(-5,0;-5,20;5,20;5,0)"), true);
+  EXPECT_EQ (db::Region (db::Path (pts + 0, pts + 2, 10)).to_string (), "(-5,0;-5,20;5,20;5,0)");
 }
 
 TEST(12) 
@@ -432,17 +432,17 @@ TEST(12)
   EXPECT_EQ (db::compare (r, "(0,0;0,10;10,10;10,0);(20,20;20,50;40,50;40,20)"), true);
   db::RegionPerimeterFilter f0 (0, 40, false);
   db::Region rr = r.filtered (f0);
-  EXPECT_EQ (db::compare (rr, ""), true);
+  EXPECT_EQ (rr.to_string (), "");
   db::RegionPerimeterFilter f1 (0, 41, false);
   rr = r.filtered (f1);
-  EXPECT_EQ (db::compare (rr, "(0,0;0,10;10,10;10,0)"), true);
+  EXPECT_EQ (rr.to_string (), "(0,0;0,10;10,10;10,0)");
   db::RegionPerimeterFilter f2 (0, 41, true);
   rr = r.filtered (f2);
-  EXPECT_EQ (db::compare (rr, "(20,20;20,50;40,50;40,20)"), true);
-  EXPECT_EQ (db::compare (rr, "(20,20;20,50;40,50;40,20)"), true);
+  EXPECT_EQ (rr.to_string (), "(20,20;20,50;40,50;40,20)");
+  EXPECT_EQ (rr.to_string (), "(20,20;20,50;40,50;40,20)");
   db::RegionPerimeterFilter f3 (50, std::numeric_limits<db::RegionPerimeterFilter::perimeter_type>::max (), false);
   r.filter (f3);
-  EXPECT_EQ (db::compare (r, "(20,20;20,50;40,50;40,20)"), true);
+  EXPECT_EQ (r.to_string (), "(20,20;20,50;40,50;40,20)");
 }
 
 TEST(13) 
@@ -453,16 +453,16 @@ TEST(13)
   EXPECT_EQ (db::compare (r, "(0,0;0,10;10,10;10,0);(20,20;20,50;40,50;40,20)"), true);
   db::RegionAreaFilter f0 (0, 100, false);
   db::Region rr = r.filtered (f0);
-  EXPECT_EQ (db::compare (rr, ""), true);
+  EXPECT_EQ (rr.to_string (), "");
   db::RegionAreaFilter f1 (0, 101, false);
   rr = r.filtered (f1);
-  EXPECT_EQ (db::compare (rr, "(0,0;0,10;10,10;10,0)"), true);
+  EXPECT_EQ (rr.to_string (), "(0,0;0,10;10,10;10,0)");
   db::RegionAreaFilter f2 (0, 101, true);
   rr = r.filtered (f2);
-  EXPECT_EQ (db::compare (rr, "(20,20;20,50;40,50;40,20)"), true);
+  EXPECT_EQ (rr.to_string (), "(20,20;20,50;40,50;40,20)");
   db::RegionAreaFilter f3 (110, std::numeric_limits<db::RegionAreaFilter::area_type>::max (), false);
   r.filter (f3);
-  EXPECT_EQ (db::compare (r, "(20,20;20,50;40,50;40,20)"), true);
+  EXPECT_EQ (r.to_string (), "(20,20;20,50;40,50;40,20)");
 }
 
 TEST(14) 
@@ -473,31 +473,31 @@ TEST(14)
   EXPECT_EQ (db::compare (r, "(0,0;0,10;10,10;10,0);(20,20;20,50;40,50;40,20)"), true);
   db::RegionBBoxFilter f0 (0, 10, false, db::RegionBBoxFilter::BoxWidth);
   db::Region rr = r.filtered (f0);
-  EXPECT_EQ (db::compare (rr, ""), true);
+  EXPECT_EQ (rr.to_string (), "");
   db::RegionBBoxFilter f1 (0, 11, false, db::RegionBBoxFilter::BoxWidth);
   rr = r.filtered (f1);
-  EXPECT_EQ (db::compare (rr, "(0,0;0,10;10,10;10,0)"), true);
+  EXPECT_EQ (rr.to_string (), "(0,0;0,10;10,10;10,0)");
   db::RegionBBoxFilter f2 (20, 21, false, db::RegionBBoxFilter::BoxWidth);
   rr = r.filtered (f2);
-  EXPECT_EQ (db::compare (rr, "(20,20;20,50;40,50;40,20)"), true);
+  EXPECT_EQ (rr.to_string (), "(20,20;20,50;40,50;40,20)");
   db::RegionBBoxFilter f3 (20, 31, false, db::RegionBBoxFilter::BoxHeight);
   rr = r.filtered (f3);
-  EXPECT_EQ (db::compare (rr, "(20,20;20,50;40,50;40,20)"), true);
+  EXPECT_EQ (rr.to_string (), "(20,20;20,50;40,50;40,20)");
   db::RegionBBoxFilter f4 (20, 31, true, db::RegionBBoxFilter::BoxHeight);
   rr = r.filtered (f4);
-  EXPECT_EQ (db::compare (rr, "(0,0;0,10;10,10;10,0)"), true);
+  EXPECT_EQ (rr.to_string (), "(0,0;0,10;10,10;10,0)");
   db::RegionBBoxFilter f5 (20, 31, false, db::RegionBBoxFilter::BoxMaxDim);
   rr = r.filtered (f5);
-  EXPECT_EQ (db::compare (rr, "(20,20;20,50;40,50;40,20)"), true);
+  EXPECT_EQ (rr.to_string (), "(20,20;20,50;40,50;40,20)");
   db::RegionBBoxFilter f6 (20, 31, false, db::RegionBBoxFilter::BoxMinDim);
   rr = r.filtered (f6);
-  EXPECT_EQ (db::compare (rr, "(20,20;20,50;40,50;40,20)"), true);
+  EXPECT_EQ (rr.to_string (), "(20,20;20,50;40,50;40,20)");
   db::RegionBBoxFilter f7 (20, 31, true, db::RegionBBoxFilter::BoxMinDim);
   rr = r.filtered (f7);
-  EXPECT_EQ (db::compare (rr, "(0,0;0,10;10,10;10,0)"), true);
+  EXPECT_EQ (rr.to_string (), "(0,0;0,10;10,10;10,0)");
   db::RegionBBoxFilter f8 (25, 26, false, db::RegionBBoxFilter::BoxAverageDim);
   rr = r.filtered (f8);
-  EXPECT_EQ (db::compare (rr, "(20,20;20,50;40,50;40,20)"), true);
+  EXPECT_EQ (rr.to_string (), "(20,20;20,50;40,50;40,20)");
 }
 
 TEST(15a) 
@@ -506,7 +506,7 @@ TEST(15a)
   db::Region r (bb + 0, bb + 3);
 
   EXPECT_EQ (db::compare (r.width_check (15), "(0,0;0,10)|(10,10;10,0);(10,0;0,0)|(0,10;10,10)"), true);
-  EXPECT_EQ (db::compare (r.width_check (5), ""), true);
+  EXPECT_EQ (r.width_check (5).to_string (), "");
   EXPECT_EQ (db::compare (r.width_check (5, db::RegionCheckOptions (false, db::Euclidian, 91)), "(0,5;0,10)|(0,10;5,10);(0,0;0,5)|(5,0;0,0);(5,10;10,10)|(10,10;10,5);(10,0;5,0)|(10,5;10,0);(20,45;20,50)|(20,50;25,50);(20,20;20,25)|(25,20;20,20);(35,50;40,50)|(40,50;40,45);(40,20;35,20)|(40,25;40,20)"), true);
   EXPECT_EQ (db::compare (r.space_check (15, db::RegionCheckOptions (false, db::Euclidian, 91)), "(9,10;10,10)|(20,20;20,21);(10,10;10,9)|(20,20;20,21);(9,10;10,10)|(21,20;20,20);(10,10;10,9)|(21,20;20,20)"), true);
   EXPECT_EQ (db::compare (r.space_check (15, db::RegionCheckOptions (false, db::Square, 91)), "(5,10;10,10)|(20,20;20,25);(10,10;10,5)|(20,20;20,25);(5,10;10,10)|(25,20;20,20);(10,10;10,5)|(25,20;20,20)"), true);
@@ -544,9 +544,9 @@ TEST(15b)
   r.insert (db::Box (db::Point (300, 300), db::Point (500, 500)));
   r.insert (db::Box (db::Point (400, 200), db::Point (500, 300)));
 
-  EXPECT_EQ (db::compare (r.width_check (120, db::RegionCheckOptions (false, db::Projection)), "(400,200;400,300)|(500,300;500,200)"), true);
+  EXPECT_EQ (r.width_check (120, db::RegionCheckOptions (false, db::Projection)).to_string (), "(400,200;400,300)|(500,300;500,200)");
   EXPECT_EQ (db::compare (r.space_check (120, db::RegionCheckOptions (false, db::Projection)), "(300,0;300,200)|(200,200;200,0);(300,300;300,500)|(200,500;200,300);(300,200;400,200)|(400,300;300,300)"), true);
-  EXPECT_EQ (db::compare (r.notch_check (120, db::RegionCheckOptions (false, db::Projection)), "(300,200;400,200)|(400,300;300,300)"), true);
+  EXPECT_EQ (r.notch_check (120, db::RegionCheckOptions (false, db::Projection)).to_string (), "(300,200;400,200)|(400,300;300,300)");
   EXPECT_EQ (db::compare (r.isolated_check (120, db::RegionCheckOptions (false, db::Projection)), "(300,0;300,200)|(200,200;200,0);(300,300;300,500)|(200,500;200,300)"), true);
 }
 
@@ -562,9 +562,9 @@ TEST(15c)
   r.insert (db::Box (db::Point (400, 200), db::Point (500, 250)));
   r.insert (db::Box (db::Point (400, 250), db::Point (500, 300)));
 
-  EXPECT_EQ (db::compare (r.width_check (120, db::RegionCheckOptions (false, db::Projection)), "(400,200;400,300)|(500,300;500,200)"), true);
+  EXPECT_EQ (r.width_check (120, db::RegionCheckOptions (false, db::Projection)).to_string (), "(400,200;400,300)|(500,300;500,200)");
   EXPECT_EQ (db::compare (r.space_check (120, db::RegionCheckOptions (false, db::Projection)), "(300,0;300,200)|(200,200;200,0);(300,300;300,500)|(200,500;200,300);(300,200;400,200)|(400,300;300,300)"), true);
-  EXPECT_EQ (db::compare (r.notch_check (120, db::RegionCheckOptions (false, db::Projection)), "(300,200;400,200)|(400,300;300,300)"), true);
+  EXPECT_EQ (r.notch_check (120, db::RegionCheckOptions (false, db::Projection)).to_string (), "(300,200;400,200)|(400,300;300,300)");
   EXPECT_EQ (db::compare (r.isolated_check (120, db::RegionCheckOptions (false, db::Projection)), "(300,0;300,200)|(200,200;200,0);(300,300;300,500)|(200,500;200,300)"), true);
 }
 
@@ -635,7 +635,7 @@ TEST(15e)
     r.insert (poly);
   }
 
-  EXPECT_EQ (db::compare (r.space_check (1000), "(20857,3600;20857,66000)|(19957,66000;19957,3600)"), true);
+  EXPECT_EQ (r.space_check (1000).to_string (), "(20857,3600;20857,66000)|(19957,66000;19957,3600)");
 }
 
 TEST(15g)
@@ -720,57 +720,57 @@ TEST(15i)
 
   EXPECT_EQ (db::compare (r.separation_check (rl + rr, 40, options), "(90,90;90,-90)/(100,-90;100,90);(-90,-90;-90,90)/(-100,90;-100,-90)"), true);
   EXPECT_EQ (db::compare (r.separation_check (rl + rt, 40, options), "(-90,-90;-90,90)/(-100,90;-100,-90);(-90,90;90,90)/(90,100;-90,100)"), true);
-  EXPECT_EQ (db::compare (r.separation_check (rl, 40, options), ""), true);
-  EXPECT_EQ (db::compare (r.separation_check (rt, 40, options), ""), true);
+  EXPECT_EQ (r.separation_check (rl, 40, options).to_string (), "");
+  EXPECT_EQ (r.separation_check (rt, 40, options).to_string (), "");
   EXPECT_EQ (db::compare (r.separation_check (rt + rr + rb, 40, options), "(-90,90;90,90)/(90,100;-90,100);(90,90;90,-90)/(100,-90;100,90);(90,-90;-90,-90)/(-90,-100;90,-100)"), true);
 
   options.rect_filter = db::TwoSidesAllowed;
 
-  EXPECT_EQ (db::compare (r.separation_check (rl + rr, 40, options), ""), true);
-  EXPECT_EQ (db::compare (r.separation_check (rl + rt, 40, options), ""), true);
-  EXPECT_EQ (db::compare (r.separation_check (rl, 40, options), "(-90,-90;-90,90)/(-100,90;-100,-90)"), true);
-  EXPECT_EQ (db::compare (r.separation_check (rt, 40, options), "(-90,90;90,90)/(90,100;-90,100)"), true);
+  EXPECT_EQ (r.separation_check (rl + rr, 40, options).to_string (), "");
+  EXPECT_EQ (r.separation_check (rl + rt, 40, options).to_string (), "");
+  EXPECT_EQ (r.separation_check (rl, 40, options).to_string (), "(-90,-90;-90,90)/(-100,90;-100,-90)");
+  EXPECT_EQ (r.separation_check (rt, 40, options).to_string (), "(-90,90;90,90)/(90,100;-90,100)");
   EXPECT_EQ (db::compare (r.separation_check (rt + rr + rb, 40, options), "(-90,90;90,90)/(90,100;-90,100);(90,90;90,-90)/(100,-90;100,90);(90,-90;-90,-90)/(-90,-100;90,-100)"), true);
 
   options.rect_filter = db::TwoOppositeSidesAllowed;
 
-  EXPECT_EQ (db::compare (r.separation_check (rl + rr, 40, options), ""), true);
+  EXPECT_EQ (r.separation_check (rl + rr, 40, options).to_string (), "");
   EXPECT_EQ (db::compare (r.separation_check (rl + rt, 40, options), "(-90,-90;-90,90)/(-100,90;-100,-90);(-90,90;90,90)/(90,100;-90,100)"), true);
-  EXPECT_EQ (db::compare (r.separation_check (rl, 40, options), "(-90,-90;-90,90)/(-100,90;-100,-90)"), true);
-  EXPECT_EQ (db::compare (r.separation_check (rt, 40, options), "(-90,90;90,90)/(90,100;-90,100)"), true);
+  EXPECT_EQ (r.separation_check (rl, 40, options).to_string (), "(-90,-90;-90,90)/(-100,90;-100,-90)");
+  EXPECT_EQ (r.separation_check (rt, 40, options).to_string (), "(-90,90;90,90)/(90,100;-90,100)");
   EXPECT_EQ (db::compare (r.separation_check (rt + rr + rb, 40, options), "(-90,90;90,90)/(90,100;-90,100);(90,90;90,-90)/(100,-90;100,90);(90,-90;-90,-90)/(-90,-100;90,-100)"), true);
 
   options.rect_filter = db::TwoConnectedSidesAllowed;
 
   EXPECT_EQ (db::compare (r.separation_check (rl + rr, 40, options), "(90,90;90,-90)/(100,-90;100,90);(-90,-90;-90,90)/(-100,90;-100,-90)"), true);
-  EXPECT_EQ (db::compare (r.separation_check (rl + rt, 40, options), ""), true);
-  EXPECT_EQ (db::compare (r.separation_check (rl, 40, options), "(-90,-90;-90,90)/(-100,90;-100,-90)"), true);
-  EXPECT_EQ (db::compare (r.separation_check (rt, 40, options), "(-90,90;90,90)/(90,100;-90,100)"), true);
+  EXPECT_EQ (r.separation_check (rl + rt, 40, options).to_string (), "");
+  EXPECT_EQ (r.separation_check (rl, 40, options).to_string (), "(-90,-90;-90,90)/(-100,90;-100,-90)");
+  EXPECT_EQ (r.separation_check (rt, 40, options).to_string (), "(-90,90;90,90)/(90,100;-90,100)");
   EXPECT_EQ (db::compare (r.separation_check (rt + rr + rb, 40, options), "(-90,90;90,90)/(90,100;-90,100);(90,90;90,-90)/(100,-90;100,90);(90,-90;-90,-90)/(-90,-100;90,-100)"), true);
 
   options.rect_filter = db::ThreeSidesAllowed;
 
   EXPECT_EQ (db::compare (r.separation_check (rl + rr, 40, options), "(90,90;90,-90)/(100,-90;100,90);(-90,-90;-90,90)/(-100,90;-100,-90)"), true);
   EXPECT_EQ (db::compare (r.separation_check (rl + rt, 40, options), "(-90,-90;-90,90)/(-100,90;-100,-90);(-90,90;90,90)/(90,100;-90,100)"), true);
-  EXPECT_EQ (db::compare (r.separation_check (rl, 40, options), "(-90,-90;-90,90)/(-100,90;-100,-90)"), true);
-  EXPECT_EQ (db::compare (r.separation_check (rt, 40, options), "(-90,90;90,90)/(90,100;-90,100)"), true);
-  EXPECT_EQ (db::compare (r.separation_check (rt + rr + rb, 40, options), ""), true);
+  EXPECT_EQ (r.separation_check (rl, 40, options).to_string (), "(-90,-90;-90,90)/(-100,90;-100,-90)");
+  EXPECT_EQ (r.separation_check (rt, 40, options).to_string (), "(-90,90;90,90)/(90,100;-90,100)");
+  EXPECT_EQ (r.separation_check (rt + rr + rb, 40, options).to_string (), "");
 
   options.rect_filter = db::RectFilter (0x9531);  //  one and two sides allowed
 
-  EXPECT_EQ (db::compare (r.separation_check (rl + rr, 40, options), ""), true);
-  EXPECT_EQ (db::compare (r.separation_check (rl + rt, 40, options), ""), true);
-  EXPECT_EQ (db::compare (r.separation_check (rl, 40, options), ""), true);
-  EXPECT_EQ (db::compare (r.separation_check (rt, 40, options), ""), true);
+  EXPECT_EQ (r.separation_check (rl + rr, 40, options).to_string (), "");
+  EXPECT_EQ (r.separation_check (rl + rt, 40, options).to_string (), "");
+  EXPECT_EQ (r.separation_check (rl, 40, options).to_string (), "");
+  EXPECT_EQ (r.separation_check (rt, 40, options).to_string (), "");
   EXPECT_EQ (db::compare (r.separation_check (rt + rr + rb, 40, options), "(-90,90;90,90)/(90,100;-90,100);(90,90;90,-90)/(100,-90;100,90);(90,-90;-90,-90)/(-90,-100;90,-100)"), true);
 
   options.rect_filter = db::RectFilter (0x31);  //  one and two connected sides allowed
 
   EXPECT_EQ (db::compare (r.separation_check (rl + rr, 40, options), "(90,90;90,-90)/(100,-90;100,90);(-90,-90;-90,90)/(-100,90;-100,-90)"), true);
-  EXPECT_EQ (db::compare (r.separation_check (rl + rt, 40, options), ""), true);
-  EXPECT_EQ (db::compare (r.separation_check (rr + rt, 40, options), ""), true);
-  EXPECT_EQ (db::compare (r.separation_check (rl, 40, options), ""), true);
-  EXPECT_EQ (db::compare (r.separation_check (rt, 40, options), ""), true);
+  EXPECT_EQ (r.separation_check (rl + rt, 40, options).to_string (), "");
+  EXPECT_EQ (r.separation_check (rr + rt, 40, options).to_string (), "");
+  EXPECT_EQ (r.separation_check (rl, 40, options).to_string (), "");
+  EXPECT_EQ (r.separation_check (rt, 40, options).to_string (), "");
   EXPECT_EQ (db::compare (r.separation_check (rt + rr + rb, 40, options), "(-90,90;90,90)/(90,100;-90,100);(90,90;90,-90)/(100,-90;100,90);(90,-90;-90,-90)/(-90,-100;90,-100)"), true);
 }
 
@@ -782,23 +782,23 @@ TEST(16)
   db::Region b;
   b.insert (db::Box (db::Point (0, 0), db::Point (100, 100)));
 
-  EXPECT_EQ (db::compare (a.inside_check (b, 15), "(10,20;10,30)/(0,9;0,41)"), true);
-  EXPECT_EQ (db::compare (a.inside_check (b, 15, db::RegionCheckOptions (true)), "(10,20;10,30)/(0,0;0,100)"), true);
+  EXPECT_EQ (a.inside_check (b, 15).to_string (), "(10,20;10,30)/(0,9;0,41)");
+  EXPECT_EQ (a.inside_check (b, 15, db::RegionCheckOptions (true)).to_string (), "(10,20;10,30)/(0,0;0,100)");
   EXPECT_EQ (db::compare (a.inside_check (b, 15, db::RegionCheckOptions (false, db::Euclidian, 91)), "(10,20;10,30)/(0,9;0,41);(10,30;15,30)/(0,30;0,41);(15,20;10,20)/(0,9;0,20)"), true);
-  EXPECT_EQ (db::compare (b.enclosing_check (a, 15), "(0,9;0,41)/(10,20;10,30)"), true);
-  EXPECT_EQ (db::compare (b.enclosing_check (a, 15, db::RegionCheckOptions (true)), "(0,0;0,100)/(10,20;10,30)"), true);
+  EXPECT_EQ (b.enclosing_check (a, 15).to_string (), "(0,9;0,41)/(10,20;10,30)");
+  EXPECT_EQ (b.enclosing_check (a, 15, db::RegionCheckOptions (true)).to_string (), "(0,0;0,100)/(10,20;10,30)");
   EXPECT_EQ (db::compare (b.enclosing_check (a, 15, db::RegionCheckOptions (false, db::Euclidian, 91)), "(0,9;0,41)/(10,20;10,30);(0,30;0,41)/(10,30;15,30);(0,9;0,20)/(15,20;10,20)"), true);
 
   b.clear ();
   b.insert (db::Box (db::Point (30, 0), db::Point (100, 100)));
-  EXPECT_EQ (db::compare (b.separation_check (a, 15), "(30,9;30,41)/(20,30;20,20)"), true);
-  EXPECT_EQ (db::compare (b.separation_check (a, 15, db::RegionCheckOptions (true)), "(30,0;30,100)/(20,30;20,20)"), true);
+  EXPECT_EQ (b.separation_check (a, 15).to_string (), "(30,9;30,41)/(20,30;20,20)");
+  EXPECT_EQ (b.separation_check (a, 15, db::RegionCheckOptions (true)).to_string (), "(30,0;30,100)/(20,30;20,20)");
   EXPECT_EQ (db::compare (b.separation_check (a, 15, db::RegionCheckOptions (false, db::Euclidian, 91)), "(30,30;30,41)/(15,30;20,30);(30,9;30,41)/(20,30;20,20);(30,9;30,20)/(20,20;15,20)"), true);
 
   b.clear ();
   b.insert (db::Box (db::Point (15, 0), db::Point (100, 100)));
-  EXPECT_EQ (db::compare (b.overlap_check (a, 15), "(15,6;15,44)/(20,30;20,20)"), true);
-  EXPECT_EQ (db::compare (b.overlap_check (a, 15, db::RegionCheckOptions (true)), "(15,0;15,100)/(20,30;20,20)"), true);
+  EXPECT_EQ (b.overlap_check (a, 15).to_string (), "(15,6;15,44)/(20,30;20,20)");
+  EXPECT_EQ (b.overlap_check (a, 15, db::RegionCheckOptions (true)).to_string (), "(15,0;15,100)/(20,30;20,20)");
   EXPECT_EQ (db::compare (b.overlap_check (a, 15, db::RegionCheckOptions (false, db::Euclidian, 91)), "(15,15;15,30)/(15,30;20,30);(15,6;15,44)/(20,30;20,20);(15,20;15,35)/(20,20;15,20)"), true);
 }
 
@@ -839,11 +839,11 @@ TEST(18a)
     o.select_not_outside (rr);
     EXPECT_EQ (db::compare (o, "(0,0;0,20;20,20;20,0);(20,30;20,50;40,50;40,30);(0,60;0,80;60,80;60,60);(0,100;0,130;30,130;30,100)"), true);
   }
-  EXPECT_EQ (db::compare (r.selected_inside (rr), "(20,30;20,50;40,50;40,30)"), true);
+  EXPECT_EQ (r.selected_inside (rr).to_string (), "(20,30;20,50;40,50;40,30)");
   {
     db::Region o = r;
     o.select_inside (rr);
-    EXPECT_EQ (db::compare (o, "(20,30;20,50;40,50;40,30)"), true);
+    EXPECT_EQ (o.to_string (), "(20,30;20,50;40,50;40,30)");
     o = r;
     EXPECT_EQ (db::compare (o.selected_not_inside (rr), "(0,0;0,20;20,20;20,0);(50,10;50,30;70,30;70,10);(70,60;70,80;90,80;90,60);(0,60;0,80;60,80;60,60);(0,100;0,130;30,130;30,100)"), true);
     EXPECT_EQ (o.selected_inside (rr).count () + o.selected_not_inside (rr).count (), size_t (6));
@@ -857,11 +857,11 @@ TEST(18a)
     o.select_interacting (rr);
     EXPECT_EQ (db::compare (o, "(0,0;0,20;20,20;20,0);(50,10;50,30;70,30;70,10);(20,30;20,50;40,50;40,30);(0,60;0,80;60,80;60,60);(0,100;0,130;30,130;30,100)"), true);
     o = r;
-    EXPECT_EQ (db::compare (o.selected_not_interacting (rr), "(70,60;70,80;90,80;90,60)"), true);
+    EXPECT_EQ (o.selected_not_interacting (rr).to_string (), "(70,60;70,80;90,80;90,60)");
     EXPECT_EQ (o.selected_interacting (rr).count () + o.selected_not_interacting (rr).count (), size_t (6));
     EXPECT_EQ (o.selected_interacting (rr).hier_count () + o.selected_not_interacting (rr).hier_count (), size_t (6));
     o.select_not_interacting (rr);
-    EXPECT_EQ (db::compare (o, "(70,60;70,80;90,80;90,60)"), true);
+    EXPECT_EQ (o.to_string (), "(70,60;70,80;90,80;90,60)");
   }
   EXPECT_EQ (db::compare (r.selected_overlapping (rr), "(0,0;0,20;20,20;20,0);(20,30;20,50;40,50;40,30);(0,60;0,80;60,80;60,60);(0,100;0,130;30,130;30,100)"), true);
   {
@@ -875,11 +875,11 @@ TEST(18a)
     o.select_not_overlapping (rr);
     EXPECT_EQ (db::compare (o, "(50,10;50,30;70,30;70,10);(70,60;70,80;90,80;90,60)"), true);
   }
-  EXPECT_EQ (db::compare (r.selected_enclosing (rr), "(0,100;0,130;30,130;30,100)"), true);
+  EXPECT_EQ (r.selected_enclosing (rr).to_string (), "(0,100;0,130;30,130;30,100)");
   {
     db::Region o = r;
     o.select_enclosing (rr);
-    EXPECT_EQ (db::compare (o, "(0,100;0,130;30,130;30,100)"), true);
+    EXPECT_EQ (o.to_string (), "(0,100;0,130;30,130;30,100)");
     o = r;
     EXPECT_EQ (db::compare (o.selected_not_enclosing (rr), "(0,0;0,20;20,20;20,0);(50,10;50,30;70,30;70,10);(70,60;70,80;90,80;90,60);(20,30;20,50;40,50;40,30);(0,60;0,80;60,80;60,60)"), true);
     EXPECT_EQ (o.selected_enclosing (rr).count () + o.selected_not_enclosing (rr).count (), size_t (6));
@@ -955,14 +955,14 @@ TEST(18c)
   rr.insert (db::Box (db::Point (0, -10), db::Point (100, 30)));
 
   EXPECT_EQ (db::compare (r.selected_outside (rr), "(-120,0;-120,20;-100,20;-100,0);(100,0;100,20;120,20;120,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_inside (rr), "(-20,0;-20,20;20,20;20,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_overlapping (rr), "(-20,0;-20,20;20,20;20,0)"), true);
+  EXPECT_EQ (r.selected_inside (rr).to_string (), "(-20,0;-20,20;20,20;20,0)");
+  EXPECT_EQ (r.selected_overlapping (rr).to_string (), "(-20,0;-20,20;20,20;20,0)");
   EXPECT_EQ (db::compare (r.selected_interacting (rr), "(-20,0;-20,20;20,20;20,0);(-120,0;-120,20;-100,20;-100,0);(100,0;100,20;120,20;120,0)"), true);
 
-  EXPECT_EQ (db::compare (r.selected_not_outside (rr), "(-20,0;-20,20;20,20;20,0)"), true);
+  EXPECT_EQ (r.selected_not_outside (rr).to_string (), "(-20,0;-20,20;20,20;20,0)");
   EXPECT_EQ (db::compare (r.selected_not_inside (rr), "(-120,0;-120,20;-100,20;-100,0);(100,0;100,20;120,20;120,0)"), true);
   EXPECT_EQ (db::compare (r.selected_not_overlapping (rr), "(-120,0;-120,20;-100,20;-100,0);(100,0;100,20;120,20;120,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr), ""), true);
+  EXPECT_EQ (r.selected_not_interacting (rr).to_string (), "");
 
   r.clear ();
   r.insert (db::Box (db::Point (-120, 0), db::Point (-100, 20)));
@@ -974,14 +974,14 @@ TEST(18c)
   rr.insert (db::Box (db::Point (0, -10), db::Point (100, 30)));
 
   EXPECT_EQ (db::compare (r.selected_outside (rr), "(-120,0;-120,20;-100,20;-100,0);(100,0;100,20;120,20;120,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_inside (rr), "(-20,0;-20,20;20,20;20,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_overlapping (rr), "(-20,0;-20,20;20,20;20,0)"), true);
+  EXPECT_EQ (r.selected_inside (rr).to_string (), "(-20,0;-20,20;20,20;20,0)");
+  EXPECT_EQ (r.selected_overlapping (rr).to_string (), "(-20,0;-20,20;20,20;20,0)");
   EXPECT_EQ (db::compare (r.selected_interacting (rr), "(-20,0;-20,20;20,20;20,0);(-120,0;-120,20;-100,20;-100,0);(100,0;100,20;120,20;120,0)"), true);
 
-  EXPECT_EQ (db::compare (r.selected_not_outside (rr), "(-20,0;-20,20;20,20;20,0)"), true);
+  EXPECT_EQ (r.selected_not_outside (rr).to_string (), "(-20,0;-20,20;20,20;20,0)");
   EXPECT_EQ (db::compare (r.selected_not_inside (rr), "(-120,0;-120,20;-100,20;-100,0);(100,0;100,20;120,20;120,0)"), true);
   EXPECT_EQ (db::compare (r.selected_not_overlapping (rr), "(-120,0;-120,20;-100,20;-100,0);(100,0;100,20;120,20;120,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr), ""), true);
+  EXPECT_EQ (r.selected_not_interacting (rr).to_string (), "");
 
   r.clear ();
   r.insert (db::Box (db::Point (-120, 0), db::Point (-100, 20)));
@@ -992,14 +992,14 @@ TEST(18c)
   rr.insert (db::Box (db::Point (-100, -10), db::Point (100, 30)));
 
   EXPECT_EQ (db::compare (r.selected_outside (rr), "(-120,0;-120,20;-100,20;-100,0);(100,0;100,20;120,20;120,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_inside (rr), "(-20,0;-20,20;20,20;20,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_overlapping (rr), "(-20,0;-20,20;20,20;20,0)"), true);
+  EXPECT_EQ (r.selected_inside (rr).to_string (), "(-20,0;-20,20;20,20;20,0)");
+  EXPECT_EQ (r.selected_overlapping (rr).to_string (), "(-20,0;-20,20;20,20;20,0)");
   EXPECT_EQ (db::compare (r.selected_interacting (rr), "(-20,0;-20,20;20,20;20,0);(-120,0;-120,20;-100,20;-100,0);(100,0;100,20;120,20;120,0)"), true);
 
-  EXPECT_EQ (db::compare (r.selected_not_outside (rr), "(-20,0;-20,20;20,20;20,0)"), true);
+  EXPECT_EQ (r.selected_not_outside (rr).to_string (), "(-20,0;-20,20;20,20;20,0)");
   EXPECT_EQ (db::compare (r.selected_not_inside (rr), "(-120,0;-120,20;-100,20;-100,0);(100,0;100,20;120,20;120,0)"), true);
   EXPECT_EQ (db::compare (r.selected_not_overlapping (rr), "(-120,0;-120,20;-100,20;-100,0);(100,0;100,20;120,20;120,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr), ""), true);
+  EXPECT_EQ (r.selected_not_interacting (rr).to_string (), "");
 
   r.clear ();
   r.insert (db::Box (db::Point (-120, 0), db::Point (-100, 20)));
@@ -1011,14 +1011,14 @@ TEST(18c)
   rr.insert (db::Box (db::Point (1, -10), db::Point (100, 30)));
 
   EXPECT_EQ (db::compare (r.selected_outside (rr), "(-120,0;-120,20;-100,20;-100,0);(100,0;100,20;120,20;120,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_inside (rr), ""), true);
-  EXPECT_EQ (db::compare (r.selected_overlapping (rr), "(-20,0;-20,20;20,20;20,0)"), true);
+  EXPECT_EQ (r.selected_inside (rr).to_string (), "");
+  EXPECT_EQ (r.selected_overlapping (rr).to_string (), "(-20,0;-20,20;20,20;20,0)");
   EXPECT_EQ (db::compare (r.selected_interacting (rr), "(-20,0;-20,20;20,20;20,0);(-120,0;-120,20;-100,20;-100,0);(100,0;100,20;120,20;120,0)"), true);
 
-  EXPECT_EQ (db::compare (r.selected_not_outside (rr), "(-20,0;-20,20;20,20;20,0)"), true);
+  EXPECT_EQ (r.selected_not_outside (rr).to_string (), "(-20,0;-20,20;20,20;20,0)");
   EXPECT_EQ (db::compare (r.selected_not_inside (rr), "(-20,0;-20,20;20,20;20,0);(-120,0;-120,20;-100,20;-100,0);(100,0;100,20;120,20;120,0)"), true);
   EXPECT_EQ (db::compare (r.selected_not_overlapping (rr), "(-120,0;-120,20;-100,20;-100,0);(100,0;100,20;120,20;120,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr), ""), true);
+  EXPECT_EQ (r.selected_not_interacting (rr).to_string (), "");
 
   r.clear ();
   r.insert (db::Box (db::Point (-100, 0), db::Point (-80, 20)));
@@ -1030,15 +1030,15 @@ TEST(18c)
   rr.insert (db::Box (db::Point (-100, -10), db::Point (0, 30)));
   rr.insert (db::Box (db::Point (0, -10), db::Point (100, 30)));
 
-  EXPECT_EQ (db::compare (r.selected_outside (rr), ""), true);
+  EXPECT_EQ (r.selected_outside (rr).to_string (), "");
   EXPECT_EQ (db::compare (r.selected_inside (rr), "(-100,0;-100,20;-80,20;-80,0);(-20,0;-20,20;20,20;20,0);(80,0;80,20;100,20;100,0)"), true);
   EXPECT_EQ (db::compare (r.selected_overlapping (rr), "(-100,0;-100,20;-80,20;-80,0);(-20,0;-20,20;20,20;20,0);(80,0;80,20;100,20;100,0)"), true);
   EXPECT_EQ (db::compare (r.selected_interacting (rr), "(-100,0;-100,20;-80,20;-80,0);(-20,0;-20,20;20,20;20,0);(80,0;80,20;100,20;100,0)"), true);
 
   EXPECT_EQ (db::compare (r.selected_not_outside (rr), "(-100,0;-100,20;-80,20;-80,0);(-20,0;-20,20;20,20;20,0);(80,0;80,20;100,20;100,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_inside (rr), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_overlapping (rr), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr), ""), true);
+  EXPECT_EQ (r.selected_not_inside (rr).to_string (), "");
+  EXPECT_EQ (r.selected_not_overlapping (rr).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr).to_string (), "");
 }
 
 TEST(18d)
@@ -1057,7 +1057,7 @@ TEST(18d)
   rr.insert (db::Box (db::Point (10, 10), db::Point (50, 90)));
   rr.insert (db::Box (db::Point (10, 110), db::Point (20, 120)));
 
-  EXPECT_EQ (db::compare (r.pull_inside (rr), "(10,110;10,120;20,120;20,110)"), true);
+  EXPECT_EQ (r.pull_inside (rr).to_string (), "(10,110;10,120;20,120;20,110)");
 
   EXPECT_EQ (db::compare (r.pull_interacting (rr), "(10,110;10,120;20,120;20,110);(10,0;10,90;50,90;50,10;20,10;20,0)"), true);
   EXPECT_EQ (db::compare (r.pull_overlapping (rr), "(10,110;10,120;20,120;20,110);(10,0;10,90;50,90;50,10;20,10;20,0)"), true);
@@ -1080,16 +1080,16 @@ TEST(19)
   r2.insert (db::Box (db::Point (0, 0), db::Point (20, 10)));
   r2.insert (db::Box (db::Point (0, 0), db::Point (20, 30)));
 
-  EXPECT_EQ (db::compare (r1.in (r2, false), "(0,0;0,30;20,30;20,0)"), true);
-  EXPECT_EQ (db::compare (r1.in (r2, true), ""), true);
-  EXPECT_EQ (db::compare (r2.in (r1, true), ""), true);
+  EXPECT_EQ (r1.in (r2, false).to_string (), "(0,0;0,30;20,30;20,0)");
+  EXPECT_EQ (r1.in (r2, true).to_string (), "");
+  EXPECT_EQ (r2.in (r1, true).to_string (), "");
 
   r1.set_merged_semantics (false);
   r2.set_merged_semantics (false);
 
   EXPECT_EQ (db::compare (r1.in (r2, false), "(0,0;0,20;20,20;20,0);(0,0;0,30;20,30;20,0)"), true);
-  EXPECT_EQ (db::compare (r1.in (r2, true), "(0,0;0,20;10,20;10,0)"), true);
-  EXPECT_EQ (db::compare (r2.in (r1, true), "(0,0;0,10;20,10;20,0)"), true);
+  EXPECT_EQ (r1.in (r2, true).to_string (), "(0,0;0,20;10,20;10,0)");
+  EXPECT_EQ (r2.in (r1, true).to_string (), "(0,0;0,10;20,10;20,0)");
 }
 
 TEST(20)
@@ -1131,7 +1131,7 @@ TEST(20)
     EXPECT_EQ (r1.has_valid_polygons (), false);
     EXPECT_EQ (r1.area (), 4000);
     EXPECT_EQ (r1.perimeter (), db::Region::perimeter_type (320));
-    EXPECT_EQ (db::compare (r1.bbox (), "(120,20;220,140)"), true);
+    EXPECT_EQ (r1.bbox ().to_string (), "(120,20;220,140)");
     EXPECT_EQ (r1.is_box (), false);
     EXPECT_EQ (r1.count (), size_t (2));
     EXPECT_EQ (r1.hier_count (), size_t (2));
@@ -1139,20 +1139,20 @@ TEST(20)
 
     db::RegionPerimeterFilter f0 (0, 100, false);
     db::Region rr = r1.filtered (f0);
-    EXPECT_EQ (db::compare (rr, "(120,20;120,40;140,40;140,20)"), true);
+    EXPECT_EQ (rr.to_string (), "(120,20;120,40;140,40;140,20)");
 
     db::Region r2 = r1;
     EXPECT_EQ (r2.has_valid_polygons (), false);
     EXPECT_EQ (r2.area (), 4000);
     EXPECT_EQ (r2.perimeter (), db::Region::perimeter_type (320));
-    EXPECT_EQ (db::compare (r2.bbox (), "(120,20;220,140)"), true);
+    EXPECT_EQ (r2.bbox ().to_string (), "(120,20;220,140)");
     EXPECT_EQ (r2.is_box (), false);
     EXPECT_EQ (r2.count (), size_t (2));
     EXPECT_EQ (r2.hier_count (), size_t (2));
     EXPECT_EQ (r2.empty (), false);
     r2.filter (f0);
     EXPECT_EQ (r2.has_valid_polygons (), true);
-    EXPECT_EQ (db::compare (r2, "(120,20;120,40;140,40;140,20)"), true);
+    EXPECT_EQ (r2.to_string (), "(120,20;120,40;140,40;140,20)");
     EXPECT_EQ (r2.count (), size_t (1));
     EXPECT_EQ (r2.hier_count (), size_t (1));
     EXPECT_EQ (r2.empty (), false);
@@ -1180,7 +1180,7 @@ TEST(20)
   {
     db::Region r1 (db::RecursiveShapeIterator (ly, ly.cell (top), l2, db::Box (60, 10, 70, 50)), db::ICplxTrans (2.0));
     EXPECT_EQ (r1.has_valid_polygons (), false);
-    EXPECT_EQ (db::compare (r1, "(120,20;120,40;140,40;140,20)"), true);
+    EXPECT_EQ (r1.to_string (), "(120,20;120,40;140,40;140,20)");
     EXPECT_EQ (r1.has_valid_polygons (), false);
     EXPECT_EQ (r1.is_box (), true);
     EXPECT_EQ (r1.count (), size_t (1));
@@ -1189,10 +1189,10 @@ TEST(20)
 
     db::Region r2 = r1;
 
-    EXPECT_EQ (db::compare (r1.transformed (db::ICplxTrans (0.5)), "(60,10;60,20;70,20;70,10)"), true);
+    EXPECT_EQ (r1.transformed (db::ICplxTrans (0.5)).to_string (), "(60,10;60,20;70,20;70,10)");
     r1.transform (db::ICplxTrans (0.5));
     EXPECT_EQ (r1.has_valid_polygons (), true);
-    EXPECT_EQ (db::compare (r1, "(60,10;60,20;70,20;70,10)"), true);
+    EXPECT_EQ (r1.to_string (), "(60,10;60,20;70,20;70,10)");
 
     r1.clear ();
     EXPECT_EQ (r1.has_valid_polygons (), true);
@@ -1202,10 +1202,10 @@ TEST(20)
     EXPECT_EQ (r1.perimeter (), db::Region::perimeter_type (0));
     EXPECT_EQ (r1.area (), 0);
 
-    EXPECT_EQ (db::compare (r2, "(120,20;120,40;140,40;140,20)"), true);
+    EXPECT_EQ (r2.to_string (), "(120,20;120,40;140,40;140,20)");
     r1.swap (r2);
 
-    EXPECT_EQ (db::compare (r1, "(120,20;120,40;140,40;140,20)"), true);
+    EXPECT_EQ (r1.to_string (), "(120,20;120,40;140,40;140,20)");
     EXPECT_EQ (r1.has_valid_polygons (), false);
     EXPECT_EQ (r2.has_valid_polygons (), true);
     EXPECT_EQ (r2.count (), size_t (0));
@@ -1243,7 +1243,7 @@ TEST(20)
     db::Region r1 (db::RecursiveShapeIterator (ly, ly.cell (top), l2));
     EXPECT_EQ (r1.has_valid_polygons (), false);
     EXPECT_EQ (db::compare (r1.space_check (30), "(60,10;60,20)|(40,40;40,10);(70,20;70,12)|(80,40;80,48);(60,20;70,20)|(92,40;80,40)"), true);
-    EXPECT_EQ (db::compare (r1.space_check (2), ""), true);
+    EXPECT_EQ (r1.space_check (2).to_string (), "");
   }
 
   {
@@ -1266,29 +1266,29 @@ TEST(20)
     db::Region r1 (db::RecursiveShapeIterator (ly, ly.cell (top), l1));
     EXPECT_EQ (r1.has_valid_polygons (), false);
     EXPECT_EQ (db::compare (r1.hulls (), "(0,0;0,30;30,30;30,0);(50,0;50,30;80,30;80,0);(50,40;50,70;80,70;80,40)"), true);
-    EXPECT_EQ (db::compare (r1.holes (), ""), true);
+    EXPECT_EQ (r1.holes ().to_string (), "");
     db::Region r2 (db::RecursiveShapeIterator (ly, ly.cell (top), l2));
     EXPECT_EQ (r2.has_valid_polygons (), false);
     EXPECT_EQ (db::compare ((r1 & r2), "(60,10;60,20;70,20;70,10);(10,10;10,30;30,30;30,10)"), true);
     EXPECT_EQ (db::compare ((r1 | r2), "(50,0;50,30;80,30;80,0);(0,0;0,30;10,30;10,40;40,40;40,10;30,10;30,0);(50,40;50,70;140,70;140,40)"), true);
     EXPECT_EQ (db::compare ((r1 + r2), "(0,0;0,30;30,30;30,0);(50,0;50,30;80,30;80,0);(50,40;50,70;80,70;80,40);(60,10;60,20;70,20;70,10);(10,10;10,40;40,40;40,10);(80,40;80,70;110,70;110,40);(110,40;110,70;140,70;140,40)"), true);
     EXPECT_EQ (db::compare ((r1 ^ r2), "(50,0;50,30;80,30;80,0/60,10;70,10;70,20;60,20);(0,0;0,30;10,30;10,40;40,40;40,10;30,10;30,0/10,10;30,10;30,30;10,30);(50,40;50,70;140,70;140,40)"), true);
-    EXPECT_EQ (db::compare ((r1 ^ r1), ""), true);
+    EXPECT_EQ ((r1 ^ r1).to_string (), "");
     EXPECT_EQ (db::compare ((r1 - r2), "(0,0;0,30;10,30;10,10;30,10;30,0);(50,0;50,30;80,30;80,0/60,10;70,10;70,20;60,20);(50,40;50,70;80,70;80,40)"), true);
-    EXPECT_EQ (db::compare ((r1 - r1), ""), true);
-    EXPECT_EQ (db::compare (r2.selected_outside (r1), "(80,40;80,70;140,70;140,40)"), true);
-    EXPECT_EQ (db::compare (r2.selected_inside (r1), "(60,10;60,20;70,20;70,10)"), true);
+    EXPECT_EQ ((r1 - r1).to_string (), "");
+    EXPECT_EQ (r2.selected_outside (r1).to_string (), "(80,40;80,70;140,70;140,40)");
+    EXPECT_EQ (r2.selected_inside (r1).to_string (), "(60,10;60,20;70,20;70,10)");
     EXPECT_EQ (db::compare (r2.selected_interacting (r1), "(60,10;60,20;70,20;70,10);(10,10;10,40;40,40;40,10);(80,40;80,70;140,70;140,40)"), true);
     EXPECT_EQ (db::compare (r2.selected_overlapping (r1), "(60,10;60,20;70,20;70,10);(10,10;10,40;40,40;40,10)"), true);
     r2.select_outside (r1);
-    EXPECT_EQ (db::compare (r2, "(80,40;80,70;140,70;140,40)"), true);
+    EXPECT_EQ (r2.to_string (), "(80,40;80,70;140,70;140,40)");
   }
 }
 
 TEST(21)
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r.strange_polygon_check (), ""), true);
+  EXPECT_EQ (r.strange_polygon_check ().to_string (), "");
 
   db::Point pts1[] = {
     db::Point (0, 0),
@@ -1317,14 +1317,14 @@ TEST(21)
 
   EXPECT_EQ (db::compare (r.strange_polygon_check (), "(500,500;500,600;600,600;600,500);(2500,500;2500,1000;3000,1000;3000,500)"), true);
   r.merge ();
-  EXPECT_EQ (db::compare (r.strange_polygon_check (), ""), true);
+  EXPECT_EQ (r.strange_polygon_check ().to_string (), "");
 }
 
 TEST(22)
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r.angle_check (0, 180.0, false), ""), true);
-  EXPECT_EQ (db::compare (r.angle_check (0, 180.0, true), ""), true);
+  EXPECT_EQ (r.angle_check (0, 180.0, false).to_string (), "");
+  EXPECT_EQ (r.angle_check (0, 180.0, true).to_string (), "");
 
   db::Point pts1[] = {
     db::Point (0, 0),
@@ -1338,11 +1338,11 @@ TEST(22)
   r.insert (poly);
 
   EXPECT_EQ (db::compare (r.angle_check (0, 180.0, false), "(0,0;0,1000)/(0,1000;1000,2000);(0,1000;1000,2000)/(1000,2000;1000,0);(1000,2000;1000,0)/(1000,0;0,0);(1000,0;0,0)/(0,0;0,1000)"), true);
-  EXPECT_EQ (db::compare (r.angle_check (0, 180.0, true), ""), true);
-  EXPECT_EQ (db::compare (r.angle_check (45.0, 45.1, false), "(0,1000;1000,2000)/(1000,2000;1000,0)"), true);
-  EXPECT_EQ (db::compare (r.angle_check (0.0, 90.0, false), "(0,1000;1000,2000)/(1000,2000;1000,0)"), true);
+  EXPECT_EQ (r.angle_check (0, 180.0, true).to_string (), "");
+  EXPECT_EQ (r.angle_check (45.0, 45.1, false).to_string (), "(0,1000;1000,2000)/(1000,2000;1000,0)");
+  EXPECT_EQ (r.angle_check (0.0, 90.0, false).to_string (), "(0,1000;1000,2000)/(1000,2000;1000,0)");
   EXPECT_EQ (db::compare (r.angle_check (0.0, 90.0, true), "(0,0;0,1000)/(0,1000;1000,2000);(1000,2000;1000,0)/(1000,0;0,0);(1000,0;0,0)/(0,0;0,1000)"), true);
-  EXPECT_EQ (db::compare (r.angle_check (90.1, 180.0, false), "(0,0;0,1000)/(0,1000;1000,2000)"), true);
+  EXPECT_EQ (r.angle_check (90.1, 180.0, false).to_string (), "(0,0;0,1000)/(0,1000;1000,2000)");
   EXPECT_EQ (db::compare (r.angle_check (90.1, 180.0, true), "(0,1000;1000,2000)/(1000,2000;1000,0);(1000,2000;1000,0)/(1000,0;0,0);(1000,0;0,0)/(0,0;0,1000)"), true);
 }
 
@@ -1365,25 +1365,25 @@ TEST(22b)
   r.set_merged_semantics (false);
 
   EXPECT_EQ (db::compare (r.angle_check (0, 180.0, false), "(0,0;1000,1000)/(1000,1000;1000,800);(1000,1000;1000,800)/(1000,800;200,800);(200,800;800,200)/(800,200;800,0);(800,200;800,0)/(800,0;0,0);(800,0;0,0)/(0,0;1000,1000)"), true);
-  EXPECT_EQ (db::compare (r.angle_check (0, 180.0, true), "(1000,800;200,800)/(200,800;800,200)"), true);
+  EXPECT_EQ (r.angle_check (0, 180.0, true).to_string (), "(1000,800;200,800)/(200,800;800,200)");
   EXPECT_EQ (db::compare (r.angle_check (45.0, 45.1, false), "(0,0;1000,1000)/(1000,1000;1000,800);(800,0;0,0)/(0,0;1000,1000)"), true);
-  EXPECT_EQ (db::compare (r.angle_check (315.0, 315.1, false), "(1000,800;200,800)/(200,800;800,200)"), true);
+  EXPECT_EQ (r.angle_check (315.0, 315.1, false).to_string (), "(1000,800;200,800)/(200,800;800,200)");
   EXPECT_EQ (db::compare (r.angle_check (45.1, 315.0, true), "(0,0;1000,1000)/(1000,1000;1000,800);(1000,800;200,800)/(200,800;800,200);(800,0;0,0)/(0,0;1000,1000)"), true);
 }
 
 TEST(23)
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r.grid_check (10, 20), ""), true);
+  EXPECT_EQ (r.grid_check (10, 20).to_string (), "");
 
   r.insert (db::Box (db::Point (0, 0), db::Point (1000, 100)));
   r.insert (db::Box (db::Point (0, 100), db::Point (105, 300)));
   r.insert (db::Box (db::Point (910, 100), db::Point (1000, 300)));
   r.insert (db::Box (db::Point (0, 290), db::Point (1000, 500)));
 
-  EXPECT_EQ (db::compare (r.grid_check (0, 0), ""), true);
-  EXPECT_EQ (db::compare (r.grid_check (5, 0), ""), true);
-  EXPECT_EQ (db::compare (r.grid_check (0, 10), ""), true);
+  EXPECT_EQ (r.grid_check (0, 0).to_string (), "");
+  EXPECT_EQ (r.grid_check (5, 0).to_string (), "");
+  EXPECT_EQ (r.grid_check (0, 10).to_string (), "");
   EXPECT_EQ (db::compare (r.grid_check (10, 10), "(105,100;105,100)/(105,100;105,100);(105,290;105,290)/(105,290;105,290)"), true);
   EXPECT_EQ (db::compare (r.grid_check (10, 20), "(105,100;105,100)/(105,100;105,100);(910,290;910,290)/(910,290;910,290);(105,290;105,290)/(105,290;105,290)"), true);
 }
@@ -1391,28 +1391,28 @@ TEST(23)
 TEST(24)
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r.snapped (10, 20), ""), true);
+  EXPECT_EQ (r.snapped (10, 20).to_string (), "");
 
   r.insert (db::Box (db::Point (0, 0), db::Point (1000, 100)));
   r.insert (db::Box (db::Point (0, 100), db::Point (105, 300)));
   r.insert (db::Box (db::Point (910, 100), db::Point (1000, 300)));
   r.insert (db::Box (db::Point (0, 290), db::Point (1000, 500)));
 
-  EXPECT_EQ (db::compare (r.snapped (0, 0), "(0,0;0,500;1000,500;1000,0/105,100;910,100;910,290;105,290)"), true);
-  EXPECT_EQ (db::compare (r.snapped (5, 0), "(0,0;0,500;1000,500;1000,0/105,100;910,100;910,290;105,290)"), true);
-  EXPECT_EQ (db::compare (r.snapped (0, 10), "(0,0;0,500;1000,500;1000,0/105,100;910,100;910,290;105,290)"), true);
-  EXPECT_EQ (db::compare (r.snapped (10, 10), "(0,0;0,500;1000,500;1000,0/110,100;910,100;910,290;110,290)"), true);
-  EXPECT_EQ (db::compare (r.snapped (10, 20), "(0,0;0,500;1000,500;1000,0/110,100;910,100;910,300;110,300)"), true);
+  EXPECT_EQ (r.snapped (0, 0).to_string (), "(0,0;0,500;1000,500;1000,0/105,100;910,100;910,290;105,290)");
+  EXPECT_EQ (r.snapped (5, 0).to_string (), "(0,0;0,500;1000,500;1000,0/105,100;910,100;910,290;105,290)");
+  EXPECT_EQ (r.snapped (0, 10).to_string (), "(0,0;0,500;1000,500;1000,0/105,100;910,100;910,290;105,290)");
+  EXPECT_EQ (r.snapped (10, 10).to_string (), "(0,0;0,500;1000,500;1000,0/110,100;910,100;910,290;110,290)");
+  EXPECT_EQ (r.snapped (10, 20).to_string (), "(0,0;0,500;1000,500;1000,0/110,100;910,100;910,300;110,300)");
 }
 
 TEST(24b)
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r.snapped (10, 20), ""), true);
+  EXPECT_EQ (r.snapped (10, 20).to_string (), "");
 
   r.insert (db::Box (db::Point (-15, -15), db::Point (15, 15)));
 
-  EXPECT_EQ (db::compare (r.snapped (10, 10), "(-10,-10;-10,20;20,20;20,-10)"), true);
+  EXPECT_EQ (r.snapped (10, 10).to_string (), "(-10,-10;-10,20;20,20;20,-10)");
 }
 
 TEST(25)
@@ -1422,7 +1422,7 @@ TEST(25)
   r.insert (db::Box (db::Point (0, 0), db::Point (500, 1000)));
   r.insert (db::Box (db::Point (0, -500), db::Point (1000, 0)));
 
-  EXPECT_EQ (db::compare (r.rounded_corners (50, 100, 16), "(80,-500;43,-485;15,-457;0,-420;0,920;15,957;43,985;80,1000;420,1000;457,985;485,957;500,920;500,40;508,22;522,8;540,0;920,0;957,-15;985,-43;1000,-80;1000,-420;985,-457;957,-485;920,-500)"), true);
+  EXPECT_EQ (r.rounded_corners (50, 100, 16).to_string (), "(80,-500;43,-485;15,-457;0,-420;0,920;15,957;43,985;80,1000;420,1000;457,985;485,957;500,920;500,40;508,22;522,8;540,0;920,0;957,-15;985,-43;1000,-80;1000,-420;985,-457;957,-485;920,-500)");
   db::Region rr = r;
   rr.round_corners (50, 100, 16);
   EXPECT_EQ (r.rounded_corners (50, 100, 16).to_string (), rr.to_string ());
@@ -1438,21 +1438,21 @@ TEST(26)
   EXPECT_EQ (db::compare ((r - db::Region ()), "(0,0;0,200;100,200;100,0);(50,50;50,250;150,250;150,50)"), true);
   EXPECT_EQ (db::compare ((r | db::Region ()), "(0,0;0,200;100,200;100,0);(50,50;50,250;150,250;150,50)"), true);
   EXPECT_EQ (db::compare ((r ^ db::Region ()), "(0,0;0,200;100,200;100,0);(50,50;50,250;150,250;150,50)"), true);
-  EXPECT_EQ (db::compare ((db::Region () - r), ""), true);
+  EXPECT_EQ ((db::Region () - r).to_string (), "");
   EXPECT_EQ (db::compare ((db::Region () | r), "(0,0;0,200;100,200;100,0);(50,50;50,250;150,250;150,50)"), true);
   EXPECT_EQ (db::compare ((db::Region () ^ r), "(0,0;0,200;100,200;100,0);(50,50;50,250;150,250;150,50)"), true);
   EXPECT_EQ (db::compare ((r & db::Region (db::Box (db::Point (20, 20), db::Point (120, 220)))), "(20,20;20,200;100,200;100,20);(50,50;50,220;120,220;120,50)"), true);
   EXPECT_EQ (db::compare ((db::Region (db::Box (db::Point (20, 20), db::Point (120, 220))) & r), "(20,20;20,200;100,200;100,20);(50,50;50,220;120,220;120,50)"), true);
 
   r.set_strict_handling (true);
-  EXPECT_EQ (db::compare ((r - db::Region ()), "(0,0;0,200;50,200;50,250;150,250;150,50;100,50;100,0)"), true);
-  EXPECT_EQ (db::compare ((r | db::Region ()), "(0,0;0,200;50,200;50,250;150,250;150,50;100,50;100,0)"), true);
-  EXPECT_EQ (db::compare ((r ^ db::Region ()), "(0,0;0,200;50,200;50,250;150,250;150,50;100,50;100,0)"), true);
-  EXPECT_EQ (db::compare ((db::Region () - r), ""), true);
-  EXPECT_EQ (db::compare ((db::Region () | r), "(0,0;0,200;50,200;50,250;150,250;150,50;100,50;100,0)"), true);
-  EXPECT_EQ (db::compare ((db::Region () ^ r), "(0,0;0,200;50,200;50,250;150,250;150,50;100,50;100,0)"), true);
-  EXPECT_EQ (db::compare ((r & db::Region (db::Box (db::Point (20, 20), db::Point (120, 220)))), "(20,20;20,200;50,200;50,220;120,220;120,50;100,50;100,20)"), true);
-  EXPECT_EQ (db::compare ((db::Region (db::Box (db::Point (20, 20), db::Point (120, 220))) & r), "(20,20;20,200;50,200;50,220;120,220;120,50;100,50;100,20)"), true);
+  EXPECT_EQ ((r - db::Region ()).to_string (), "(0,0;0,200;50,200;50,250;150,250;150,50;100,50;100,0)");
+  EXPECT_EQ ((r | db::Region ()).to_string (), "(0,0;0,200;50,200;50,250;150,250;150,50;100,50;100,0)");
+  EXPECT_EQ ((r ^ db::Region ()).to_string (), "(0,0;0,200;50,200;50,250;150,250;150,50;100,50;100,0)");
+  EXPECT_EQ ((db::Region () - r).to_string (), "");
+  EXPECT_EQ ((db::Region () | r).to_string (), "(0,0;0,200;50,200;50,250;150,250;150,50;100,50;100,0)");
+  EXPECT_EQ ((db::Region () ^ r).to_string (), "(0,0;0,200;50,200;50,250;150,250;150,50;100,50;100,0)");
+  EXPECT_EQ ((r & db::Region (db::Box (db::Point (20, 20), db::Point (120, 220)))).to_string (), "(20,20;20,200;50,200;50,220;120,220;120,50;100,50;100,20)");
+  EXPECT_EQ ((db::Region (db::Box (db::Point (20, 20), db::Point (120, 220))) & r).to_string (), "(20,20;20,200;50,200;50,220;120,220;120,50;100,50;100,20)");
 
   r.set_strict_handling (false);
   EXPECT_EQ (db::compare ((r - db::Region ()), "(0,0;0,200;100,200;100,0);(50,50;50,250;150,250;150,50)"), true);
@@ -1467,12 +1467,12 @@ TEST(27)
   db::Region r;
   r.insert (db::Box (db::Point (0, 0), db::Point (100, 200)));
 
-  EXPECT_EQ (db::compare (r.sized (db::Coord (-10), db::Coord (-20)), "(10,20;10,180;90,180;90,20)"), true);
-  EXPECT_EQ (db::compare (r.sized (db::Coord (-50), db::Coord (-20)), ""), true);
-  EXPECT_EQ (db::compare (r.sized (db::Coord (-50), db::Coord (-100)), ""), true);
-  EXPECT_EQ (db::compare (r.sized (db::Coord (-55), db::Coord (-20)), ""), true);
-  EXPECT_EQ (db::compare (r.sized (db::Coord (-10), db::Coord (-105)), ""), true);
-  EXPECT_EQ (db::compare (r.sized (db::Coord (-55), db::Coord (-105)), ""), true);
+  EXPECT_EQ (r.sized (db::Coord (-10), db::Coord (-20)).to_string (), "(10,20;10,180;90,180;90,20)");
+  EXPECT_EQ (r.sized (db::Coord (-50), db::Coord (-20)).to_string (), "");
+  EXPECT_EQ (r.sized (db::Coord (-50), db::Coord (-100)).to_string (), "");
+  EXPECT_EQ (r.sized (db::Coord (-55), db::Coord (-20)).to_string (), "");
+  EXPECT_EQ (r.sized (db::Coord (-10), db::Coord (-105)).to_string (), "");
+  EXPECT_EQ (r.sized (db::Coord (-55), db::Coord (-105)).to_string (), "");
 }
 
 TEST(28) 
@@ -1484,8 +1484,8 @@ TEST(28)
   db::Region r2;
   r2.insert (db::Box (db::Point (100, 100), db::Point (200, 300)));
 
-  EXPECT_EQ (db::compare ((r1 & r2), ""), true);
-  EXPECT_EQ (db::compare ((r1 & r2.sized (db::Coord (5), db::Coord (5))), "(95,95;95,200;100,200;100,95)"), true);
+  EXPECT_EQ ((r1 & r2).to_string (), "");
+  EXPECT_EQ ((r1 & r2.sized (db::Coord (5), db::Coord (5))).to_string (), "(95,95;95,200;100,200;100,95)");
 }
 
 TEST(29) 
@@ -1498,84 +1498,84 @@ TEST(29)
 TEST(30a)
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))).to_string (), "");
   r.insert (db::Box (db::Point (0, 0), db::Point (100, 200)));
   r.insert (db::Box (db::Point (-100, -100), db::Point (0, 0)));
   r.set_merged_semantics (false);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))), "(0,0;0,200;100,200;100,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))), "(-100,-100;-100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.selected_interacting (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))).to_string (), "(0,0;0,200;100,200;100,0)");
+  EXPECT_EQ (r.selected_not_interacting (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))).to_string (), "(-100,-100;-100,0;0,0;0,-100)");
   EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (-20, -20), db::Point (30, 30)))), "(-100,-100;-100,0;0,0;0,-100);(0,0;0,200;100,200;100,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (-200, -200), db::Point (-190, -190)))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Edges (db::Edge (db::Point (-200, -200), db::Point (-190, -190)))).to_string (), "");
   db::Region rr = r;
   r.select_interacting (db::Edges (db::Edge (db::Point (-20, -20), db::Point (-10, -10))));
-  EXPECT_EQ (db::compare (r, "(-100,-100;-100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.to_string (), "(-100,-100;-100,0;0,0;0,-100)");
   rr.select_not_interacting (db::Edges (db::Edge (db::Point (-20, -20), db::Point (-10, -10))));
-  EXPECT_EQ (db::compare (rr, "(0,0;0,200;100,200;100,0)"), true);
+  EXPECT_EQ (rr.to_string (), "(0,0;0,200;100,200;100,0)");
 
   r.clear ();
   r.insert(db::Box (db::Point (1000, 0), db::Point (6000, 4000)));
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (0, 4000), db::Point (2000, 6000)))), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (1000, 4000), db::Point (2000, 6000)))), "(1000,0;1000,4000;6000,4000;6000,0)"), true);
-  EXPECT_EQ (db::compare (db::Edges (db::Edge (db::Point (0, 4000), db::Point (2000, 6000))).selected_interacting (r), ""), true);
-  EXPECT_EQ (db::compare (db::Edges (db::Edge (db::Point (1000, 4000), db::Point (2000, 6000))).selected_interacting (r), "(1000,4000;2000,6000)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (1000, 4001), db::Point (2000, 6000)))), ""), true);
-  EXPECT_EQ (db::compare (db::Edges (db::Edge (db::Point (1000, 4001), db::Point (2000, 6000))).selected_interacting (r), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (1000, 3999), db::Point (1000, 6000)))), "(1000,0;1000,4000;6000,4000;6000,0)"), true);
-  EXPECT_EQ (db::compare (db::Edges (db::Edge (db::Point (1000, 3999), db::Point (1000, 6000))).selected_interacting (r), "(1000,3999;1000,6000)"), true);
+  EXPECT_EQ (r.selected_interacting (db::Edges (db::Edge (db::Point (0, 4000), db::Point (2000, 6000)))).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (db::Edges (db::Edge (db::Point (1000, 4000), db::Point (2000, 6000)))).to_string (), "(1000,0;1000,4000;6000,4000;6000,0)");
+  EXPECT_EQ (db::Edges (db::Edge (db::Point (0, 4000), db::Point (2000, 6000))).selected_interacting (r).to_string (), "");
+  EXPECT_EQ (db::Edges (db::Edge (db::Point (1000, 4000), db::Point (2000, 6000))).selected_interacting (r).to_string (), "(1000,4000;2000,6000)");
+  EXPECT_EQ (r.selected_interacting (db::Edges (db::Edge (db::Point (1000, 4001), db::Point (2000, 6000)))).to_string (), "");
+  EXPECT_EQ (db::Edges (db::Edge (db::Point (1000, 4001), db::Point (2000, 6000))).selected_interacting (r).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (db::Edges (db::Edge (db::Point (1000, 3999), db::Point (1000, 6000)))).to_string (), "(1000,0;1000,4000;6000,4000;6000,0)");
+  EXPECT_EQ (db::Edges (db::Edge (db::Point (1000, 3999), db::Point (1000, 6000))).selected_interacting (r).to_string (), "(1000,3999;1000,6000)");
 }
 
 TEST(30b)
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))).to_string (), "");
   r.insert (db::Box (db::Point (0, 0), db::Point (100, 200)));
   r.insert (db::Box (db::Point (-100, -100), db::Point (0, 0)));
   r.set_merged_semantics (true);
   r.set_min_coherence (true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))), "(0,0;0,200;100,200;100,0)"), true);
+  EXPECT_EQ (r.selected_interacting (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))).to_string (), "(0,0;0,200;100,200;100,0)");
   EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (-20, -20), db::Point (30, 30)))), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (-200, -200), db::Point (-190, -190)))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Edges (db::Edge (db::Point (-200, -200), db::Point (-190, -190)))).to_string (), "");
   r.select_interacting (db::Edges (db::Edge (db::Point (-20, -20), db::Point (-10, -10))));
-  EXPECT_EQ (db::compare (r, "(-100,-100;-100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.to_string (), "(-100,-100;-100,0;0,0;0,-100)");
 }
 
 TEST(30c)
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))).to_string (), "");
   r.insert (db::Box (db::Point (0, 0), db::Point (100, 200)));
   r.insert (db::Box (db::Point (-100, -100), db::Point (0, 0)));
   r.set_merged_semantics (true);
   r.set_min_coherence (false);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (-20, -20), db::Point (30, 30)))), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (-200, -200), db::Point (-190, -190)))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (db::Edges (db::Edge (db::Point (-20, -20), db::Point (30, 30)))).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (db::Edges (db::Edge (db::Point (-200, -200), db::Point (-190, -190)))).to_string (), "");
   r.select_interacting (db::Edges (db::Edge (db::Point (-20, -20), db::Point (-10, -10))));
-  EXPECT_EQ (db::compare (r, "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
 }
 
 TEST(31)
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r.pull_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))), ""), true);
+  EXPECT_EQ (r.pull_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))).to_string (), "");
   r.insert (db::Box (db::Point (0, 0), db::Point (100, 200)));
   r.insert (db::Box (db::Point (-100, -100), db::Point (0, 0)));
   r.set_merged_semantics (true);
   r.set_min_coherence (false);
-  EXPECT_EQ (db::compare (r.pull_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))), "(20,20;20,30;30,30;30,20)"), true);
-  EXPECT_EQ (db::compare (r.pull_interacting (db::Region (db::Box (db::Point (-20, -20), db::Point (30, 30)))), "(-20,-20;-20,30;30,30;30,-20)"), true);
-  EXPECT_EQ (db::compare (r.pull_interacting (db::Region (db::Box (db::Point (-200, -200), db::Point (-190, -190)))), ""), true);
+  EXPECT_EQ (r.pull_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))).to_string (), "(20,20;20,30;30,30;30,20)");
+  EXPECT_EQ (r.pull_interacting (db::Region (db::Box (db::Point (-20, -20), db::Point (30, 30)))).to_string (), "(-20,-20;-20,30;30,30;30,-20)");
+  EXPECT_EQ (r.pull_interacting (db::Region (db::Box (db::Point (-200, -200), db::Point (-190, -190)))).to_string (), "");
 
   r.clear ();
   r.insert(db::Box (db::Point (1000, 0), db::Point (6000, 4000)));
-  EXPECT_EQ (db::compare (r.pull_overlapping (db::Region (db::Box (db::Point (0, 4000), db::Point (2000, 6000)))), ""), true);
-  EXPECT_EQ (db::compare (db::Region (db::Box (db::Point (0, 4000), db::Point (2000, 6000))).pull_overlapping (r), ""), true);
-  EXPECT_EQ (db::compare (r.pull_overlapping (db::Region (db::Box (db::Point (0, 4000), db::Point (1000, 6000)))), ""), true);
-  EXPECT_EQ (db::compare (db::Region (db::Box (db::Point (0, 4000), db::Point (1000, 6000))).pull_overlapping (r), ""), true);
-  EXPECT_EQ (db::compare (r.pull_overlapping (db::Region (db::Box (db::Point (0, 4001), db::Point (2000, 6000)))), ""), true);
-  EXPECT_EQ (db::compare (db::Region (db::Box (db::Point (0, 4001), db::Point (2000, 6000))).pull_overlapping (r), ""), true);
-  EXPECT_EQ (db::compare (r.pull_overlapping (db::Region (db::Box (db::Point (0, 3999), db::Point (1001, 6000)))), "(0,3999;0,6000;1001,6000;1001,3999)"), true);
-  EXPECT_EQ (db::compare (db::Region (db::Box (db::Point (0, 3999), db::Point (1001, 6000))).pull_overlapping (r), "(1000,0;1000,4000;6000,4000;6000,0)"), true);
+  EXPECT_EQ (r.pull_overlapping (db::Region (db::Box (db::Point (0, 4000), db::Point (2000, 6000)))).to_string (), "");
+  EXPECT_EQ (db::Region (db::Box (db::Point (0, 4000), db::Point (2000, 6000))).pull_overlapping (r).to_string (), "");
+  EXPECT_EQ (r.pull_overlapping (db::Region (db::Box (db::Point (0, 4000), db::Point (1000, 6000)))).to_string (), "");
+  EXPECT_EQ (db::Region (db::Box (db::Point (0, 4000), db::Point (1000, 6000))).pull_overlapping (r).to_string (), "");
+  EXPECT_EQ (r.pull_overlapping (db::Region (db::Box (db::Point (0, 4001), db::Point (2000, 6000)))).to_string (), "");
+  EXPECT_EQ (db::Region (db::Box (db::Point (0, 4001), db::Point (2000, 6000))).pull_overlapping (r).to_string (), "");
+  EXPECT_EQ (r.pull_overlapping (db::Region (db::Box (db::Point (0, 3999), db::Point (1001, 6000)))).to_string (), "(0,3999;0,6000;1001,6000;1001,3999)");
+  EXPECT_EQ (db::Region (db::Box (db::Point (0, 3999), db::Point (1001, 6000))).pull_overlapping (r).to_string (), "(1000,0;1000,4000;6000,4000;6000,0)");
 }
 
 TEST(32a_snap)
@@ -1681,79 +1681,79 @@ TEST(33b_snap)
 TEST(34a)
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))).to_string (), "");
   r.insert (db::Box (db::Point (0, 0), db::Point (100, 200)));
   r.insert (db::Box (db::Point (-100, -100), db::Point (0, 0)));
   r.set_merged_semantics (false);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))), "(0,0;0,200;100,200;100,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))), "(-100,-100;-100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))).to_string (), "(0,0;0,200;100,200;100,0)");
+  EXPECT_EQ (r.selected_not_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))).to_string (), "(-100,-100;-100,0;0,0;0,-100)");
   db::Texts tt;
   tt.insert (db::Text ("abc", db::Trans (db::Vector (30, 30))));
   tt.insert (db::Text ("xyz", db::Trans (db::Vector (-100, 0))));
   EXPECT_EQ (db::compare (r.selected_interacting (tt), "(-100,-100;-100,0;0,0;0,-100);(0,0;0,200;100,200;100,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (300, 30))))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (300, 30))))).to_string (), "");
   db::Region rr = r;
   r.select_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (-10, -10)))));
-  EXPECT_EQ (db::compare (r, "(-100,-100;-100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.to_string (), "(-100,-100;-100,0;0,0;0,-100)");
   rr.select_not_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (-10, -10)))));
-  EXPECT_EQ (db::compare (rr, "(0,0;0,200;100,200;100,0)"), true);
+  EXPECT_EQ (rr.to_string (), "(0,0;0,200;100,200;100,0)");
 
   r.clear ();
   r.insert(db::Box (db::Point (1000, 0), db::Point (6000, 4000)));
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (2000, 6000))))), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (2000, 2000))))), "(1000,0;1000,4000;6000,4000;6000,0)"), true);
-  EXPECT_EQ (db::compare (db::Texts (db::Text ("abc", db::Trans (db::Vector (2000, 6000)))).selected_interacting (r), ""), true);
-  EXPECT_EQ (db::compare (db::Texts (db::Text ("abc", db::Trans (db::Vector (2000, 2000)))).selected_interacting (r), "('abc',r0 2000,2000)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (2000, 6000))))), ""), true);
-  EXPECT_EQ (db::compare (db::Texts (db::Text ("abc", db::Trans (db::Vector (2000, 6000)))).selected_interacting (r), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (1000, 2000))))), "(1000,0;1000,4000;6000,4000;6000,0)"), true);
-  EXPECT_EQ (db::compare (db::Texts (db::Text ("abc", db::Trans (db::Vector (1000, 2000)))).selected_interacting (r), "('abc',r0 1000,2000)"), true);
+  EXPECT_EQ (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (2000, 6000))))).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (2000, 2000))))).to_string (), "(1000,0;1000,4000;6000,4000;6000,0)");
+  EXPECT_EQ (db::Texts (db::Text ("abc", db::Trans (db::Vector (2000, 6000)))).selected_interacting (r).to_string (), "");
+  EXPECT_EQ (db::Texts (db::Text ("abc", db::Trans (db::Vector (2000, 2000)))).selected_interacting (r).to_string (), "('abc',r0 2000,2000)");
+  EXPECT_EQ (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (2000, 6000))))).to_string (), "");
+  EXPECT_EQ (db::Texts (db::Text ("abc", db::Trans (db::Vector (2000, 6000)))).selected_interacting (r).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (1000, 2000))))).to_string (), "(1000,0;1000,4000;6000,4000;6000,0)");
+  EXPECT_EQ (db::Texts (db::Text ("abc", db::Trans (db::Vector (1000, 2000)))).selected_interacting (r).to_string (), "('abc',r0 1000,2000)");
 }
 
 TEST(34b)
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))).to_string (), "");
   r.insert (db::Box (db::Point (0, 0), db::Point (100, 200)));
   r.insert (db::Box (db::Point (-100, -100), db::Point (0, 0)));
   r.set_merged_semantics (true);
   r.set_min_coherence (true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))), "(0,0;0,200;100,200;100,0)"), true);
+  EXPECT_EQ (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))).to_string (), "(0,0;0,200;100,200;100,0)");
   db::Texts tt;
   tt.insert (db::Text ("abc", db::Trans (db::Vector (30, 30))));
   tt.insert (db::Text ("xyz", db::Trans (db::Vector (-100, 0))));
   EXPECT_EQ (db::compare (r.selected_interacting (tt), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (-190, -190))))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (-190, -190))))).to_string (), "");
   r.select_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (-10, -10)))));
-  EXPECT_EQ (db::compare (r, "(-100,-100;-100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.to_string (), "(-100,-100;-100,0;0,0;0,-100)");
 }
 
 TEST(34c)
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))).to_string (), "");
   r.insert (db::Box (db::Point (0, 0), db::Point (100, 200)));
   r.insert (db::Box (db::Point (-100, -100), db::Point (0, 0)));
   r.set_merged_semantics (true);
   r.set_min_coherence (false);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (0, 0))))), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (-190, -190))))), ""), true);
+  EXPECT_EQ (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (0, 0))))).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (-190, -190))))).to_string (), "");
   r.select_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (-10, -10)))));
-  EXPECT_EQ (db::compare (r, "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
 }
 
 TEST(34d)
 {
   db::Region r;
-  EXPECT_EQ (db::compare (r.pull_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))), ""), true);
+  EXPECT_EQ (r.pull_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))).to_string (), "");
   r.insert (db::Box (db::Point (0, 0), db::Point (100, 200)));
   r.insert (db::Box (db::Point (-100, -100), db::Point (0, 0)));
   r.set_merged_semantics (true);
   r.set_min_coherence (false);
-  EXPECT_EQ (db::compare (r.pull_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))), "('abc',r0 30,30)"), true);
-  EXPECT_EQ (db::compare (r.pull_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (0, 0))))), "('abc',r0 0,0)"), true);
-  EXPECT_EQ (db::compare (r.pull_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (-190, -190))))), ""), true);
+  EXPECT_EQ (r.pull_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))).to_string (), "('abc',r0 30,30)");
+  EXPECT_EQ (r.pull_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (0, 0))))).to_string (), "('abc',r0 0,0)");
+  EXPECT_EQ (r.pull_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (-190, -190))))).to_string (), "");
 }
 
 TEST(35a_interact_with_count_region)
@@ -1775,57 +1775,57 @@ TEST(35a_interact_with_count_region)
   rr.insert (db::Box (db::Point (90, -10), db::Point (110, 10)));
   rr.insert (db::Box (db::Point (-110, -110), db::Point (-90, -90)));
 
-  EXPECT_EQ (db::compare (r.selected_interacting (empty), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 0, 2), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 1, 2), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 1, 4), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 2, 4), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 2, 1), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 3, 4), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 4, 5), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 5, 5), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr2), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr2, 1, 2), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr2, 1, 4), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr2, 2, 5), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr2, 4, 5), ""), true);
+  EXPECT_EQ (r.selected_interacting (empty).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr, 0, 2).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr, 1, 2).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr, 1, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr, 2, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr, 2, 1).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr, 3, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr, 4, 5).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr, 5, 5).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr2, 1, 2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr2, 1, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr2, 2, 5).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr2, 4, 5).to_string (), "");
 
   EXPECT_EQ (db::compare (r.selected_not_interacting (empty), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 0, 2), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 1, 2), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 1, 4), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 2, 4), ""), true);
+  EXPECT_EQ (r.selected_not_interacting (rr).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 0, 2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_not_interacting (rr, 1, 2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_not_interacting (rr, 1, 4).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 2, 4).to_string (), "");
   EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 2, 1), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 3, 4), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 4, 5), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 5, 5), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr2), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr2, 1, 2), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr2, 1, 4), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr2, 2, 5), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr2, 4, 5), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.selected_not_interacting (rr, 3, 4).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 4, 5).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 5, 5).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_not_interacting (rr2).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr2, 1, 2).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr2, 1, 4).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr2, 2, 5).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr2, 4, 5).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
 
   r.set_merged_semantics (false);
 
-  EXPECT_EQ (db::compare (r.selected_interacting (empty), ""), true);
+  EXPECT_EQ (r.selected_interacting (empty).to_string (), "");
   EXPECT_EQ (db::compare (r.selected_interacting (rr), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 0, 2), "(0,0;0,200;100,200;100,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 1, 2), "(0,0;0,200;100,200;100,0)"), true);
+  EXPECT_EQ (r.selected_interacting (rr, 0, 2).to_string (), "(0,0;0,200;100,200;100,0)");
+  EXPECT_EQ (r.selected_interacting (rr, 1, 2).to_string (), "(0,0;0,200;100,200;100,0)");
   EXPECT_EQ (db::compare (r.selected_interacting (rr, 1, 4), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
   EXPECT_EQ (db::compare (r.selected_interacting (rr, 2, 4), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 2, 1), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 3, 4), "(-100,-100;-100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.selected_interacting (rr, 2, 1).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr, 3, 4).to_string (), "(-100,-100;-100,0;0,0;0,-100)");
 
   EXPECT_EQ (db::compare (r.selected_not_interacting (empty), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 0, 2), "(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 1, 2), "(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 1, 4), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 2, 4), ""), true);
+  EXPECT_EQ (r.selected_not_interacting (rr).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 0, 2).to_string (), "(-100,-100;-100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_not_interacting (rr, 1, 2).to_string (), "(-100,-100;-100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_not_interacting (rr, 1, 4).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 2, 4).to_string (), "");
   EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 2, 1), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 3, 4), "(0,0;0,200;100,200;100,0)"), true);
+  EXPECT_EQ (r.selected_not_interacting (rr, 3, 4).to_string (), "(0,0;0,200;100,200;100,0)");
 }
 
 TEST(35b_interact_with_count_edge)
@@ -1847,57 +1847,57 @@ TEST(35b_interact_with_count_edge)
   rr.insert (db::Edge (db::Point (90, -10), db::Point (110, 10)));
   rr.insert (db::Edge (db::Point (-110, -110), db::Point (-90, -90)));
 
-  EXPECT_EQ (db::compare (r.selected_interacting (empty), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 0, 2), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 1, 2), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 1, 4), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 2, 4), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 2, 1), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 3, 4), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 4, 5), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 5, 5), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr2), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr2, 1, 2), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr2, 1, 4), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr2, 2, 5), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr2, 4, 5), ""), true);
+  EXPECT_EQ (r.selected_interacting (empty).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr, 0, 2).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr, 1, 2).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr, 1, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr, 2, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr, 2, 1).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr, 3, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr, 4, 5).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr, 5, 5).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr2, 1, 2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr2, 1, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr2, 2, 5).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr2, 4, 5).to_string (), "");
 
   EXPECT_EQ (db::compare (r.selected_not_interacting (empty), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 0, 2), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 1, 2), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 1, 4), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 2, 4), ""), true);
+  EXPECT_EQ (r.selected_not_interacting (rr).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 0, 2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_not_interacting (rr, 1, 2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_not_interacting (rr, 1, 4).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 2, 4).to_string (), "");
   EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 2, 1), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 3, 4), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 4, 5), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 5, 5), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr2), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr2, 1, 2), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr2, 1, 4), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr2, 2, 5), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr2, 4, 5), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.selected_not_interacting (rr, 3, 4).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 4, 5).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 5, 5).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_not_interacting (rr2).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr2, 1, 2).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr2, 1, 4).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr2, 2, 5).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr2, 4, 5).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
 
   r.set_merged_semantics (false);
 
-  EXPECT_EQ (db::compare (r.selected_interacting (empty), ""), true);
+  EXPECT_EQ (r.selected_interacting (empty).to_string (), "");
   EXPECT_EQ (db::compare (r.selected_interacting (rr), "(-100,-100;-100,0;0,0;0,-100);(0,0;0,200;100,200;100,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 0, 2), "(0,0;0,200;100,200;100,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 1, 2), "(0,0;0,200;100,200;100,0)"), true);
+  EXPECT_EQ (r.selected_interacting (rr, 0, 2).to_string (), "(0,0;0,200;100,200;100,0)");
+  EXPECT_EQ (r.selected_interacting (rr, 1, 2).to_string (), "(0,0;0,200;100,200;100,0)");
   EXPECT_EQ (db::compare (r.selected_interacting (rr, 1, 4), "(-100,-100;-100,0;0,0;0,-100);(0,0;0,200;100,200;100,0)"), true);
   EXPECT_EQ (db::compare (r.selected_interacting (rr, 2, 4), "(-100,-100;-100,0;0,0;0,-100);(0,0;0,200;100,200;100,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 2, 1), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 3, 4), "(-100,-100;-100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.selected_interacting (rr, 2, 1).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr, 3, 4).to_string (), "(-100,-100;-100,0;0,0;0,-100)");
 
   EXPECT_EQ (db::compare (r.selected_not_interacting (empty), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 0, 2), "(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 1, 2), "(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 1, 4), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 2, 4), ""), true);
+  EXPECT_EQ (r.selected_not_interacting (rr).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 0, 2).to_string (), "(-100,-100;-100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_not_interacting (rr, 1, 2).to_string (), "(-100,-100;-100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_not_interacting (rr, 1, 4).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 2, 4).to_string (), "");
   EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 2, 1), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 3, 4), "(0,0;0,200;100,200;100,0)"), true);
+  EXPECT_EQ (r.selected_not_interacting (rr, 3, 4).to_string (), "(0,0;0,200;100,200;100,0)");
 }
 
 TEST(35c_interact_with_count_text)
@@ -1918,57 +1918,57 @@ TEST(35c_interact_with_count_text)
   rr.insert (db::Text ("x", db::Trans (db::Vector (100, 0))));
   rr.insert (db::Text ("y", db::Trans (db::Vector (-100, -100))));
 
-  EXPECT_EQ (db::compare (r.selected_interacting (empty), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 0, 2), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 1, 2), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 1, 4), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 2, 4), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 2, 1), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 3, 4), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 4, 5), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 5, 5), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr2), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr2, 1, 2), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr2, 1, 4), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr2, 2, 5), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr2, 4, 5), ""), true);
+  EXPECT_EQ (r.selected_interacting (empty).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr, 0, 2).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr, 1, 2).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr, 1, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr, 2, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr, 2, 1).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr, 3, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr, 4, 5).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr, 5, 5).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr2, 1, 2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr2, 1, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr2, 2, 5).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_interacting (rr2, 4, 5).to_string (), "");
 
   EXPECT_EQ (db::compare (r.selected_not_interacting (empty), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 0, 2), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 1, 2), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 1, 4), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 2, 4), ""), true);
+  EXPECT_EQ (r.selected_not_interacting (rr).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 0, 2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_not_interacting (rr, 1, 2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_not_interacting (rr, 1, 4).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 2, 4).to_string (), "");
   EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 2, 1), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 3, 4), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 4, 5), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 5, 5), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr2), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr2, 1, 2), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr2, 1, 4), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr2, 2, 5), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr2, 4, 5), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.selected_not_interacting (rr, 3, 4).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 4, 5).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 5, 5).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_not_interacting (rr2).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr2, 1, 2).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr2, 1, 4).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr2, 2, 5).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr2, 4, 5).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
 
   r.set_merged_semantics (false);
 
-  EXPECT_EQ (db::compare (r.selected_interacting (empty), ""), true);
+  EXPECT_EQ (r.selected_interacting (empty).to_string (), "");
   EXPECT_EQ (db::compare (r.selected_interacting (rr), "(-100,-100;-100,0;0,0;0,-100);(0,0;0,200;100,200;100,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 0, 2), "(0,0;0,200;100,200;100,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 1, 2), "(0,0;0,200;100,200;100,0)"), true);
+  EXPECT_EQ (r.selected_interacting (rr, 0, 2).to_string (), "(0,0;0,200;100,200;100,0)");
+  EXPECT_EQ (r.selected_interacting (rr, 1, 2).to_string (), "(0,0;0,200;100,200;100,0)");
   EXPECT_EQ (db::compare (r.selected_interacting (rr, 1, 4), "(-100,-100;-100,0;0,0;0,-100);(0,0;0,200;100,200;100,0)"), true);
   EXPECT_EQ (db::compare (r.selected_interacting (rr, 2, 4), "(-100,-100;-100,0;0,0;0,-100);(0,0;0,200;100,200;100,0)"), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 2, 1), ""), true);
-  EXPECT_EQ (db::compare (r.selected_interacting (rr, 3, 4), "(-100,-100;-100,0;0,0;0,-100)"), true);
+  EXPECT_EQ (r.selected_interacting (rr, 2, 1).to_string (), "");
+  EXPECT_EQ (r.selected_interacting (rr, 3, 4).to_string (), "(-100,-100;-100,0;0,0;0,-100)");
 
   EXPECT_EQ (db::compare (r.selected_not_interacting (empty), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 0, 2), "(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 1, 2), "(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 1, 4), ""), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 2, 4), ""), true);
+  EXPECT_EQ (r.selected_not_interacting (rr).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 0, 2).to_string (), "(-100,-100;-100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_not_interacting (rr, 1, 2).to_string (), "(-100,-100;-100,0;0,0;0,-100)");
+  EXPECT_EQ (r.selected_not_interacting (rr, 1, 4).to_string (), "");
+  EXPECT_EQ (r.selected_not_interacting (rr, 2, 4).to_string (), "");
   EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 2, 1), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
-  EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 3, 4), "(0,0;0,200;100,200;100,0)"), true);
+  EXPECT_EQ (r.selected_not_interacting (rr, 3, 4).to_string (), "(0,0;0,200;100,200;100,0)");
 }
 
 TEST(100_Processors)
@@ -1980,16 +1980,16 @@ TEST(100_Processors)
   r.insert (db::Box (db::Point (100, 300), db::Point (200, 500)));
 
   EXPECT_EQ (db::compare (r.processed (db::CornersAsDots (-180.0, true, 180.0, true)), "(100,0;100,0);(0,0;0,0);(0,200;0,200);(100,200;100,200);(200,300;200,300);(0,300;0,300);(0,400;0,400);(100,400;100,400);(100,500;100,500);(200,500;200,500)"), true);
-  EXPECT_EQ (db::compare (r.processed (db::CornersAsDots (0.0, true, 180.0, true)), "(100,400;100,400)"), true);
+  EXPECT_EQ (r.processed (db::CornersAsDots (0.0, true, 180.0, true)).to_string (), "(100,400;100,400)");
   EXPECT_EQ (db::compare (r.processed (db::CornersAsDots (-90.0, true, 90.0, true)), "(100,0;100,0);(0,0;0,0);(0,200;0,200);(100,200;100,200);(200,300;200,300);(0,300;0,300);(0,400;0,400);(100,400;100,400);(100,500;100,500);(200,500;200,500)"), true);
-  EXPECT_EQ (db::compare (r.processed (db::CornersAsDots (-90.0, false, 90.0, true)), "(100,400;100,400)"), true);
+  EXPECT_EQ (r.processed (db::CornersAsDots (-90.0, false, 90.0, true)).to_string (), "(100,400;100,400)");
   EXPECT_EQ (db::compare (r.processed (db::CornersAsDots (-90.0, true, 90.0, false)), "(100,0;100,0);(0,0;0,0);(0,200;0,200);(100,200;100,200);(200,300;200,300);(0,300;0,300);(0,400;0,400);(100,500;100,500);(200,500;200,500)"), true);
-  EXPECT_EQ (db::compare (r.processed (db::CornersAsDots (-90.0, false, 90.0, false)), ""), true);
+  EXPECT_EQ (r.processed (db::CornersAsDots (-90.0, false, 90.0, false)).to_string (), "");
   db::Region ext;
   r.processed (db::CornersAsDots (0.0, true, 180.0, true)).extended (ext, 10, 10, 20, 20);
-  EXPECT_EQ (db::compare (ext, "(90,380;90,420;110,420;110,380)"), true);
+  EXPECT_EQ (ext.to_string (), "(90,380;90,420;110,420;110,380)");
   EXPECT_EQ (db::compare (r.processed (db::CornersAsRectangles (-180.0, true, 180.0, true, 2)), "(98,-2;98,2;102,2;102,-2);(-2,-2;-2,2;2,2;2,-2);(-2,198;-2,202;2,202;2,198);(98,198;98,202;102,202;102,198);(198,298;198,302;202,302;202,298);(-2,298;-2,302;2,302;2,298);(-2,398;-2,402;2,402;2,398);(98,398;98,402;102,402;102,398);(98,498;98,502;102,502;102,498);(198,498;198,502;202,502;202,498)"), true);
-  EXPECT_EQ (db::compare (r.processed (db::CornersAsRectangles (0.0, true, 180.0, true, 2)), "(98,398;98,402;102,402;102,398)"), true);
+  EXPECT_EQ (r.processed (db::CornersAsRectangles (0.0, true, 180.0, true, 2)).to_string (), "(98,398;98,402;102,402;102,398)");
 
   EXPECT_EQ (db::compare (r.processed (db::extents_processor<db::Polygon> (0, 0)), "(0,0;0,200;100,200;100,0);(0,300;0,500;200,500;200,300)"), true);
   EXPECT_EQ (db::compare (r.processed (db::extents_processor<db::Polygon> (10, 20)), "(-10,-20;-10,220;110,220;110,-20);(-10,280;-10,520;210,520;210,280)"), true);
@@ -2038,14 +2038,14 @@ TEST(issue_277)
   r.insert (db::Box (0, 0, 400, 400));
   r.insert (db::Box (400, 400, 800, 800));
 
-  EXPECT_EQ (db::compare (r.sized (1).merged (false, 1), ""), true);
+  EXPECT_EQ (r.sized (1).merged (false, 1).to_string (), "");
 
   r.set_min_coherence (true);
-  EXPECT_EQ (db::compare (r.sized (1).merged (false, 1), "(399,399;399,401;401,401;401,399)"), true);
+  EXPECT_EQ (r.sized (1).merged (false, 1).to_string (), "(399,399;399,401;401,401;401,399)");
 
   r.merge ();
-  EXPECT_EQ (db::compare (r.sized (1).merged (false, 1), "(399,399;399,401;401,401;401,399)"), true);
+  EXPECT_EQ (r.sized (1).merged (false, 1).to_string (), "(399,399;399,401;401,401;401,399)");
 
   r.set_min_coherence (false);  //  needs to merge again
-  EXPECT_EQ (db::compare (r.sized (1).merged (false, 1), ""), true);
+  EXPECT_EQ (r.sized (1).merged (false, 1).to_string (), "");
 }
diff --git a/src/db/unit_tests/dbTextsTests.cc b/src/db/unit_tests/dbTextsTests.cc
index ab5fee294..5ec0a4aba 100644
--- a/src/db/unit_tests/dbTextsTests.cc
+++ b/src/db/unit_tests/dbTextsTests.cc
@@ -27,6 +27,7 @@
 #include "dbTextsUtils.h"
 #include "dbEdges.h"
 #include "dbRegion.h"
+#include "dbTestSupport.h"
 
 TEST(1) 
 {
@@ -88,21 +89,21 @@ TEST(2)
   texts.insert (db::Text ("abc", db::Trans (db::Vector (100, -200))));
   texts.insert (db::Text ("uvw", db::Trans (db::Vector (110, 210))));
 
-  EXPECT_EQ (texts.to_string (), "('abc',r0 100,-200);('uvw',r0 110,210)");
+  EXPECT_EQ (db::compare (texts, "('abc',r0 100,-200);('uvw',r0 110,210)"), true);
 
   db::Texts ee;
   std::string s = texts.to_string ();
   tl::Extractor ex (s.c_str ());
   EXPECT_EQ (ex.try_read (ee), true);
-  EXPECT_EQ (ee.to_string (), "('abc',r0 100,-200);('uvw',r0 110,210)");
+  EXPECT_EQ (db::compare (ee, "('abc',r0 100,-200);('uvw',r0 110,210)"), true);
 
   db::Edges e;
   texts.edges (e);
-  EXPECT_EQ (e.to_string (), "(100,-200;100,-200);(110,210;110,210)");
+  EXPECT_EQ (db::compare (e, "(100,-200;100,-200);(110,210;110,210)"), true);
 
   db::Region r;
   texts.polygons (r);
-  EXPECT_EQ (r.to_string (), "(99,-201;99,-199;101,-199;101,-201);(109,209;109,211;111,211;111,209)");
+  EXPECT_EQ (db::compare (r, "(99,-201;99,-199;101,-199;101,-201);(109,209;109,211;111,211;111,209)"), true);
 }
 
 TEST(3) 
@@ -160,7 +161,7 @@ TEST(5)
   texts.insert_into_as_polygons (&ly, top_cell, l1, 1);
 
   db::Region r (db::RecursiveShapeIterator (ly, ly.cell (top_cell), l1));
-  EXPECT_EQ (r.to_string (), "(99,-201;99,-199;101,-199;101,-201);(109,209;109,211;111,211;111,209)");
+  EXPECT_EQ (db::compare (r, "(99,-201;99,-199;101,-199;101,-201);(109,209;109,211;111,211;111,209)"), true);
 }
 
 TEST(6)
@@ -176,7 +177,7 @@ TEST(6)
   texts.insert_into (&ly, top_cell, l1);
 
   db::Texts r (db::RecursiveShapeIterator (ly, ly.cell (top_cell), l1));
-  EXPECT_EQ (r.to_string (), "('abc',r0 100,-200);('uvw',r0 110,210)");
+  EXPECT_EQ (db::compare (r, "('abc',r0 100,-200);('uvw',r0 110,210)"), true);
 }
 
 TEST(7)
diff --git a/src/pya/unit_tests/pya.cc b/src/pya/unit_tests/pyaTests.cc
similarity index 100%
rename from src/pya/unit_tests/pya.cc
rename to src/pya/unit_tests/pyaTests.cc
diff --git a/src/pya/unit_tests/unit_tests.pro b/src/pya/unit_tests/unit_tests.pro
index d0de37465..2d2ac0634 100644
--- a/src/pya/unit_tests/unit_tests.pro
+++ b/src/pya/unit_tests/unit_tests.pro
@@ -7,7 +7,7 @@ TARGET = pya_tests
 include($$PWD/../../lib_ut.pri)
 
 SOURCES = \
-  pya.cc
+  pyaTests.cc
 
 INCLUDEPATH += $$PYA_INC $$DB_INC $$TL_INC $$GSI_INC
 DEPENDPATH += $$PYA_INC $$DB_INC $$TL_INC $$GSI_INC
diff --git a/testdata/ruby/dbEdgePairsTest.rb b/testdata/ruby/dbEdgePairsTest.rb
index c63397c1b..021dbb358 100644
--- a/testdata/ruby/dbEdgePairsTest.rb
+++ b/testdata/ruby/dbEdgePairsTest.rb
@@ -23,6 +23,13 @@ end
 
 load("test_prologue.rb")
 
+# normalizes a specification string for region, edges etc.
+# such that the order of the objects becomes irrelevant
+def csort(s)
+  # splits at ");(" without consuming the brackets
+  s.split(/(?<=\));(?=\()/).sort.join(";")
+end
+
 class DBEdgePairs_TestClass < TestBase
 
   # Basics
@@ -47,7 +54,7 @@ class DBEdgePairs_TestClass < TestBase
     assert_equal(r.extents(5, -5).to_s, "(-25,5;-25,95;5,95;5,5)")
     assert_equal(r.first_edges.to_s, "(0,0;0,100)")
     assert_equal(r.second_edges.to_s, "(-10,0;-20,50)")
-    assert_equal(r.edges.to_s, "(0,0;0,100);(-10,0;-20,50)")
+    assert_equal(csort(r.edges.to_s), csort("(0,0;0,100);(-10,0;-20,50)"))
     assert_equal(r.is_empty?, false)
     assert_equal(r.size, 1)
     assert_equal(r[0].to_s, "(0,0;0,100)/(-10,0;-20,50)")
@@ -105,9 +112,9 @@ class DBEdgePairs_TestClass < TestBase
     r2.insert(RBA::Edge::new(1, 0, 1, 100), RBA::Edge::new(-11, 0, -21, 50))
     r2.insert(RBA::Edge::new(1, 1, 1, 101), RBA::Edge::new(-11, 1, -21, 51))
 
-    assert_equal((r1 + r2).to_s, "(0,0;0,100)/(-10,0;-20,50);(0,1;0,101)/(-10,1;-20,51);(1,0;1,100)/(-11,0;-21,50);(1,1;1,101)/(-11,1;-21,51)")
+    assert_equal(csort((r1 + r2).to_s), csort("(0,0;0,100)/(-10,0;-20,50);(0,1;0,101)/(-10,1;-20,51);(1,0;1,100)/(-11,0;-21,50);(1,1;1,101)/(-11,1;-21,51)"))
     r1 += r2
-    assert_equal(r1.to_s, "(0,0;0,100)/(-10,0;-20,50);(0,1;0,101)/(-10,1;-20,51);(1,0;1,100)/(-11,0;-21,50);(1,1;1,101)/(-11,1;-21,51)")
+    assert_equal(csort(r1.to_s), csort("(0,0;0,100)/(-10,0;-20,50);(0,1;0,101)/(-10,1;-20,51);(1,0;1,100)/(-11,0;-21,50);(1,1;1,101)/(-11,1;-21,51)"))
 
   end
 
@@ -118,7 +125,7 @@ class DBEdgePairs_TestClass < TestBase
     ep3 = RBA::EdgePair::new(RBA::Edge::new(0, 0, 0, 10), RBA::Edge::new(10, 10, 10, 0))
 
     r1 = RBA::EdgePairs::new([ ep1, ep2 ])
-    assert_equal(r1.to_s, "(0,1;2,3)/(10,11;12,13);(20,21;22,23)/(30,31;32,33)")
+    assert_equal(csort(r1.to_s), csort("(0,1;2,3)/(10,11;12,13);(20,21;22,23)/(30,31;32,33)"))
 
     r1 = RBA::EdgePairs::new(ep1)
     assert_equal(r1.to_s, "(0,1;2,3)/(10,11;12,13)")
@@ -127,7 +134,7 @@ class DBEdgePairs_TestClass < TestBase
     s.insert(ep1)
     s.insert(ep2)
     r1 = RBA::EdgePairs::new(s)
-    assert_equal(r1.to_s, "(0,1;2,3)/(10,11;12,13);(20,21;22,23)/(30,31;32,33)")
+    assert_equal(csort(r1.to_s), csort("(0,1;2,3)/(10,11;12,13);(20,21;22,23)/(30,31;32,33)"))
 
     ly = RBA::Layout::new
     l1 = ly.layer("l1")
diff --git a/testdata/ruby/dbEdgesTest.rb b/testdata/ruby/dbEdgesTest.rb
index 0c64b5821..4c7f29c17 100644
--- a/testdata/ruby/dbEdgesTest.rb
+++ b/testdata/ruby/dbEdgesTest.rb
@@ -23,6 +23,13 @@ end
 
 load("test_prologue.rb")
 
+# normalizes a specification string for region, edges etc.
+# such that the order of the objects becomes irrelevant
+def csort(s)
+  # splits at ");(" without consuming the brackets
+  s.split(/(?<=\));(?=\()/).sort.join(";")
+end
+
 class DBEdges_TestClass < TestBase
 
   # Basics
@@ -47,7 +54,7 @@ class DBEdges_TestClass < TestBase
     assert_equal(r.is_merged?, true)
 
     r.assign(RBA::Edges::new([RBA::Edge::new(10, 20, 100, 200), RBA::Edge::new(11, 21, 101, 201)]))
-    assert_equal(r.to_s, "(10,20;100,200);(11,21;101,201)")
+    assert_equal(csort(r.to_s), csort("(10,20;100,200);(11,21;101,201)"))
     assert_equal(r.is_empty?, false)
     assert_equal(r.count, 2)
     assert_equal(r.hier_count, 2)
@@ -63,7 +70,7 @@ class DBEdges_TestClass < TestBase
     assert_equal(r.is_merged?, true)
 
     r.assign(RBA::Edges::new(RBA::Box::new(10, 20, 100, 200)))
-    assert_equal(r.to_s, "(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)")
+    assert_equal(csort(r.to_s), csort("(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)"))
     s = "" 
     r.each do |e|
       s.empty? || s += ";"
@@ -108,7 +115,7 @@ class DBEdges_TestClass < TestBase
     assert_equal(r.is_merged?, true)
     
     r = RBA::Edges::new(RBA::Polygon::new(RBA::Box::new(10, 20, 100, 200)))
-    assert_equal(r.to_s, "(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)")
+    assert_equal(csort(r.to_s), csort("(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)"))
     assert_equal(r.is_empty?, false)
     assert_equal(r.count, 4)
     assert_equal(r.hier_count, 4)
@@ -116,7 +123,7 @@ class DBEdges_TestClass < TestBase
     assert_equal(r.is_merged?, false)
     
     r = RBA::Edges::new(RBA::SimplePolygon::new(RBA::Box::new(10, 20, 100, 200)))
-    assert_equal(r.to_s, "(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)")
+    assert_equal(csort(r.to_s), csort("(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)"))
     assert_equal(r.is_empty?, false)
     assert_equal(r.count, 4)
     assert_equal(r.hier_count, 4)
@@ -128,18 +135,18 @@ class DBEdges_TestClass < TestBase
     r.insert(RBA::Box::new(10, 20, 100, 200))
     assert_equal(r.is_merged?, false)
     assert_equal(r.merged_semantics?, true)
-    assert_equal(r.to_s, "(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20);(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)")
-    assert_equal(r.merged.to_s, "(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)")
+    assert_equal(csort(r.to_s), csort("(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20);(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)"))
+    assert_equal(csort(r.merged.to_s), csort("(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)"))
     assert_equal(r.length, 2*90+2*180)
     r.merged_semantics = false
     assert_equal(r.merged_semantics?, false)
     assert_equal(r.length, 2*(2*90+2*180))
     
     r = RBA::Edges::new(RBA::Path::new([ RBA::Point::new(0, 0), RBA::Point::new(100, 0) ], 20))
-    assert_equal(r.to_s, "(0,-10;0,10);(0,10;100,10);(100,10;100,-10);(100,-10;0,-10)")
-    assert_equal(r.extents.to_s, "(0,-10;0,-10;0,10;0,10);(0,10;100,10;100,10;0,10);(100,-10;100,-10;100,10;100,10);(0,-10;100,-10;100,-10;0,-10)")
-    assert_equal(r.extents(10).to_s, "(-10,-20;-10,20;10,20;10,-20);(-10,0;-10,20;110,20;110,0);(90,-20;90,20;110,20;110,-20);(-10,-20;-10,0;110,0;110,-20)")
-    assert_equal(r.extents(5, -5).to_s, "(-5,-5;-5,5;5,5;5,-5);(95,-5;95,5;105,5;105,-5)")
+    assert_equal(csort(r.to_s), csort("(0,-10;0,10);(0,10;100,10);(100,10;100,-10);(100,-10;0,-10)"))
+    assert_equal(csort(r.extents.to_s), csort("(0,-10;0,-10;0,10;0,10);(0,10;100,10;100,10;0,10);(100,-10;100,-10;100,10;100,10);(0,-10;100,-10;100,-10;0,-10)"))
+    assert_equal(csort(r.extents(10).to_s), csort("(-10,-20;-10,20;10,20;10,-20);(-10,0;-10,20;110,20;110,0);(90,-20;90,20;110,20;110,-20);(-10,-20;-10,0;110,0;110,-20)"))
+    assert_equal(csort(r.extents(5, -5).to_s), csort("(-5,-5;-5,5;5,5;5,-5);(95,-5;95,5;105,5;105,-5)"))
     assert_equal(r.is_empty?, false)
     assert_equal(r.count, 4)
     assert_equal(r.hier_count, 4)
@@ -150,7 +157,7 @@ class DBEdges_TestClass < TestBase
         RBA::Polygon::new(RBA::Box::new(10, 20, 100, 200)),
         RBA::Polygon::new(RBA::Box::new(20, 50, 120, 250))
     ] )
-    assert_equal(r.to_s, "(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20);(20,50;20,250);(20,250;120,250);(120,250;120,50);(120,50;20,50)")
+    assert_equal(csort(r.to_s), csort("(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20);(20,50;20,250);(20,250;120,250);(120,250;120,50);(120,50;20,50)"))
     assert_equal(r.is_empty?, false)
     assert_equal(r.count, 8)
     assert_equal(r.hier_count, 8)
@@ -225,28 +232,28 @@ class DBEdges_TestClass < TestBase
     assert_equal(r.to_s, "(10,20;100,200)")
     r.clear
     r.insert(RBA::Box::new(10, 20, 100, 200))
-    assert_equal(r.to_s, "(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)")
+    assert_equal(csort(r.to_s), csort("(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)"))
     r.clear
     r.insert(RBA::Polygon::new(RBA::Box::new(10, 20, 100, 200)))
-    assert_equal(r.to_s, "(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)")
+    assert_equal(csort(r.to_s), csort("(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)"))
     r.clear
     r.insert(RBA::SimplePolygon::new(RBA::Box::new(10, 20, 100, 200)))
-    assert_equal(r.to_s, "(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)")
+    assert_equal(csort(r.to_s), csort("(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)"))
     r.clear
     r.insert(RBA::Path::new([ RBA::Point::new(0, 0), RBA::Point::new(100, 0) ], 20))
-    assert_equal(r.to_s, "(0,-10;0,10);(0,10;100,10);(100,10;100,-10);(100,-10;0,-10)")
+    assert_equal(csort(r.to_s), csort("(0,-10;0,10);(0,10;100,10);(100,10;100,-10);(100,-10;0,-10)"))
     r.clear
     r.insert( [
         RBA::Polygon::new(RBA::Box::new(10, 20, 100, 200)),
         RBA::Polygon::new(RBA::Box::new(20, 50, 120, 250))
     ] )
-    assert_equal(r.to_s, "(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20);(20,50;20,250);(20,250;120,250);(120,250;120,50);(120,50;20,50)")
+    assert_equal(csort(r.to_s), csort("(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20);(20,50;20,250);(20,250;120,250);(120,250;120,50);(120,50;20,50)"))
     r.clear
     r.insert( [
         RBA::Edge::new(10, 20, 100, 200),
         RBA::Edge::new(20, 50, 120, 250)
     ] )
-    assert_equal(r.to_s, "(10,20;100,200);(20,50;120,250)")
+    assert_equal(csort(r.to_s), csort("(10,20;100,200);(20,50;120,250)"))
     r.clear
     r.insert(ly.begin_shapes(c1.cell_index, l1))
     assert_equal(r.to_s(30), "(-10,-20;-10,20);(-10,20;10,20);(10,20;10,-20);(10,-20;-10,-20);(-10,80;-10,120);(-10,120;10,120);(10,120;10,80);(10,80;-10,80);(190,80;190,120);(190,120;210,120);(210,120;210,80);(210,80;190,80)")
@@ -264,7 +271,7 @@ class DBEdges_TestClass < TestBase
     rr = RBA::Region::new
     rr.insert(RBA::Box::new(10, 20, 100, 200))
     r.insert(rr)
-    assert_equal(r.to_s, "(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)")
+    assert_equal(csort(r.to_s), csort("(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)"))
 
     r = RBA::Edges::new
     s = RBA::Shapes::new
@@ -276,7 +283,7 @@ class DBEdges_TestClass < TestBase
     s = RBA::Shapes::new
     s.insert(RBA::Polygon::new(RBA::Box::new(10, 20, 100, 200)))
     r.insert(s)
-    assert_equal(r.to_s, "(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)")
+    assert_equal(csort(r.to_s), csort("(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)"))
 
     r = RBA::Edges::new
     s = RBA::Shapes::new
@@ -307,14 +314,14 @@ class DBEdges_TestClass < TestBase
     r2.insert(RBA::Edge::new(50, 0, 200, 0))
 
     r = r1 + r2
-    assert_equal(r.to_s, "(0,0;100,0);(50,0;200,0)")
+    assert_equal(csort(r.to_s), csort("(0,0;100,0);(50,0;200,0)"))
     assert_equal(r.merged.to_s, "(0,0;200,0)")
     r.merge
     assert_equal(r.is_merged?, true)
     assert_equal(r.to_s, "(0,0;200,0)")
     r = r1.dup
     r += r2
-    assert_equal(r.to_s, "(0,0;100,0);(50,0;200,0)")
+    assert_equal(csort(r.to_s), csort("(0,0;100,0);(50,0;200,0)"))
 
     r = r1 | r2
     assert_equal(r.to_s, "(0,0;200,0)")
@@ -341,11 +348,11 @@ class DBEdges_TestClass < TestBase
     assert_equal(r.to_s, "(0,0;50,0)")
 
     r = r1 ^ r2
-    assert_equal(r.to_s, "(0,0;50,0);(100,0;200,0)")
+    assert_equal(csort(r.to_s), csort("(0,0;50,0);(100,0;200,0)"))
     assert_equal(r.is_merged?, true)
     r = r1.dup
     r ^= r2
-    assert_equal(r.to_s, "(0,0;50,0);(100,0;200,0)")
+    assert_equal(csort(r.to_s), csort("(0,0;50,0);(100,0;200,0)"))
 
   end
 
@@ -370,10 +377,10 @@ class DBEdges_TestClass < TestBase
     r = RBA::Edges::new
     r.insert(RBA::Edge::new(0, 0, 100, 0))
     r.insert(RBA::Edge::new(100, 0, 100, 100))
-    assert_equal(r.extended(1, 2, 3, 4, false).to_s, "(-1,-4;-1,3;102,3;102,-4);(97,-1;97,102;104,102;104,-1)")
+    assert_equal(csort(r.extended(1, 2, 3, 4, false).to_s), csort("(-1,-4;-1,3;102,3;102,-4);(97,-1;97,102;104,102;104,-1)"))
     assert_equal(r.extended(1, 2, 3, 4, true).to_s, "(-1,-4;-1,3;97,3;97,102;104,102;104,-4)")
-    assert_equal(r.extended_in(1).to_s, "(0,-1;0,0;100,0;100,-1);(100,0;100,100;101,100;101,0)")
-    assert_equal(r.extended_out(1).to_s, "(0,0;0,1;100,1;100,0);(99,0;99,100;100,100;100,0)")
+    assert_equal(csort(r.extended_in(1).to_s), csort("(0,-1;0,0;100,0;100,-1);(100,0;100,100;101,100;101,0)"))
+    assert_equal(csort(r.extended_out(1).to_s), csort("(0,0;0,1;100,1;100,0);(99,0;99,100;100,100;100,0)"))
 
   end
 
@@ -414,24 +421,24 @@ class DBEdges_TestClass < TestBase
     assert_equal(r3a.separation_check(r1, 15, false, RBA::Edges::Projection, nil, 380, 500).to_s, "")
     assert_equal(r3a.separation_check(r1, 15, false, RBA::Edges::Projection, nil, 0, 300).to_s, "(-10,10;-10,0)/(0,0;0,10)")
     
-    assert_equal(r3b.overlap_check(r1, 15).to_s, "(-10,10;10,10)/(21,0;0,0);(10,10;10,-10)/(0,0;0,21)")
-    assert_equal(r3b.overlap_check(r1, 15, false, RBA::Edges::Projection, nil, nil, nil).to_s, "(0,10;10,10)/(10,0;0,0);(10,10;10,0)/(0,0;0,10)")
-    assert_equal(r3b.overlap_check(r1, 15, true, RBA::Edges::Projection, nil, nil, nil).to_s, "(-10,10;10,10)/(100,0;0,0);(10,10;10,-10)/(0,0;0,200)")
+    assert_equal(csort(r3b.overlap_check(r1, 15).to_s), csort("(-10,10;10,10)/(21,0;0,0);(10,10;10,-10)/(0,0;0,21)"))
+    assert_equal(csort(r3b.overlap_check(r1, 15, false, RBA::Edges::Projection, nil, nil, nil).to_s), csort("(0,10;10,10)/(10,0;0,0);(10,10;10,0)/(0,0;0,10)"))
+    assert_equal(csort(r3b.overlap_check(r1, 15, true, RBA::Edges::Projection, nil, nil, nil).to_s), csort("(-10,10;10,10)/(100,0;0,0);(10,10;10,-10)/(0,0;0,200)"))
     assert_equal(r3b.overlap_check(r1, 15, true, RBA::Edges::Projection, 0.0, nil, nil).to_s, "")
-    assert_equal(r3b.overlap_check(r1, 15, false, RBA::Edges::Projection, nil, 0, 500).to_s, "(0,10;10,10)/(10,0;0,0);(10,10;10,0)/(0,0;0,10)")
+    assert_equal(csort(r3b.overlap_check(r1, 15, false, RBA::Edges::Projection, nil, 0, 500).to_s), csort("(0,10;10,10)/(10,0;0,0);(10,10;10,0)/(0,0;0,10)"))
     assert_equal(r3b.overlap_check(r1, 15, false, RBA::Edges::Projection, nil, 380, 500).to_s, "")
-    assert_equal(r3b.overlap_check(r1, 15, false, RBA::Edges::Projection, nil, 0, 300).to_s, "(0,10;10,10)/(10,0;0,0);(10,10;10,0)/(0,0;0,10)")
+    assert_equal(csort(r3b.overlap_check(r1, 15, false, RBA::Edges::Projection, nil, 0, 300).to_s), csort("(0,10;10,10)/(10,0;0,0);(10,10;10,0)/(0,0;0,10)"))
     
-    assert_equal((r2 | r1).space_check(25).to_s, "(120,20;120,380)/(100,395;100,5);(0,200;50,200)/(50,220;10,220)")
-    assert_equal((r2 | r1).space_check(25, false, RBA::Edges::Projection, nil, nil, nil).to_s, "(120,20;120,380)/(100,380;100,20);(10,200;50,200)/(50,220;10,220)")
-    assert_equal((r2 | r1).space_check(25, true, RBA::Edges::Projection, nil, nil, nil).to_s, "(120,20;120,380)/(100,400;100,0);(0,200;50,200)/(50,220;10,220)")
+    assert_equal(csort((r2 | r1).space_check(25).to_s), csort("(120,20;120,380)/(100,395;100,5);(0,200;50,200)/(50,220;10,220)"))
+    assert_equal(csort((r2 | r1).space_check(25, false, RBA::Edges::Projection, nil, nil, nil).to_s), csort("(120,20;120,380)/(100,380;100,20);(10,200;50,200)/(50,220;10,220)"))
+    assert_equal(csort((r2 | r1).space_check(25, true, RBA::Edges::Projection, nil, nil, nil).to_s), csort("(120,20;120,380)/(100,400;100,0);(0,200;50,200)/(50,220;10,220)"))
     assert_equal((r2 | r1).space_check(25, true, RBA::Edges::Projection, 0.0, nil, nil).to_s, "")
     assert_equal((r2 | r1).space_check(25, true, RBA::Edges::Projection, nil, 50, nil).to_s, "(120,20;120,380)/(100,400;100,0)")
     assert_equal((r2 | r1).space_check(25, true, RBA::Edges::Projection, nil, nil, 50).to_s, "(0,200;50,200)/(50,220;10,220)")
 
-    assert_equal((r2 | r1).width_check(60).to_s, "(120,20;120,380)/(130,380;130,20);(50,200;50,220)/(100,253;100,167)")
-    assert_equal((r2 | r1).width_check(60, false, RBA::Edges::Projection, nil, nil, nil).to_s, "(120,20;120,380)/(130,380;130,20);(50,200;50,220)/(100,220;100,200)")
-    assert_equal((r2 | r1).width_check(60, true, RBA::Edges::Projection, nil, nil, nil).to_s, "(120,20;120,380)/(130,380;130,20);(50,200;50,220)/(100,400;100,0)")
+    assert_equal(csort((r2 | r1).width_check(60).to_s), csort("(120,20;120,380)/(130,380;130,20);(50,200;50,220)/(100,253;100,167)"))
+    assert_equal(csort((r2 | r1).width_check(60, false, RBA::Edges::Projection, nil, nil, nil).to_s), csort("(120,20;120,380)/(130,380;130,20);(50,200;50,220)/(100,220;100,200)"))
+    assert_equal(csort((r2 | r1).width_check(60, true, RBA::Edges::Projection, nil, nil, nil).to_s), csort("(120,20;120,380)/(130,380;130,20);(50,200;50,220)/(100,400;100,0)"))
     assert_equal((r2 | r1).width_check(60, true, RBA::Edges::Projection, 0.0, nil, nil).to_s, "")
     assert_equal((r2 | r1).width_check(60, true, RBA::Edges::Projection, nil, 50, nil).to_s, "(120,20;120,380)/(130,380;130,20)")
     assert_equal((r2 | r1).width_check(60, true, RBA::Edges::Projection, nil, nil, 50).to_s, "(50,200;50,220)/(100,400;100,0)")
@@ -505,18 +512,18 @@ class DBEdges_TestClass < TestBase
     r1.merged_semantics = false
     r2.merged_semantics = false
 
-    assert_equal(r1.in(r2).to_s, "(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)")
-    assert_equal(r2.in(r1).to_s, "(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)")
-    assert_equal(r1.not_in(r2).to_s, "(50,70;50,270);(50,270;150,270);(150,270;150,70);(150,70;50,70)")
-    assert_equal(r2.not_in(r1).to_s, "(100,70;100,270);(100,270;250,270);(250,270;250,70);(250,70;100,70)")
+    assert_equal(csort(r1.in(r2).to_s), csort("(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)"))
+    assert_equal(csort(r2.in(r1).to_s), csort("(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)"))
+    assert_equal(csort(r1.not_in(r2).to_s), csort("(50,70;50,270);(50,270;150,270);(150,270;150,70);(150,70;50,70)"))
+    assert_equal(csort(r2.not_in(r1).to_s), csort("(100,70;100,270);(100,270;250,270);(250,270;250,70);(250,70;100,70)"))
 
     r1.merged_semantics = true
     r2.merged_semantics = true
 
-    assert_equal(r1.in(r2).to_s, "(10,20;10,200);(10,200;100,200);(100,20;10,20)")
-    assert_equal(r2.in(r1).to_s, "(10,20;10,200);(10,200;100,200);(100,20;10,20)")
-    assert_equal(r1.not_in(r2).to_s, "(100,200;100,20);(50,70;50,270);(50,270;150,270);(150,270;150,70);(150,70;50,70)")
-    assert_equal(r2.not_in(r1).to_s, "(100,270;250,270);(250,270;250,70);(250,70;100,70);(100,70;100,20);(100,200;100,270)")
+    assert_equal(csort(r1.in(r2).to_s), csort("(10,20;10,200);(10,200;100,200);(100,20;10,20)"))
+    assert_equal(csort(r2.in(r1).to_s), csort("(10,20;10,200);(10,200;100,200);(100,20;10,20)"))
+    assert_equal(csort(r1.not_in(r2).to_s), csort("(100,200;100,20);(50,70;50,270);(50,270;150,270);(150,270;150,70);(150,70;50,70)"))
+    assert_equal(csort(r2.not_in(r1).to_s), csort("(100,270;250,270);(250,270;250,70);(250,70;100,70);(100,70;100,20);(100,200;100,270)"))
 
   end
 
@@ -539,16 +546,16 @@ class DBEdges_TestClass < TestBase
     ee.select_inside_part(r)
     assert_equal(ee.to_s, "(0,100;100,100)")
 
-    assert_equal((e - r).to_s, "(-100,100;0,100);(100,100;200,100)")
-    assert_equal(e.outside_part(r).to_s, "(-100,100;0,100);(100,100;200,100)")
+    assert_equal(csort((e - r).to_s), csort("(-100,100;0,100);(100,100;200,100)"))
+    assert_equal(csort(e.outside_part(r).to_s), csort("(-100,100;0,100);(100,100;200,100)"))
 
     ee = e.dup
     ee -= r
-    assert_equal(ee.to_s, "(-100,100;0,100);(100,100;200,100)")
+    assert_equal(csort(ee.to_s), csort("(-100,100;0,100);(100,100;200,100)"))
 
     ee = e.dup
     ee.select_outside_part(r)
-    assert_equal(ee.to_s, "(-100,100;0,100);(100,100;200,100)")
+    assert_equal(csort(ee.to_s), csort("(-100,100;0,100);(100,100;200,100)"))
 
     e.clear
     e.insert(RBA::Edge::new(-100, 0, 200, 0))
@@ -563,16 +570,16 @@ class DBEdges_TestClass < TestBase
     ee.select_inside_part(r)
     assert_equal(ee.to_s, "")
 
-    assert_equal((e - r).to_s, "(-100,0;0,0);(100,0;200,0)")
-    assert_equal(e.outside_part(r).to_s, "(-100,0;0,0);(0,0;100,0);(100,0;200,0)")
+    assert_equal(csort((e - r).to_s), csort("(-100,0;0,0);(100,0;200,0)"))
+    assert_equal(csort(e.outside_part(r).to_s), csort("(-100,0;0,0);(0,0;100,0);(100,0;200,0)"))
 
     ee = e.dup
     ee -= r
-    assert_equal(ee.to_s, "(-100,0;0,0);(100,0;200,0)")
+    assert_equal(csort(ee.to_s), csort("(-100,0;0,0);(100,0;200,0)"))
 
     ee = e.dup
     ee.select_outside_part(r)
-    assert_equal(ee.to_s, "(-100,0;0,0);(0,0;100,0);(100,0;200,0)")
+    assert_equal(csort(ee.to_s), csort("(-100,0;0,0);(0,0;100,0);(100,0;200,0)"))
 
   end
 
@@ -604,7 +611,7 @@ class DBEdges_TestClass < TestBase
     target.each_cell { |c| cells << c.name }
     assert_equal(cells.join(","), "TOP,C2")
     assert_equal(RBA::Edges::new(target.cell("TOP").shapes(target_li)).to_s, "")
-    assert_equal(RBA::Edges::new(target.cell("C2").shapes(target_li)).to_s, "(-10,-20;-10,20);(-10,20;10,20);(10,20;10,-20);(10,-20;-10,-20)")
+    assert_equal(csort(RBA::Edges::new(target.cell("C2").shapes(target_li)).to_s), csort("(-10,-20;-10,20);(-10,20;10,20);(10,20;10,-20);(10,-20;-10,-20)"))
 
     r.flatten
 
diff --git a/testdata/ruby/dbRegionTest.rb b/testdata/ruby/dbRegionTest.rb
index 33554fac3..b5d273646 100644
--- a/testdata/ruby/dbRegionTest.rb
+++ b/testdata/ruby/dbRegionTest.rb
@@ -23,6 +23,13 @@ end
 
 load("test_prologue.rb")
 
+# normalizes a specification string for region, edges etc.
+# such that the order of the objects becomes irrelevant
+def csort(s)
+  # splits at ");(" without consuming the brackets
+  s.split(/(?<=\));(?=\()/).sort.join(";")
+end
+
 class DBRegion_TestClass < TestBase
 
   # Basics
@@ -47,7 +54,7 @@ class DBRegion_TestClass < TestBase
     assert_equal(r.bbox.to_s, "(10,20;100,200)")
     assert_equal(r.is_merged?, true)
     assert_equal(r.is_box?, true)
-    assert_equal(r.edges.to_s, "(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)")
+    assert_equal(csort(r.edges.to_s), csort("(10,20;10,200);(10,200;100,200);(100,200;100,20);(100,20;10,20)"))
 
     assert_equal(r.moved(RBA::Point::new(10, 20)).bbox.to_s, "(20,40;110,220)")
     assert_equal(r.moved(10, 20).bbox.to_s, "(20,40;110,220)")
@@ -115,7 +122,7 @@ class DBRegion_TestClass < TestBase
         RBA::Polygon::new(RBA::Box::new(10, 20, 100, 200)),
         RBA::Polygon::new(RBA::Box::new(20, 50, 120, 250))
     ] )
-    assert_equal(r.to_s, "(10,20;10,200;100,200;100,20);(20,50;20,250;120,250;120,50)")
+    assert_equal(csort(r.to_s), csort("(10,20;10,200;100,200;100,20);(20,50;20,250;120,250;120,50)"))
     s = "" 
     r.each do |p|
       s.empty? || s += ";"
@@ -156,7 +163,7 @@ class DBRegion_TestClass < TestBase
     c2.shapes(l2).insert(RBA::Text::new("BB", RBA::Vector::new(10, 20)))
     
     r = RBA::Region::new(ly.begin_shapes(c1.cell_index, l1))
-    assert_equal(r.to_s, "(-10,-20;-10,20;10,20;10,-20);(-10,80;-10,120;10,120;10,80);(190,80;190,120;210,120;210,80)")
+    assert_equal(csort(r.to_s), csort("(-10,-20;-10,20;10,20;10,-20);(-10,80;-10,120;10,120;10,80);(190,80;190,120;210,120;210,80)"))
     assert_equal(r.is_empty?, false)
     assert_equal(r.count, 3)
     assert_equal(r.hier_count, 3)
@@ -172,19 +179,19 @@ class DBRegion_TestClass < TestBase
     assert_equal(r.is_merged?, false)
     
     r = RBA::Region::new(ly.begin_shapes(c1.cell_index, l2), "*")
-    assert_equal(r.to_s, "(-11,-21;-11,-19;-9,-19;-9,-21);(9,19;9,21;11,21;11,19);(-11,79;-11,81;-9,81;-9,79);(9,119;9,121;11,121;11,119);(189,79;189,81;191,81;191,79);(209,119;209,121;211,121;211,119)")
+    assert_equal(csort(r.to_s), csort("(-11,-21;-11,-19;-9,-19;-9,-21);(9,19;9,21;11,21;11,19);(-11,79;-11,81;-9,81;-9,79);(9,119;9,121;11,121;11,119);(189,79;189,81;191,81;191,79);(209,119;209,121;211,121;211,119)"))
     r = RBA::Region::new(ly.begin_shapes(c1.cell_index, l2), "A*")
-    assert_equal(r.to_s, "(-11,-21;-11,-19;-9,-19;-9,-21);(-11,79;-11,81;-9,81;-9,79);(189,79;189,81;191,81;191,79)")
+    assert_equal(csort(r.to_s), csort("(-11,-21;-11,-19;-9,-19;-9,-21);(-11,79;-11,81;-9,81;-9,79);(189,79;189,81;191,81;191,79)"))
     r = RBA::Region::new(ly.begin_shapes(c1.cell_index, l2), "A*", false)
     assert_equal(r.to_s, "")
     r = RBA::Region::new(ly.begin_shapes(c1.cell_index, l2), "AA", false)
-    assert_equal(r.to_s, "(-11,-21;-11,-19;-9,-19;-9,-21);(-11,79;-11,81;-9,81;-9,79);(189,79;189,81;191,81;191,79)")
+    assert_equal(csort(r.to_s), csort("(-11,-21;-11,-19;-9,-19;-9,-21);(-11,79;-11,81;-9,81;-9,79);(189,79;189,81;191,81;191,79)"))
 
     r = RBA::Region::new(ly.begin_shapes(c1.cell_index, l1), RBA::ICplxTrans::new(10, 20))
-    assert_equal(r.to_s, "(0,0;0,40;20,40;20,0);(0,100;0,140;20,140;20,100);(200,100;200,140;220,140;220,100)")
-    assert_equal(r.extents.to_s, "(0,0;0,40;20,40;20,0);(0,100;0,140;20,140;20,100);(200,100;200,140;220,140;220,100)")
-    assert_equal(r.extents(10).to_s, "(-10,-10;-10,50;30,50;30,-10);(-10,90;-10,150;30,150;30,90);(190,90;190,150;230,150;230,90)")
-    assert_equal(r.extents(5, -5).to_s, "(-5,5;-5,35;25,35;25,5);(-5,105;-5,135;25,135;25,105);(195,105;195,135;225,135;225,105)")
+    assert_equal(csort(r.to_s), csort("(0,0;0,40;20,40;20,0);(0,100;0,140;20,140;20,100);(200,100;200,140;220,140;220,100)"))
+    assert_equal(csort(r.extents.to_s), csort("(0,0;0,40;20,40;20,0);(0,100;0,140;20,140;20,100);(200,100;200,140;220,140;220,100)"))
+    assert_equal(csort(r.extents(10).to_s), csort("(-10,-10;-10,50;30,50;30,-10);(-10,90;-10,150;30,150;30,90);(190,90;190,150;230,150;230,90)"))
+    assert_equal(csort(r.extents(5, -5).to_s), csort("(-5,5;-5,35;25,35;25,5);(-5,105;-5,135;25,135;25,105);(195,105;195,135;225,135;225,105)"))
     assert_equal(r.is_empty?, false)
     assert_equal(r.is_box?, false)
     assert_equal(r.count, 3)
@@ -214,13 +221,13 @@ class DBRegion_TestClass < TestBase
         RBA::Polygon::new(RBA::Box::new(10, 20, 100, 200)),
         RBA::Polygon::new(RBA::Box::new(20, 50, 120, 250))
     ] )
-    assert_equal(r.to_s, "(10,20;10,200;100,200;100,20);(20,50;20,250;120,250;120,50)")
+    assert_equal(csort(r.to_s), csort("(10,20;10,200;100,200;100,20);(20,50;20,250;120,250;120,50)"))
     r.clear
     r.insert(ly.begin_shapes(c1.cell_index, l1))
-    assert_equal(r.to_s, "(-10,-20;-10,20;10,20;10,-20);(-10,80;-10,120;10,120;10,80);(190,80;190,120;210,120;210,80)")
+    assert_equal(csort(r.to_s), csort("(-10,-20;-10,20;10,20;10,-20);(-10,80;-10,120;10,120;10,80);(190,80;190,120;210,120;210,80)"))
     r.clear
     r.insert(ly.begin_shapes(c1.cell_index, l1), RBA::ICplxTrans::new(10, 20))
-    assert_equal(r.to_s, "(0,0;0,40;20,40;20,0);(0,100;0,140;20,140;20,100);(200,100;200,140;220,140;220,100)")
+    assert_equal(csort(r.to_s), csort("(0,0;0,40;20,40;20,0);(0,100;0,140;20,140;20,100);(200,100;200,140;220,140;220,100)"))
 
     r = RBA::Region::new
     rr = RBA::Region::new
@@ -281,15 +288,15 @@ class DBRegion_TestClass < TestBase
     
     assert_equal((r1 ^ r2).to_s, "(-10,-20;-10,160;10,160;10,200;100,200;100,20;80,20;80,-20/10,20;80,20;80,160;10,160)")
     r1.min_coherence = true
-    assert_equal((r1 ^ r2).to_s, "(-10,-20;-10,160;10,160;10,20;80,20;80,-20);(80,20;80,160;10,160;10,200;100,200;100,20)")
+    assert_equal(csort((r1 ^ r2).to_s), csort("(-10,-20;-10,160;10,160;10,20;80,20;80,-20);(80,20;80,160;10,160;10,200;100,200;100,20)"))
     rr = r1.dup
     rr ^= r2
-    assert_equal(rr.to_s, "(-10,-20;-10,160;10,160;10,20;80,20;80,-20);(80,20;80,160;10,160;10,200;100,200;100,20)")
+    assert_equal(csort(rr.to_s), csort("(-10,-20;-10,160;10,160;10,20;80,20;80,-20);(80,20;80,160;10,160;10,200;100,200;100,20)"))
     
-    assert_equal((r1 + r2).to_s, "(10,20;10,200;100,200;100,20);(-10,-20;-10,160;80,160;80,-20)")
+    assert_equal(csort((r1 + r2).to_s), csort("(10,20;10,200;100,200;100,20);(-10,-20;-10,160;80,160;80,-20)"))
     rr = r1.dup
     rr += r2
-    assert_equal(rr.to_s, "(10,20;10,200;100,200;100,20);(-10,-20;-10,160;80,160;80,-20)")
+    assert_equal(csort(rr.to_s), csort("(10,20;10,200;100,200;100,20);(-10,-20;-10,160;80,160;80,-20)"))
     
     assert_equal((r1 | r2).to_s, "(-10,-20;-10,160;10,160;10,200;100,200;100,20;80,20;80,-20)")
     rr = r1.dup
@@ -318,15 +325,15 @@ class DBRegion_TestClass < TestBase
     rr.size(10, 2)
     assert_equal(rr.to_s, "(-20,-30;-20,170;0,170;0,210;110,210;110,10;90,10;90,-30)")
 
-    assert_equal((r1 + r2).sized(10, 2).to_s, "(0,10;0,210;110,210;110,10);(-20,-30;-20,170;90,170;90,-30)")
+    assert_equal(csort((r1 + r2).sized(10, 2).to_s), csort("(0,10;0,210;110,210;110,10);(-20,-30;-20,170;90,170;90,-30)"))
     rr = (r1 + r2).dup
     rr.size(10, 2)
-    assert_equal(rr.to_s, "(0,10;0,210;110,210;110,10);(-20,-30;-20,170;90,170;90,-30)")
+    assert_equal(csort(rr.to_s), csort("(0,10;0,210;110,210;110,10);(-20,-30;-20,170;90,170;90,-30)"))
 
-    assert_equal((r1 + r2).sized(10, 20, 2).to_s, "(0,0;0,220;110,220;110,0);(-20,-40;-20,180;90,180;90,-40)")
+    assert_equal(csort((r1 + r2).sized(10, 20, 2).to_s), csort("(0,0;0,220;110,220;110,0);(-20,-40;-20,180;90,180;90,-40)"))
     rr = (r1 + r2).dup
     rr.size(10, 20, 2)
-    assert_equal(rr.to_s, "(0,0;0,220;110,220;110,0);(-20,-40;-20,180;90,180;90,-40)")
+    assert_equal(csort(rr.to_s), csort("(0,0;0,220;110,220;110,0);(-20,-40;-20,180;90,180;90,-40)"))
 
   end
 
@@ -359,8 +366,8 @@ class DBRegion_TestClass < TestBase
     r2.insert(RBA::Box::new(40, 20, 60, 50))
 
     r = r1 ^ r2
-    assert_equal(r.holes.to_s, "(10,20;10,50;30,50;30,20);(40,20;40,50;60,50;60,20)")
-    assert_equal(r.hulls.to_s, "(-10,-20;-10,200;100,200;100,-20);(-10,220;-10,400;100,400;100,220)")
+    assert_equal(csort(r.holes.to_s), csort("(10,20;10,50;30,50;30,20);(40,20;40,50;60,50;60,20)"))
+    assert_equal(csort(r.hulls.to_s), csort("(-10,-20;-10,200;100,200;100,-20);(-10,220;-10,400;100,400;100,220)"))
 
     r1 = RBA::Region::new
     r1.insert(RBA::Box::new(0, 0, 1000, 100))
@@ -371,13 +378,13 @@ class DBRegion_TestClass < TestBase
     assert_equal(r2.to_s, "(0,0;0,100;900,100;900,1000;1000,1000;1000,0)")
     r2 = r1.dup
     r2.break(0, 3.0)
-    assert_equal(r2.to_s, "(0,0;0,100;1000,100;1000,0);(900,100;900,1000;1000,1000;1000,100)")
+    assert_equal(csort(r2.to_s), csort("(0,0;0,100;1000,100;1000,0);(900,100;900,1000;1000,1000;1000,100)"))
     r2 = r1.dup
     r2.break(4, 0.0)
-    assert_equal(r2.to_s, "(0,0;0,100;1000,100;1000,0);(900,100;900,1000;1000,1000;1000,100)")
+    assert_equal(csort(r2.to_s), csort("(0,0;0,100;1000,100;1000,0);(900,100;900,1000;1000,1000;1000,100)"))
     r2 = r1.dup
     r2.break(4, 3.0)
-    assert_equal(r2.to_s, "(0,0;0,100;1000,100;1000,0);(900,100;900,1000;1000,1000;1000,100)")
+    assert_equal(csort(r2.to_s), csort("(0,0;0,100;1000,100;1000,0);(900,100;900,1000;1000,1000;1000,100)"))
 
   end
 
@@ -392,42 +399,42 @@ class DBRegion_TestClass < TestBase
 
     assert_equal(r.with_area(20000, false).to_s, "(0,0;0,200;100,200;100,0)")
     assert_equal(r.with_area(20000, true).to_s, "(0,0;0,100;400,100;400,0)")
-    assert_equal(r.with_area(10000, nil, false).to_s, "(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)")
+    assert_equal(csort(r.with_area(10000, nil, false).to_s), csort("(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)"))
     assert_equal(r.with_area(10000, 20000, false).to_s, "")
     assert_equal(r.with_area(nil, 20001, false).to_s, "(0,0;0,200;100,200;100,0)")
-    assert_equal(r.with_area(10000, 20000, true).to_s, "(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)")
+    assert_equal(csort(r.with_area(10000, 20000, true).to_s), csort("(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)"))
     
     assert_equal(r.with_perimeter(600, false).to_s, "(0,0;0,200;100,200;100,0)")
     assert_equal(r.with_perimeter(600, true).to_s, "(0,0;0,100;400,100;400,0)")
-    assert_equal(r.with_perimeter(600, nil, false).to_s, "(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)")
+    assert_equal(csort(r.with_perimeter(600, nil, false).to_s), csort("(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)"))
     assert_equal(r.with_perimeter(600, 1000, false).to_s, "(0,0;0,200;100,200;100,0)")
     assert_equal(r.with_perimeter(nil, 1000, false).to_s, "(0,0;0,200;100,200;100,0)")
     assert_equal(r.with_perimeter(600, 1000, true).to_s, "(0,0;0,100;400,100;400,0)")
     
     assert_equal(r.with_bbox_height(200, false).to_s, "(0,0;0,200;100,200;100,0)")
     assert_equal(r.with_bbox_height(200, true).to_s, "(0,0;0,100;400,100;400,0)")
-    assert_equal(r.with_bbox_height(100, nil, false).to_s, "(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)")
+    assert_equal(csort(r.with_bbox_height(100, nil, false).to_s), csort("(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)"))
     assert_equal(r.with_bbox_height(100, 200, false).to_s, "(0,0;0,100;400,100;400,0)")
-    assert_equal(r.with_bbox_height(nil, 201, false).to_s, "(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)")
+    assert_equal(csort(r.with_bbox_height(nil, 201, false).to_s), csort("(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)"))
     assert_equal(r.with_bbox_height(100, 200, true).to_s, "(0,0;0,200;100,200;100,0)")
     
     assert_equal(r.with_bbox_width(400, false).to_s, "(0,0;0,100;400,100;400,0)")
     assert_equal(r.with_bbox_width(400, true).to_s, "(0,0;0,200;100,200;100,0)")
-    assert_equal(r.with_bbox_width(100, nil, false).to_s, "(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)")
+    assert_equal(csort(r.with_bbox_width(100, nil, false).to_s), csort("(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)"))
     assert_equal(r.with_bbox_width(100, 400, false).to_s, "(0,0;0,200;100,200;100,0)")
-    assert_equal(r.with_bbox_width(nil, 401, false).to_s, "(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)")
+    assert_equal(csort(r.with_bbox_width(nil, 401, false).to_s), csort("(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)"))
     assert_equal(r.with_bbox_width(100, 400, true).to_s, "(0,0;0,100;400,100;400,0)")
     
-    assert_equal(r.with_bbox_min(100, false).to_s, "(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)")
+    assert_equal(csort(r.with_bbox_min(100, false).to_s), csort("(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)"))
     assert_equal(r.with_bbox_min(100, true).to_s, "")
-    assert_equal(r.with_bbox_min(100, nil, false).to_s, "(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)")
-    assert_equal(r.with_bbox_min(100, 101, false).to_s, "(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)")
-    assert_equal(r.with_bbox_min(nil, 101, false).to_s, "(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)")
+    assert_equal(csort(r.with_bbox_min(100, nil, false).to_s), csort("(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)"))
+    assert_equal(csort(r.with_bbox_min(100, 101, false).to_s), csort("(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)"))
+    assert_equal(csort(r.with_bbox_min(nil, 101, false).to_s), csort("(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)"))
     assert_equal(r.with_bbox_min(100, 101, true).to_s, "")
     
     assert_equal(r.with_bbox_max(200, false).to_s, "(0,0;0,200;100,200;100,0)")
     assert_equal(r.with_bbox_max(200, true).to_s, "(0,0;0,100;400,100;400,0)")
-    assert_equal(r.with_bbox_max(200, nil, false).to_s, "(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)")
+    assert_equal(csort(r.with_bbox_max(200, nil, false).to_s), csort("(0,0;0,200;100,200;100,0);(0,0;0,100;400,100;400,0)"))
     assert_equal(r.with_bbox_max(200, 400, false).to_s, "(0,0;0,200;100,200;100,0)")
     assert_equal(r.with_bbox_max(nil, 400, false).to_s, "(0,0;0,200;100,200;100,0)")
     assert_equal(r.with_bbox_max(200, 400, true).to_s, "(0,0;0,100;400,100;400,0)")
@@ -470,13 +477,13 @@ class DBRegion_TestClass < TestBase
     assert_equal(r3a.separation_check(r1, 15, false, RBA::Region::Projection, nil, 380, 500).to_s, "")
     assert_equal(r3a.separation_check(r1, 15, false, RBA::Region::Projection, nil, 0, 300).to_s, "(-10,10;-10,0)/(0,0;0,10)")
     
-    assert_equal(r3b.overlap_check(r1, 15).to_s, "(-10,10;10,10)/(21,0;0,0);(10,10;10,-10)/(0,0;0,21)")
-    assert_equal(r3b.overlap_check(r1, 15, false, RBA::Region::Projection, nil, nil, nil).to_s, "(0,10;10,10)/(10,0;0,0);(10,10;10,0)/(0,0;0,10)")
-    assert_equal(r3b.overlap_check(r1, 15, true, RBA::Region::Projection, nil, nil, nil).to_s, "(-10,10;10,10)/(100,0;0,0);(10,10;10,-10)/(0,0;0,200)")
+    assert_equal(csort(r3b.overlap_check(r1, 15).to_s), csort("(-10,10;10,10)/(21,0;0,0);(10,10;10,-10)/(0,0;0,21)"))
+    assert_equal(csort(r3b.overlap_check(r1, 15, false, RBA::Region::Projection, nil, nil, nil).to_s), csort("(0,10;10,10)/(10,0;0,0);(10,10;10,0)/(0,0;0,10)"))
+    assert_equal(csort(r3b.overlap_check(r1, 15, true, RBA::Region::Projection, nil, nil, nil).to_s), csort("(-10,10;10,10)/(100,0;0,0);(10,10;10,-10)/(0,0;0,200)"))
     assert_equal(r3b.overlap_check(r1, 15, true, RBA::Region::Projection, 0.0, nil, nil).to_s, "")
-    assert_equal(r3b.overlap_check(r1, 15, false, RBA::Region::Projection, nil, 0, 500).to_s, "(0,10;10,10)/(10,0;0,0);(10,10;10,0)/(0,0;0,10)")
+    assert_equal(csort(r3b.overlap_check(r1, 15, false, RBA::Region::Projection, nil, 0, 500).to_s), csort("(0,10;10,10)/(10,0;0,0);(10,10;10,0)/(0,0;0,10)"))
     assert_equal(r3b.overlap_check(r1, 15, false, RBA::Region::Projection, nil, 380, 500).to_s, "")
-    assert_equal(r3b.overlap_check(r1, 15, false, RBA::Region::Projection, nil, 0, 300).to_s, "(0,10;10,10)/(10,0;0,0);(10,10;10,0)/(0,0;0,10)")
+    assert_equal(csort(r3b.overlap_check(r1, 15, false, RBA::Region::Projection, nil, 0, 300).to_s), csort("(0,10;10,10)/(10,0;0,0);(10,10;10,0)/(0,0;0,10)"))
     
     assert_equal((r1 | r2).merged.isolated_check(25).to_s, "(120,20;120,380)|(100,395;100,5)")
     assert_equal((r1 | r2).merged.isolated_check(25, false, RBA::Region::Projection, nil, nil, nil).to_s, "(120,20;120,380)|(100,380;100,20)")
@@ -497,16 +504,16 @@ class DBRegion_TestClass < TestBase
     assert_equal((r1 | r2).merged.notch_check(25, true, RBA::Region::Projection, nil, 40, 50).to_s, "(0,200;50,200)|(50,220;10,220)")
     assert_equal((r1 | r2).merged.notch_check(25, true, RBA::Region::Projection, nil, nil, 40).to_s, "")
 
-    assert_equal((r1 | r2).merged.space_check(25).to_s, "(120,20;120,380)|(100,395;100,5);(0,200;50,200)|(50,220;10,220)")
-    assert_equal((r1 | r2).merged.space_check(25, false, RBA::Region::Projection, nil, nil, nil).to_s, "(120,20;120,380)|(100,380;100,20);(10,200;50,200)|(50,220;10,220)")
-    assert_equal((r1 | r2).merged.space_check(25, true, RBA::Region::Projection, nil, nil, nil).to_s, "(120,20;120,380)|(100,400;100,0);(0,200;50,200)|(50,220;10,220)")
+    assert_equal(csort((r1 | r2).merged.space_check(25).to_s), csort("(120,20;120,380)|(100,395;100,5);(0,200;50,200)|(50,220;10,220)"))
+    assert_equal(csort((r1 | r2).merged.space_check(25, false, RBA::Region::Projection, nil, nil, nil).to_s), csort("(120,20;120,380)|(100,380;100,20);(10,200;50,200)|(50,220;10,220)"))
+    assert_equal(csort((r1 | r2).merged.space_check(25, true, RBA::Region::Projection, nil, nil, nil).to_s), csort("(120,20;120,380)|(100,400;100,0);(0,200;50,200)|(50,220;10,220)"))
     assert_equal((r1 | r2).merged.space_check(25, true, RBA::Region::Projection, 0.0, nil, nil).to_s, "")
     assert_equal((r1 | r2).merged.space_check(25, true, RBA::Region::Projection, nil, 50, nil).to_s, "(120,20;120,380)|(100,400;100,0)")
     assert_equal((r1 | r2).merged.space_check(25, true, RBA::Region::Projection, nil, nil, 50).to_s, "(0,200;50,200)|(50,220;10,220)")
 
-    assert_equal((r1 | r2).merged.width_check(60).to_s, "(120,20;120,380)|(130,380;130,20);(50,200;50,220)|(100,253;100,167)")
-    assert_equal((r1 | r2).merged.width_check(60, false, RBA::Region::Projection, nil, nil, nil).to_s, "(120,20;120,380)|(130,380;130,20);(50,200;50,220)|(100,220;100,200)")
-    assert_equal((r1 | r2).merged.width_check(60, true, RBA::Region::Projection, nil, nil, nil).to_s, "(120,20;120,380)|(130,380;130,20);(50,200;50,220)|(100,400;100,0)")
+    assert_equal(csort((r1 | r2).merged.width_check(60).to_s), csort("(120,20;120,380)|(130,380;130,20);(50,200;50,220)|(100,253;100,167)"))
+    assert_equal(csort((r1 | r2).merged.width_check(60, false, RBA::Region::Projection, nil, nil, nil).to_s), csort("(120,20;120,380)|(130,380;130,20);(50,200;50,220)|(100,220;100,200)"))
+    assert_equal(csort((r1 | r2).merged.width_check(60, true, RBA::Region::Projection, nil, nil, nil).to_s), csort("(120,20;120,380)|(130,380;130,20);(50,200;50,220)|(100,400;100,0)"))
     assert_equal((r1 | r2).merged.width_check(60, true, RBA::Region::Projection, 0.0, nil, nil).to_s, "")
     assert_equal((r1 | r2).merged.width_check(60, true, RBA::Region::Projection, nil, 50, nil).to_s, "(120,20;120,380)|(130,380;130,20)")
     assert_equal((r1 | r2).merged.width_check(60, true, RBA::Region::Projection, nil, nil, 50).to_s, "(50,200;50,220)|(100,400;100,0)")
@@ -529,67 +536,67 @@ class DBRegion_TestClass < TestBase
     assert_equal(r1.merged_semantics?, false)
 
     assert_equal(r1.inside(r2).to_s, "(10,20;10,200;100,200;100,20)")
-    assert_equal(r1.not_inside(r2).to_s, "(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)")
-    assert_equal(r1.interacting(r2).to_s, "(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)")
-    assert_equal(r1.interacting(r3, 1).to_s, "(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)")
-    assert_equal(r1.interacting(r3, 2).to_s, "(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)")
+    assert_equal(csort(r1.not_inside(r2).to_s), csort("(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
+    assert_equal(csort(r1.interacting(r2).to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
+    assert_equal(csort(r1.interacting(r3, 1).to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
+    assert_equal(csort(r1.interacting(r3, 2).to_s), csort("(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
     assert_equal(r1.interacting(r3, 3).to_s, "")
     assert_equal(r1.interacting(r3, 1, 1).to_s, "(10,20;10,200;100,200;100,20)")
-    assert_equal(r1.interacting(r3, 2, 2).to_s, "(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)")
+    assert_equal(csort(r1.interacting(r3, 2, 2).to_s), csort("(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
     assert_equal(r1.not_interacting(r2).to_s, "")
     assert_equal(r1.not_interacting(r3, 1).to_s, "")
     assert_equal(r1.not_interacting(r3, 2).to_s, "(10,20;10,200;100,200;100,20)")
-    assert_equal(r1.not_interacting(r3, 3).to_s, "(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)")
-    assert_equal(r1.not_interacting(r3, 1, 1).to_s, "(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)")
+    assert_equal(csort(r1.not_interacting(r3, 3).to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
+    assert_equal(csort(r1.not_interacting(r3, 1, 1).to_s), csort("(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
     assert_equal(r1.not_interacting(r3, 2, 2).to_s, "(10,20;10,200;100,200;100,20)")
-    assert_equal(r1.overlapping(r2).to_s, "(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70)")
+    assert_equal(csort(r1.overlapping(r2).to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70)"))
     assert_equal(r1.not_overlapping(r2).to_s, "(100,70;100,270;250,270;250,70)")
     assert_equal(r1.outside(r2).to_s, "(100,70;100,270;250,270;250,70)")
-    assert_equal(r1.not_outside(r2).to_s, "(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70)")
+    assert_equal(csort(r1.not_outside(r2).to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70)"))
 
     e2 = RBA::Edges::new(RBA::Edge::new(-10, -20, 100, 200))
     e3 = RBA::Edges::new(RBA::Edge::new(150, 270, 160, 280))
     e3 += e2
 
-    assert_equal(r1.interacting(e2).to_s, "(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)")
-    assert_equal(r1.interacting(e3, 1).to_s, "(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)")
-    assert_equal(r1.interacting(e3, 2).to_s, "(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70)")
+    assert_equal(csort(r1.interacting(e2).to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)"))
+    assert_equal(csort(r1.interacting(e3, 1).to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)"))
+    assert_equal(csort(r1.interacting(e3, 2).to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70)"))
     assert_equal(r1.interacting(e3, 3).to_s, "")
     assert_equal(r1.interacting(e3, 1, 1).to_s, "(10,20;10,200;100,200;100,20)")
-    assert_equal(r1.interacting(e3, 2, 2).to_s, "(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70)")
+    assert_equal(csort(r1.interacting(e3, 2, 2).to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70)"))
     assert_equal(r1.not_interacting(e2).to_s, "")
     assert_equal(r1.not_interacting(e3, 1).to_s, "")
     assert_equal(r1.not_interacting(e3, 2).to_s, "(10,20;10,200;100,200;100,20)")
-    assert_equal(r1.not_interacting(e3, 3).to_s, "(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)")
-    assert_equal(r1.not_interacting(e3, 1, 1).to_s, "(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70)")
+    assert_equal(csort(r1.not_interacting(e3, 3).to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)"))
+    assert_equal(csort(r1.not_interacting(e3, 1, 1).to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70)"))
     assert_equal(r1.not_interacting(e3, 2, 2).to_s, "(10,20;10,200;100,200;100,20)")
 
     t2 = RBA::Texts::new(RBA::Text::new("a", RBA::Trans::new(50, 100)))
     t3 = RBA::Texts::new(RBA::Text::new("b", RBA::Trans::new(150, 270)))
     t3 += t2
 
-    assert_equal(r1.interacting(t2).to_s, "(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)")
-    assert_equal(r1.interacting(t3, 1).to_s, "(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)")
+    assert_equal(csort(r1.interacting(t2).to_s), csort("(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)"))
+    assert_equal(csort(r1.interacting(t3, 1).to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)"))
     assert_equal(r1.interacting(t3, 2).to_s, "(50,70;50,270;150,270;150,70)")
     assert_equal(r1.interacting(t3, 3).to_s, "")
-    assert_equal(r1.interacting(t3, 1, 1).to_s, "(100,70;100,270;250,270;250,70);(10,20;10,200;100,200;100,20)")
+    assert_equal(csort(r1.interacting(t3, 1, 1).to_s), csort("(100,70;100,270;250,270;250,70);(10,20;10,200;100,200;100,20)"))
     assert_equal(r1.interacting(t3, 2, 2).to_s, "(50,70;50,270;150,270;150,70)")
     assert_equal(r1.not_interacting(t2).to_s, "(100,70;100,270;250,270;250,70)")
     assert_equal(r1.not_interacting(t3, 1).to_s, "")
-    assert_equal(r1.not_interacting(t3, 2).to_s, "(100,70;100,270;250,270;250,70);(10,20;10,200;100,200;100,20)")
-    assert_equal(r1.not_interacting(t3, 3).to_s, "(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)")
+    assert_equal(csort(r1.not_interacting(t3, 2).to_s), csort("(100,70;100,270;250,270;250,70);(10,20;10,200;100,200;100,20)"))
+    assert_equal(csort(r1.not_interacting(t3, 3).to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)"))
     assert_equal(r1.not_interacting(t3, 1, 1).to_s, "(50,70;50,270;150,270;150,70)")
-    assert_equal(r1.not_interacting(t3, 2, 2).to_s, "(100,70;100,270;250,270;250,70);(10,20;10,200;100,200;100,20)")
+    assert_equal(csort(r1.not_interacting(t3, 2, 2).to_s), csort("(100,70;100,270;250,270;250,70);(10,20;10,200;100,200;100,20)"))
 
     rr = r1.dup
     rr.select_interacting(r2)
-    assert_equal(rr.to_s, "(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)")
+    assert_equal(csort(rr.to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
     rr = r1.dup
     rr.select_interacting(r3, 2, 2)
-    assert_equal(rr.to_s, "(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)")
+    assert_equal(csort(rr.to_s), csort("(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
     rr = r1.dup
     rr.select_interacting(e3, 2, 2)
-    assert_equal(rr.to_s, "(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70)")
+    assert_equal(csort(rr.to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70)"))
     rr = r1.dup
     rr.select_interacting(t3, 2, 2)
     assert_equal(rr.to_s, "(50,70;50,270;150,270;150,70)")
@@ -605,11 +612,11 @@ class DBRegion_TestClass < TestBase
     assert_equal(rr.to_s, "(10,20;10,200;100,200;100,20)")
     rr = r1.dup
     rr.select_not_interacting(t3, 2, 2)
-    assert_equal(rr.to_s, "(100,70;100,270;250,270;250,70);(10,20;10,200;100,200;100,20)")
+    assert_equal(csort(rr.to_s), csort("(100,70;100,270;250,270;250,70);(10,20;10,200;100,200;100,20)"))
     
     rr = r1.dup
     rr.select_overlapping(r2)
-    assert_equal(rr.to_s, "(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70)")
+    assert_equal(csort(rr.to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70)"))
     
     rr = r1.dup
     rr.select_not_overlapping(r2)
@@ -621,7 +628,7 @@ class DBRegion_TestClass < TestBase
     
     rr = r1.dup
     rr.select_not_outside(r2)
-    assert_equal(rr.to_s, "(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70)")
+    assert_equal(csort(rr.to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70)"))
     
     rr = r1.dup
     rr.select_inside(r2)
@@ -629,7 +636,7 @@ class DBRegion_TestClass < TestBase
     
     rr = r1.dup
     rr.select_not_inside(r2)
-    assert_equal(rr.to_s, "(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)")
+    assert_equal(csort(rr.to_s), csort("(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
     
     r1.merged_semantics = true
 
@@ -686,9 +693,9 @@ class DBRegion_TestClass < TestBase
     r1.insert(RBA::Polygon::new([ RBA::Point::new(0, 0), RBA::Point::new(0, 100), RBA::Point::new(50, 100), RBA::Point::new(50, 200), RBA::Point::new(100, 200), RBA::Point::new(100, 0) ]))
 
     r1.merged_semantics = false
-    assert_equal(r1.rectangles.to_s, "(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70)")
-    assert_equal(r1.non_rectangles.to_s, "(0,0;100,100;100,0);(0,0;0,100;50,100;50,200;100,200;100,0)")
-    assert_equal(r1.rectilinear.to_s, "(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70);(0,0;0,100;50,100;50,200;100,200;100,0)")
+    assert_equal(csort(r1.rectangles.to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70)"))
+    assert_equal(csort(r1.non_rectangles.to_s), csort("(0,0;100,100;100,0);(0,0;0,100;50,100;50,200;100,200;100,0)"))
+    assert_equal(csort(r1.rectilinear.to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70);(0,0;0,100;50,100;50,200;100,200;100,0)"))
     assert_equal(r1.non_rectilinear.to_s, "(0,0;100,100;100,0)")
 
     r1.merged_semantics = true
@@ -726,7 +733,7 @@ class DBRegion_TestClass < TestBase
     ]
     r.insert(RBA::Polygon::new(pts))
 
-    assert_equal(r.strange_polygon_check.to_s, "(500,500;500,600;600,600;600,500);(2500,500;2500,1000;3000,1000;3000,500)")
+    assert_equal(csort(r.strange_polygon_check.to_s), csort("(500,500;500,600;600,600;600,500);(2500,500;2500,1000;3000,1000;3000,500)"))
     r.merge 
     assert_equal(r.strange_polygon_check.to_s, "")
 
@@ -748,14 +755,14 @@ class DBRegion_TestClass < TestBase
 
     r.insert(RBA::Polygon::new(pts))
 
-    assert_equal(r.with_angle(0, 180.0, false).to_s, "(0,0;0,1000)/(0,1000;1000,2000);(0,1000;1000,2000)/(1000,2000;1000,0);(1000,2000;1000,0)/(1000,0;0,0);(1000,0;0,0)/(0,0;0,1000)")
+    assert_equal(csort(r.with_angle(0, 180.0, false).to_s), csort("(0,0;0,1000)/(0,1000;1000,2000);(0,1000;1000,2000)/(1000,2000;1000,0);(1000,2000;1000,0)/(1000,0;0,0);(1000,0;0,0)/(0,0;0,1000)"))
     assert_equal(r.with_angle(0, 180.0, true).to_s, "")
     assert_equal(r.with_angle(45.0, 45.1, false).to_s, "(0,1000;1000,2000)/(1000,2000;1000,0)")
     assert_equal(r.with_angle(45.0, false).to_s, "(0,1000;1000,2000)/(1000,2000;1000,0)")
     assert_equal(r.with_angle(0.0, 90.0, false).to_s, "(0,1000;1000,2000)/(1000,2000;1000,0)")
-    assert_equal(r.with_angle(0.0, 90.0, true).to_s, "(0,0;0,1000)/(0,1000;1000,2000);(1000,2000;1000,0)/(1000,0;0,0);(1000,0;0,0)/(0,0;0,1000)")
+    assert_equal(csort(r.with_angle(0.0, 90.0, true).to_s), csort("(0,0;0,1000)/(0,1000;1000,2000);(1000,2000;1000,0)/(1000,0;0,0);(1000,0;0,0)/(0,0;0,1000)"))
     assert_equal(r.with_angle(90.1, 180.0, false).to_s, "(0,0;0,1000)/(0,1000;1000,2000)")
-    assert_equal(r.with_angle(90.1, 180.0, true).to_s, "(0,1000;1000,2000)/(1000,2000;1000,0);(1000,2000;1000,0)/(1000,0;0,0);(1000,0;0,0)/(0,0;0,1000)")
+    assert_equal(csort(r.with_angle(90.1, 180.0, true).to_s), csort("(0,1000;1000,2000)/(1000,2000;1000,0);(1000,2000;1000,0)/(1000,0;0,0);(1000,0;0,0)/(0,0;0,1000)"))
   
   end
 
@@ -773,8 +780,8 @@ class DBRegion_TestClass < TestBase
     assert_equal(r.grid_check(0, 0).to_s, "")
     assert_equal(r.grid_check(5, 0).to_s, "")
     assert_equal(r.grid_check(0, 10).to_s, "")
-    assert_equal(r.grid_check(10, 10).to_s, "(105,100;105,100)/(105,100;105,100);(105,290;105,290)/(105,290;105,290)")
-    assert_equal(r.grid_check(10, 20).to_s, "(105,100;105,100)/(105,100;105,100);(910,290;910,290)/(910,290;910,290);(105,290;105,290)/(105,290;105,290)")
+    assert_equal(csort(r.grid_check(10, 10).to_s), csort("(105,100;105,100)/(105,100;105,100);(105,290;105,290)/(105,290;105,290)"))
+    assert_equal(csort(r.grid_check(10, 20).to_s), csort("(105,100;105,100)/(105,100;105,100);(910,290;910,290)/(910,290;910,290);(105,290;105,290)/(105,290;105,290)"))
 
   end
 
@@ -822,7 +829,7 @@ class DBRegion_TestClass < TestBase
 
     r2 = RBA::Region::new;
 
-    assert_equal((r - r2).to_s, "(0,0;0,1000;500,1000;500,0);(200,300;200,1200;600,1200;600,300)")
+    assert_equal(csort((r - r2).to_s), csort("(0,0;0,1000;500,1000;500,0);(200,300;200,1200;600,1200;600,300)"))
     assert_equal(r.strict_handling?, false)
 
     r.strict_handling = true
@@ -840,12 +847,12 @@ class DBRegion_TestClass < TestBase
     p = RBA::Polygon::from_s("(0,40;0,50;10,50;10,40;0,40)")
     r.insert(p)
 
-    assert_equal(RBA::Region::new(r.decompose_convex).to_s, "(0,10;0,30;10,30;10,10);(10,30;10,40;40,40;40,30);(0,30;0,50;10,50;10,30);(30,0;30,30;40,30;40,0);(0,0;0,10;30,10;30,0)")
-    assert_equal(r.decompose_convex_to_region.to_s, "(0,10;0,30;10,30;10,10);(10,30;10,40;40,40;40,30);(0,30;0,50;10,50;10,30);(30,0;30,30;40,30;40,0);(0,0;0,10;30,10;30,0)")
-    assert_equal(RBA::Region::new(r.decompose_convex(RBA::Polygon::PO_horizontal)).to_s, "(0,10;0,30;10,30;10,10);(0,30;0,40;40,40;40,30);(0,40;0,50;10,50;10,40);(30,10;30,30;40,30;40,10);(0,0;0,10;40,10;40,0)")
-    assert_equal(RBA::Region::new(r.decompose_trapezoids).to_s, "(0,0;0,10;40,10;40,0);(0,10;0,30;10,30;10,10);(30,10;30,30;40,30;40,10);(0,30;0,40;40,40;40,30);(0,40;0,50;10,50;10,40)")
-    assert_equal(r.decompose_trapezoids_to_region.to_s, "(0,0;0,10;40,10;40,0);(0,10;0,30;10,30;10,10);(30,10;30,30;40,30;40,10);(0,30;0,40;40,40;40,30);(0,40;0,50;10,50;10,40)")
-    assert_equal(RBA::Region::new(r.decompose_trapezoids(RBA::Polygon::TD_htrapezoids)).to_s, "(0,10;0,30;10,30;10,10);(10,30;10,40;40,40;40,30);(0,30;0,50;10,50;10,30);(30,0;30,30;40,30;40,0);(0,0;0,10;30,10;30,0)")
+    assert_equal(csort(RBA::Region::new(r.decompose_convex).to_s), csort("(0,10;0,30;10,30;10,10);(10,30;10,40;40,40;40,30);(0,30;0,50;10,50;10,30);(30,0;30,30;40,30;40,0);(0,0;0,10;30,10;30,0)"))
+    assert_equal(csort(r.decompose_convex_to_region.to_s), csort("(0,10;0,30;10,30;10,10);(10,30;10,40;40,40;40,30);(0,30;0,50;10,50;10,30);(30,0;30,30;40,30;40,0);(0,0;0,10;30,10;30,0)"))
+    assert_equal(csort(RBA::Region::new(r.decompose_convex(RBA::Polygon::PO_horizontal)).to_s), csort("(0,10;0,30;10,30;10,10);(0,30;0,40;40,40;40,30);(0,40;0,50;10,50;10,40);(30,10;30,30;40,30;40,10);(0,0;0,10;40,10;40,0)"))
+    assert_equal(csort(RBA::Region::new(r.decompose_trapezoids).to_s), csort("(0,0;0,10;40,10;40,0);(0,10;0,30;10,30;10,10);(30,10;30,30;40,30;40,10);(0,30;0,40;40,40;40,30);(0,40;0,50;10,50;10,40)"))
+    assert_equal(csort(r.decompose_trapezoids_to_region.to_s), csort("(0,0;0,10;40,10;40,0);(0,10;0,30;10,30;10,10);(30,10;30,30;40,30;40,10);(0,30;0,40;40,40;40,30);(0,40;0,50;10,50;10,40)"))
+    assert_equal(csort(RBA::Region::new(r.decompose_trapezoids(RBA::Polygon::TD_htrapezoids)).to_s), csort("(0,10;0,30;10,30;10,10);(10,30;10,40;40,40;40,30);(0,30;0,50;10,50;10,30);(30,0;30,30;40,30;40,0);(0,0;0,10;30,10;30,0)"))
 
   end
 
@@ -856,12 +863,12 @@ class DBRegion_TestClass < TestBase
     p = RBA::Polygon::from_s("(0,0;0,80;40,40;40,0/10,10;30,10;30,30;10,30)")
     r.insert(p)
     
-    assert_equal(r.corners.to_s, "(39,-1;39,1;41,1;41,-1);(-1,-1;-1,1;1,1;1,-1);(-1,79;-1,81;1,81;1,79);(39,39;39,41;41,41;41,39);(9,29;9,31;11,31;11,29);(9,9;9,11;11,11;11,9);(29,9;29,11;31,11;31,9);(29,29;29,31;31,31;31,29)")
-    assert_equal(r.corners(-90.0, 90.0).to_s, "(39,-1;39,1;41,1;41,-1);(-1,-1;-1,1;1,1;1,-1);(39,39;39,41;41,41;41,39);(9,29;9,31;11,31;11,29);(9,9;9,11;11,11;11,9);(29,9;29,11;31,11;31,9);(29,29;29,31;31,31;31,29)")
-    assert_equal(r.corners(-90.0, -90.0).to_s, "(39,-1;39,1;41,1;41,-1);(-1,-1;-1,1;1,1;1,-1)")
+    assert_equal(csort(r.corners.to_s), csort("(39,-1;39,1;41,1;41,-1);(-1,-1;-1,1;1,1;1,-1);(-1,79;-1,81;1,81;1,79);(39,39;39,41;41,41;41,39);(9,29;9,31;11,31;11,29);(9,9;9,11;11,11;11,9);(29,9;29,11;31,11;31,9);(29,29;29,31;31,31;31,29)"))
+    assert_equal(csort(r.corners(-90.0, 90.0).to_s), csort("(39,-1;39,1;41,1;41,-1);(-1,-1;-1,1;1,1;1,-1);(39,39;39,41;41,41;41,39);(9,29;9,31;11,31;11,29);(9,9;9,11;11,11;11,9);(29,9;29,11;31,11;31,9);(29,29;29,31;31,31;31,29)"))
+    assert_equal(csort(r.corners(-90.0, -90.0).to_s), csort("(39,-1;39,1;41,1;41,-1);(-1,-1;-1,1;1,1;1,-1)"))
     assert_equal(r.corners(-45.0, -45.0).to_s, "(39,39;39,41;41,41;41,39)")
-    assert_equal(r.corners(-90.0, -45.0).to_s, "(39,-1;39,1;41,1;41,-1);(-1,-1;-1,1;1,1;1,-1);(39,39;39,41;41,41;41,39)")
-    assert_equal(r.corners(90.0, 90.0).to_s, "(9,29;9,31;11,31;11,29);(9,9;9,11;11,11;11,9);(29,9;29,11;31,11;31,9);(29,29;29,31;31,31;31,29)")
+    assert_equal(csort(r.corners(-90.0, -45.0).to_s), csort("(39,-1;39,1;41,1;41,-1);(-1,-1;-1,1;1,1;1,-1);(39,39;39,41;41,41;41,39)"))
+    assert_equal(csort(r.corners(90.0, 90.0).to_s), csort("(9,29;9,31;11,31;11,29);(9,9;9,11;11,11;11,9);(29,9;29,11;31,11;31,9);(29,29;29,31;31,31;31,29)"))
 
   end
 
@@ -994,19 +1001,19 @@ class DBRegion_TestClass < TestBase
     r.insert(RBA::Box::new(0, 10000, 2000, 12000))
 
     assert_equal(r.with_bbox_width(1000, false).to_s, "(0,0;0,5000;1000,5000;1000,0)")
-    assert_equal(r.with_bbox_width(1000, true).to_s, "(3000,0;3000,1000;7000,1000;7000,0);(0,10000;0,12000;2000,12000;2000,10000)")
-    assert_equal(r.with_bbox_width(1000, 2001, false).to_s, "(0,0;0,5000;1000,5000;1000,0);(0,10000;0,12000;2000,12000;2000,10000)")
+    assert_equal(csort(r.with_bbox_width(1000, true).to_s), csort("(3000,0;3000,1000;7000,1000;7000,0);(0,10000;0,12000;2000,12000;2000,10000)"))
+    assert_equal(csort(r.with_bbox_width(1000, 2001, false).to_s), csort("(0,0;0,5000;1000,5000;1000,0);(0,10000;0,12000;2000,12000;2000,10000)"))
     assert_equal(r.with_bbox_width(1000, 2000, false).to_s, "(0,0;0,5000;1000,5000;1000,0)")
     assert_equal(r.with_bbox_width(1000, 2001, true).to_s, "(3000,0;3000,1000;7000,1000;7000,0)")
 
     assert_equal(r.with_bbox_height(5000, false).to_s, "(0,0;0,5000;1000,5000;1000,0)")
-    assert_equal(r.with_bbox_height(5000, true).to_s, "(3000,0;3000,1000;7000,1000;7000,0);(0,10000;0,12000;2000,12000;2000,10000)")
-    assert_equal(r.with_bbox_height(1000, 2001, false).to_s, "(3000,0;3000,1000;7000,1000;7000,0);(0,10000;0,12000;2000,12000;2000,10000)")
+    assert_equal(csort(r.with_bbox_height(5000, true).to_s), csort("(3000,0;3000,1000;7000,1000;7000,0);(0,10000;0,12000;2000,12000;2000,10000)"))
+    assert_equal(csort(r.with_bbox_height(1000, 2001, false).to_s), csort("(3000,0;3000,1000;7000,1000;7000,0);(0,10000;0,12000;2000,12000;2000,10000)"))
     assert_equal(r.with_bbox_height(1000, 1001, false).to_s, "(3000,0;3000,1000;7000,1000;7000,0)")
-    assert_equal(r.with_bbox_height(1000, 1001, true).to_s, "(0,0;0,5000;1000,5000;1000,0);(0,10000;0,12000;2000,12000;2000,10000)")
+    assert_equal(csort(r.with_bbox_height(1000, 1001, true).to_s), csort("(0,0;0,5000;1000,5000;1000,0);(0,10000;0,12000;2000,12000;2000,10000)"))
 
     assert_equal(r.with_bbox_aspect_ratio(1.0, false).to_s, "(0,10000;0,12000;2000,12000;2000,10000)")
-    assert_equal(r.with_bbox_aspect_ratio(1.0, true).to_s, "(3000,0;3000,1000;7000,1000;7000,0);(0,0;0,5000;1000,5000;1000,0)")
+    assert_equal(csort(r.with_bbox_aspect_ratio(1.0, true).to_s), csort("(3000,0;3000,1000;7000,1000;7000,0);(0,0;0,5000;1000,5000;1000,0)"))
     assert_equal(r.with_bbox_aspect_ratio(0.9, 1.0, false).to_s, "(0,10000;0,12000;2000,12000;2000,10000)")
     assert_equal(r.with_bbox_aspect_ratio(1.0, 1.1, false).to_s, "(0,10000;0,12000;2000,12000;2000,10000)")
     assert_equal(r.with_bbox_aspect_ratio(0.9, 0.95, false).to_s, "")
@@ -1014,17 +1021,17 @@ class DBRegion_TestClass < TestBase
     assert_equal(r.with_bbox_aspect_ratio(1.0, 1.1, false, false, true).to_s, "")
 
     assert_equal(r.with_relative_height(1.0, false).to_s, "(0,10000;0,12000;2000,12000;2000,10000)")
-    assert_equal(r.with_relative_height(1.0, true).to_s, "(3000,0;3000,1000;7000,1000;7000,0);(0,0;0,5000;1000,5000;1000,0)")
+    assert_equal(csort(r.with_relative_height(1.0, true).to_s), csort("(3000,0;3000,1000;7000,1000;7000,0);(0,0;0,5000;1000,5000;1000,0)"))
     assert_equal(r.with_relative_height(0.9, 1.0, false).to_s, "(0,10000;0,12000;2000,12000;2000,10000)")
     assert_equal(r.with_relative_height(1.0, 1.1, false).to_s, "(0,10000;0,12000;2000,12000;2000,10000)")
     assert_equal(r.with_relative_height(0.9, 0.95, false).to_s, "")
     assert_equal(r.with_relative_height(0.9, 1.0, false, true, false).to_s, "")
     assert_equal(r.with_relative_height(1.0, 1.1, false, false, true).to_s, "")
 
-    assert_equal(r.rectangles.to_s, "(3000,0;3000,1000;7000,1000;7000,0);(0,0;0,5000;1000,5000;1000,0);(0,10000;0,12000;2000,12000;2000,10000)")
+    assert_equal(csort(r.rectangles.to_s), csort("(3000,0;3000,1000;7000,1000;7000,0);(0,0;0,5000;1000,5000;1000,0);(0,10000;0,12000;2000,12000;2000,10000)"))
     assert_equal(r.non_rectangles.to_s, "")
     assert_equal(r.squares.to_s, "(0,10000;0,12000;2000,12000;2000,10000)")
-    assert_equal(r.non_squares.to_s, "(3000,0;3000,1000;7000,1000;7000,0);(0,0;0,5000;1000,5000;1000,0)")
+    assert_equal(csort(r.non_squares.to_s), csort("(3000,0;3000,1000;7000,1000;7000,0);(0,0;0,5000;1000,5000;1000,0)"))
 
     r = RBA::Region::new
     r.insert(RBA::Box::new(0, 0, 1000, 2000))
diff --git a/testdata/ruby/dbTextsTest.rb b/testdata/ruby/dbTextsTest.rb
index dd038d77d..bff5640d2 100644
--- a/testdata/ruby/dbTextsTest.rb
+++ b/testdata/ruby/dbTextsTest.rb
@@ -23,6 +23,13 @@ end
 
 load("test_prologue.rb")
 
+# normalizes a specification string for region, edges etc.
+# such that the order of the objects becomes irrelevant
+def csort(s)
+  # splits at ");(" without consuming the brackets
+  s.split(/(?<=\));(?=\()/).sort.join(";")
+end
+
 class DBTexts_TestClass < TestBase
 
   # Basics
@@ -106,9 +113,9 @@ class DBTexts_TestClass < TestBase
     r1.insert(RBA::Text::new("abc", RBA::Trans::new(RBA::Vector::new(101, -201))))
     r1.insert(RBA::Text::new("uvm", RBA::Trans::new(RBA::Vector::new(111, 211))))
 
-    assert_equal((r1 + r2).to_s, "('abc',r0 100,-200);('uvm',r0 110,210);('abc',r0 101,-201);('uvm',r0 111,211)")
+    assert_equal(csort((r1 + r2).to_s), csort("('abc',r0 100,-200);('uvm',r0 110,210);('abc',r0 101,-201);('uvm',r0 111,211)"))
     r1 += r2
-    assert_equal(r1.to_s, "('abc',r0 100,-200);('uvm',r0 110,210);('abc',r0 101,-201);('uvm',r0 111,211)")
+    assert_equal(csort(r1.to_s), csort("('abc',r0 100,-200);('uvm',r0 110,210);('abc',r0 101,-201);('uvm',r0 111,211)"))
 
   end
 
@@ -119,7 +126,7 @@ class DBTexts_TestClass < TestBase
     text3 = RBA::Text::new("xyz", RBA::Trans::new(RBA::Vector::new(-101, 201)))
 
     r1 = RBA::Texts::new([ text1, text2 ])
-    assert_equal(r1.to_s, "('abc',r0 100,-200);('uvm',r0 110,210)")
+    assert_equal(csort(r1.to_s), csort("('abc',r0 100,-200);('uvm',r0 110,210)"))
     assert_equal(r1.with_text("abc", false).to_s, "('abc',r0 100,-200)")
     assert_equal(r1.with_text("abc", true).to_s, "('uvm',r0 110,210)")
     assert_equal(r1.with_match("*b*", false).to_s, "('abc',r0 100,-200)")
@@ -132,7 +139,7 @@ class DBTexts_TestClass < TestBase
     s.insert(text1)
     s.insert(text2)
     r1 = RBA::Texts::new(s)
-    assert_equal(r1.to_s, "('abc',r0 100,-200);('uvm',r0 110,210)")
+    assert_equal(csort(r1.to_s), csort("('abc',r0 100,-200);('uvm',r0 110,210)"))
 
     ly = RBA::Layout::new
     l1 = ly.layer("l1")