Adding upstream version 1.3.upstream/1.3upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

45 files changed, 9961 insertions, 0 deletions

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
new file mode 100644
index 0000000..95e10d4
--- /dev/null
+++ b/tests/CMakeLists.txt
@@ -0,0 +1,56 @@
+
+find_package(GTest REQUIRED MODULE)
+# Use this variable for tests which provide their own main().
+SET(2GEOM_TESTS_SRC
+#bezier-utils-test
+#lin_alg_test
+sbasis-text-test
+root-find-test
+implicitization-test
+#timing-test
+#rtree-performance-test
+)
+
+# Use this variable for GTest tests which should have a default main().
+SET(2GEOM_GTESTS_SRC
+affine-test
+angle-test
+bezier-test
+choose-test
+circle-test
+convex-hull-test
+coord-test
+ellipse-test
+elliptical-arc-test
+intersection-graph-test
+interval-test
+line-test
+nl-vector-test
+parallelogram-test
+path-test
+planar-graph-test
+point-test
+polynomial-test
+rect-test
+sbasis-test
+self-intersections-test
+)
+
+foreach(source ${2GEOM_GTESTS_SRC})
+	add_executable(${source} ${source}.cpp)
+	target_include_directories(${source} PRIVATE ${GSL_INCLUDE_DIRS} ${GTK3_INCLUDE_DIRS})
+	target_link_libraries(${source} 2geom GTest::Main ${GSL_LIBRARIES} ${GTK3_LIBRARIES})
+	add_test(NAME ${source} COMMAND ${source})
+endforeach()
+
+foreach(source ${2GEOM_TESTS_SRC})
+    add_executable(${source} ${source}.cpp)
+    target_include_directories(${source} PRIVATE ${GSL_INCLUDE_DIRS} ${GTK3_INCLUDE_DIRS})
+    target_link_libraries(${source} 2geom GTest::GTest ${GSL_LIBRARIES} ${GTK3_LIBRARIES})
+    add_test(NAME ${source} COMMAND ${source})
+endforeach(source)
+
+if(WIN32 AND 2GEOM_BUILD_SHARED)
+    add_custom_target(copy ALL COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_BINARY_DIR}/src/2geom/lib2geom.dll ${CMAKE_BINARY_DIR}/src/tests/lib2geom.dll)
+    add_dependencies(copy 2geom)
+endif()
diff --git a/tests/WontSnapToSomeCurveSegments.svg b/tests/WontSnapToSomeCurveSegments.svg
new file mode 100644
index 0000000..b7e8dfb
--- /dev/null
+++ b/tests/WontSnapToSomeCurveSegments.svg
@@ -0,0 +1,129 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="800"
+   height="400"
+   id="svg3975"
+   version="1.1"
+   inkscape:version="0.48+devel r10639 custom"
+   sodipodi:docname="825840-geom-bbox-nan-stroke-width-2.svg">
+  <defs
+     id="defs3977">
+    <marker
+       inkscape:stockid="Arrow2Lend"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="Arrow2Lend"
+       style="overflow:visible">
+      <path
+         id="path3915"
+         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
+         inkscape:connector-curvature="0" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow2Mend"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="Arrow2Mend"
+       style="overflow:visible">
+      <path
+         id="path3921"
+         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         transform="scale(-0.6,-0.6)"
+         inkscape:connector-curvature="0" />
+    </marker>
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="0.76013979"
+     inkscape:cx="406.66823"
+     inkscape:cy="300.66798"
+     inkscape:document-units="px"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     inkscape:window-width="1047"
+     inkscape:window-height="815"
+     inkscape:window-x="736"
+     inkscape:window-y="62"
+     inkscape:window-maximized="0"
+     borderlayer="false"
+     inkscape:showpageshadow="false"
+     inkscape:snap-center="false"
+     inkscape:snap-text-baseline="false"
+     inkscape:object-nodes="false"
+     inkscape:snap-midpoints="false"
+     inkscape:object-paths="true"
+     inkscape:snap-global="true"
+     showguides="true"
+     inkscape:guide-bbox="true"
+     inkscape:snap-intersection-paths="false"
+     inkscape:snap-others="false"
+     inkscape:snap-bbox="false"
+     inkscape:bbox-paths="false"
+     inkscape:bbox-nodes="false"
+     inkscape:snap-bbox-edge-midpoints="false"
+     inkscape:snap-bbox-midpoints="false"
+     inkscape:snap-smooth-nodes="false"
+     inkscape:snap-object-midpoints="false"
+     inkscape:snap-page="false">
+    <inkscape:grid
+       type="xygrid"
+       id="grid4495"
+       empspacing="2"
+       visible="true"
+       enabled="true"
+       snapvisiblegridlinesonly="true"
+       dotted="false"
+       color="#009862"
+       opacity="0.40392157"
+       empcolor="#ff0000"
+       empopacity="0.1254902"
+       spacingx="50px"
+       spacingy="50px" />
+  </sodipodi:namedview>
+  <metadata
+     id="metadata3980">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1">
+    <path
+       style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 262.6037,35.824151 c 0,0 -92.64892,-187.405851 30,-149.999981 104.06976,31.739531 170,109.9999815 170,109.9999815 l -10,-59.9999905 c 0,0 40,79.99999 -40,79.99999 -80,0 -70,-129.999981 -70,-129.999981 l 50,0 C 435.13571,-131.5667 652.76275,126.44872 505.74322,108.05672 358.73876,89.666591 292.6037,-14.175849 292.6037,15.824151 c 0,30 -30,20 -30,20 z"
+       id="path3132"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="csccsccssc" />
+  </g>
+  <g
+     inkscape:groupmode="layer"
+     id="layer2"
+     inkscape:label="illustrate" />
+</svg>
diff --git a/tests/affine-test.cpp b/tests/affine-test.cpp
new file mode 100644
index 0000000..2ddeb1d
--- /dev/null
+++ b/tests/affine-test.cpp
@@ -0,0 +1,429 @@
+/** @file
+ * @brief Unit tests for Affine
+ * Uses the Google Testing Framework
+ *//*
+ * Authors:
+ *   Krzysztof Kosiński <tweenk.pl@gmail.com>
+ * 
+ * Copyright 2010 Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include <gtest/gtest.h>
+#include <2geom/affine.h>
+#include <2geom/transforms.h>
+
+namespace Geom {
+
+TEST(AffineTest, Equality) {
+    Affine e; // identity
+    Affine a(1, 2, 3, 4, 5, 6);
+    EXPECT_EQ(e, e);
+    EXPECT_EQ(e, Geom::identity());
+    EXPECT_EQ(e, Geom::Affine::identity());
+    EXPECT_NE(e, a);
+}
+
+TEST(AffineTest, Classification) {
+    {
+        Affine a; // identity
+        EXPECT_TRUE(a.isIdentity());
+        EXPECT_TRUE(a.isTranslation());
+        EXPECT_TRUE(a.isScale());
+        EXPECT_TRUE(a.isUniformScale());
+        EXPECT_TRUE(a.isRotation());
+        EXPECT_TRUE(a.isHShear());
+        EXPECT_TRUE(a.isVShear());
+        EXPECT_TRUE(a.isZoom());
+        EXPECT_FALSE(a.isNonzeroTranslation());
+        EXPECT_FALSE(a.isNonzeroScale());
+        EXPECT_FALSE(a.isNonzeroUniformScale());
+        EXPECT_FALSE(a.isNonzeroRotation());
+        EXPECT_FALSE(a.isNonzeroNonpureRotation());
+        EXPECT_FALSE(a.isNonzeroHShear());
+        EXPECT_FALSE(a.isNonzeroVShear());
+        EXPECT_TRUE(a.preservesArea());
+        EXPECT_TRUE(a.preservesAngles());
+        EXPECT_TRUE(a.preservesDistances());
+        EXPECT_FALSE(a.flips());
+        EXPECT_FALSE(a.isSingular());
+    }
+    {
+        Affine a = Translate(10, 15); // pure translation
+        EXPECT_FALSE(a.isIdentity());
+        EXPECT_TRUE(a.isTranslation());
+        EXPECT_FALSE(a.isScale());
+        EXPECT_FALSE(a.isUniformScale());
+        EXPECT_FALSE(a.isRotation());
+        EXPECT_FALSE(a.isHShear());
+        EXPECT_FALSE(a.isVShear());
+        EXPECT_TRUE(a.isZoom());
+        EXPECT_TRUE(a.isNonzeroTranslation());
+        EXPECT_FALSE(a.isNonzeroScale());
+        EXPECT_FALSE(a.isNonzeroUniformScale());
+        EXPECT_FALSE(a.isNonzeroRotation());
+        EXPECT_FALSE(a.isNonzeroNonpureRotation());
+        EXPECT_FALSE(a.isNonzeroHShear());
+        EXPECT_FALSE(a.isNonzeroVShear());
+        EXPECT_TRUE(a.preservesArea());
+        EXPECT_TRUE(a.preservesAngles());
+        EXPECT_TRUE(a.preservesDistances());
+        EXPECT_FALSE(a.flips());
+        EXPECT_FALSE(a.isSingular());
+    }
+    {
+        Affine a = Scale(-1.0, 1.0); // flip on the X axis
+        EXPECT_FALSE(a.isIdentity());
+        EXPECT_FALSE(a.isTranslation());
+        EXPECT_TRUE(a.isScale());
+        EXPECT_TRUE(a.isUniformScale());
+        EXPECT_FALSE(a.isRotation());
+        EXPECT_FALSE(a.isHShear());
+        EXPECT_FALSE(a.isVShear());
+        EXPECT_FALSE(a.isZoom()); // zoom must be non-flipping
+        EXPECT_FALSE(a.isNonzeroTranslation());
+        EXPECT_TRUE(a.isNonzeroScale());
+        EXPECT_TRUE(a.isNonzeroUniformScale());
+        EXPECT_FALSE(a.isNonzeroRotation());
+        EXPECT_FALSE(a.isNonzeroNonpureRotation());
+        EXPECT_FALSE(a.isNonzeroHShear());
+        EXPECT_FALSE(a.isNonzeroVShear());
+        EXPECT_TRUE(a.preservesArea());
+        EXPECT_TRUE(a.preservesAngles());
+        EXPECT_TRUE(a.preservesDistances());
+        EXPECT_TRUE(a.flips());
+        EXPECT_FALSE(a.isSingular());
+    }
+    {
+        Affine a = Scale(0.5, 0.5); // pure uniform scale
+        EXPECT_FALSE(a.isIdentity());
+        EXPECT_FALSE(a.isTranslation());
+        EXPECT_TRUE(a.isScale());
+        EXPECT_TRUE(a.isUniformScale());
+        EXPECT_FALSE(a.isRotation());
+        EXPECT_FALSE(a.isHShear());
+        EXPECT_FALSE(a.isVShear());
+        EXPECT_TRUE(a.isZoom());
+        EXPECT_FALSE(a.isNonzeroTranslation());
+        EXPECT_TRUE(a.isNonzeroScale());
+        EXPECT_TRUE(a.isNonzeroUniformScale());
+        EXPECT_FALSE(a.isNonzeroRotation());
+        EXPECT_FALSE(a.isNonzeroNonpureRotation());
+        EXPECT_FALSE(a.isNonzeroHShear());
+        EXPECT_FALSE(a.isNonzeroVShear());
+        EXPECT_FALSE(a.preservesArea());
+        EXPECT_TRUE(a.preservesAngles());
+        EXPECT_FALSE(a.preservesDistances());
+        EXPECT_FALSE(a.flips());
+        EXPECT_FALSE(a.isSingular());
+    }
+    {
+        Affine a = Scale(0.5, -0.5); // pure uniform flipping scale
+        EXPECT_FALSE(a.isIdentity());
+        EXPECT_FALSE(a.isTranslation());
+        EXPECT_TRUE(a.isScale());
+        EXPECT_TRUE(a.isUniformScale());
+        EXPECT_FALSE(a.isRotation());
+        EXPECT_FALSE(a.isHShear());
+        EXPECT_FALSE(a.isVShear());
+        EXPECT_FALSE(a.isZoom()); // zoom must be non-flipping
+        EXPECT_FALSE(a.isNonzeroTranslation());
+        EXPECT_TRUE(a.isNonzeroScale());
+        EXPECT_TRUE(a.isNonzeroUniformScale());
+        EXPECT_FALSE(a.isNonzeroRotation());
+        EXPECT_FALSE(a.isNonzeroNonpureRotation());
+        EXPECT_FALSE(a.isNonzeroHShear());
+        EXPECT_FALSE(a.isNonzeroVShear());
+        EXPECT_FALSE(a.preservesArea());
+        EXPECT_TRUE(a.preservesAngles());
+        EXPECT_FALSE(a.preservesDistances());
+        EXPECT_TRUE(a.flips());
+        EXPECT_FALSE(a.isSingular());
+    }
+    {
+        Affine a = Scale(0.5, 0.7); // pure non-uniform scale
+        EXPECT_FALSE(a.isIdentity());
+        EXPECT_FALSE(a.isTranslation());
+        EXPECT_TRUE(a.isScale());
+        EXPECT_FALSE(a.isUniformScale());
+        EXPECT_FALSE(a.isRotation());
+        EXPECT_FALSE(a.isHShear());
+        EXPECT_FALSE(a.isVShear());
+        EXPECT_FALSE(a.isZoom());
+        EXPECT_FALSE(a.isNonzeroTranslation());
+        EXPECT_TRUE(a.isNonzeroScale());
+        EXPECT_FALSE(a.isNonzeroUniformScale());
+        EXPECT_FALSE(a.isNonzeroRotation());
+        EXPECT_FALSE(a.isNonzeroNonpureRotation());
+        EXPECT_FALSE(a.isNonzeroHShear());
+        EXPECT_FALSE(a.isNonzeroVShear());
+        EXPECT_FALSE(a.preservesArea());
+        EXPECT_FALSE(a.preservesAngles());
+        EXPECT_FALSE(a.preservesDistances());
+        EXPECT_FALSE(a.flips());
+        EXPECT_FALSE(a.isSingular());
+    }
+    {
+        Affine a = Scale(0.5, 2.0); // "squeeze" transform (non-uniform scale with det=1)
+        EXPECT_FALSE(a.isIdentity());
+        EXPECT_FALSE(a.isTranslation());
+        EXPECT_TRUE(a.isScale());
+        EXPECT_FALSE(a.isUniformScale());
+        EXPECT_FALSE(a.isRotation());
+        EXPECT_FALSE(a.isHShear());
+        EXPECT_FALSE(a.isVShear());
+        EXPECT_FALSE(a.isZoom());
+        EXPECT_FALSE(a.isNonzeroTranslation());
+        EXPECT_TRUE(a.isNonzeroScale());
+        EXPECT_FALSE(a.isNonzeroUniformScale());
+        EXPECT_FALSE(a.isNonzeroRotation());
+        EXPECT_FALSE(a.isNonzeroNonpureRotation());
+        EXPECT_FALSE(a.isNonzeroHShear());
+        EXPECT_FALSE(a.isNonzeroVShear());
+        EXPECT_TRUE(a.preservesArea());
+        EXPECT_FALSE(a.preservesAngles());
+        EXPECT_FALSE(a.preservesDistances());
+        EXPECT_FALSE(a.flips());
+        EXPECT_FALSE(a.isSingular());
+    }
+    {
+        Affine a = Rotate(0.7); // pure rotation
+        EXPECT_FALSE(a.isIdentity());
+        EXPECT_FALSE(a.isTranslation());
+        EXPECT_FALSE(a.isScale());
+        EXPECT_FALSE(a.isUniformScale());
+        EXPECT_TRUE(a.isRotation());
+        EXPECT_FALSE(a.isHShear());
+        EXPECT_FALSE(a.isVShear());
+        EXPECT_FALSE(a.isZoom());
+        EXPECT_FALSE(a.isNonzeroTranslation());
+        EXPECT_FALSE(a.isNonzeroScale());
+        EXPECT_FALSE(a.isNonzeroUniformScale());
+        EXPECT_TRUE(a.isNonzeroRotation());
+        EXPECT_TRUE(a.isNonzeroNonpureRotation());
+        EXPECT_EQ(a.rotationCenter(), Point(0.0,0.0));
+        EXPECT_FALSE(a.isNonzeroHShear());
+        EXPECT_FALSE(a.isNonzeroVShear());
+        EXPECT_TRUE(a.preservesArea());
+        EXPECT_TRUE(a.preservesAngles());
+        EXPECT_TRUE(a.preservesDistances());
+        EXPECT_FALSE(a.flips());
+        EXPECT_FALSE(a.isSingular());
+    }
+    {
+        Point rotation_center(1.23,4.56);
+        Affine a = Translate(-rotation_center) * Rotate(0.7) * Translate(rotation_center); // rotation around (1.23,4.56)
+        EXPECT_FALSE(a.isIdentity());
+        EXPECT_FALSE(a.isTranslation());
+        EXPECT_FALSE(a.isScale());
+        EXPECT_FALSE(a.isUniformScale());
+        EXPECT_FALSE(a.isRotation());
+        EXPECT_FALSE(a.isHShear());
+        EXPECT_FALSE(a.isVShear());
+        EXPECT_FALSE(a.isZoom());
+        EXPECT_FALSE(a.isNonzeroTranslation());
+        EXPECT_FALSE(a.isNonzeroScale());
+        EXPECT_FALSE(a.isNonzeroUniformScale());
+        EXPECT_FALSE(a.isNonzeroRotation());
+        EXPECT_TRUE(a.isNonzeroNonpureRotation());
+        EXPECT_TRUE(are_near(a.rotationCenter(), rotation_center, 1e-7));
+        EXPECT_FALSE(a.isNonzeroHShear());
+        EXPECT_FALSE(a.isNonzeroVShear());
+        EXPECT_TRUE(a.preservesArea());
+        EXPECT_TRUE(a.preservesAngles());
+        EXPECT_TRUE(a.preservesDistances());
+        EXPECT_FALSE(a.flips());
+        EXPECT_FALSE(a.isSingular());
+    }
+    {
+        Affine a = HShear(0.5); // pure horizontal shear
+        EXPECT_FALSE(a.isIdentity());
+        EXPECT_FALSE(a.isTranslation());
+        EXPECT_FALSE(a.isScale());
+        EXPECT_FALSE(a.isUniformScale());
+        EXPECT_FALSE(a.isRotation());
+        EXPECT_TRUE(a.isHShear());
+        EXPECT_FALSE(a.isVShear());
+        EXPECT_FALSE(a.isZoom());
+        EXPECT_FALSE(a.isNonzeroTranslation());
+        EXPECT_FALSE(a.isNonzeroScale());
+        EXPECT_FALSE(a.isNonzeroUniformScale());
+        EXPECT_FALSE(a.isNonzeroRotation());
+        EXPECT_FALSE(a.isNonzeroNonpureRotation());
+        EXPECT_TRUE(a.isNonzeroHShear());
+        EXPECT_FALSE(a.isNonzeroVShear());
+        EXPECT_TRUE(a.preservesArea());
+        EXPECT_FALSE(a.preservesAngles());
+        EXPECT_FALSE(a.preservesDistances());
+        EXPECT_FALSE(a.flips());
+        EXPECT_FALSE(a.isSingular());
+    }
+    {
+        Affine a = VShear(0.5); // pure vertical shear
+        EXPECT_FALSE(a.isIdentity());
+        EXPECT_FALSE(a.isTranslation());
+        EXPECT_FALSE(a.isScale());
+        EXPECT_FALSE(a.isUniformScale());
+        EXPECT_FALSE(a.isRotation());
+        EXPECT_FALSE(a.isHShear());
+        EXPECT_TRUE(a.isVShear());
+        EXPECT_FALSE(a.isZoom());
+        EXPECT_FALSE(a.isNonzeroTranslation());
+        EXPECT_FALSE(a.isNonzeroScale());
+        EXPECT_FALSE(a.isNonzeroUniformScale());
+        EXPECT_FALSE(a.isNonzeroRotation());
+        EXPECT_FALSE(a.isNonzeroNonpureRotation());
+        EXPECT_FALSE(a.isNonzeroHShear());
+        EXPECT_TRUE(a.isNonzeroVShear());
+        EXPECT_TRUE(a.preservesArea());
+        EXPECT_FALSE(a.preservesAngles());
+        EXPECT_FALSE(a.preservesDistances());
+        EXPECT_FALSE(a.flips());
+        EXPECT_FALSE(a.isSingular());
+    }
+    {
+        Affine a = Zoom(3.0, Translate(10, 15)); // zoom
+        EXPECT_FALSE(a.isIdentity());
+        EXPECT_FALSE(a.isTranslation());
+        EXPECT_FALSE(a.isScale());
+        EXPECT_FALSE(a.isUniformScale());
+        EXPECT_FALSE(a.isRotation());
+        EXPECT_FALSE(a.isHShear());
+        EXPECT_FALSE(a.isVShear());
+        EXPECT_TRUE(a.isZoom());
+        EXPECT_FALSE(a.isNonzeroTranslation());
+        EXPECT_FALSE(a.isNonzeroScale());
+        EXPECT_FALSE(a.isNonzeroUniformScale());
+        EXPECT_FALSE(a.isNonzeroRotation());
+        EXPECT_FALSE(a.isNonzeroNonpureRotation());
+        EXPECT_FALSE(a.isNonzeroHShear());
+        EXPECT_FALSE(a.isNonzeroVShear());
+        EXPECT_FALSE(a.preservesArea());
+        EXPECT_TRUE(a.preservesAngles());
+        EXPECT_FALSE(a.preservesDistances());
+        EXPECT_FALSE(a.flips());
+        EXPECT_FALSE(a.isSingular());
+        
+        EXPECT_TRUE(a.withoutTranslation().isUniformScale());
+        EXPECT_TRUE(a.withoutTranslation().isNonzeroUniformScale());
+    }
+    {
+        Affine a(0, 0, 0, 0, 0, 0); // zero matrix (singular)
+        EXPECT_FALSE(a.isIdentity());
+        EXPECT_FALSE(a.isTranslation());
+        EXPECT_FALSE(a.isScale());
+        EXPECT_FALSE(a.isUniformScale());
+        EXPECT_FALSE(a.isRotation());
+        EXPECT_FALSE(a.isHShear());
+        EXPECT_FALSE(a.isVShear());
+        EXPECT_FALSE(a.isZoom());
+        EXPECT_FALSE(a.isNonzeroTranslation());
+        EXPECT_FALSE(a.isNonzeroScale());
+        EXPECT_FALSE(a.isNonzeroUniformScale());
+        EXPECT_FALSE(a.isNonzeroRotation());
+        EXPECT_FALSE(a.isNonzeroNonpureRotation());
+        EXPECT_FALSE(a.isNonzeroHShear());
+        EXPECT_FALSE(a.isNonzeroVShear());
+        EXPECT_FALSE(a.preservesArea());
+        EXPECT_FALSE(a.preservesAngles());
+        EXPECT_FALSE(a.preservesDistances());
+        EXPECT_FALSE(a.flips());
+        EXPECT_TRUE(a.isSingular());
+    }
+    {
+        Affine a(0, 1, 0, 1, 10, 10); // another singular matrix
+        EXPECT_FALSE(a.isIdentity());
+        EXPECT_FALSE(a.isTranslation());
+        EXPECT_FALSE(a.isScale());
+        EXPECT_FALSE(a.isUniformScale());
+        EXPECT_FALSE(a.isRotation());
+        EXPECT_FALSE(a.isHShear());
+        EXPECT_FALSE(a.isVShear());
+        EXPECT_FALSE(a.isZoom());
+        EXPECT_FALSE(a.isNonzeroTranslation());
+        EXPECT_FALSE(a.isNonzeroScale());
+        EXPECT_FALSE(a.isNonzeroUniformScale());
+        EXPECT_FALSE(a.isNonzeroRotation());
+        EXPECT_FALSE(a.isNonzeroNonpureRotation());
+        EXPECT_FALSE(a.isNonzeroHShear());
+        EXPECT_FALSE(a.isNonzeroVShear());
+        EXPECT_FALSE(a.preservesArea());
+        EXPECT_FALSE(a.preservesAngles());
+        EXPECT_FALSE(a.preservesDistances());
+        EXPECT_FALSE(a.flips());
+        EXPECT_TRUE(a.isSingular());
+    }
+}
+
+TEST(AffineTest, Inversion) {
+    Affine i(1, 2, 1, -2, 10, 15); // invertible
+    Affine n(1, 2, 1, 2, 15, 30); // non-invertible
+    Affine e; // identity
+    EXPECT_EQ(i * i.inverse(), e);
+    EXPECT_EQ(i.inverse().inverse(), i);
+    EXPECT_EQ(n.inverse(), e);
+    EXPECT_EQ(e.inverse(), e);
+}
+
+TEST(AffineTest, CoordinateAccess) {
+    Affine a(0, 1, 2, 3, 4, 5);
+    for (int i=0; i<6; ++i) {
+        EXPECT_EQ(a[i], i);
+    }
+    for (int i=0; i<6; ++i) {
+        a[i] = 5*i;
+    }
+    for (int i=0; i<6; ++i) {
+        EXPECT_EQ(a[i], 5*i);
+    }
+}
+
+TEST(AffineTest, Nearness) {
+    Affine a1(1, 0, 1, 2, 1e-8, 1e-8);
+    Affine a2(1+1e-8, 0, 1, 2-1e-8, -1e-8, -1e-8);
+    EXPECT_TRUE(are_near(a1, a2, 1e-7));
+    EXPECT_FALSE(are_near(a1, a2, 1e-9));
+}
+
+TEST(AffineTest, Multiplication) {
+    // test whether noncommutative multiplications work correctly
+    Affine a1 = Scale(0.1), a2 = Translate(10, 10), a3 = Scale(10.0);
+    Affine t1 = Translate(1, 1), t100 = Translate(100, 100);
+    EXPECT_EQ(a1 * a2 * a3, t100);
+    EXPECT_EQ(a3 * a2 * a1, t1);
+}
+
+} // end namespace Geom
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/angle-test.cpp b/tests/angle-test.cpp
new file mode 100644
index 0000000..687be65
--- /dev/null
+++ b/tests/angle-test.cpp
@@ -0,0 +1,209 @@
+/** @file
+ * @brief Unit tests for Angle and AngleInterval.
+ * Uses the Google Testing Framework
+ *//*
+ * Authors:
+ *   Krzysztof Kosiński <tweenk.pl@gmail.com>
+ * 
+ * Copyright 2015 Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include <2geom/angle.h>
+#include <glib.h>
+#include "testing.h"
+
+using namespace Geom;
+
+TEST(AngleIntervalTest, InnerAngleConstrutor) {
+    std::vector<AngleInterval> ivs;
+
+    ivs.emplace_back(0, M_PI, true);
+    ivs.emplace_back(0, M_PI, false);
+    ivs.emplace_back(M_PI, 0, true);
+    ivs.emplace_back(M_PI, 0, false);
+    ivs.emplace_back(Angle(0), Angle(0), Angle(M_PI));
+
+    for (auto & iv : ivs) {
+        AngleInterval inner(iv.angleAt(0), iv.angleAt(0.5), iv.angleAt(1));
+        EXPECT_EQ(inner, iv);
+    }
+}
+
+TEST(AngleIntervalTest, Containment) {
+    AngleInterval a(0, M_PI, true);
+    AngleInterval b(0, M_PI, false);
+    AngleInterval c(M_PI, 0, true);
+    AngleInterval d(M_PI, 0, false);
+    AngleInterval e = AngleInterval::create_full(M_PI, true);
+
+    EXPECT_TRUE(a.contains(1.));
+    EXPECT_FALSE(a.contains(5.));
+    EXPECT_EQ(a.extent(), M_PI);
+
+    EXPECT_FALSE(b.contains(1.));
+    EXPECT_TRUE(b.contains(5.));
+    EXPECT_EQ(b.extent(), M_PI);
+
+    EXPECT_FALSE(c.contains(1.));
+    EXPECT_TRUE(c.contains(5.));
+    EXPECT_EQ(c.extent(), M_PI);
+
+    EXPECT_TRUE(d.contains(1.));
+    EXPECT_FALSE(d.contains(5.));
+    EXPECT_EQ(d.extent(), M_PI);
+
+    EXPECT_TRUE(e.contains(1.));
+    EXPECT_TRUE(e.contains(5.));
+    EXPECT_EQ(e.extent(), 2*M_PI);
+}
+
+TEST(AngleIntervalTest, TimeAtAngle) {
+    Coord pi32 = (3./2.)*M_PI;
+    AngleInterval a(M_PI, pi32, true);
+    AngleInterval b(pi32, M_PI, true);
+    AngleInterval c(M_PI, 0, false);
+    AngleInterval d(M_PI/2, M_PI, false);
+    AngleInterval e = AngleInterval::create_full(M_PI, true);
+    AngleInterval f = AngleInterval::create_full(M_PI, false);
+    Interval unit(0, 1);
+
+    EXPECT_EQ(a.timeAtAngle(M_PI), 0);
+    EXPECT_EQ(a.timeAtAngle(pi32), 1);
+    EXPECT_EQ(a.extent(), M_PI/2);
+    for (Coord t = -1; t <= 2; t += 0.125) {
+        Coord angle = lerp(t, M_PI, pi32);
+        Coord ti = a.timeAtAngle(angle);
+        EXPECT_EQ(unit.contains(ti), a.contains(angle));
+        EXPECT_FLOAT_EQ(ti, t);
+    }
+
+    EXPECT_EQ(b.timeAtAngle(pi32), 0);
+    EXPECT_EQ(b.timeAtAngle(M_PI), 1);
+    EXPECT_EQ(b.extent(), pi32);
+    EXPECT_FLOAT_EQ(b.timeAtAngle(M_PI/4), 0.5);
+    EXPECT_FLOAT_EQ(b.timeAtAngle(0), 1./3.);
+    EXPECT_FLOAT_EQ(b.timeAtAngle((11./8)*M_PI), -1./12);
+    for (Coord t = -0.125; t <= 1.125; t += 0.0625) {
+        Coord angle = lerp(t, pi32, 3*M_PI);
+        Coord ti = b.timeAtAngle(angle);
+        EXPECT_EQ(unit.contains(ti), b.contains(angle));
+        EXPECT_FLOAT_EQ(ti, t);
+    }
+
+    EXPECT_EQ(c.timeAtAngle(M_PI), 0);
+    EXPECT_EQ(c.timeAtAngle(0), 1);
+    EXPECT_EQ(c.extent(), M_PI);
+    EXPECT_FLOAT_EQ(c.timeAtAngle(M_PI/2), 0.5);
+    for (Coord t = -0.25; t <= 1.25; t += 0.125) {
+        Coord angle = lerp(t, M_PI, 0);
+        Coord ti = c.timeAtAngle(angle);
+        EXPECT_EQ(unit.contains(ti), c.contains(angle));
+        EXPECT_FLOAT_EQ(ti, t);
+    }
+
+    EXPECT_EQ(d.timeAtAngle(M_PI/2), 0);
+    EXPECT_EQ(d.timeAtAngle(M_PI), 1);
+    EXPECT_EQ(d.extent(), pi32);
+    EXPECT_FLOAT_EQ(d.timeAtAngle(-M_PI/4), 0.5);
+    for (Coord t = -0.125; t <= 1.125; t += 0.0625) {
+        Coord angle = lerp(t, M_PI/2, -M_PI);
+        Coord ti = d.timeAtAngle(angle);
+        EXPECT_EQ(unit.contains(ti), d.contains(angle));
+        EXPECT_FLOAT_EQ(ti, t);
+    }
+
+    EXPECT_EQ(e.timeAtAngle(M_PI), 0);
+    EXPECT_EQ(e.extent(), 2*M_PI);
+    EXPECT_FLOAT_EQ(e.timeAtAngle(0), 0.5);
+    for (Coord t = 0; t < 1; t += 0.125) {
+        Coord angle = lerp(t, M_PI, 3*M_PI);
+        Coord ti = e.timeAtAngle(angle);
+        EXPECT_EQ(unit.contains(ti), true);
+        EXPECT_EQ(e.contains(angle), true);
+        EXPECT_FLOAT_EQ(ti, t);
+    }
+
+    EXPECT_EQ(f.timeAtAngle(M_PI), 0);
+    EXPECT_EQ(f.extent(), 2*M_PI);
+    EXPECT_FLOAT_EQ(e.timeAtAngle(0), 0.5);
+    for (Coord t = 0; t < 1; t += 0.125) {
+        Coord angle = lerp(t, M_PI, -M_PI);
+        Coord ti = f.timeAtAngle(angle);
+        EXPECT_EQ(unit.contains(ti), true);
+        EXPECT_EQ(f.contains(angle), true);
+        EXPECT_FLOAT_EQ(ti, t);
+    }
+}
+
+TEST(AngleIntervalTest, AngleAt) {
+    Coord pi32 = (3./2.)*M_PI;
+    AngleInterval a(M_PI, pi32, true);
+    AngleInterval c(M_PI, 0, false);
+    AngleInterval f1 = AngleInterval::create_full(0, true);
+    AngleInterval f2 = AngleInterval::create_full(M_PI, false);
+
+    EXPECT_EQ(a.angleAt(0), M_PI);
+    EXPECT_EQ(a.angleAt(1), pi32);
+    EXPECT_EQ(a.extent(), M_PI/2);
+    for (Coord t = -1; t <= 2; t += 0.125) {
+        EXPECT_FLOAT_EQ(a.angleAt(t), Angle(lerp(t, M_PI, pi32)));
+    }
+
+    EXPECT_EQ(c.angleAt(0), M_PI);
+    EXPECT_EQ(c.angleAt(1), 0.);
+    EXPECT_EQ(c.extent(), M_PI);
+    for (Coord t = -0.25; t <= 1.25; t += 0.0625) {
+        EXPECT_FLOAT_EQ(c.angleAt(t), Angle(lerp(t, M_PI, 0)));
+    }
+
+    EXPECT_EQ(f1.angleAt(0), 0.);
+    EXPECT_EQ(f1.angleAt(1), 0.);
+    for (Coord t = 0; t < 1; t += 0.125) {
+        EXPECT_FLOAT_EQ(f1.angleAt(t), Angle(lerp(t, 0, 2*M_PI)));
+    }
+    EXPECT_EQ(f2.angleAt(0), M_PI);
+    EXPECT_EQ(f2.angleAt(1), M_PI);
+    for (Coord t = 0; t < 1; t += 0.125) {
+        EXPECT_FLOAT_EQ(f2.angleAt(t), Angle(lerp(t, M_PI, -M_PI)));
+    }
+}
+
+TEST(AngleIntervalTest, Extent) {
+     Coord pi32 = (3./2.)*M_PI;
+    AngleInterval a(M_PI, pi32, true);
+    AngleInterval b(pi32, M_PI, true);
+    AngleInterval c(M_PI, 0, false);
+    AngleInterval d(M_PI/2, M_PI, false);
+
+    EXPECT_EQ(a.extent(), M_PI/2);
+    EXPECT_EQ(a.sweepAngle(), M_PI/2);
+    EXPECT_EQ(b.extent(), pi32);
+    EXPECT_EQ(b.sweepAngle(), pi32);
+    EXPECT_EQ(c.extent(), M_PI);
+    EXPECT_EQ(c.sweepAngle(), -M_PI);
+    EXPECT_EQ(d.extent(), pi32);
+    EXPECT_EQ(d.sweepAngle(), -pi32);
+}
diff --git a/tests/bezier-sbasis-transforms.py b/tests/bezier-sbasis-transforms.py
new file mode 100644
index 0000000..1dc850f
--- /dev/null
+++ b/tests/bezier-sbasis-transforms.py
@@ -0,0 +1,72 @@
+#!/usr/bin/python
+
+from Numeric import *
+from LinearAlgebra import *
+
+pascals_triangle = []
+rows_done = 0
+
+def choose(n, k):
+    r = 1
+    for i in range(1,k+1):
+        r *= n-k+i
+        r /= i
+    return r
+
+# http://www.research.att.com/~njas/sequences/A109954
+def T(n, k):
+    return ((-1)**(n+k))*choose(n+k+2, 2*k+2)
+
+def inver(q):
+    result = zeros((q+2,q+2))
+    q2 = q/2+1
+    for i in range(q2):
+        for j in range(i+1):
+            val = T(i,j)
+            result[q/2-j][q/2-i] = val
+            result[q/2+j+2][q/2+i+2] = val
+            result[q/2+j+2][q/2-i-1] = -val
+            if q/2+i+3 < q+2:
+                result[q/2-j][q/2+i+3] = -val
+            
+    for i in range(q+2):
+        result[q2][i] = [1,-1][(i-q2)%2]
+    return result
+        
+def simple(q):
+    result = zeros((q+2,q+2))
+    for i in range(q/2+1):
+        for j in range(q+1):
+            result[j][i] = choose(q-2*i, j-i)
+            result[j+1][q-i+1] = choose(q-2*i, j-i)
+    result[q/2+1][q/2+1] = 1
+    return result
+
+print "The aim of the game is to work out the correct indexing to make the two matrices match :)"
+
+s = simple(4)
+si = floor(inverse(s)+0.5)
+print si.astype(Int)
+print inver(4)
+exit(0)
+print "<html><head><title></title></head><body>"
+
+def arrayhtml(a):
+    s = "<table>"
+    r,c = a.shape
+    for i in range(r):
+        s += "<tr>";
+        for j in range(c):
+            s += "<td>%g</td>" % a[i,j]
+        s += "</tr>"
+    s += "</table>"
+    return s
+
+for i in [21]:#range(1,13,2):
+    s = simple(i)
+    print "<h1>T<sup>-1</sup> = </h1>"
+    print arrayhtml(s)
+    print "<h1>T = </h1>"
+    print arrayhtml(floor(inverse(s)+0.5))
+
+print "</body></html>"
diff --git a/tests/bezier-test.cpp b/tests/bezier-test.cpp
new file mode 100644
index 0000000..0799393
--- /dev/null
+++ b/tests/bezier-test.cpp
@@ -0,0 +1,680 @@
+/** @file
+ * @brief Unit tests for Affine.
+ * Uses the Google Testing Framework
+ *//*
+ * Authors:
+ *   Nathan Hurst <njh@njhurst.com>
+ *   Krzysztof Kosiński <tweenk.pl@gmail.com>
+ *   Johan Engelen <j.b.c.engelen@alumnus.utwente.nl>
+ *
+ * Copyright 2010 Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include "testing.h"
+#include <iostream>
+
+#include <2geom/bezier.h>
+#include <2geom/polynomial.h>
+#include <2geom/basic-intersection.h>
+#include <2geom/bezier-curve.h>
+#include <vector>
+#include <iterator>
+#include <glib.h>
+
+using std::vector, std::min, std::max;
+using namespace Geom;
+
+Poly lin_poly(double a, double b) { // ax + b
+    Poly p;
+    p.push_back(b);
+    p.push_back(a);
+    return p;
+}
+
+bool are_equal(Bezier A, Bezier B) {
+    int maxSize = max(A.size(), B.size());
+    double t = 0., dt = 1./maxSize;
+
+    for(int i = 0; i <= maxSize; i++) {
+        EXPECT_FLOAT_EQ(A.valueAt(t), B.valueAt(t));// return false;
+        t += dt;
+    }
+    return true;
+}
+
+class BezierTest : public ::testing::Test {
+protected:
+
+    BezierTest()
+        : zero(fragments[0])
+        , unit(fragments[1])
+        , hump(fragments[2])
+        , wiggle(fragments[3])
+    {
+        zero = Bezier(0.0,0.0);
+        unit = Bezier(0.0,1.0);
+        hump = Bezier(0,1,0);
+        wiggle = Bezier(0,1,-2,3);
+    }
+
+    Bezier fragments[4];
+    Bezier &zero, &unit, &hump, &wiggle;
+};
+
+TEST_F(BezierTest, Basics) {
+
+    //std::cout << unit <<std::endl;
+    //std::cout << hump <<std::endl;
+
+    EXPECT_TRUE(Bezier(0,0,0,0).isZero());
+    EXPECT_TRUE(Bezier(0,1,2,3).isFinite());
+
+    EXPECT_EQ(3u, Bezier(0,2,4,5).order());
+
+    ///cout << " Bezier::Bezier(const Bezier& b);\n";
+    //cout << Bezier(wiggle) << " == " << wiggle << endl;
+
+    //cout << "explicit Bezier(unsigned ord);\n";
+    //cout << Bezier(10) << endl;
+
+    //cout << "Bezier(Coord c0, Coord c1);\n";
+    //cout << Bezier(0.0,1.0) << endl;
+
+    //cout << "Bezier(Coord c0, Coord c1, Coord c2);\n";
+    //cout << Bezier(0,1, 2) << endl;
+
+    //cout << "Bezier(Coord c0, Coord c1, Coord c2, Coord c3);\n";
+    //cout << Bezier(0,1,2,3) << endl;
+
+    //cout << "unsigned degree();\n";
+    EXPECT_EQ(2u, hump.degree());
+
+    //cout << "unsigned size();\n";
+    EXPECT_EQ(3u, hump.size());
+}
+
+TEST_F(BezierTest, ValueAt) {
+    EXPECT_EQ(0.0, wiggle.at0());
+    EXPECT_EQ(3.0, wiggle.at1());
+
+    EXPECT_EQ(0.0, wiggle.valueAt(0.5));
+
+    EXPECT_EQ(0.0, wiggle(0.5));
+
+    //cout << "SBasis toSBasis();\n";
+    //cout << unit.toSBasis() << endl;
+    //cout << hump.toSBasis() << endl;
+    //cout << wiggle.toSBasis() << endl;
+}
+
+TEST_F(BezierTest, Casteljau) {
+    unsigned N = wiggle.order() + 1;
+    std::vector<Coord> left(N), right(N);
+    std::vector<Coord> left2(N), right2(N);
+    double eps = 1e-15;
+
+    for (unsigned i = 0; i < 10000; ++i) {
+        double t = g_random_double_range(0, 1);
+        double vok = bernstein_value_at(t, &wiggle[0], wiggle.order());
+        double v = casteljau_subdivision<double>(t, &wiggle[0], &left[0], &right[0], wiggle.order());
+        EXPECT_near(v, vok, eps);
+        EXPECT_EQ(left[0], wiggle.at0());
+        EXPECT_EQ(left[wiggle.order()], right[0]);
+        EXPECT_EQ(right[wiggle.order()], wiggle.at1());
+
+        double vl = casteljau_subdivision<double>(t, &wiggle[0], &left2[0], NULL, wiggle.order());
+        double vr = casteljau_subdivision<double>(t, &wiggle[0], NULL, &right2[0], wiggle.order());
+        EXPECT_EQ(vl, vok);
+        EXPECT_near(vr, vok, eps);
+        EXPECT_vector_near(left2, left, eps);
+        EXPECT_vector_equal(right2, right);
+
+        double vnone = casteljau_subdivision<double>(t, &wiggle[0], NULL, NULL, wiggle.order());
+        EXPECT_near(vnone, vok, 1e-12);
+    }
+}
+
+TEST_F(BezierTest, Portion) {
+    constexpr Coord eps{1e-12};
+
+    for (unsigned i = 0; i < 10000; ++i) {
+        double from = g_random_double_range(0, 1);
+        double to = g_random_double_range(0, 1);
+        for (auto & input : fragments) {
+            Bezier result = portion(input, from, to);
+
+            // the endpoints must correspond exactly
+            EXPECT_near(result.at0(), input.valueAt(from), eps);
+            EXPECT_near(result.at1(), input.valueAt(to), eps);
+        }
+    }
+}
+
+TEST_F(BezierTest, Subdivide) {
+    std::vector<std::pair<Bezier, double> > errors;
+    for (unsigned i = 0; i < 10000; ++i) {
+        double t = g_random_double_range(0, 1e-6);
+        for (auto & input : fragments) {
+            std::pair<Bezier, Bezier> result = input.subdivide(t);
+
+            // the endpoints must correspond exactly
+            // moreover, the subdivision point must be exactly equal to valueAt(t)
+            EXPECT_DOUBLE_EQ(result.first.at0(), input.at0());
+            EXPECT_DOUBLE_EQ(result.first.at1(), result.second.at0());
+            EXPECT_DOUBLE_EQ(result.second.at0(), input.valueAt(t));
+            EXPECT_DOUBLE_EQ(result.second.at1(), input.at1());
+
+            // ditto for valueAt
+            EXPECT_DOUBLE_EQ(result.first.valueAt(0), input.valueAt(0));
+            EXPECT_DOUBLE_EQ(result.first.valueAt(1), result.second.valueAt(0));
+            EXPECT_DOUBLE_EQ(result.second.valueAt(0), input.valueAt(t));
+            EXPECT_DOUBLE_EQ(result.second.valueAt(1), input.valueAt(1));
+
+            if (result.first.at1() != result.second.at0()) {
+                errors.emplace_back(input, t);
+            }
+        }
+    }
+    if (!errors.empty()) {
+        std::cout << "Found " << errors.size() << " subdivision errors" << std::endl;
+        for (unsigned i = 0; i < errors.size(); ++i) {
+            std::cout << "Error #" << i << ":\n"
+                          << errors[i].first << "\n"
+                          << "t: " << format_coord_nice(errors[i].second) << std::endl;
+        }
+    }
+}
+
+TEST_F(BezierTest, Mutation) {
+//Coord &operator[](unsigned ix);
+//Coord const &operator[](unsigned ix);
+//void setCoeff(unsigned ix double val);
+    //cout << "bigun\n";
+    Bezier bigun(Bezier::Order(30));
+    bigun.setCoeff(5,10.0);
+    for(unsigned i = 0; i < bigun.size(); i++) {
+        EXPECT_EQ((i == 5) ? 10 : 0, bigun[i]);
+    }
+
+    bigun[5] = -3;
+    for(unsigned i = 0; i < bigun.size(); i++) {
+        EXPECT_EQ((i == 5) ? -3 : 0, bigun[i]);
+    }
+}
+
+TEST_F(BezierTest, MultiDerivative) {
+    vector<double> vnd = wiggle.valueAndDerivatives(0.5, 5);
+    expect_array((const double[]){0,0,12,72,0,0}, vnd);
+}
+
+TEST_F(BezierTest, DegreeElevation) {
+    EXPECT_TRUE(are_equal(wiggle, wiggle));
+    Bezier Q = wiggle;
+    Bezier P = Q.elevate_degree();
+    EXPECT_EQ(P.size(), Q.size()+1);
+    //EXPECT_EQ(0, P.forward_difference(1)[0]);
+    EXPECT_TRUE(are_equal(Q, P));
+    Q = wiggle;
+    P = Q.elevate_to_degree(10);
+    EXPECT_EQ(10u, P.order());
+    EXPECT_TRUE(are_equal(Q, P));
+    //EXPECT_EQ(0, P.forward_difference(10)[0]);
+    /*Q = wiggle.elevate_degree();
+    P = Q.reduce_degree();
+    EXPECT_EQ(P.size()+1, Q.size());
+    EXPECT_TRUE(are_equal(Q, P));*/
+}
+//std::pair<Bezier, Bezier > subdivide(Coord t);
+
+// Constructs a linear Bezier with root at t
+Bezier linear_root(double t) {
+    return Bezier(0-t, 1-t);
+}
+
+// Constructs a Bezier with roots at the locations in x
+Bezier array_roots(vector<double> x) {
+    Bezier b(1);
+    for(double i : x) {
+        b = multiply(b, linear_root(i));
+    }
+    return b;
+}
+
+TEST_F(BezierTest, Deflate) {
+    Bezier b = array_roots(vector_from_array((const double[]){0,0.25,0.5}));
+    EXPECT_FLOAT_EQ(0, b.at0());
+    b = b.deflate();
+    EXPECT_FLOAT_EQ(0, b.valueAt(0.25));
+    b = b.subdivide(0.25).second;
+    EXPECT_FLOAT_EQ(0, b.at0());
+    b = b.deflate();
+    const double rootposition = (0.5-0.25) / (1-0.25);
+    constexpr Coord eps{1e-12};
+    EXPECT_near(0.0, b.valueAt(rootposition), eps);
+    b = b.subdivide(rootposition).second;
+    EXPECT_near(0.0, b.at0(), eps);
+}
+
+TEST_F(BezierTest, Roots) {
+    expect_array((const double[]){0, 0.5, 0.5}, wiggle.roots());
+
+    /*Bezier bigun(Bezier::Order(30));
+    for(unsigned i = 0; i < bigun.size(); i++) {
+        bigun.setCoeff(i,rand()-0.5);
+    }
+    cout << bigun.roots() << endl;*/
+
+    // The results of our rootfinding are at the moment fairly inaccurate.
+    double eps = 5e-4;
+
+    vector<vector<double> > tests;
+    tests.push_back(vector_from_array((const double[]){0}));
+    tests.push_back(vector_from_array((const double[]){1}));
+    tests.push_back(vector_from_array((const double[]){0, 0}));
+    tests.push_back(vector_from_array((const double[]){0.5}));
+    tests.push_back(vector_from_array((const double[]){0.5, 0.5}));
+    tests.push_back(vector_from_array((const double[]){0.1, 0.1}));
+    tests.push_back(vector_from_array((const double[]){0.1, 0.1, 0.1}));
+    tests.push_back(vector_from_array((const double[]){0.25,0.75}));
+    tests.push_back(vector_from_array((const double[]){0.5,0.5}));
+    tests.push_back(vector_from_array((const double[]){0, 0.2, 0.6, 0.6, 1}));
+    tests.push_back(vector_from_array((const double[]){.1,.2,.3,.4,.5,.6}));
+    tests.push_back(vector_from_array((const double[]){0.25,0.25,0.25,0.75,0.75,0.75}));
+
+    for(auto & test : tests) {
+        Bezier b = array_roots(test);
+        //std::cout << tests[test_i] << ": " << b << std::endl;
+        //std::cout << b.roots() << std::endl;
+        EXPECT_vector_near(test, b.roots(), eps);
+    }
+}
+
+TEST_F(BezierTest, BoundsExact) {
+    OptInterval unit_bounds = bounds_exact(unit);
+    EXPECT_EQ(unit_bounds->min(), 0);
+    EXPECT_EQ(unit_bounds->max(), 1);
+
+    OptInterval hump_bounds = bounds_exact(hump);
+    EXPECT_EQ(hump_bounds->min(), 0);
+    EXPECT_FLOAT_EQ(hump_bounds->max(), hump.valueAt(0.5));
+
+    OptInterval wiggle_bounds = bounds_exact(wiggle);
+    EXPECT_EQ(wiggle_bounds->min(), 0);
+    EXPECT_EQ(wiggle_bounds->max(), 3);
+}
+
+TEST_F(BezierTest, Operators) {
+    // Test equality operators
+    EXPECT_EQ(zero, zero);
+    EXPECT_EQ(hump, hump);
+    EXPECT_EQ(wiggle, wiggle);
+    EXPECT_EQ(unit, unit);
+
+    EXPECT_NE(zero, hump);
+    EXPECT_NE(hump, zero);
+    EXPECT_NE(wiggle, hump);
+    EXPECT_NE(zero, wiggle);
+    EXPECT_NE(wiggle, unit);
+
+    // Recall that hump == Bezier(0,1,0);
+    EXPECT_EQ(hump + 3, Bezier(3, 4, 3));
+    EXPECT_EQ(hump - 3, Bezier(-3, -2, -3));
+    EXPECT_EQ(hump * 3, Bezier(0, 3, 0));
+    EXPECT_EQ(hump / 3, Bezier(0, 1.0/3.0, 0));
+    EXPECT_EQ(-hump, Bezier(0, -1, 0));
+
+    Bezier reverse_wiggle = reverse(wiggle);
+    EXPECT_EQ(reverse_wiggle.at0(), wiggle.at1());
+    EXPECT_EQ(reverse_wiggle.at1(), wiggle.at0());
+    EXPECT_TRUE(are_equal(reverse(reverse_wiggle), wiggle));
+
+    //cout << "Bezier portion(const Bezier & a, double from, double to);\n";
+    //cout << portion(Bezier(0.0,2.0), 0.5, 1) << endl;
+
+// std::vector<Point> bezier_points(const D2<Bezier > & a) {
+
+    /*cout << "Bezier derivative(const Bezier & a);\n";
+    std::cout << derivative(hump) <<std::endl;
+    std::cout << integral(hump) <<std::endl;*/
+
+    EXPECT_TRUE(are_equal(derivative(integral(wiggle)), wiggle));
+    //std::cout << derivative(integral(hump)) <<std::endl;
+    expect_array((const double []){0.5}, derivative(hump).roots());
+
+    EXPECT_TRUE(bounds_fast(hump)->contains(Interval(0,hump.valueAt(0.5))));
+
+    EXPECT_EQ(Interval(0,hump.valueAt(0.5)), *bounds_exact(hump));
+
+    Interval tight_local_bounds(min(hump.valueAt(0.3),hump.valueAt(0.6)),
+             hump.valueAt(0.5));
+    EXPECT_TRUE(bounds_local(hump, Interval(0.3, 0.6))->contains(tight_local_bounds));
+
+    Bezier Bs[] = {unit, hump, wiggle};
+    for(auto B : Bs) {
+        Bezier product = multiply(B, B);
+        for(int i = 0; i <= 16; i++) {
+            double t = i/16.0;
+            double b = B.valueAt(t);
+            EXPECT_near(b*b, product.valueAt(t), 1e-12);
+        }
+    }
+}
+
+struct XPt {
+    XPt(Coord x, Coord y, Coord ta, Coord tb)
+        : p(x, y), ta(ta), tb(tb)
+    {}
+    XPt() {}
+    Point p;
+    Coord ta, tb;
+};
+
+struct XTest {
+    D2<Bezier> a;
+    D2<Bezier> b;
+    std::vector<XPt> s;
+};
+
+struct CILess {
+    bool operator()(CurveIntersection const &a, CurveIntersection const &b) const {
+        if (a.first < b.first) return true;
+        if (a.first == b.first && a.second < b.second) return true;
+        return false;
+    }
+};
+
+TEST_F(BezierTest, Intersection) {
+    /* Intersection test cases taken from:
+     * Dieter Lasser (1988), Calculating the Self-Intersections of Bezier Curves
+     * https://archive.org/stream/calculatingselfi00lass
+     *
+     * The intersection points are not actually calculated to a high precision
+     * in the paper. The most relevant tests are whether the curves actually
+     * intersect at the returned time values (i.e. whether a(ta) = b(tb))
+     * and whether the number of intersections is correct.
+     */
+    typedef D2<Bezier> D2Bez;
+    std::vector<XTest> tests;
+
+    // Example 1
+    tests.emplace_back();
+    tests.back().a = D2Bez(Bezier(-3.3, -3.3, 0, 3.3, 3.3), Bezier(1.3, -0.7, 2.3, -0.7, 1.3));
+    tests.back().b = D2Bez(Bezier(-4.0, -4.0, 0, 4.0, 4.0), Bezier(-0.35, 3.0, -2.6, 3.0, -0.35));
+    tests.back().s.resize(4);
+    tests.back().s[0] = XPt(-3.12109, 0.76362, 0.09834, 0.20604);
+    tests.back().s[1] = XPt(-1.67341, 0.60298, 0.32366, 0.35662);
+    tests.back().s[2] = XPt(1.67341, 0.60298, 0.67634, 0.64338);
+    tests.back().s[3] = XPt(3.12109, 0.76362, 0.90166, 0.79396);
+
+    // Example 2
+    tests.emplace_back();
+    tests.back().a = D2Bez(Bezier(0, 0, 3, 3), Bezier(0, 14, -9, 5));
+    tests.back().b = D2Bez(Bezier(-1, 13, -10, 4), Bezier(4, 4, 1, 1));
+    tests.back().s.resize(9);
+    tests.back().s[0] = XPt(0.00809, 1.17249, 0.03029, 0.85430);
+    tests.back().s[1] = XPt(0.02596, 1.97778, 0.05471, 0.61825);
+    tests.back().s[2] = XPt(0.17250, 3.99191, 0.14570, 0.03029);
+    tests.back().s[3] = XPt(0.97778, 3.97404, 0.38175, 0.05471);
+    tests.back().s[4] = XPt(1.5, 2.5, 0.5, 0.5);
+    tests.back().s[5] = XPt(2.02221, 1.02596, 0.61825, 0.94529);
+    tests.back().s[6] = XPt(2.82750, 1.00809, 0.85430, 0.96971);
+    tests.back().s[7] = XPt(2.97404, 3.02221, 0.94529, 0.38175);
+    tests.back().s[8] = XPt(2.99191, 3.82750, 0.96971, 0.14570);
+
+    // Example 3
+    tests.emplace_back();
+    tests.back().a = D2Bez(Bezier(-5, -5, -3, 0, 3, 5, 5), Bezier(0, 3.555, -1, 4.17, -1, 3.555, 0));
+    tests.back().b = D2Bez(Bezier(-6, -6, -3, 0, 3, 6, 6), Bezier(3, -0.555, 4, -1.17, 4, -0.555, 3));
+    tests.back().s.resize(6);
+    tests.back().s[0] = XPt(-3.64353, 1.49822, 0.23120, 0.27305);
+    tests.back().s[1] = XPt(-2.92393, 1.50086, 0.29330, 0.32148);
+    tests.back().s[2] = XPt(-0.77325, 1.49989, 0.44827, 0.45409);
+    tests.back().s[3] = XPt(0.77325, 1.49989, 0.55173, 0.54591);
+    tests.back().s[4] = XPt(2.92393, 1.50086, 0.70670, 0.67852);
+    tests.back().s[5] = XPt(3.64353, 1.49822, 0.76880, 0.72695);
+
+    // Example 4
+    tests.emplace_back();
+    tests.back().a = D2Bez(Bezier(-4, -10, -2, -2, 2, 2, 10, 4), Bezier(0, 6, 6, 0, 0, 6, 6, 0));
+    tests.back().b = D2Bez(Bezier(-8, 0, 8), Bezier(1, 6, 1));
+    tests.back().s.resize(4);
+    tests.back().s[0] = XPt(-5.69310, 2.23393, 0.06613, 0.14418);
+    tests.back().s[1] = XPt(-2.68113, 3.21920, 0.35152, 0.33243);
+    tests.back().s[2] = XPt(2.68113, 3.21920, 0.64848, 0.66757);
+    tests.back().s[3] = XPt(5.69310, 2.23393, 0.93387, 0.85582);
+
+    //std::cout << std::setprecision(5);
+
+    for (unsigned i = 0; i < tests.size(); ++i) {
+        BezierCurve a(tests[i].a), b(tests[i].b);
+        std::vector<CurveIntersection> xs;
+        xs = a.intersect(b, 1e-8);
+        std::sort(xs.begin(), xs.end(), CILess());
+        //xs.erase(std::unique(xs.begin(), xs.end(), XEqual()), xs.end());
+
+        std::cout << "\n\n"
+                  << "===============================\n"
+                  << "=== Intersection Testcase " << i+1 << " ===\n"
+                  << "===============================\n" << std::endl;
+
+        EXPECT_EQ(xs.size(), tests[i].s.size());
+        //if (xs.size() != tests[i].s.size()) continue;
+
+        for (unsigned j = 0; j < std::min(xs.size(), tests[i].s.size()); ++j) {
+            std::cout << xs[j].first << " = " << a.pointAt(xs[j].first) << "   "
+                      << xs[j].second << " = " << b.pointAt(xs[j].second) << "\n"
+                      << tests[i].s[j].ta << " = " << tests[i].a.valueAt(tests[i].s[j].ta) << "   "
+                      << tests[i].s[j].tb << " = " << tests[i].b.valueAt(tests[i].s[j].tb) << std::endl;
+        }
+
+        EXPECT_intersections_valid(a, b, xs, 1e-6);
+    }
+
+    #if 0
+    // these contain second-order intersections
+    Coord a5x[] = {-1.5, -1.5, -10, -10, 0, 10, 10, 1.5, 1.5};
+    Coord a5y[] = {0, -8, -8, 9, 9, 9, -8, -8, 0};
+    Coord b5x[] = {-3, -12, 0, 12, 3};
+    Coord b5y[] = {-5, 8, 2.062507, 8, -5};
+    Coord p5x[] = {-3.60359, -5.44653, 0, 5.44653, 3.60359};
+    Coord p5y[] = {-4.10631, -0.76332, 4.14844, -0.76332, -4.10631};
+    Coord p5ta[] = {0.01787, 0.10171, 0.5, 0.89829, 0.98213};
+    Coord p5tb[] = {0.12443, 0.28110, 0.5, 0.71890, 0.87557};
+
+    Coord a6x[] = {5, 14, 10, -12, -12, -2};
+    Coord a6y[] = {1, 6, -6, -6, 2, 2};
+    Coord b6x[] = {0, 2, -10.5, -10.5, 3.5, 3, 8, 6};
+    Coord b6y[] = {0, -8, -8, 9, 9, -4.129807, -4.129807, 3};
+    Coord p6x[] = {6.29966, 5.87601, 0.04246, -4.67397, -3.57214};
+    Coord p6y[] = {1.63288, -0.86192, -2.38219, -2.17973, 1.91463};
+    Coord p6ta[] = {0.03184, 0.33990, 0.49353, 0.62148, 0.96618};
+    Coord p6tb[] = {0.96977, 0.85797, 0.05087, 0.28232, 0.46102};
+    #endif
+}
+
+/** Basic test for intersecting a quadratic Bézier with a line segment. */
+TEST_F(BezierTest, QuadraticIntersectLineSeg)
+{
+    double const EPS = 1e-12;
+    auto const bow = QuadraticBezier({0, 0}, {1, 1}, {2, 0});
+    auto const highhoriz  = LineSegment(Point(0, 0), Point(2, 0));
+    auto const midhoriz   = LineSegment(Point(0, 0.25), Point(2, 0.25));
+    auto const lowhoriz   = LineSegment(Point(0, 0.5), Point(2, 0.5));
+    auto const noninters  = LineSegment(Point(0, 0.5 + EPS), Point(2, 0.5 + EPS));
+    auto const noninters2 = LineSegment(Point(1, 0), Point(1, 0.5 - EPS));
+
+    auto const endpoint_intersections = bow.intersect(highhoriz, EPS);
+    EXPECT_EQ(endpoint_intersections.size(), 2);
+    EXPECT_intersections_valid(bow, highhoriz, endpoint_intersections, EPS);
+    for (auto const &ex : endpoint_intersections) {
+        EXPECT_DOUBLE_EQ(ex.point()[Y], 0.0);
+    }
+
+    auto const mid_intersections = bow.intersect(midhoriz, EPS);
+    EXPECT_EQ(mid_intersections.size(), 2);
+    EXPECT_intersections_valid(bow, midhoriz, mid_intersections, EPS);
+    for (auto const &mx : mid_intersections) {
+        EXPECT_DOUBLE_EQ(mx.point()[Y], 0.25);
+    }
+
+    auto const tangent_intersection = bow.intersect(lowhoriz, EPS);
+    EXPECT_EQ(tangent_intersection.size(), 1);
+    EXPECT_intersections_valid(bow, lowhoriz, tangent_intersection, EPS);
+    for (auto const &tx : tangent_intersection) {
+        EXPECT_DOUBLE_EQ(tx.point()[Y], 0.5);
+    }
+
+    auto no_intersections = bow.intersect(noninters, EPS);
+    EXPECT_TRUE(no_intersections.empty());
+
+    no_intersections = bow.intersect(noninters2, EPS);
+    EXPECT_TRUE(no_intersections.empty());
+}
+
+TEST_F(BezierTest, QuadraticIntersectLineRandom)
+{
+    g_random_set_seed(0xB747A380);
+    auto const diagonal = LineSegment(Point(0, 0), Point(1, 1));
+    double const EPS = 1e-12;
+
+    for (unsigned i = 0; i < 10'000; i++) {
+        auto q = QuadraticBezier({0, 1}, {g_random_double_range(0.0, 1.0), g_random_double_range(0.0, 1.0)}, {1, 0});
+        auto xings = q.intersect(diagonal, EPS);
+        ASSERT_EQ(xings.size(), 1);
+        auto pt = xings[0].point();
+        EXPECT_TRUE(are_near(pt[X], pt[Y], EPS));
+        EXPECT_intersections_valid(q, diagonal, xings, EPS);
+    }
+}
+
+/** Basic test for intersecting a cubic Bézier with a line segment. */
+TEST_F(BezierTest, CubicIntersectLine)
+{
+    double const EPS = 1e-12;
+    auto const wavelet = CubicBezier({0, 0}, {1, 2}, {0, -2}, {1, 0});
+
+    auto const unit_seg = LineSegment(Point(0, 0), Point(1, 0));
+    auto const expect3 = wavelet.intersect(unit_seg, EPS);
+    EXPECT_EQ(expect3.size(), 3);
+    EXPECT_intersections_valid(wavelet, unit_seg, expect3, EPS);
+
+    auto const half_seg = LineSegment(Point(0, 0), Point(0.5, 0));
+    auto const expect2 = wavelet.intersect(half_seg, EPS);
+    EXPECT_EQ(expect2.size(), 2);
+    EXPECT_intersections_valid(wavelet, half_seg, expect2, EPS);
+
+    auto const less_than_half = LineSegment(Point(0, 0), Point(0.5 - EPS, 0));
+    auto const expect1 = wavelet.intersect(less_than_half, EPS);
+    EXPECT_EQ(expect1.size(), 1);
+    EXPECT_intersections_valid(wavelet, less_than_half, expect1, EPS);
+
+    auto const dollar_stroke = LineSegment(Point(0, 0.5), Point(1, -0.5));
+    auto const dollar_xings = wavelet.intersect(dollar_stroke, EPS);
+    EXPECT_EQ(dollar_xings.size(), 3);
+    EXPECT_intersections_valid(wavelet, dollar_stroke, dollar_xings, EPS);
+}
+
+TEST_F(BezierTest, CubicIntersectLineRandom)
+{
+    g_random_set_seed(0xCAFECAFE);
+    auto const diagonal = LineSegment(Point(0, 0), Point(1, 1));
+    double const EPS = 1e-8;
+
+    for (unsigned i = 0; i < 10'000; i++) {
+        double a1 = g_random_double_range(0.0, 1.0);
+        double a2 = g_random_double_range(a1, 1.0);
+        double b1 = g_random_double_range(0.0, 1.0);
+        double b2 = g_random_double_range(0.0, b1);
+
+        auto c = CubicBezier({0, 1}, {a1, a2}, {b1, b2}, {1, 0});
+        auto xings = c.intersect(diagonal, EPS);
+        ASSERT_EQ(xings.size(), 1);
+        auto pt = xings[0].point();
+        EXPECT_TRUE(are_near(pt[X], pt[Y], EPS));
+        EXPECT_intersections_valid(c, diagonal, xings, EPS);
+    }
+}
+
+/** Regression test for issue https://gitlab.com/inkscape/lib2geom/-/issues/47 . */
+TEST_F(BezierTest, Balloon)
+{
+    auto const loop = CubicBezier({0, 0}, {4, -2}, {4, 2}, {0, 0});
+    auto const seghoriz = LineSegment(Point(-1, 0), Point(0, 0));
+
+    for (double EPS : {1e-6, 1e-9, 1e-12}) {
+        // We expect that 2 intersections are found: one at each end of the loop,
+        // both at the coordinates (0, 0).
+        auto xings_horiz = loop.intersect(seghoriz, EPS);
+        EXPECT_EQ(xings_horiz.size(), 2);
+        EXPECT_intersections_valid(loop, seghoriz, xings_horiz, EPS);
+    }
+}
+
+TEST_F(BezierTest, ExpandToTransformedTest)
+{
+    auto test_curve = [] (Curve const &c) {
+        constexpr int N = 50;
+        for (int i = 0; i < N; i++) {
+            auto angle = 2 * M_PI * i / N;
+            auto transform = Affine(Rotate(angle));
+            
+            auto copy = std::unique_ptr<Curve>(c.duplicate());
+            *copy *= transform;
+            auto box1 = copy->boundsExact();
+            
+            auto pt = c.initialPoint() * transform;
+            auto box2 = Rect(pt, pt);
+            c.expandToTransformed(box2, transform);
+            
+            for (auto i : { X, Y }) {
+                EXPECT_DOUBLE_EQ(box1[i].min(), box2[i].min());
+                EXPECT_DOUBLE_EQ(box1[i].max(), box2[i].max());
+            }
+        }
+    };
+    
+    test_curve(LineSegment(Point(-1, 0), Point(1, 2)));
+    test_curve(QuadraticBezier(Point(-1, 0), Point(1, 1), Point(3, 0)));
+    test_curve(CubicBezier(Point(-1, 0), Point(1, 1), Point(2, -2), Point(3, 0)));
+}
+
+TEST_F(BezierTest, ForwardDifferenceTest)
+{
+    auto b = Bezier(3, 4, 2, -5, 7);
+    EXPECT_EQ(b.forward_difference(1), Bezier(19, 34, 22, 5));
+    EXPECT_EQ(b.forward_difference(2), Bezier(-3, 2, 2));
+}
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/bezier-utils-test.cpp b/tests/bezier-utils-test.cpp
new file mode 100644
index 0000000..6f95ccd
--- /dev/null
+++ b/tests/bezier-utils-test.cpp
@@ -0,0 +1,333 @@
+#include "utest.h"
+#include <glib.h>
+
+/* MenTaLguY disclaims all responsibility for this evil idea for testing
+   static functions.  The main disadvantages are that we retain the
+   #define's and `using' directives of the included file. */
+#include "../bezier-utils.cpp"
+
+using Geom::Point;
+
+static bool range_approx_equal(double const a[], double const b[], unsigned len);
+
+/* (Returns false if NaN encountered.) */
+template<class T>
+static bool range_equal(T const a[], T const b[], unsigned len) {
+    for (unsigned i = 0; i < len; ++i) {
+        if ( a[i] != b[i] ) {
+            return false;
+        }
+    }
+    return true;
+}
+
+inline bool point_approx_equal(Geom::Point const &a, Geom::Point const &b, double const eps)
+{
+    using Geom::X; using Geom::Y;
+    return ( Geom_DF_TEST_CLOSE(a[X], b[X], eps) &&
+             Geom_DF_TEST_CLOSE(a[Y], b[Y], eps) );
+}
+
+static inline double square(double const x) {
+    return x * x;
+}
+
+/** Determine whether the found control points are the same as previously found on some developer's
+    machine.  Doesn't call utest__fail, just writes a message to stdout for diagnostic purposes:
+    the most important test is that the root-mean-square of errors in the estimation are low rather
+    than that the control points found are the same.
+**/
+static void compare_ctlpts(Point const est_b[], Point const exp_est_b[])
+{
+    unsigned diff_mask = 0;
+    for (unsigned i = 0; i < 4; ++i) {
+        for (unsigned d = 0; d < 2; ++d) {
+            if ( fabs( est_b[i][d] - exp_est_b[i][d] ) > 1.1e-5 ) {
+                diff_mask |= 1 << ( i * 2 + d );
+            }
+        }
+    }
+    if ( diff_mask != 0 ) {
+        printf("Warning: got different control points from previously-coded (diffs=0x%x).\n",
+               diff_mask);
+        printf(" Previous:");
+        for (unsigned i = 0; i < 4; ++i) {
+            printf(" (%g, %g)", exp_est_b[i][0], exp_est_b[i][1]); // localizing ok
+        }
+        putchar('\n');
+        printf(" Found:   ");
+        for (unsigned i = 0; i < 4; ++i) {
+            printf(" (%g, %g)", est_b[i][0], est_b[i][1]); // localizing ok
+        }
+        putchar('\n');
+    }
+}
+
+static void compare_rms(Point const est_b[], double const t[], Point const d[], unsigned const n,
+                        double const exp_rms_error)
+{
+    double sum_errsq = 0.0;
+    for (unsigned i = 0; i < n; ++i) {
+        Point const fit_pt = bezier_pt(3, est_b, t[i]);
+        Point const diff = fit_pt - d[i];
+        sum_errsq += dot(diff, diff);
+    }
+    double const rms_error = sqrt( sum_errsq / n );
+    UTEST_ASSERT( rms_error <= exp_rms_error + 1.1e-6 );
+    if ( rms_error < exp_rms_error - 1.1e-6 ) {
+        /* The fitter code appears to have improved [or the floating point calculations differ
+           on this machine from the machine where exp_rms_error was calculated]. */
+        printf("N.B. rms_error regression requirement can be decreased: have rms_error=%g.\n", rms_error); // localizing ok
+    }
+}
+
+int main(int argc, char *argv[]) {
+    utest_start("bezier-utils.cpp");
+
+    UTEST_TEST("copy_without_nans_or_adjacent_duplicates") {
+        Geom::Point const src[] = {
+            Point(2., 3.),
+            Point(2., 3.),
+            Point(0., 0.),
+            Point(2., 3.),
+            Point(2., 3.),
+            Point(1., 9.),
+            Point(1., 9.)
+        };
+        Point const exp_dest[] = {
+            Point(2., 3.),
+            Point(0., 0.),
+            Point(2., 3.),
+            Point(1., 9.)
+        };
+        g_assert( G_N_ELEMENTS(src) == 7 );
+        Point dest[7];
+        struct tst {
+            unsigned src_ix0;
+            unsigned src_len;
+            unsigned exp_dest_ix0;
+            unsigned exp_dest_len;
+        } const test_data[] = {
+            /* src start ix, src len, exp_dest start ix, exp dest len */
+            {0, 0, 0, 0},
+            {2, 1, 1, 1},
+            {0, 1, 0, 1},
+            {0, 2, 0, 1},
+            {0, 3, 0, 2},
+            {1, 3, 0, 3},
+            {0, 5, 0, 3},
+            {0, 6, 0, 4},
+            {0, 7, 0, 4}
+        };
+        for (unsigned i = 0 ; i < G_N_ELEMENTS(test_data) ; ++i) {
+            tst const &t = test_data[i];
+            UTEST_ASSERT( t.exp_dest_len
+                          == copy_without_nans_or_adjacent_duplicates(src + t.src_ix0,
+                                                                      t.src_len,
+                                                                      dest) );
+            UTEST_ASSERT(range_equal(dest,
+                                     exp_dest + t.exp_dest_ix0,
+                                     t.exp_dest_len));
+        }
+    }
+
+    UTEST_TEST("bezier_pt(1)") {
+        Point const a[] = {Point(2.0, 4.0),
+                           Point(1.0, 8.0)};
+        UTEST_ASSERT( bezier_pt(1, a, 0.0) == a[0] );
+        UTEST_ASSERT( bezier_pt(1, a, 1.0) == a[1] );
+        UTEST_ASSERT( bezier_pt(1, a, 0.5) == Point(1.5, 6.0) );
+        double const t[] = {0.5, 0.25, 0.3, 0.6};
+        for (unsigned i = 0; i < G_N_ELEMENTS(t); ++i) {
+            double const ti = t[i], si = 1.0 - ti;
+            UTEST_ASSERT( bezier_pt(1, a, ti) == si * a[0] + ti * a[1] );
+        }
+    }
+
+    UTEST_TEST("bezier_pt(2)") {
+        Point const b[] = {Point(1.0, 2.0),
+                           Point(8.0, 4.0),
+                           Point(3.0, 1.0)};
+        UTEST_ASSERT( bezier_pt(2, b, 0.0) == b[0] );
+        UTEST_ASSERT( bezier_pt(2, b, 1.0) == b[2] );
+        UTEST_ASSERT( bezier_pt(2, b, 0.5) == Point(5.0, 2.75) );
+        double const t[] = {0.5, 0.25, 0.3, 0.6};
+        for (unsigned i = 0; i < G_N_ELEMENTS(t); ++i) {
+            double const ti = t[i], si = 1.0 - ti;
+            Point const exp_pt( si*si * b[0] + 2*si*ti * b[1] + ti*ti * b[2] );
+            Point const pt(bezier_pt(2, b, ti));
+            UTEST_ASSERT(point_approx_equal(pt, exp_pt, 1e-11));
+        }
+    }
+
+    Point const c[] = {Point(1.0, 2.0),
+                       Point(8.0, 4.0),
+                       Point(3.0, 1.0),
+                       Point(-2.0, -4.0)};
+    UTEST_TEST("bezier_pt(3)") {
+        UTEST_ASSERT( bezier_pt(3, c, 0.0) == c[0] );
+        UTEST_ASSERT( bezier_pt(3, c, 1.0) == c[3] );
+        UTEST_ASSERT( bezier_pt(3, c, 0.5) == Point(4.0, 13.0/8.0) );
+        double const t[] = {0.5, 0.25, 0.3, 0.6};
+        for (unsigned i = 0; i < G_N_ELEMENTS(t); ++i) {
+            double const ti = t[i], si = 1.0 - ti;
+            UTEST_ASSERT( LInfty( bezier_pt(3, c, ti)
+                                  - ( si*si*si * c[0] +
+                                      3*si*si*ti * c[1] +
+                                      3*si*ti*ti * c[2] +
+                                      ti*ti*ti * c[3] ) )
+                          < 1e-4 );
+        }
+    }
+
+    struct Err_tst {
+        Point pt;
+        double u;
+        double err;
+    } const err_tst[] = {
+        {c[0], 0.0, 0.0},
+        {Point(4.0, 13.0/8.0), 0.5, 0.0},
+        {Point(4.0, 2.0), 0.5, 9.0/64.0},
+        {Point(3.0, 2.0), 0.5, 1.0 + 9.0/64.0},
+        {Point(6.0, 2.0), 0.5, 4.0 + 9.0/64.0},
+        {c[3], 1.0, 0.0},
+    };
+
+    UTEST_TEST("compute_max_error_ratio") {
+        Point d[G_N_ELEMENTS(err_tst)];
+        double u[G_N_ELEMENTS(err_tst)];
+        for (unsigned i = 0; i < G_N_ELEMENTS(err_tst); ++i) {
+            Err_tst const &t = err_tst[i];
+            d[i] = t.pt;
+            u[i] = t.u;
+        }
+        g_assert( G_N_ELEMENTS(u) == G_N_ELEMENTS(d) );
+        unsigned max_ix = ~0u;
+        double const err_ratio = compute_max_error_ratio(d, u, G_N_ELEMENTS(d), c, 1.0, &max_ix);
+        UTEST_ASSERT( fabs( sqrt(err_tst[4].err) - err_ratio ) < 1e-12 );
+        UTEST_ASSERT( max_ix == 4 );
+    }
+
+    UTEST_TEST("chord_length_parameterize") {
+        /* n == 2 */
+        {
+            Point const d[] = {Point(2.9415, -5.8149),
+                               Point(23.021, 4.9814)};
+            double u[G_N_ELEMENTS(d)];
+            double const exp_u[] = {0.0, 1.0};
+            g_assert( G_N_ELEMENTS(u) == G_N_ELEMENTS(exp_u) );
+            chord_length_parameterize(d, u, G_N_ELEMENTS(d));
+            UTEST_ASSERT(range_equal(u, exp_u, G_N_ELEMENTS(exp_u)));
+        }
+
+        /* Straight line. */
+        {
+            double const exp_u[] = {0.0, 0.1829, 0.2105, 0.2105, 0.619, 0.815, 0.999, 1.0};
+            unsigned const n = G_N_ELEMENTS(exp_u);
+            Point d[n];
+            double u[n];
+            Point const a(-23.985, 4.915), b(4.9127, 5.203);
+            for (unsigned i = 0; i < n; ++i) {
+                double bi = exp_u[i], ai = 1.0 - bi;
+                d[i] = ai * a  +  bi * b;
+            }
+            chord_length_parameterize(d, u, n);
+            UTEST_ASSERT(range_approx_equal(u, exp_u, n));
+        }
+    }
+
+    /* Feed it some points that can be fit exactly with a single bezier segment, and see how
+       well it manages. */
+    Point const src_b[4] = {Point(5., -3.),
+                            Point(8., 0.),
+                            Point(4., 2.),
+                            Point(3., 3.)};
+    double const t[] = {0.0, .001, .03, .05, .09, .13, .18, .25, .29, .33, .39, .44,
+                        .51, .57, .62, .69, .75, .81, .91, .93, .97, .98, .999, 1.0};
+    unsigned const n = G_N_ELEMENTS(t);
+    Point d[n];
+    for (unsigned i = 0; i < n; ++i) {
+        d[i] = bezier_pt(3, src_b, t[i]);
+    }
+    Point const tHat1(unit_vector( src_b[1] - src_b[0] ));
+    Point const tHat2(unit_vector( src_b[2] - src_b[3] ));
+
+    UTEST_TEST("generate_bezier") {
+        Point est_b[4];
+        generate_bezier(est_b, d, t, n, tHat1, tHat2, 1.0);
+
+        compare_ctlpts(est_b, src_b);
+
+        /* We're being unfair here in using our t[] rather than best t[] for est_b: we
+           may over-estimate RMS of errors. */
+        compare_rms(est_b, t, d, n, 1e-8);
+    }
+
+    UTEST_TEST("sp_bezier_fit_cubic_full") {
+        Point est_b[4];
+        int splitpoints[2];
+        gint const succ = sp_bezier_fit_cubic_full(est_b, splitpoints, d, n, tHat1, tHat2, square(1.2), 1);
+        UTEST_ASSERT( succ == 1 );
+
+        Point const exp_est_b[4] = {
+            Point(5.000000, -3.000000),
+            Point(7.5753, -0.4247),
+            Point(4.77533, 1.22467),
+            Point(3, 3)
+        };
+        compare_ctlpts(est_b, exp_est_b);
+
+        /* We're being unfair here in using our t[] rather than best t[] for est_b: we
+           may over-estimate RMS of errors. */
+        compare_rms(est_b, t, d, n, .307911);
+    }
+
+    UTEST_TEST("sp_bezier_fit_cubic") {
+        Point est_b[4];
+        gint const succ = sp_bezier_fit_cubic(est_b, d, n, square(1.2));
+        UTEST_ASSERT( succ == 1 );
+
+        Point const exp_est_b[4] = {
+            Point(5.000000, -3.000000),
+            Point(7.57134, -0.423509),
+            Point(4.77929, 1.22426),
+            Point(3, 3)
+        };
+        compare_ctlpts(est_b, exp_est_b);
+
+#if 1 /* A change has been made to right_tangent.  I believe that usually this change
+         will result in better fitting, but it won't do as well for this example where
+         we happen to be feeding a t=0.999 point to the fitter. */
+        printf("TODO: Update this test case for revised right_tangent implementation.\n");
+        /* In particular, have a test case to show whether the new implementation
+           really is likely to be better on average. */
+#else
+        /* We're being unfair here in using our t[] rather than best t[] for est_b: we
+           may over-estimate RMS of errors. */
+        compare_rms(est_b, t, d, n, .307983);
+#endif
+    }
+
+    return !utest_end();
+}
+
+/* (Returns false if NaN encountered.) */
+static bool range_approx_equal(double const a[], double const b[], unsigned const len) {
+    for (unsigned i = 0; i < len; ++i) {
+        if (!( fabs( a[i] - b[i] ) < 1e-4 )) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/choose-test.cpp b/tests/choose-test.cpp
new file mode 100644
index 0000000..c2b2b50
--- /dev/null
+++ b/tests/choose-test.cpp
@@ -0,0 +1,79 @@
+/** @file
+ * @brief Unit tests for the binomial coefficient function.
+ * Uses the Google Testing Framework
+ *//*
+ * Authors:
+ *   Krzysztof Kosiński <tweenk.pl@gmail.com>
+ * 
+ * Copyright 2015 Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include "testing.h"
+#include <2geom/choose.h>
+#include <glib.h>
+
+using namespace Geom;
+
+TEST(ChooseTest, PascalsTriangle) {
+    // check whether the values match Pascal's triangle
+    for (unsigned i = 0; i < 500; ++i) {
+        int n = g_random_int_range(3, 100);
+        int k = g_random_int_range(1, n-1);
+
+        double a = choose<double>(n, k);
+        double b = choose<double>(n-1, k);
+        double c = choose<double>(n-1, k-1);
+
+        EXPECT_NEAR((b + c) / a, 1.0, 1e-14);
+    }
+}
+
+TEST(ChooseTest, Values) {
+    // test some well-known values
+    EXPECT_EQ(choose<double>(0, 0), 1);
+    EXPECT_EQ(choose<double>(1, 0), 1);
+    EXPECT_EQ(choose<double>(1, 1), 1);
+    EXPECT_EQ(choose<double>(127, 127), 1);
+    EXPECT_EQ(choose<double>(92, 0), 1);
+    EXPECT_EQ(choose<double>(2, 1), 2);
+
+    // number of possible flops in Texas Hold 'Em Poker
+    EXPECT_EQ(choose<double>(50,  3), 19600.);
+    EXPECT_EQ(choose<double>(50, 47), 19600.);
+    // number of possible hands in bridge
+    EXPECT_EQ(choose<double>(52, 13), 635013559600.);
+    EXPECT_EQ(choose<double>(52, 39), 635013559600.);
+    // number of possible Lotto results
+    EXPECT_EQ(choose<double>(49,  6), 13983816.);
+    EXPECT_EQ(choose<double>(49, 43), 13983816.);
+}
+
+TEST(ChooseTest, Unsigned) {
+    auto const BIG = std::numeric_limits<unsigned>::max() - 1;
+    EXPECT_EQ(choose<unsigned>(BIG, BIG - 1), BIG);
+    EXPECT_EQ(choose<unsigned>(BIG, BIG), 1);
+    EXPECT_EQ(choose<unsigned>(BIG, BIG + 1), 0);
+}
diff --git a/tests/circle-test.cpp b/tests/circle-test.cpp
new file mode 100644
index 0000000..5ff6493
--- /dev/null
+++ b/tests/circle-test.cpp
@@ -0,0 +1,141 @@
+/** @file
+ * @brief Unit tests for Circle and related functions.
+ * Uses the Google Testing Framework
+ *//*
+ * Authors:
+ *   Krzysztof Kosiński <tweenk.pl@gmail.com>
+ * 
+ * Copyright 2015 Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include "testing.h"
+#include <2geom/circle.h>
+#include <2geom/line.h>
+
+using namespace Geom;
+
+TEST(CircleTest, Equality) {
+    Circle a(4, 5, 6);
+    Circle b(Point(4, 5), 6);
+    Circle c(4.00000001, 5, 6);
+
+    EXPECT_EQ(a, b);
+    EXPECT_NE(a, c);
+    EXPECT_NE(b, c);
+}
+
+TEST(CircleTest, Nearness) {
+    Circle a(4, 5, 6);
+    Circle b(4.000007, 5, 6);
+    Circle c(4, 5, 6.000007);
+    Circle d(4.000007, 5, 6.000007);
+    Circle e(4, 5, 7);
+
+    EXPECT_TRUE(are_near(a, b, 1e-5));
+    EXPECT_TRUE(are_near(a, c, 1e-5));
+    EXPECT_TRUE(are_near(c, d, 1e-5));
+    EXPECT_FALSE(are_near(a, d, 1e-5));
+    EXPECT_FALSE(are_near(a, e, 1e-2));
+    EXPECT_FALSE(are_near(b, e, 1e-2));
+    EXPECT_FALSE(are_near(c, e, 1e-2));
+}
+
+TEST(CircleTest, UnitCircleTransform) {
+    Circle c(17, 23, 22);
+
+    Point q = c.pointAt(M_PI/2);
+    Point p = Point(0, 1) * c.unitCircleTransform();
+    Point r = q * c.inverseUnitCircleTransform();
+
+    EXPECT_FLOAT_EQ(p[X], q[X]);
+    EXPECT_FLOAT_EQ(p[Y], q[Y]);
+    EXPECT_FLOAT_EQ(r[X], 0);
+    EXPECT_FLOAT_EQ(r[Y], 1);
+}
+
+TEST(CircleTest, Coefficients) {
+    Circle circ(5, 12, 87), circ2;
+
+    Coord a, b, c, d;
+    circ.coefficients(a, b, c, d);
+    circ2.setCoefficients(a, b, c, d);
+
+    EXPECT_TRUE(are_near(circ, circ2, 1e-15));
+
+    for (unsigned i = 0; i < 100; ++i) {
+        Coord t = -5 + 0.111 * i;
+        Point p = circ.pointAt(t);
+        Coord eqres = a * p[X]*p[X] + a*p[Y]*p[Y] + b*p[X] + c*p[Y] + d;
+        EXPECT_NEAR(eqres, 0, 1e-11);
+    }
+}
+
+TEST(CircleTest, CircleIntersection) {
+    Circle a(5, 5, 5), b(15, 5, 5), c(10, 10, 6), d(-5, 5, 2);
+    std::vector<ShapeIntersection> r1, r2, r3;
+
+    r1 = a.intersect(b);
+    ASSERT_EQ(r1.size(), 1u);
+    EXPECT_EQ(r1[0].point(), Point(10,5));
+    EXPECT_intersections_valid(a, b, r1, 1e-15);
+
+    r2 = a.intersect(c);
+    EXPECT_EQ(r2.size(), 2u);
+    EXPECT_intersections_valid(a, c, r2, 1e-15);
+
+    r3 = b.intersect(c);
+    EXPECT_EQ(r3.size(), 2u);
+    EXPECT_intersections_valid(b, c, r3, 4e-15);
+
+    EXPECT_TRUE(a.intersect(d).empty());
+    EXPECT_TRUE(b.intersect(d).empty());
+    EXPECT_TRUE(c.intersect(d).empty());
+}
+
+TEST(CircleTest, LineIntersection) {
+    Circle c(5, 5, 10);
+    Line l1(Point(-5, -20), Point(-5, 20));
+    Line l2(Point(0, 0), Point(10, 2.3));
+    Line l3(Point(20, -20), Point(0, -20));
+
+    EXPECT_TRUE(c.intersects(l1));
+    EXPECT_TRUE(c.intersects(l2));
+    EXPECT_FALSE(c.intersects(l3));
+
+    std::vector<ShapeIntersection> r1, r2, r3;
+
+    r1 = c.intersect(l1);
+    ASSERT_EQ(r1.size(), 1u);
+    EXPECT_EQ(r1[0].point(), Point(-5, 5));
+    EXPECT_intersections_valid(c, l1, r1, 1e-15);
+
+    r2 = c.intersect(l2);
+    EXPECT_EQ(r2.size(), 2u);
+    EXPECT_intersections_valid(c, l2, r2, 1e-14);
+
+    r3 = c.intersect(l3);
+    EXPECT_TRUE(r3.empty());
+}
diff --git a/tests/convex-hull-test.cpp b/tests/convex-hull-test.cpp
new file mode 100644
index 0000000..2f20f43
--- /dev/null
+++ b/tests/convex-hull-test.cpp
@@ -0,0 +1,335 @@
+/** @file
+ * @brief Unit tests for ConvexHull and related functions.
+ * Uses the Google Testing Framework
+ *//*
+ * Authors:
+ *   Nathan Hurst <njh@njhurst.com>
+ *   Krzysztof Kosiński <tweenk.pl@gmail.com>
+ * 
+ * Copyright 2011-2015 Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include "testing.h"
+#include <iostream>
+
+#include <2geom/convex-hull.h>
+#include <vector>
+#include <iterator>
+
+#ifndef M_PI
+# define M_PI 3.14159265358979323846
+#endif
+
+using namespace std;
+using namespace Geom;
+
+void points_from_shape(std::vector<Point> &pts, std::string const &shape) {
+    pts.clear();
+    int x = 0, y = 0;
+    for (char c : shape) {
+        if (c == '\n') {
+            x = 0; ++y;
+            continue;
+        }
+        if (c == ' ') {
+            ++x;
+            continue;
+        }
+        pts.emplace_back(x, y);
+        ++x;
+    }
+}
+
+class ConvexHullTest : public ::testing::Test {
+protected:
+    ConvexHullTest()
+        : null(hulls[0])
+        , point(hulls[1])
+        , line(hulls[2])
+        , triangle(hulls[3])
+        , square(hulls[4])
+        , hexagon(hulls[5])
+        , antihexagon(hulls[6])
+        , gem(hulls[7])
+        , diamond(hulls[8])
+    {
+        null = ConvexHull();
+
+        std::vector<Point> pts;
+
+        pts.emplace_back(0,0);
+        point = ConvexHull(pts);
+        pts.emplace_back(1,0);
+        line = ConvexHull(pts);
+        pts.emplace_back(0,1);
+        triangle = ConvexHull(pts);
+        pts.emplace_back(1,1);
+        square = ConvexHull(pts);
+        pts.clear();
+
+        for(int i = 0; i < 6; i++) {
+            pts.emplace_back(cos(i*M_PI*2/6), sin(i*M_PI*2/6));
+        }
+        hexagon = ConvexHull(pts);
+        pts.clear();
+
+        for(int i = 0; i < 6; i++) {
+            pts.emplace_back(cos((1-i*2)*M_PI/6), sin((1-i*2)*M_PI/6));
+        }
+        antihexagon = ConvexHull(pts);
+        pts.clear();
+
+        gem_shape = 
+            " ++++  \n"
+            "++++++ \n"
+            "++++++ \n"
+            "++++++ \n"
+            " ++++  \n";
+        points_from_shape(pts, gem_shape);
+        gem.swap(pts);
+
+        diamond_shape =
+            "   +    \n"
+            " +++++  \n"
+            " +++++  \n"
+            "+++++++ \n"
+            " +++++  \n"
+            " +++++  \n"
+            "   +    \n";
+        points_from_shape(pts, diamond_shape);
+        diamond.swap(pts);
+    }
+
+    ConvexHull hulls[9];
+    ConvexHull &null, &point, &line, &triangle, &square, &hexagon, &antihexagon, &gem, &diamond;
+    std::string gem_shape, diamond_shape;
+};
+
+void check_convex(ConvexHull &/*ch*/) {
+    // TODO
+}
+
+TEST_F(ConvexHullTest, SizeAndDegeneracy) {
+    EXPECT_EQ(0u, null.size());
+    EXPECT_TRUE(null.empty());
+    EXPECT_TRUE(null.isDegenerate());
+    EXPECT_FALSE(null.isSingular());
+    EXPECT_FALSE(null.isLinear());
+
+    EXPECT_EQ(1u, point.size());
+    EXPECT_FALSE(point.empty());
+    EXPECT_TRUE(point.isDegenerate());
+    EXPECT_TRUE(point.isSingular());
+    EXPECT_FALSE(point.isLinear());
+
+    EXPECT_EQ(2u, line.size());
+    EXPECT_FALSE(line.empty());
+    EXPECT_TRUE(line.isDegenerate());
+    EXPECT_FALSE(line.isSingular());
+    EXPECT_TRUE(line.isLinear());
+
+    EXPECT_EQ(3u, triangle.size());
+    EXPECT_FALSE(triangle.empty());
+    EXPECT_FALSE(triangle.isDegenerate());
+    EXPECT_FALSE(triangle.isSingular());
+    EXPECT_FALSE(triangle.isLinear());
+
+    EXPECT_EQ(4u, square.size());
+    EXPECT_FALSE(square.empty());
+    EXPECT_FALSE(square.isDegenerate());
+    EXPECT_FALSE(square.isSingular());
+    EXPECT_FALSE(square.isLinear());
+
+    EXPECT_EQ(6u, hexagon.size());
+    EXPECT_FALSE(hexagon.empty());
+    EXPECT_FALSE(hexagon.isDegenerate());
+    EXPECT_FALSE(hexagon.isSingular());
+    EXPECT_FALSE(hexagon.isLinear());
+
+    EXPECT_EQ(6u, antihexagon.size());
+    EXPECT_FALSE(antihexagon.empty());
+    EXPECT_FALSE(antihexagon.isDegenerate());
+    EXPECT_FALSE(antihexagon.isSingular());
+    EXPECT_FALSE(antihexagon.isLinear());
+
+    EXPECT_EQ(8u, gem.size());
+    EXPECT_FALSE(gem.empty());
+    EXPECT_FALSE(gem.isDegenerate());
+    EXPECT_FALSE(gem.isSingular());
+    EXPECT_FALSE(gem.isLinear());
+
+    EXPECT_EQ(8u, diamond.size());
+    EXPECT_FALSE(diamond.empty());
+    EXPECT_FALSE(diamond.isDegenerate());
+    EXPECT_FALSE(diamond.isSingular());
+    EXPECT_FALSE(diamond.isLinear());
+}
+
+
+TEST_F(ConvexHullTest, Area) {
+    EXPECT_EQ(0, null.area());
+    EXPECT_EQ(0, point.area());
+    EXPECT_EQ(0, line.area());
+    EXPECT_EQ(0.5, triangle.area());
+    EXPECT_EQ(1, square.area());
+    EXPECT_EQ(18, gem.area());
+    EXPECT_EQ(24, diamond.area());
+    EXPECT_FLOAT_EQ(6*(0.5*1*sin(M_PI/3)), hexagon.area());
+    EXPECT_FLOAT_EQ(6*(0.5*1*sin(M_PI/3)), antihexagon.area());
+}
+
+TEST_F(ConvexHullTest, Bounds) {
+    //Rect hexbounds(-1,sin(M_PI/3),1,-sin(M_PI/3));
+
+    EXPECT_EQ(OptRect(), null.bounds());
+    EXPECT_EQ(OptRect(0,0,0,0), point.bounds());
+    EXPECT_EQ(OptRect(0,0,1,0), line.bounds());
+    EXPECT_EQ(OptRect(0,0,1,1), triangle.bounds());
+    EXPECT_EQ(OptRect(0,0,1,1), square.bounds());
+    EXPECT_EQ(OptRect(0,0,5,4), gem.bounds());
+    EXPECT_EQ(OptRect(0,0,6,6), diamond.bounds());
+    //EXPECT_TRUE(hexbounds == hexagon.bounds());
+    //EXPECT_TRUE(hexbounds == antihexagon.bounds());
+}
+
+::testing::AssertionResult HullContainsPoint(ConvexHull const &h, Point const &p) {
+    if (h.contains(p)) {
+        return ::testing::AssertionSuccess();
+    } else {
+        return ::testing::AssertionFailure()
+            << "Convex hull:\n"
+            << h << "\ndoes not contain " << p;
+    }
+}
+
+TEST_F(ConvexHullTest, PointContainment) {
+    Point zero(0,0), half(0.5, 0.5), x(0.25, 0.25);
+    EXPECT_FALSE(HullContainsPoint(null, zero));
+    EXPECT_TRUE(HullContainsPoint(point, zero));
+    EXPECT_TRUE(HullContainsPoint(line, zero));
+    EXPECT_TRUE(HullContainsPoint(triangle, zero));
+    EXPECT_TRUE(HullContainsPoint(square, zero));
+    EXPECT_FALSE(HullContainsPoint(line, half));
+    EXPECT_TRUE(HullContainsPoint(triangle, x));
+    EXPECT_TRUE(HullContainsPoint(triangle, half));
+    EXPECT_TRUE(HullContainsPoint(square, half));
+    EXPECT_TRUE(HullContainsPoint(hexagon, zero));
+    EXPECT_TRUE(HullContainsPoint(antihexagon, zero));
+
+    std::vector<Point> pts;
+
+    points_from_shape(pts, gem_shape);
+    for (auto & pt : pts) {
+        EXPECT_TRUE(HullContainsPoint(gem, pt));
+    }
+
+    points_from_shape(pts, diamond_shape);
+    for (auto & pt : pts) {
+        EXPECT_TRUE(HullContainsPoint(diamond, pt));
+    }
+
+    /*EXPECT_FALSE(null.interiorContains(zero));
+    EXPECT_FALSE(point.interiorContains(zero));
+    EXPECT_FALSE(line.interiorContains(zero));
+    EXPECT_FALSE(triangle.interiorContains(zero));
+    EXPECT_FALSE(square.interiorContains(zero));
+    EXPECT_FALSE(line.interiorContains(half));
+    EXPECT_FALSE(triangle.interiorContains(Point(0,0.5)));
+    EXPECT_FALSE(triangle.interiorContains(half));
+    EXPECT_TRUE(square.interiorContains(half));*/
+}
+
+TEST_F(ConvexHullTest, ExtremePoints) {
+    Point zero(0,0);
+    EXPECT_EQ(0., point.top());
+    EXPECT_EQ(0., point.right());
+    EXPECT_EQ(0., point.bottom());
+    EXPECT_EQ(0., point.left());
+    EXPECT_EQ(zero, point.topPoint());
+    EXPECT_EQ(zero, point.rightPoint());
+    EXPECT_EQ(zero, point.bottomPoint());
+    EXPECT_EQ(zero, point.leftPoint());
+
+    // line from 0,0 to 1,0
+    EXPECT_EQ(0., line.top());
+    EXPECT_EQ(1., line.right());
+    EXPECT_EQ(0., line.bottom());
+    EXPECT_EQ(0., line.left());
+    EXPECT_EQ(Point(1,0), line.topPoint());
+    EXPECT_EQ(Point(1,0), line.rightPoint());
+    EXPECT_EQ(Point(0,0), line.bottomPoint());
+    EXPECT_EQ(Point(0,0), line.leftPoint());
+
+    // triangle 0,0 1,0 0,1
+    EXPECT_EQ(0., triangle.top());
+    EXPECT_EQ(1., triangle.right());
+    EXPECT_EQ(1., triangle.bottom());
+    EXPECT_EQ(0., triangle.left());
+    EXPECT_EQ(Point(1,0), triangle.topPoint());
+    EXPECT_EQ(Point(1,0), triangle.rightPoint());
+    EXPECT_EQ(Point(0,1), triangle.bottomPoint());
+    EXPECT_EQ(Point(0,0), triangle.leftPoint());
+
+    // square 0,0 to 1,1
+    EXPECT_EQ(0., square.top());
+    EXPECT_EQ(1., square.right());
+    EXPECT_EQ(1., square.bottom());
+    EXPECT_EQ(0., square.left());
+    EXPECT_EQ(Point(1,0), square.topPoint());
+    EXPECT_EQ(Point(1,1), square.rightPoint());
+    EXPECT_EQ(Point(0,1), square.bottomPoint());
+    EXPECT_EQ(Point(0,0), square.leftPoint());
+
+    EXPECT_EQ(0., gem.top());
+    EXPECT_EQ(5., gem.right());
+    EXPECT_EQ(4., gem.bottom());
+    EXPECT_EQ(0., gem.left());
+    EXPECT_EQ(Point(4,0), gem.topPoint());
+    EXPECT_EQ(Point(5,3), gem.rightPoint());
+    EXPECT_EQ(Point(1,4), gem.bottomPoint());
+    EXPECT_EQ(Point(0,1), gem.leftPoint());
+
+    EXPECT_EQ(0., diamond.top());
+    EXPECT_EQ(6., diamond.right());
+    EXPECT_EQ(6., diamond.bottom());
+    EXPECT_EQ(0., diamond.left());
+    EXPECT_EQ(Point(3,0), diamond.topPoint());
+    EXPECT_EQ(Point(6,3), diamond.rightPoint());
+    EXPECT_EQ(Point(3,6), diamond.bottomPoint());
+    EXPECT_EQ(Point(0,3), diamond.leftPoint());
+}
+
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/coord-test.cpp b/tests/coord-test.cpp
new file mode 100644
index 0000000..c96b095
--- /dev/null
+++ b/tests/coord-test.cpp
@@ -0,0 +1,90 @@
+/** @file
+ * @brief Unit tests for functions related to Coord.
+ * Uses the Google Testing Framework
+ *//*
+ * Authors:
+ *   Krzysztof Kosiński <tweenk.pl@gmail.com>
+ * 
+ * Copyright 2014 Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include <gtest/gtest.h>
+#include <2geom/coord.h>
+#include <climits>
+#include <stdint.h>
+#include <glib.h>
+#include <iostream>
+
+namespace Geom {
+
+TEST(CoordTest, StringRoundtripShortest) {
+    union {
+        uint64_t u;
+        double d;
+    };
+    for (unsigned i = 0; i < 100000; ++i) {
+        u = uint64_t(g_random_int()) | (uint64_t(g_random_int()) << 32);
+        if (!std::isfinite(d)) continue;
+
+        std::string str = format_coord_shortest(d);
+        double x = parse_coord(str);
+        if (x != d) {
+            std::cout << std::endl << d << " -> " << str << " -> " << x << std::endl;
+        }
+        EXPECT_EQ(d, x);
+    }
+}
+
+TEST(CoordTest, StringRoundtripNice) {
+    union {
+        uint64_t u;
+        double d;
+    };
+    for (unsigned i = 0; i < 100000; ++i) {
+        u = uint64_t(g_random_int()) | (uint64_t(g_random_int()) << 32);
+        if (!std::isfinite(d)) continue;
+
+        std::string str = format_coord_nice(d);
+        double x = parse_coord(str);
+        if (x != d) {
+            std::cout << std::endl << d << " -> " << str << " -> " << x << std::endl;
+        }
+        EXPECT_EQ(d, x);
+    }
+}
+
+} // end namespace Geom
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/dependent-project/.gitignore b/tests/dependent-project/.gitignore
new file mode 100644
index 0000000..0bb214c
--- /dev/null
+++ b/tests/dependent-project/.gitignore
@@ -0,0 +1,2 @@
+build-as-subproject
+build-with-find-package
\ No newline at end of file
diff --git a/tests/dependent-project/CMakeLists.txt b/tests/dependent-project/CMakeLists.txt
new file mode 100644
index 0000000..c371114
--- /dev/null
+++ b/tests/dependent-project/CMakeLists.txt
@@ -0,0 +1,27 @@
+cmake_minimum_required(VERSION 3.1)
+project(test_dep_2geom CXX C)
+set(CMAKE_CXX_STANDARD 17)
+
+option(2GEOM_AS_SUBPROJECT "include 2geom as subproject" OFF)
+
+if (2GEOM_AS_SUBPROJECT)
+    message("Using 2geom as subdirectory")
+    set(2GEOM_BUILD_SHARED ON CACHE BOOL "Build 2geom shared version")
+    add_subdirectory("../../" 2geom)
+else()
+    message("Using installed 2geom")
+    find_package(2Geom REQUIRED)
+endif()
+
+add_library(my_lib SHARED my_lib.cpp)
+add_executable(main main.cpp)
+target_link_libraries(main my_lib)
+target_link_libraries(my_lib PUBLIC 2Geom::2geom)
+
+install(TARGETS
+        main
+        my_lib
+    RUNTIME DESTINATION bin
+    ARCHIVE DESTINATION lib
+    LIBRARY DESTINATION lib
+    )
diff --git a/tests/dependent-project/main.cpp b/tests/dependent-project/main.cpp
new file mode 100644
index 0000000..6b6469c
--- /dev/null
+++ b/tests/dependent-project/main.cpp
@@ -0,0 +1,12 @@
+#include <2geom/2geom.h>
+#include <iostream>
+#include "my_lib.h"
+
+int main() {
+    Geom::Rect rect1(0, 0, 1, 1);
+    Geom::Rect rect2(0.5, 0.5, 1.5, 1.5);
+
+    std::cout << sum_of_three_points(Geom::Point(1, 1), Geom::Point(1, 2), Geom::Point(2, 3));
+
+    return rect1.intersects(rect2) ? 0 : 1;
+}
diff --git a/tests/dependent-project/my_lib.cpp b/tests/dependent-project/my_lib.cpp
new file mode 100644
index 0000000..d5af62a
--- /dev/null
+++ b/tests/dependent-project/my_lib.cpp
@@ -0,0 +1,6 @@
+#include "my_lib.h"
+
+using namespace Geom;
+Point sum_of_three_points(const Point&a, const Point&b, const Point&c){
+    return a+b+c;
+}
\ No newline at end of file
diff --git a/tests/dependent-project/my_lib.h b/tests/dependent-project/my_lib.h
new file mode 100644
index 0000000..2278aaf
--- /dev/null
+++ b/tests/dependent-project/my_lib.h
@@ -0,0 +1,4 @@
+#pragma once
+#include <2geom/2geom.h>
+
+Geom::Point sum_of_three_points(const Geom::Point&a, const Geom::Point&b, const Geom::Point&c);
\ No newline at end of file
diff --git a/tests/ellipse-test.cpp b/tests/ellipse-test.cpp
new file mode 100644
index 0000000..38eca0e
--- /dev/null
+++ b/tests/ellipse-test.cpp
@@ -0,0 +1,410 @@
+/** @file
+ * @brief Unit tests for Ellipse and related functions
+ * Uses the Google Testing Framework
+ *//*
+ * Authors:
+ *   Krzysztof Kosiński <tweenk.pl@gmail.com>
+ *
+ * Copyright 2015 Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include <iostream>
+#include <glib.h>
+
+#include <2geom/angle.h>
+#include <2geom/ellipse.h>
+#include <2geom/elliptical-arc.h>
+#include <memory>
+
+#include "testing.h"
+
+#ifndef M_SQRT2
+#  define M_SQRT2 1.41421356237309504880
+#endif
+
+using namespace Geom;
+
+TEST(EllipseTest, Arcs) {
+    Ellipse e(Point(5,10), Point(5, 10), 0);
+
+    std::unique_ptr<EllipticalArc> arc1(e.arc(Point(5,0), Point(0,0), Point(0,10)));
+
+    EXPECT_EQ(arc1->initialPoint(), Point(5,0));
+    EXPECT_EQ(arc1->finalPoint(), Point(0,10));
+    EXPECT_EQ(arc1->boundsExact(), Rect::from_xywh(0,0,5,10));
+    EXPECT_EQ(arc1->center(), e.center());
+    EXPECT_EQ(arc1->largeArc(), false);
+    EXPECT_EQ(arc1->sweep(), false);
+
+    std::unique_ptr<EllipticalArc> arc1r(e.arc(Point(0,10), Point(0,0), Point(5,0)));
+
+    EXPECT_EQ(arc1r->boundsExact(), arc1->boundsExact());
+    EXPECT_EQ(arc1r->sweep(), true);
+    EXPECT_EQ(arc1r->largeArc(), false);
+
+    std::unique_ptr<EllipticalArc> arc2(e.arc(Point(5,0), Point(10,20), Point(0,10)));
+
+    EXPECT_EQ(arc2->boundsExact(), Rect::from_xywh(0,0,10,20));
+    EXPECT_EQ(arc2->largeArc(), true);
+    EXPECT_EQ(arc2->sweep(), true);
+
+    std::unique_ptr<EllipticalArc> arc2r(e.arc(Point(0,10), Point(10,20), Point(5,0)));
+
+    EXPECT_EQ(arc2r->boundsExact(), arc2->boundsExact());
+    EXPECT_EQ(arc2r->largeArc(), true);
+    EXPECT_EQ(arc2r->sweep(), false);
+
+    // exactly half arc
+    std::unique_ptr<EllipticalArc> arc3(e.arc(Point(5,0), Point(0,10), Point(5,20)));
+
+    EXPECT_EQ(arc3->boundsExact(), Rect::from_xywh(0,0,5,20));
+    EXPECT_EQ(arc3->largeArc(), false);
+    EXPECT_EQ(arc3->sweep(), false);
+
+    // inner point exactly at midpoint between endpoints
+    std::unique_ptr<EllipticalArc> arc4(e.arc(Point(5,0), Point(2.5,5), Point(0,10)));
+
+    EXPECT_EQ(arc4->initialPoint(), Point(5,0));
+    EXPECT_EQ(arc4->finalPoint(), Point(0,10));
+    EXPECT_EQ(arc4->boundsExact(), Rect::from_xywh(0,0,5,10));
+    EXPECT_EQ(arc4->largeArc(), false);
+    EXPECT_EQ(arc4->sweep(), false);
+
+    std::unique_ptr<EllipticalArc> arc4r(e.arc(Point(0,10), Point(2.5,5), Point(5,0)));
+
+    EXPECT_EQ(arc4r->initialPoint(), Point(0,10));
+    EXPECT_EQ(arc4r->finalPoint(), Point(5,0));
+    EXPECT_EQ(arc4r->boundsExact(), Rect::from_xywh(0,0,5,10));
+    EXPECT_EQ(arc4r->largeArc(), false);
+    EXPECT_EQ(arc4r->sweep(), true);
+}
+
+TEST(EllipseTest, AreNear) {
+    Ellipse e1(Point(5.000001,10), Point(5,10), Angle::from_degrees(45));
+    Ellipse e2(Point(5.000000,10), Point(5,10), Angle::from_degrees(225));
+    Ellipse e3(Point(4.999999,10), Point(10,5), Angle::from_degrees(135));
+    Ellipse e4(Point(5.000001,10), Point(10,5), Angle::from_degrees(315));
+
+    EXPECT_TRUE(are_near(e1, e2, 1e-5));
+    EXPECT_TRUE(are_near(e1, e3, 1e-5));
+    EXPECT_TRUE(are_near(e1, e4, 1e-5));
+
+    Ellipse c1(Point(20.000001,35.000001), Point(5.000001,4.999999), Angle::from_degrees(180.00001));
+    Ellipse c2(Point(19.999999,34.999999), Point(4.999999,5.000001), Angle::from_degrees(179.99999));
+    //std::cout << c1 << "\n" << c2 << std::endl;
+    EXPECT_TRUE(are_near(c1, c2, 2e-5));
+
+    EXPECT_FALSE(are_near(c1, e1, 1e-5));
+    EXPECT_FALSE(are_near(c2, e1, 1e-5));
+    EXPECT_FALSE(are_near(c1, e2, 1e-5));
+    EXPECT_FALSE(are_near(c2, e2, 1e-5));
+    EXPECT_FALSE(are_near(c1, e3, 1e-5));
+    EXPECT_FALSE(are_near(c2, e3, 1e-5));
+    EXPECT_FALSE(are_near(c1, e4, 1e-5));
+    EXPECT_FALSE(are_near(c2, e4, 1e-5));
+}
+
+TEST(EllipseTest, Transformations) {
+    Ellipse e(Point(5,10), Point(5,10), Angle::from_degrees(45));
+
+    Ellipse er = e * Rotate::around(Point(5,10), Angle::from_degrees(45));
+    Ellipse ercmp(Point(5,10), Point(5,10), Angle::from_degrees(90));
+    //std::cout << e << "\n" << er << "\n" << ercmp << std::endl;
+    EXPECT_TRUE(are_near(er, ercmp, 1e-12));
+
+    Ellipse eflip = e * Affine(Scale(-1,1));
+    Ellipse eflipcmp(Point(-5, 10), Point(5,10), Angle::from_degrees(135));
+    EXPECT_TRUE(are_near(eflip, eflipcmp, 1e-12));
+}
+
+TEST(EllipseTest, TimeAt) {
+    Ellipse e(Point(4, 17), Point(22, 34), 2);
+
+    for (unsigned i = 0; i < 100; ++i) {
+        Coord t = g_random_double_range(0, 2*M_PI);
+        Point p = e.pointAt(t);
+        Coord t2 = e.timeAt(p);
+        EXPECT_FLOAT_EQ(t, t2);
+    }
+}
+
+TEST(EllipseTest, LineIntersection) {
+    Ellipse e(Point(0, 0), Point(3, 2), 0);
+    Line l(Point(0, -2), Point(1, 0));
+
+    std::vector<ShapeIntersection> xs = e.intersect(l);
+
+    ASSERT_EQ(xs.size(), 2ul);
+
+    // due to numeric imprecision when evaluating Ellipse,
+    // the points may deviate by around 2e-16
+    EXPECT_NEAR(xs[0].point()[X], 0, 1e-15);
+    EXPECT_NEAR(xs[0].point()[Y], -2, 1e-15);
+    EXPECT_NEAR(xs[1].point()[X], 9./5, 1e-15);
+    EXPECT_NEAR(xs[1].point()[Y], 8./5, 1e-15);
+
+    EXPECT_intersections_valid(e, l, xs, 1e-15);
+
+    // Test with a degenerate ellipse
+    auto degen = Ellipse({0, 0}, {3, 2}, 0);
+    degen *= Scale(1.0, 0.0); // Squash to the X-axis interval [-3, 3].
+
+    g_random_set_seed(0xCAFECAFE);
+    // Intersect with a line
+    for (size_t _ = 0; _ < 10'000; _++) {
+        auto line = Line(Point(g_random_double_range(-3.0, 3.0), g_random_double_range(-3.0, -1.0)),
+                         Point(g_random_double_range(-3.0, 3.0), g_random_double_range(1.0, 3.0)));
+        auto xings = degen.intersect(line);
+        EXPECT_EQ(xings.size(), 2u);
+        EXPECT_intersections_valid(degen, line, xings, 1e-14);
+    }
+    // Intersect with another, non-degenerate ellipse
+    for (size_t _ = 0; _ < 10'000; _++) {
+        auto other = Ellipse(Point(g_random_double_range(-1.0, 1.0), g_random_double_range(-1.0, 1.0)),
+                             Point(g_random_double_range(1.0, 2.0), g_random_double_range(1.0, 3.0)), 0);
+        auto xings = degen.intersect(other);
+        EXPECT_intersections_valid(degen, other, xings, 1e-14);
+    }
+    // Intersect with another ellipse which is also degenerate
+    for (size_t _ = 0; _ < 10'000; _++) {
+        auto other = Ellipse({0, 0}, {1, 1}, 0); // Unit circle
+        other *= Scale(0.0, g_random_double_range(0.5, 4.0)); // Squash to Y axis
+        other *= Rotate(g_random_double_range(-1.5, 1.5)); // Rotate a little (still passes through the origin)
+        other *= Translate(g_random_double_range(-2.9, 2.9), 0.0);
+        auto xings = degen.intersect(other);
+        EXPECT_EQ(xings.size(), 4u);
+        EXPECT_intersections_valid(degen, other, xings, 1e-14);
+    }
+}
+
+TEST(EllipseTest, EllipseIntersection) {
+    Ellipse e1;
+    Ellipse e2;
+    std::vector<ShapeIntersection> xs;
+
+    e1.set(Point(300, 300), Point(212, 70), -0.785);
+    e2.set(Point(250, 300), Point(230, 90), 1.321);
+    xs = e1.intersect(e2);
+    EXPECT_EQ(xs.size(), 4ul);
+    EXPECT_intersections_valid(e1, e2, xs, 4e-10);
+
+    e1.set(Point(0, 0), Point(1, 1), 0);
+    e2.set(Point(0, 1), Point(1, 1), 0);
+    xs = e1.intersect(e2);
+    EXPECT_EQ(xs.size(), 2ul);
+    EXPECT_intersections_valid(e1, e2, xs, 1e-10);
+
+    e1.set(Point(0, 0), Point(1, 1), 0);
+    e2.set(Point(1, 0), Point(1, 1), 0);
+    xs = e1.intersect(e2);
+    EXPECT_EQ(xs.size(), 2ul);
+    EXPECT_intersections_valid(e1, e2, xs, 1e-10);
+
+    // === Test detection of external tangency between ellipses ===
+    // Perpendicular major axes
+    e1.set({0, 0}, {5, 3}, 0); // rightmost point (5, 0)
+    e2.set({6, 0}, {1, 2}, 0); // leftmost point (5, 0)
+    xs = e1.intersect(e2);
+    ASSERT_GT(xs.size(), 0);
+    EXPECT_intersections_valid(e1, e2, xs, 1e-10);
+    EXPECT_TRUE(are_near(xs[0].point(), Point(5, 0)));
+
+    // Collinear major axes
+    e1.set({30, 0}, {9, 1}, 0); // leftmost point (21, 0)
+    e2.set({18, 0}, {3, 2}, 0); // rightmost point (21, 0)
+    xs = e1.intersect(e2);
+    ASSERT_GT(xs.size(), 0);
+    EXPECT_intersections_valid(e1, e2, xs, 1e-10);
+    EXPECT_TRUE(are_near(xs[0].point(), Point(21, 0)));
+
+    // Circles not aligned to an axis (Pythagorean triple: 3^2 + 4^2 == 5^2)
+    e1.set({0, 0}, {3, 3}, 0); // radius 3
+    e2.set({3, 4}, {2, 2}, 0); // radius 2
+    // We know 2 + 3 == 5 == distance((0, 0), (3, 4)) so there's an external tangency
+    // between these circles, at a point at distance 3 from the origin, on the line x = 0.75 y.
+    xs = e1.intersect(e2);
+    ASSERT_GT(xs.size(), 0);
+    EXPECT_intersections_valid(e1, e2, xs, 1e-6);
+
+    // === Test the detection of internal tangency between ellipses ===
+    // Perpendicular major axes
+    e1.set({0, 0}, {8, 17}, 0); // rightmost point (8, 0)
+    e2.set({6, 0}, {2, 1}, 0); // rightmost point (8, 0)
+    xs = e1.intersect(e2);
+    ASSERT_GT(xs.size(), 0);
+    EXPECT_intersections_valid(e1, e2, xs, 1e-10);
+    EXPECT_TRUE(are_near(xs[0].point(), Point(8, 0)));
+
+    // Collinear major axes
+    e1.set({30, 0}, {9, 5}, 0); // rightmost point (39, 0)
+    e2.set({36, 0}, {3, 1}, 0); // rightmost point (39, 0)
+    xs = e1.intersect(e2);
+    ASSERT_GT(xs.size(), 0);
+    EXPECT_intersections_valid(e1, e2, xs, 1e-6);
+    EXPECT_TRUE(are_near(xs[0].point(), Point(39, 0)));
+
+    // Circles not aligned to an axis (Pythagorean triple: 3^2 + 4^2 == 5^2)
+    e1.set({4, 3}, {5, 5}, 0); // Passes through (0, 0), center on the line y = 0.75 x
+    e2.set({8, 6}, {10, 10}, 0); // Also passes through (0, 0), center on the same line.
+    xs = e1.intersect(e2);
+    ASSERT_GT(xs.size(), 0);
+    EXPECT_intersections_valid(e1, e2, xs, 1e-6);
+    EXPECT_TRUE(are_near(xs[0].point(), Point(0, 0)));
+}
+
+TEST(EllipseTest, BezierIntersection) {
+    Ellipse e(Point(300, 300), Point(212, 70), -3.926);
+    D2<Bezier> b(Bezier(100, 300, 100, 500), Bezier(100, 100, 500, 500));
+
+    std::vector<ShapeIntersection> xs = e.intersect(b);
+
+    EXPECT_EQ(xs.size(), 2ul);
+    EXPECT_intersections_valid(e, b, xs, 6e-12);
+}
+
+TEST(EllipseTest, Coefficients) {
+    std::vector<Ellipse> es;
+    es.emplace_back(Point(-15,25), Point(10,15), Angle::from_degrees(45).radians0());
+    es.emplace_back(Point(-10,33), Point(40,20), M_PI);
+    es.emplace_back(Point(10,-33), Point(40,20), Angle::from_degrees(135).radians0());
+    es.emplace_back(Point(-10,-33), Point(50,10), Angle::from_degrees(330).radians0());
+
+    for (auto & i : es) {
+        Coord a, b, c, d, e, f;
+        i.coefficients(a, b, c, d, e, f);
+        Ellipse te(a, b, c, d, e, f);
+        EXPECT_near(i, te, 1e-10);
+        for (Coord t = -5; t < 5; t += 0.125) {
+            Point p = i.pointAt(t);
+            Coord eq = a*p[X]*p[X] + b*p[X]*p[Y] + c*p[Y]*p[Y]
+              + d*p[X] + e*p[Y] + f;
+            EXPECT_NEAR(eq, 0, 1e-10);
+        }
+    }
+}
+
+TEST(EllipseTest, UnitCircleTransform) {
+    std::vector<Ellipse> es;
+    es.emplace_back(Point(-15,25), Point(10,15), Angle::from_degrees(45));
+    es.emplace_back(Point(-10,33), Point(40,20), M_PI);
+    es.emplace_back(Point(10,-33), Point(40,20), Angle::from_degrees(135));
+    es.emplace_back(Point(-10,-33), Point(50,10), Angle::from_degrees(330));
+
+    for (auto & e : es) {
+        EXPECT_near(e.unitCircleTransform() * e.inverseUnitCircleTransform(), Affine::identity(), 1e-8);
+
+        for (Coord t = -1; t < 10; t += 0.25) {
+            Point p = e.pointAt(t);
+            p *= e.inverseUnitCircleTransform();
+            EXPECT_near(p.length(), 1., 1e-10);
+            p *= e.unitCircleTransform();
+            EXPECT_near(e.pointAt(t), p, 1e-10);
+        }
+    }
+}
+
+TEST(EllipseTest, PointAt) {
+    Ellipse a(Point(0,0), Point(10,20), 0);
+    EXPECT_near(a.pointAt(0), Point(10,0), 1e-10);
+    EXPECT_near(a.pointAt(M_PI/2), Point(0,20), 1e-10);
+    EXPECT_near(a.pointAt(M_PI), Point(-10,0), 1e-10);
+    EXPECT_near(a.pointAt(3*M_PI/2), Point(0,-20), 1e-10);
+
+    Ellipse b(Point(0,0), Point(10,20), M_PI/2);
+    EXPECT_near(b.pointAt(0), Point(0,10), 1e-10);
+    EXPECT_near(b.pointAt(M_PI/2), Point(-20,0), 1e-10);
+    EXPECT_near(b.pointAt(M_PI), Point(0,-10), 1e-10);
+    EXPECT_near(b.pointAt(3*M_PI/2), Point(20,0), 1e-10);
+}
+
+TEST(EllipseTest, UnitTangentAt) {
+    Ellipse a(Point(14,-7), Point(20,10), 0);
+    Ellipse b(Point(-77,23), Point(40,10), Angle::from_degrees(45));
+
+    EXPECT_near(a.unitTangentAt(0), Point(0,1), 1e-12);
+    EXPECT_near(a.unitTangentAt(M_PI/2), Point(-1,0), 1e-12);
+    EXPECT_near(a.unitTangentAt(M_PI), Point(0,-1), 1e-12);
+    EXPECT_near(a.unitTangentAt(3*M_PI/2), Point(1,0), 1e-12);
+
+    EXPECT_near(b.unitTangentAt(0), Point(-M_SQRT2/2, M_SQRT2/2), 1e-12);
+    EXPECT_near(b.unitTangentAt(M_PI/2), Point(-M_SQRT2/2, -M_SQRT2/2), 1e-12);
+    EXPECT_near(b.unitTangentAt(M_PI), Point(M_SQRT2/2, -M_SQRT2/2), 1e-12);
+    EXPECT_near(b.unitTangentAt(3*M_PI/2), Point(M_SQRT2/2, M_SQRT2/2), 1e-12);
+}
+
+TEST(EllipseTest, Bounds)
+{
+    // Create example ellipses
+    std::vector<Ellipse> es;
+    es.emplace_back(Point(-15,25), Point(10,15), Angle::from_degrees(45));
+    es.emplace_back(Point(-10,33), Point(40,20), M_PI);
+    es.emplace_back(Point(10,-33), Point(40,20), Angle::from_degrees(111));
+    es.emplace_back(Point(-10,-33), Point(50,10), Angle::from_degrees(222));
+
+    // for reproducibility
+    g_random_set_seed(1234);
+
+    for (auto & e : es) {
+        Rect r = e.boundsExact();
+        Rect f = e.boundsFast();
+        for (unsigned j = 0; j < 10000; ++j) {
+            Coord t = g_random_double_range(-M_PI, M_PI);
+            auto const p = e.pointAt(t);
+            EXPECT_TRUE(r.contains(p));
+            EXPECT_TRUE(f.contains(p));
+        }
+    }
+
+    Ellipse e(Point(0,0), Point(10, 10), M_PI);
+    Rect bounds = e.boundsExact();
+    Rect coarse = e.boundsFast();
+    EXPECT_EQ(bounds, Rect(Point(-10,-10), Point(10,10)));
+    EXPECT_TRUE(bounds.contains(e.pointAt(0)));
+    EXPECT_TRUE(bounds.contains(e.pointAt(M_PI/2)));
+    EXPECT_TRUE(bounds.contains(e.pointAt(M_PI)));
+    EXPECT_TRUE(bounds.contains(e.pointAt(3*M_PI/2)));
+    EXPECT_TRUE(bounds.contains(e.pointAt(2*M_PI)));
+    EXPECT_TRUE(coarse.contains(e.pointAt(0)));
+    EXPECT_TRUE(coarse.contains(e.pointAt(M_PI/2)));
+    EXPECT_TRUE(coarse.contains(e.pointAt(M_PI)));
+    EXPECT_TRUE(coarse.contains(e.pointAt(3*M_PI/2)));
+    EXPECT_TRUE(coarse.contains(e.pointAt(2*M_PI)));
+
+    e = Ellipse(Point(0,0), Point(10, 10), M_PI/2);
+    bounds = e.boundsExact();
+    coarse = e.boundsFast();
+    EXPECT_EQ(bounds, Rect(Point(-10,-10), Point(10,10)));
+    EXPECT_TRUE(bounds.contains(e.pointAt(0)));
+    EXPECT_TRUE(bounds.contains(e.pointAt(M_PI/2)));
+    EXPECT_TRUE(bounds.contains(e.pointAt(M_PI)));
+    EXPECT_TRUE(bounds.contains(e.pointAt(3*M_PI/2)));
+    EXPECT_TRUE(bounds.contains(e.pointAt(2*M_PI)));
+    EXPECT_TRUE(coarse.contains(e.pointAt(0)));
+    EXPECT_TRUE(coarse.contains(e.pointAt(M_PI/2)));
+    EXPECT_TRUE(coarse.contains(e.pointAt(M_PI)));
+    EXPECT_TRUE(coarse.contains(e.pointAt(3*M_PI/2)));
+    EXPECT_TRUE(coarse.contains(e.pointAt(2*M_PI)));
+}
diff --git a/tests/elliptical-arc-test.cpp b/tests/elliptical-arc-test.cpp
new file mode 100644
index 0000000..1f6eff7
--- /dev/null
+++ b/tests/elliptical-arc-test.cpp
@@ -0,0 +1,275 @@
+/** @file
+ * @brief Unit tests for EllipticalArc.
+ * Uses the Google Testing Framework
+ *//*
+ * Authors:
+ *   Krzysztof Kosiński <tweenk.pl@gmail.com>
+ *
+ * Copyright 2015 Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include "testing.h"
+#include <2geom/elliptical-arc.h>
+#include <glib.h>
+
+using namespace Geom;
+
+TEST(EllipticalArcTest, PointAt) {
+    EllipticalArc a(Point(0,0), Point(10,20), M_PI/2, false, true, Point(-40,0));
+    EXPECT_near(a.pointAt(0), a.initialPoint(), 1e-14);
+    EXPECT_near(a.pointAt(1), a.finalPoint(), 1e-14);
+    EXPECT_near(a.pointAt(0.5), Point(-20,10), 1e-14);
+
+    EllipticalArc b(Point(0,0), Point(10,20), 0, false, true, Point(-40,0));
+    EXPECT_near(b.pointAt(0), b.initialPoint(), 1e-14);
+    EXPECT_near(b.pointAt(1), b.finalPoint(), 1e-14);
+    EXPECT_near(b.pointAt(0.5), Point(-20,40), 1e-14);
+
+    EllipticalArc c(Point(200,0), Point(40,20), Angle::from_degrees(90), false, false, Point(200,100));
+    EXPECT_near(c.pointAt(0), c.initialPoint(), 1e-13);
+    EXPECT_near(c.pointAt(1), c.finalPoint(), 1e-13);
+    EXPECT_near(c.pointAt(0.5), Point(175, 50), 1e-13);
+}
+
+TEST(EllipticalArc, Transform) {
+    EllipticalArc a(Point(0,0), Point(10,20), M_PI/2, false, true, Point(-40,0));
+    EllipticalArc b(Point(-40,0), Point(10,20), M_PI/2, false, true, Point(0,0));
+    EllipticalArc c = a;
+    Affine m = Rotate::around(Point(-20,0), M_PI);
+    c.transform(m);
+
+    for (unsigned i = 0; i <= 100; ++i) {
+        Coord t = i/100.;
+        EXPECT_near(c.pointAt(t), b.pointAt(t), 1e-12);
+        EXPECT_near(a.pointAt(t)*m, c.pointAt(t), 1e-12);
+    }
+}
+
+TEST(EllipticalArcTest, Duplicate) {
+    EllipticalArc a(Point(0,0), Point(10,20), M_PI/2, true, false, Point(-40,0));
+    EllipticalArc *b = static_cast<EllipticalArc*>(a.duplicate());
+    EXPECT_EQ(a, *b);
+    delete b;
+}
+
+TEST(EllipticalArcTest, LineSegmentIntersection) {
+    std::vector<CurveIntersection> r1;
+    EllipticalArc a3(Point(0,0), Point(5,1.5), 0, true, true, Point(0,2));
+    LineSegment ls(Point(0,5), Point(7,-3));
+    r1 = a3.intersect(ls);
+    EXPECT_EQ(r1.size(), 2u);
+    EXPECT_intersections_valid(a3, ls, r1, 1e-10);
+
+    g_random_set_seed(0xB747A380);
+    // Test with randomized arcs and segments.
+    for (size_t _ = 0; _ < 10'000; _++) {
+        auto arc = EllipticalArc({g_random_double_range(1.0, 5.0), 0.0},
+                                 {g_random_double_range(6.0, 8.0), g_random_double_range(2.0, 7.0)},
+                                  g_random_double_range(-0.5, 0.5), true, g_random_boolean(),
+                                 {g_random_double_range(-5.0, -1.0), 0.0});
+        Coord x = g_random_double_range(15, 30);
+        Coord y = g_random_double_range(10, 20);
+        auto seg = LineSegment(Point(-x, y), Point(x, -y));
+        auto xings = arc.intersect(seg);
+        EXPECT_EQ(xings.size(), 1u);
+        EXPECT_intersections_valid(arc, seg, xings, 1e-12);
+    }
+
+    // Test with degenerate arcs
+    EllipticalArc x_squash_pos{{3.0, 0.0}, {3.0, 2.0}, 0, true, true, {-3.0, 0.0}};
+    EllipticalArc x_squash_neg{{3.0, 0.0}, {3.0, 2.0}, 0, true, false, {-3.0, 0.0}};
+    auto const squash_to_x = Scale(1.0, 0.0);
+    x_squash_pos *= squash_to_x; // squash to X axis interval [-3, 3].
+    x_squash_neg *= squash_to_x;
+
+    for (size_t _ = 0; _ < 10'000; _++) {
+        auto seg = LineSegment(Point(g_random_double_range(-3.0, 3.0), g_random_double_range(-3.0, -1.0)),
+                               Point(g_random_double_range(-3.0, 3.0), g_random_double_range(1.0, 3.0)));
+        auto xings = x_squash_pos.intersect(seg);
+        EXPECT_EQ(xings.size(), 1u);
+        EXPECT_intersections_valid(x_squash_pos, seg, xings, 1e-12);
+
+        std::unique_ptr<Curve> rev{x_squash_pos.reverse()};
+        xings = rev->intersect(seg);
+        EXPECT_EQ(xings.size(), 1u);
+        EXPECT_intersections_valid(*rev, seg, xings, 1e-12);
+
+        xings = x_squash_neg.intersect(seg);
+        EXPECT_EQ(xings.size(), 1u);
+        EXPECT_intersections_valid(x_squash_neg, seg, xings, 1e-12);
+
+        rev.reset(x_squash_neg.reverse());
+        xings = rev->intersect(seg);
+        EXPECT_EQ(xings.size(), 1u);
+        EXPECT_intersections_valid(*rev, seg, xings, 1e-12);
+    }
+
+    // Now test with an arc squashed to the Y-axis.
+    EllipticalArc y_squash_pos{{0.0, -2.0}, {3.0, 2.0}, 0, true, true, {0.0, 2.0}};
+    EllipticalArc y_squash_neg{{0.0, -2.0}, {3.0, 2.0}, 0, true, false, {0.0, 2.0}};
+    auto const squash_to_y = Scale(0.0, 1.0);
+    y_squash_pos *= squash_to_y; // Y-axis interval [-2, 2].
+    y_squash_neg *= squash_to_y;
+
+    for (size_t _ = 0; _ < 10'000; _++) {
+        auto seg = LineSegment(Point(g_random_double_range(-3.0, -1.0), g_random_double_range(-2.0, 2.0)),
+                               Point(g_random_double_range(1.0, 3.0),   g_random_double_range(-2.0, 2.0)));
+        auto xings = y_squash_pos.intersect(seg, 1e-10);
+        EXPECT_EQ(xings.size(), 1u);
+        EXPECT_intersections_valid(y_squash_pos, seg, xings, 1e-12);
+
+        std::unique_ptr<Curve> rev{y_squash_pos.reverse()};
+        xings = rev->intersect(seg, 1e-12);
+        EXPECT_EQ(xings.size(), 1u);
+        EXPECT_intersections_valid(*rev, seg, xings, 1e-12);
+
+        xings = y_squash_neg.intersect(seg, 1e-12);
+        EXPECT_EQ(xings.size(), 1u);
+        EXPECT_intersections_valid(y_squash_neg, seg, xings, 1e-12);
+
+        rev.reset(y_squash_neg.reverse());
+        xings = rev->intersect(seg, 1e-12);
+        EXPECT_EQ(xings.size(), 1u);
+        EXPECT_intersections_valid(*rev, seg, xings, 1e-12);
+    }
+
+    // Test whether the coincidence between the common endpoints of an
+    // arc and a segment is correctly detected as an intersection.
+    {
+        Point const from{1, 0};
+        Point const to{0.30901699437494745, 0.9510565162951535};
+        auto arc = EllipticalArc(from, {1, 1}, 0, false, true, to);
+        auto seg = LineSegment({0, 0}, to);
+        auto xings = arc.intersect(seg);
+        ASSERT_EQ(xings.size(), 1);
+        EXPECT_TRUE(are_near(xings[0].point(), to, 1e-12));
+        EXPECT_TRUE(are_near(xings[0].first, 1.0, 1e-24));
+        EXPECT_TRUE(are_near(xings[0].second, 1.0, 1e-24));
+
+        auto seg2 = LineSegment(Point{1, 1}, from);
+        xings = arc.intersect(seg2);
+        ASSERT_EQ(xings.size(), 1);
+        EXPECT_TRUE(are_near(xings[0].point(), from, 1e-12));
+        EXPECT_TRUE(are_near(xings[0].first, 0.0, 1e-24));
+        EXPECT_TRUE(are_near(xings[0].second, 1.0, 1e-24));
+    }
+}
+
+TEST(EllipticalArcTest, ArcIntersection) {
+    std::vector<CurveIntersection> r1, r2;
+
+    EllipticalArc a1(Point(0,0), Point(6,3), 0.1, false, false, Point(10,0));
+    EllipticalArc a2(Point(0,2), Point(6,3), -0.1, false, true, Point(10,2));
+    r1 = a1.intersect(a2);
+    EXPECT_EQ(r1.size(), 2u);
+    EXPECT_intersections_valid(a1, a2, r1, 1e-10);
+
+    EllipticalArc a3(Point(0,0), Point(5,1.5), 0, true, true, Point(0,2));
+    EllipticalArc a4(Point(3,5), Point(5,1.5), M_PI/2, true, true, Point(5,0));
+    r2 = a3.intersect(a4);
+    EXPECT_EQ(r2.size(), 3u);
+    EXPECT_intersections_valid(a3, a4, r2, 1e-10);
+
+    // Make sure intersections are found between two identical arcs on the unit circle.
+    EllipticalArc const upper(Point(1, 0), Point(1, 1), 0, true, true, Point(-1, 0));
+    auto self_intersect = upper.intersect(upper);
+    EXPECT_EQ(self_intersect.size(), 2u);
+
+    // Make sure intersections are found between overlapping arcs.
+    EllipticalArc const right(Point(0, -1), Point(1, 1), 0, true, true, Point(0, 1));
+    auto quartering_overlap_xings = right.intersect(upper);
+    EXPECT_EQ(quartering_overlap_xings.size(), 2u);
+
+    // Make sure intersecections are found between an arc and its sub-arc.
+    EllipticalArc const middle(upper.pointAtAngle(0.25 * M_PI), Point(1, 1), 0, true, true, upper.pointAtAngle(-0.25 * M_PI));
+    EXPECT_EQ(middle.intersect(upper).size(), 2u);
+
+    // Make sure intersections are NOT found between non-overlapping sub-arcs of the same circle.
+    EllipticalArc const arc1{Point(1, 0), Point(1, 1), 0, true, true, Point(0, 1)};
+    EllipticalArc const arc2{Point(-1, 0), Point(1, 1), 0, true, true, Point(0, -1)};
+    EXPECT_EQ(arc1.intersect(arc2).size(), 0u);
+
+    // Overlapping sub-arcs but on an Ellipse with different rays.
+    EllipticalArc const eccentric{Point(2, 0), Point(2, 1), 0, true, true, Point(-2, 0)};
+    EllipticalArc const subarc{eccentric.pointAtAngle(0.8), Point(2, 1), 0, true, true, eccentric.pointAtAngle(2)};
+    EXPECT_EQ(eccentric.intersect(subarc).size(), 2u);
+
+    // Check intersection times for two touching arcs.
+    EllipticalArc const lower{Point(-1, 0), Point(1, 1), 0, false, true, Point(0, -1)};
+    auto expected_neg_x = upper.intersect(lower);
+    ASSERT_EQ(expected_neg_x.size(), 1);
+    auto const &left_pt = expected_neg_x[0];
+    EXPECT_EQ(left_pt.point(), Point(-1, 0));
+    EXPECT_DOUBLE_EQ(left_pt.first, 1.0); // Expect (-1, 0) reached at the end of upper
+    EXPECT_DOUBLE_EQ(left_pt.second, 0.0); // Expect (-1, 0) passed at the start of lower
+}
+
+TEST(EllipticalArcTest, BezierIntersection) {
+    std::vector<CurveIntersection> r1, r2;
+
+    EllipticalArc a3(Point(0,0), Point(1.5,5), M_PI/2, true, true, Point(0,2));
+    CubicBezier bez1(Point(0,3), Point(7,3), Point(0,-1), Point(7,-1));
+    r1 = a3.intersect(bez1);
+    EXPECT_EQ(r1.size(), 2u);
+    EXPECT_intersections_valid(a3, bez1, r1, 1e-10);
+
+    EllipticalArc a4(Point(3,5), Point(5,1.5), 3*M_PI/2, true, true, Point(5,5));
+    CubicBezier bez2(Point(0,5), Point(10,-4), Point(10,5), Point(0,-4));
+    r2 = a4.intersect(bez2);
+    EXPECT_EQ(r2.size(), 4u);
+    EXPECT_intersections_valid(a4, bez2, r2, 1e-10);
+}
+
+TEST(EllipticalArcTest, ExpandToTransformedTest)
+{
+    auto test_curve = [] (EllipticalArc const &c) {
+        constexpr int N = 50;
+        for (int i = 0; i < N; i++) {
+            auto angle = 2 * M_PI * i / N;
+            auto transform = Affine(Rotate(angle)) * Scale(0.9, 1.2);
+
+            auto copy = std::unique_ptr<Curve>(c.duplicate());
+            *copy *= transform;
+            auto box1 = copy->boundsExact();
+
+            auto pt = c.initialPoint() * transform;
+            auto box2 = Rect(pt, pt);
+            c.expandToTransformed(box2, transform);
+
+            for (auto i : { X, Y }) {
+                EXPECT_NEAR(box1[i].min(), box2[i].min(), 2e-15);
+                EXPECT_NEAR(box1[i].max(), box2[i].max(), 2e-15);
+            }
+        }
+    };
+
+    test_curve(EllipticalArc(Point(0, 0), 1.0, 2.0, 0.0, false, false, Point(1, 1)));
+    test_curve(EllipticalArc(Point(0, 0), 3.0, 2.0, M_PI / 6, false, false, Point(1, 1)));
+    test_curve(EllipticalArc(Point(0, 0), 1.0, 2.0, M_PI / 5, true, true, Point(1, 1)));
+    test_curve(EllipticalArc(Point(1, 0), 1.0, 0.0, M_PI / 5, false, false, Point(1, 1)));
+    test_curve(EllipticalArc(Point(1, 0), 0.0, 0.0, 0.0, false, false, Point(2, 0)));
+    test_curve(EllipticalArc(Point(1, 0), 0.0, 0.0, 0.0, false, false, Point(1, 0)));
+}
diff --git a/tests/implicitization-test.cpp b/tests/implicitization-test.cpp
new file mode 100644
index 0000000..bfc4c58
--- /dev/null
+++ b/tests/implicitization-test.cpp
@@ -0,0 +1,130 @@
+/*
+ * Test program for implicitization routines
+ *
+ * Authors:
+ *      Marco Cecchetti <mrcekets at gmail.com>
+ *
+ * Copyright 2008  authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+
+
+#include <2geom/symbolic/implicit.h>
+
+#include "pick.h"
+
+#include <iostream>
+
+
+
+
+void print_basis(Geom::SL::basis_type const& b)
+{
+    for (size_t i= 0; i < 2; ++i)
+    {
+        for (size_t j= 0; j < 3; ++j)
+        {
+            std::cout << "b[" << i << "][" << j << "] = " << b[i][j] << "\n";
+        }
+    }
+}
+
+
+
+
+int main( int argc, char * argv[] )
+{
+    // degree of polinomial parametrization
+    // warning: not set N to a value greater than 20!
+    // (10 in case you don't utilize the micro-basis)
+    // determinant computation becomes very expensive
+    unsigned int N = 4;
+    // max modulus of polynomial coefficients
+    unsigned int M = 1000;
+
+    if (argc > 1)
+        N = std::atoi(argv[1]);
+    if (argc > 2)
+        M = std::atoi(argv[2]);
+
+    Geom::SL::MVPoly1 f, g;
+    Geom::SL::basis_type b;
+    Geom::SL::MVPoly3 p, q;
+    Geom::SL::Matrix<Geom::SL::MVPoly2> B;
+    Geom::SL::MVPoly2 r;
+
+    // generate two univariate polynomial with degree N
+    // and coeffcient in the range [-M, M]
+    f = pick_multipoly_max<1>(N, M);
+    g = pick_multipoly_max<1>(N, M);
+
+    std::cout << "parametrization: \n";
+    std::cout << "f = " << f << std::endl;
+    std::cout << "g = " << g << "\n\n";
+
+    // computes the micro-basis
+    microbasis(b, f, g);
+    // in case you want utilize directly the initial basis
+    // you should uncomment the next row and comment
+    // the microbasis function call
+    //make_initial_basis(b, f, g);
+
+    std::cout << "generators in vector form : \n";
+    print_basis(b);
+    std::cout << std::endl;
+
+    // micro-basis generators
+    basis_to_poly(p, b[0]);
+    basis_to_poly(q, b[1]);
+
+    std::cout << "generators as polynomial in R[t,x,y] : \n";
+    std::cout << "p = " << p << std::endl;
+    std::cout << "q = " << q << "\n\n";
+
+    // make up the Bezout matrix and compute the determinant
+    B = make_bezout_matrix(p, q);
+    r = determinant_minor(B);
+    r.normalize();
+
+    std::cout << "Bezout matrix: (entries are bivariate polynomials) \n";
+    std::cout << "B = " << B << "\n\n";
+    std::cout << "determinant: \n";
+    std::cout << "r(x, y) = " << r << "\n\n";
+
+    return EXIT_SUCCESS;
+}
+
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/intersection-graph-test.cpp b/tests/intersection-graph-test.cpp
new file mode 100644
index 0000000..19fb25c
--- /dev/null
+++ b/tests/intersection-graph-test.cpp
@@ -0,0 +1,266 @@
+/** @file
+ * @brief Unit tests for PathIntersectionGraph, aka Boolean operations.
+ * Uses the Google Testing Framework
+ *//*
+ * Authors:
+ *   Krzysztof Kosiński <tweenk.pl@gmail.com>
+ * 
+ * Copyright 2015 Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include "testing.h"
+#include <iostream>
+
+#include <2geom/intersection-graph.h>
+#include <2geom/pathvector.h>
+#include <2geom/svg-path-parser.h>
+#include <2geom/svg-path-writer.h>
+#include <glib.h>
+
+using namespace std;
+using namespace Geom;
+
+Path string_to_path(const char* s) {
+    PathVector pv = parse_svg_path(s);
+    assert(pv.size() == 1u);
+    return pv[0];
+}
+
+enum Operation {
+    UNION,
+    INTERSECTION,
+    XOR,
+    A_MINUS_B,
+    B_MINUS_A
+};
+
+class IntersectionGraphTest : public ::testing::Test {
+protected:
+    IntersectionGraphTest() {
+        rectangle = string_to_path("M 0,0 L 5,0 5,8 0,8 Z");
+        bigrect = string_to_path("M -3,-4 L 7,-4 7,12 -3,12 Z");
+        bigh = string_to_path("M 2,-3 L 3,-2 1,2 3,4 4,2 6,3 2,11 0,10 2,5 1,4 -1,6 -2,5 Z");
+        smallrect = string_to_path("M 7,4 L 9,4 9,7 7,7 Z");
+        g_random_set_seed(2345);
+    }
+
+    void checkRandomPoints(PathVector const &a, PathVector const &b, PathVector const &result,
+                           Operation op, unsigned npts = 5000)
+    {
+        Rect bounds = *(a.boundsFast() | b.boundsFast());
+        for (unsigned i = 0; i < npts; ++i) {
+            Point p;
+            p[X] = g_random_double_range(bounds[X].min(), bounds[X].max());
+            p[Y] = g_random_double_range(bounds[Y].min(), bounds[Y].max());
+            bool in_a = a.winding(p) % 2;
+            bool in_b = b.winding(p) % 2;
+            bool in_res = result.winding(p) % 2;
+
+            switch (op) {
+            case UNION:
+                EXPECT_EQ(in_res, in_a || in_b);
+                break;
+            case INTERSECTION:
+                EXPECT_EQ(in_res, in_a && in_b);
+                break;
+            case XOR:
+                EXPECT_EQ(in_res, in_a ^ in_b);
+                break;
+            case A_MINUS_B:
+                EXPECT_EQ(in_res, in_a && !in_b);
+                break;
+            case B_MINUS_A:
+                EXPECT_EQ(in_res, !in_a && in_b);
+                break;
+            }
+        }
+    }
+
+    Path rectangle, bigrect, bigh, smallrect;
+};
+
+TEST_F(IntersectionGraphTest, Union) {
+    PathIntersectionGraph graph(rectangle, bigh);
+    //std::cout << graph << std::endl;
+    PathVector r = graph.getUnion();
+    EXPECT_EQ(r.size(), 1u);
+    EXPECT_EQ(r.curveCount(), 19u);
+
+    checkRandomPoints(rectangle, bigh, r, UNION);
+
+    /*SVGPathWriter wr;
+    wr.feed(r);
+    std::cout << wr.str() << std::endl;*/
+}
+
+TEST_F(IntersectionGraphTest, DisjointUnion) {
+    PathIntersectionGraph graph(rectangle, smallrect);
+
+    PathVector r = graph.getUnion();
+    EXPECT_EQ(r.size(), 2u);
+    checkRandomPoints(rectangle, smallrect, r, UNION);
+}
+
+TEST_F(IntersectionGraphTest, CoverUnion) {
+    PathIntersectionGraph graph(bigrect, bigh);
+    PathVector r = graph.getUnion();
+    EXPECT_EQ(r.size(), 1u);
+    EXPECT_EQ(r, bigrect);
+}
+
+TEST_F(IntersectionGraphTest, Subtraction) {
+    PathIntersectionGraph graph(rectangle, bigh);
+    PathVector a = graph.getAminusB();
+    EXPECT_EQ(a.size(), 4u);
+    EXPECT_EQ(a.curveCount(), 17u);
+    checkRandomPoints(rectangle, bigh, a, A_MINUS_B);
+
+    PathVector b = graph.getBminusA();
+    EXPECT_EQ(b.size(), 4u);
+    EXPECT_EQ(b.curveCount(), 15u);
+    checkRandomPoints(rectangle, bigh, b, B_MINUS_A);
+
+    PathVector x = graph.getXOR();
+    EXPECT_EQ(x.size(), 8u);
+    EXPECT_EQ(x.curveCount(), 32u);
+    checkRandomPoints(rectangle, bigh, x, XOR);
+}
+
+TEST_F(IntersectionGraphTest, PointOnEdge) {
+    PathVector a = string_to_path("M 0,0 L 10,0 10,10 0,10 z");
+    PathVector b = string_to_path("M -5,2 L 0,2 5,5 0,8 -5,8 z");
+
+    PathIntersectionGraph graph(a, b);
+    PathVector u = graph.getUnion();
+    //std::cout << u << std::endl;
+    EXPECT_EQ(u.size(), 1u);
+    EXPECT_EQ(u.curveCount(), 8u);
+    checkRandomPoints(a, b, u, UNION);
+
+    PathVector i = graph.getIntersection();
+    //std::cout << i << std::endl;
+    EXPECT_EQ(i.size(), 1u);
+    EXPECT_EQ(i.curveCount(), 3u);
+    checkRandomPoints(a, b, i, INTERSECTION);
+
+    PathVector s1 = graph.getAminusB();
+    //std::cout << s1 << std::endl;
+    EXPECT_EQ(s1.size(), 1u);
+    EXPECT_EQ(s1.curveCount(), 7u);
+    checkRandomPoints(a, b, s1, A_MINUS_B);
+
+    PathVector s2 = graph.getBminusA();
+    //std::cout << s2 << std::endl;
+    EXPECT_EQ(s2.size(), 1u);
+    EXPECT_EQ(s2.curveCount(), 4u);
+    checkRandomPoints(a, b, s2, B_MINUS_A);
+
+    PathVector x = graph.getXOR();
+    //std::cout << x << std::endl;
+    EXPECT_EQ(x.size(), 2u);
+    EXPECT_EQ(x.curveCount(), 11u);
+    checkRandomPoints(a, b, x, XOR);
+}
+
+TEST_F(IntersectionGraphTest, RhombusInSquare) {
+    PathVector square = string_to_path("M 0,0 L 10,0 10,10 0,10 z");
+    PathVector rhombus = string_to_path("M 5,0 L 10,5 5,10 0,5 z");
+
+    PathIntersectionGraph graph(square, rhombus);
+    //std::cout << graph << std::endl;
+    PathVector u = graph.getUnion();
+    EXPECT_EQ(u.size(), 1u);
+    EXPECT_EQ(u.curveCount(), 4u);
+    checkRandomPoints(square, rhombus, u, UNION);
+
+    PathVector i = graph.getIntersection();
+    EXPECT_EQ(i.size(), 1u);
+    EXPECT_EQ(i.curveCount(), 4u);
+    checkRandomPoints(square, rhombus, i, INTERSECTION);
+
+    PathVector s1 = graph.getAminusB();
+    EXPECT_EQ(s1.size(), 2u);
+    EXPECT_EQ(s1.curveCount(), 8u);
+    checkRandomPoints(square, rhombus, s1, A_MINUS_B);
+
+    PathVector s2 = graph.getBminusA();
+    EXPECT_EQ(s2.size(), 0u);
+    EXPECT_EQ(s2.curveCount(), 0u);
+    checkRandomPoints(square, rhombus, s2, B_MINUS_A);
+}
+
+TEST_F(IntersectionGraphTest, EmptyOperand) {
+    PathVector square = string_to_path("M 0,0 L 20, 0 L 20, 20 L 0, 20 Z");
+    PathVector empty;
+
+    auto graph = PathIntersectionGraph(square, empty);
+    // Taking union with the empty set should be a no-op: A ∪ ∅ = A
+    PathVector u = graph.getUnion();
+    EXPECT_EQ(u.size(), 1u);
+    EXPECT_EQ(u.curveCount(), 4u);
+
+    // Intersection with empty should produce empty: A ∩ ∅ = ∅
+    PathVector i = graph.getIntersection();
+    EXPECT_EQ(i.size(), 0u);
+
+    // Subtracting empty set should be a no-op: A ∖ ∅ = A
+    PathVector rd = graph.getAminusB();
+    EXPECT_EQ(rd.size(), 1u);
+    EXPECT_EQ(rd.curveCount(), 4u);
+
+    // Subtracting FROM the empty set should produce the empty set: ∅ ∖ A = ∅
+    PathVector ld = graph.getBminusA();
+    EXPECT_EQ(ld.size(), 0u);
+}
+
+// this test is disabled, since we cannot handle overlapping segments for now.
+#if 0
+TEST_F(IntersectionGraphTest, EqualUnionAndIntersection) {
+    PathVector shape = string_to_path("M 0,0 L 2,1 -1,2 -1,3 0,3 z");
+    PathIntersectionGraph graph(shape, shape);
+    std::cout << graph << std::endl;
+    PathVector a = graph.getUnion();
+    std::cout << shape << std::endl;
+    std::cout << a << std::endl;
+    checkRandomPoints(shape, shape, a, UNION);
+
+    PathIntersectionGraph graph2(bigh, bigh);
+    PathVector b = graph2.getIntersection();
+    checkRandomPoints(bigh, bigh, b, INTERSECTION);
+    std::cout << b <<std::endl;
+}
+#endif
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/interval-test.cpp b/tests/interval-test.cpp
new file mode 100644
index 0000000..eccea70
--- /dev/null
+++ b/tests/interval-test.cpp
@@ -0,0 +1,54 @@
+/** @file
+ * @brief Unit tests for Interval, OptInterval, IntInterval, OptIntInterval.
+ *//*
+ * Authors:
+ *   Thomas Holder
+ *
+ * Copyright 2021 Authors
+ *
+ * SPDX-License-Identifier: LGPL-2.1 OR MPL-1.1
+ */
+
+#include <2geom/interval.h>
+#include <gtest/gtest.h>
+
+TEST(IntervalTest, EqualityTest)
+{
+    Geom::Interval a(3, 5), a2(a), b(4, 7);
+    Geom::OptInterval empty, oa = a;
+
+    EXPECT_TRUE(a == a);
+    EXPECT_FALSE(a != a);
+    EXPECT_TRUE(a == a2);
+    EXPECT_FALSE(a != a2);
+    EXPECT_TRUE(empty == empty);
+    EXPECT_FALSE(empty != empty);
+    EXPECT_FALSE(a == empty);
+    EXPECT_TRUE(a != empty);
+    EXPECT_FALSE(empty == a);
+    EXPECT_TRUE(empty != a);
+    EXPECT_FALSE(a == b);
+    EXPECT_TRUE(a != b);
+    EXPECT_TRUE(a == oa);
+    EXPECT_FALSE(a != oa);
+
+    Geom::IntInterval ia(3, 5), ia2(ia), ib(4, 7);
+    Geom::OptIntInterval iempty, ioa = ia;
+
+    EXPECT_TRUE(ia == ia);
+    EXPECT_FALSE(ia != ia);
+    EXPECT_TRUE(ia == ia2);
+    EXPECT_FALSE(ia != ia2);
+    EXPECT_TRUE(iempty == iempty);
+    EXPECT_FALSE(iempty != iempty);
+    EXPECT_FALSE(ia == iempty);
+    EXPECT_TRUE(ia != iempty);
+    EXPECT_FALSE(iempty == ia);
+    EXPECT_TRUE(iempty != ia);
+    EXPECT_FALSE(ia == ib);
+    EXPECT_TRUE(ia != ib);
+    EXPECT_TRUE(ia == ioa);
+    EXPECT_FALSE(ia != ioa);
+}
+
+// vim: filetype=cpp:expandtab:shiftwidth=4:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/linalg-test.cpp b/tests/linalg-test.cpp
new file mode 100644
index 0000000..b7e2f42
--- /dev/null
+++ b/tests/linalg-test.cpp
@@ -0,0 +1,502 @@
+
+
+#include "numeric/vector.h"
+#include "numeric/matrix.h"
+
+#include <iostream>
+
+using namespace Geom;
+
+
+template< class charT >
+inline
+std::basic_ostream<charT> & 
+operator<< (std::basic_ostream<charT> & os, const std::pair<size_t, size_t>& index_pair)
+{
+	os << "{" << index_pair.first << "," << index_pair.second << "}";
+	return os;
+}
+
+template< typename T, typename U>
+void check_test( const char* description, T output, U expected )
+{
+	bool result = ( output == expected );
+	std::cout << "# " << description << " : ";
+	if ( result )
+		std::cout << "success!" << std::endl;
+	else
+		std::cout << "fail!" << std::endl
+		          << "    output:    " << output << std::endl
+		          << "    expected:  " << expected << std::endl;
+}
+
+
+void vector_test()
+{
+	// Deprecated. Replaced by ** Vector examples **
+	// in nl-vector-test.cpp
+	/*
+	NL::Vector v1(10), v2(10), v3(5);
+	for (unsigned int i = 0; i < v1.size(); ++i)
+	{
+		v1[i] = i;
+	}
+	std::cout << "v1: " << v1 << std::endl;
+	v2 = v1;
+	std::cout << "v2 = v1 : " << v2 << std::endl;
+	bool value = (v1 == v2);
+	std::cout << "(v1 == v2) : " << value << std::endl;
+	v2.scale(10);
+	std::cout << "v2.scale(10) : " << v2 << std::endl;
+	value = (v1 == v2);
+	std::cout << "(v1 == v2) : " << value << std::endl;
+	v2.translate(20);
+	std::cout << "v2.translate(20) : " << v2 << std::endl;
+	v2 += v1;
+	std::cout << "v2 += v1 : " << v2 << std::endl;
+	v2.swap_elements(3, 9);
+	std::cout << "v2.swap_elements(3, 9) : " << v2 << std::endl;
+	v2.reverse();
+	std::cout << "v2.reverse() : " << v2 << std::endl;
+	value = v2.is_positive();
+	std::cout << "v2.is_positive() : " << value << std::endl;
+	v2 -= v1;
+	std::cout << "v2 -= v1 : " << v2 << std::endl;
+	double bound = v2.max();
+	std::cout << "v2.max() : " << bound << std::endl;
+	bound = v2.min();
+	std::cout << "v2.min() : " << bound << std::endl;
+	unsigned int index = v2.max_index();
+	std::cout << "v2.max_index() : " << index << std::endl;
+	index = v2.min_index();
+	std::cout << "v2.min_index() : " << index << std::endl;
+	v2.set_basis(4);
+	std::cout << "v2.set_basis(4) : " << v2 << std::endl;
+	value = v2.is_non_negative();
+	std::cout << "v2.is_non_negative() : " << value << std::endl;
+	v2.set_all(0);
+	std::cout << "v2.set_all(0) : " << v2 << std::endl;
+	value = v2.is_zero();
+	std::cout << "v2.is_zero() : " << value << std::endl;
+	NL::swap(v1, v2);
+	std::cout << "swap(v1, v2) : v1: " << v1 << " v2: " << v2 << std::endl;
+	*/
+}
+
+
+void const_vector_view_test()
+{
+	NL::Vector v1(10);
+	for (unsigned int i = 0; i < v1.size(); ++i)
+		v1[i] = i;
+	NL::VectorView vv1(v1, 5, 1, 2);
+	vv1.scale(10);
+	std::cout << "v1 = " << v1 << std::endl;
+	
+	NL::ConstVectorView cvv1(v1, 6, 1);
+	check_test( "cvv1(v1, 6, 1)", cvv1.str(), "[10, 2, 30, 4, 50, 6]");
+	NL::ConstVectorView cvv2(v1, 3, 1, 3);
+	check_test( "cvv2(v1, 3, 1, 3)", cvv2.str(), "[10, 4, 70]");
+	NL::ConstVectorView cvv3(vv1, 3, 0, 2);
+	std::cout << "vv1 = " << vv1 << std::endl;
+	check_test( "cvv3(vv1, 3, 0, 2)", cvv3.str(), "[10, 50, 90]");
+	NL::ConstVectorView cvv4(cvv1, 3, 1, 2);
+	check_test( "cvv4(cvv1, 3, 1, 2)", cvv4.str(), "[2, 4, 6]");
+	bool value = (cvv2 == cvv4);
+	check_test( "(cvv2 == cvv4)", value, false);
+	
+	value = cvv2.is_zero();
+	check_test( "cvv2.is_zero()", value, false);
+	value = cvv2.is_negative();
+	check_test( "cvv2.is_negative()", value, false);
+	value = cvv2.is_positive();
+	check_test( "cvv2.is_positive()", value, true);
+	value = cvv2.is_non_negative();
+	check_test( "cvv2.is_non_negative()", value, true);
+
+	NL::VectorView vv2(v1, 3, 1, 3);
+	vv2.scale(-1);
+	value = cvv2.is_zero();
+	std::cout << "v1 = " << v1 << std::endl;
+	check_test( "cvv2.is_zero()", value, false);
+	value = cvv2.is_negative();
+	check_test( "cvv2.is_negative()", value, true);
+	value = cvv2.is_positive();
+	check_test( "cvv2.is_positive()", value, false);
+	value = cvv2.is_non_negative();
+	check_test( "cvv2.is_non_negative()", value, false);
+	
+	vv2.set_all(0);
+	std::cout << "v1 = " << v1 << std::endl;
+	value = cvv2.is_zero();
+	check_test( "cvv2.is_zero()", value, true);	
+	value = cvv2.is_negative();
+	check_test( "cvv2.is_negative()", value, false);
+	value = cvv2.is_positive();
+	check_test( "cvv2.is_positive()", value, false);
+	value = cvv2.is_non_negative();
+	check_test( "cvv2.is_non_negative()", value, true);
+	
+	vv1.reverse();
+	vv2[0] = -1;
+	std::cout << "v1 = " << v1 << std::endl;
+	value = cvv2.is_zero();
+	check_test( "cvv2.is_zero()", value, false);	
+	value = cvv2.is_negative();
+	check_test( "cvv2.is_negative()", value, false);
+	value = cvv2.is_positive();
+	check_test( "cvv2.is_positive()", value, false);
+	value = cvv2.is_non_negative();
+	check_test( "cvv2.is_non_negative()", value, false);
+	
+	vv2 = cvv2;
+	value = (vv2 == cvv2);
+	std::cout << "vv2 = " << vv2 << std::endl;
+	check_test( "(vv2 == cvv2)", value, true);
+	NL::Vector v2(cvv2.size());
+	v2 = cvv4;
+	value = (v2 == cvv2);
+	std::cout << "v2 = " << v2 << std::endl;
+	check_test( "(v2 == cvv2)", value, false);
+	const NL::Vector v3(cvv2.size());
+	NL::ConstVectorView cvv5(v3, v3.size());
+	check_test( "cvv5(v3, v3.size())", cvv4.str(), "[2, 0, 6]");
+
+}
+
+void vector_view_test()
+{
+	// Deprecated. Replaced by ** VectorView examples **
+	// in nl-vector-test.cpp
+	/*
+	NL::Vector v1(10);
+	for (unsigned int i = 0; i < v1.size(); ++i)
+		v1[i] = i;
+	NL::VectorView vv1(v1, 5), vv2(v1, 5, 3), vv3(v1, 5, 0, 2), vv4(v1, 5, 1, 2);
+	std::cout << "v1 = " << v1 << std::endl;
+	check_test( "vv1(v1, 5)", vv1.str(), "[0, 1, 2, 3, 4]");
+	check_test( "vv2(v1, 5, 3)", vv2.str(), "[3, 4, 5, 6, 7]");
+	check_test( "vv3(v1, 5, 0, 2)", vv3.str(), "[0, 2, 4, 6, 8]");
+	check_test( "vv4(v1, 5, 1, 2)", vv4.str(), "[1, 3, 5, 7, 9]");
+	
+	NL::VectorView vv5(vv4, 3, 0, 2);
+	std::cout << "vv4 = " << vv4 << std::endl;
+	check_test( "vv5(vv4, 3, 0, 2)", vv5.str(), "[1, 5, 9]");
+	vv5.scale(10);
+	check_test( "vv5.scale(10) : vv5", vv5.str(), "[10, 50, 90]");
+	check_test( "              : v1", v1.str(), "[0, 10, 2, 3, 4, 50, 6, 7, 8, 90]");
+	vv5.translate(20);
+	check_test( "vv5.translate(20) : vv5", vv5.str(), "[30, 70, 110]");
+	check_test( "                  : v1", v1.str(), "[0, 30, 2, 3, 4, 70, 6, 7, 8, 110]");
+	vv1 += vv2;
+	check_test("vv1 += vv2", vv1.str(), "[3, 34, 72, 9, 11]");
+	vv1 -= vv2;
+	check_test("vv1 -= vv2", vv1.str(), "[-6, 23, 2, 3, 4]");
+	NL::ConstVectorView cvv1(vv3, 3);
+	vv5 = cvv1;
+	check_test("vv5 = cvv1", vv5.str(), "[-6, 2, 4]");
+	vv5 += cvv1;
+	check_test("vv5 += cvv1", vv5.str(), "[-12, 4, 8]");
+	vv5 -= cvv1;
+	check_test("vv5 -= cvv1", vv5.str(), "[-6, 2, 4]");
+	NL::Vector v2(vv1);
+	std::cout << "v2 = " << v2 << std::endl;
+	vv1 = v2;
+	check_test( "vv1 = v2", vv1.str(), "[-6, -6, 2, 3, 4]");
+	vv1 += v2;
+	check_test( "vv1 += v2", vv1.str(), "[-12, -12, 4, 6, 8]");
+	vv1 -= v2;
+	check_test( "vv1 -= v2", vv1.str(), "[-6, -6, 2, 3, 4]");
+	NL::swap_view(vv1, vv4);
+	check_test( "swap_view(vv1, vv4)", v1.str(), "[-6, -6, 2, 3, 4, 2, 6, 7, 8, 4]");
+	*/
+}
+
+
+void const_matrix_view_test()
+{
+	NL::Matrix m0(8,4);
+	for (size_t i = 0; i < m0.rows(); ++i)
+	{
+		for (size_t j = 0; j < m0.columns(); ++j)
+		{
+			m0(i,j) = 10 * i + j;
+		}
+	}
+	std::cout << "m0 = " << m0 << std::endl;
+	
+	// constructor test
+	NL::Matrix m1(m0);
+	NL::ConstMatrixView cmv1(m1, 2, 1, 4, 2);
+	check_test("cmv1(m1, 2, 1, 4, 2)", cmv1.str(), "[[21, 22], [31, 32], [41, 42], [51, 52]]");
+	NL::MatrixView mv1(m1, 2, 0, 4, 4);
+	NL::ConstMatrixView cmv2(mv1, 2, 1, 2, 2);
+	check_test("cmv2(mv1, 2, 1, 2, 2)", cmv2.str(), "[[41, 42], [51, 52]]");
+	NL::ConstMatrixView cmv3(cmv1, 1, 1, 3, 1);
+	check_test("cmv3(cmv1, 1, 1, 2, 1)", cmv3.str(), "[[32], [42], [52]]");
+	const NL::Matrix & m2 = m1;
+	NL::ConstMatrixView cmv4(m2, 2, 1, 4, 2);
+	check_test("cmv4(m2, 2, 1, 4, 2)", cmv4.str(), "[[21, 22], [31, 32], [41, 42], [51, 52]]");
+	const NL::MatrixView & mv2 = mv1;
+	NL::ConstMatrixView cmv5(mv2, 2, 1, 2, 2);
+	check_test("cmv5(mv2, 2, 1, 2, 2)", cmv5.str(), "[[41, 42], [51, 52]]");
+	
+	// row and column view test
+	NL::ConstVectorView cvv1 = cmv1.row_const_view(2);
+	check_test("cvv1 = cmv1.row_const_view(2)", cvv1.str(), "[41, 42]");
+	NL::ConstVectorView cvv2 = cmv1.column_const_view(0);
+	check_test("cvv2 = cmv1.column_const_view(0)", cvv2.str(), "[21, 31, 41, 51]");
+	
+	// property test
+	bool value = cmv1.is_negative();
+	check_test("cmv1.is_negative()", value, false);
+	value = cmv1.is_non_negative();
+	check_test("cmv1.is_non_negative()", value, true);
+	value = cmv1.is_positive();
+	check_test("cmv1.is_positive()", value, true);
+	value = cmv1.is_zero();
+	check_test("cmv1.is_zero()", value, false);
+	
+	m1.scale(-1);
+	value = cmv1.is_negative();
+	check_test("cmv1.is_negative()", value, true);
+	value = cmv1.is_non_negative();
+	check_test("cmv1.is_non_negative()", value, false);
+	value = cmv1.is_positive();
+	check_test("cmv1.is_positive()", value, false);
+	value = cmv1.is_zero();
+	check_test("cmv1.is_zero()", value, false);
+	
+	m1.translate(35);
+	value = cmv1.is_negative();
+	check_test("cmv1.is_negative()", value, false);
+	value = cmv1.is_non_negative();
+	check_test("cmv1.is_non_negative()", value, false);
+	value = cmv1.is_positive();
+	check_test("cmv1.is_positive()", value, false);
+	value = cmv1.is_zero();
+	check_test("cmv1.is_zero()", value, false);
+	
+	m1.set_all(0);
+	value = cmv1.is_negative();
+	check_test("cmv1.is_negative()", value, false);
+	value = cmv1.is_non_negative();
+	check_test("cmv1.is_non_negative()", value, true);
+	value = cmv1.is_positive();
+	check_test("cmv1.is_positive()", value, false);
+	value = cmv1.is_zero();
+	check_test("cmv1.is_zero()", value, true);
+	
+	m1.set_identity();
+	value = cmv1.is_negative();
+	check_test("cmv1.is_negative()", value, false);
+	value = cmv1.is_non_negative();
+	check_test("cmv1.is_non_negative()", value, true);
+	value = cmv1.is_positive();
+	check_test("cmv1.is_positive()", value, false);
+	value = cmv1.is_zero();
+	check_test("cmv1.is_zero()", value, false);
+	
+	// max, min test
+	m1 = m0;
+	std::cout << "cmv1 = " << cmv1 << std::endl;
+	std::pair<size_t, size_t> out_elem = cmv1.max_index();
+	std::pair<size_t, size_t> exp_elem(3,1);
+	check_test("cmv1.max_index()", out_elem, exp_elem);
+	double bound = cmv1.max();
+	check_test("cmv1.max()", bound, cmv1(exp_elem.first, exp_elem.second));
+	out_elem = cmv1.min_index();
+	exp_elem.first = 0; exp_elem.second = 0;
+	check_test("cmv1.min_index()", out_elem, exp_elem);
+	bound = cmv1.min();
+	check_test("cmv1.min()", bound, cmv1(exp_elem.first, exp_elem.second));
+	
+}
+
+
+void matrix_view_test()
+{
+	NL::Matrix m0(8,4);
+	for (size_t i = 0; i < m0.rows(); ++i)
+	{
+		for (size_t j = 0; j < m0.columns(); ++j)
+		{
+			m0(i,j) = 10 * i + j;
+		}
+	}
+	std::cout << "m0 = " << m0 << std::endl;
+	
+	// constructor test
+	NL::Matrix m1(m0);
+	NL::MatrixView mv1(m1, 2, 1, 4, 2);
+	check_test("mv1(m1, 2, 1, 4, 2)", mv1.str(), "[[21, 22], [31, 32], [41, 42], [51, 52]]");
+	NL::MatrixView mv2(mv1, 2, 1, 2, 1);
+	check_test("mv2(mv1, 2, 1, 2, 1)", mv2.str(), "[[42], [52]]");
+
+	// operator = test
+	NL::Matrix m2(4,2);
+	m2.set_all(0);
+	mv1 = m2;
+	check_test("mv1 = m2", m1.str(), "[[0, 1, 2, 3], [10, 11, 12, 13], [20, 0, 0, 23], [30, 0, 0, 33], [40, 0, 0, 43], [50, 0, 0, 53], [60, 61, 62, 63], [70, 71, 72, 73]]");
+	m1 = m0;
+	NL::MatrixView mv3(m2, 0, 0, 4, 2);
+	mv1 = mv3;
+	check_test("mv1 = mv3", m1.str(), "[[0, 1, 2, 3], [10, 11, 12, 13], [20, 0, 0, 23], [30, 0, 0, 33], [40, 0, 0, 43], [50, 0, 0, 53], [60, 61, 62, 63], [70, 71, 72, 73]]");
+	m1 = m0;
+	NL::ConstMatrixView cmv1(m2, 0, 0, 4, 2);
+	mv1 = cmv1;
+	check_test("mv1 = cmv1", m1.str(), "[[0, 1, 2, 3], [10, 11, 12, 13], [20, 0, 0, 23], [30, 0, 0, 33], [40, 0, 0, 43], [50, 0, 0, 53], [60, 61, 62, 63], [70, 71, 72, 73]]");
+	
+	// operator == test
+	m2.set_identity();
+	mv1 = m2;
+	bool value =  (mv1 == m2);
+	check_test("(mv1 == m2)", value, true);
+	value = (mv1 == mv3);
+	check_test("(mv1 == mv3)", value, true);
+	value = (mv1 == cmv1);
+	check_test("(mv1 == cmv1)", value, true);
+	
+	// row and column view test
+	m1 = m0;
+	NL::ConstVectorView cvv1 = mv1.row_const_view(2);
+	check_test("cvv1 = mv1.row_const_view(2)", cvv1.str(), "[41, 42]");
+	NL::ConstVectorView cvv2 = mv1.column_const_view(0);
+	check_test("cvv2 = mv1.column_const_view(0)", cvv2.str(), "[21, 31, 41, 51]");
+	NL::VectorView vv1 = mv1.row_view(2);
+	check_test("vv1 = mv1.row_view(2)", vv1.str(), "[41, 42]");
+	NL::VectorView vv2 = mv1.column_view(0);
+	check_test("vv2 = mv1.column_view(0)", vv2.str(), "[21, 31, 41, 51]");
+	
+	// swap_view test
+	m1 = m0;
+	swap_view(mv1, mv3);
+	check_test("swap_view(mv1, mv3) : mv1", mv1.str(), "[[1, 0], [0, 1], [0, 0], [0, 0]]");
+	check_test("                    : m1", m1.str(), m0.str());
+	check_test("                    : mv3", mv3.str(), "[[21, 22], [31, 32], [41, 42], [51, 52]]");
+	check_test("                    : m2", m2.str(), "[[1, 0], [0, 1], [0, 0], [0, 0]]");
+	swap_view(mv1, mv3);
+	
+	// modifying operations test
+	m1 = m0;
+	m2.set_all(10);
+	mv1 += m2;
+	check_test("mv1 += m2", m1.str(), "[[0, 1, 2, 3], [10, 11, 12, 13], [20, 31, 32, 23], [30, 41, 42, 33], [40, 51, 52, 43], [50, 61, 62, 53], [60, 61, 62, 63], [70, 71, 72, 73]]");
+	mv1 -= m2;
+	check_test("mv1 -= m2", m1.str(), m0.str());
+	mv1 += mv3;
+	check_test("mv1 += mv3", m1.str(), "[[0, 1, 2, 3], [10, 11, 12, 13], [20, 31, 32, 23], [30, 41, 42, 33], [40, 51, 52, 43], [50, 61, 62, 53], [60, 61, 62, 63], [70, 71, 72, 73]]");
+	mv1 -= mv3;
+	check_test("mv1 -= mv3", m1.str(), m0.str());
+	mv1 += cmv1;
+	check_test("mv1 += cmv1", m1.str(), "[[0, 1, 2, 3], [10, 11, 12, 13], [20, 31, 32, 23], [30, 41, 42, 33], [40, 51, 52, 43], [50, 61, 62, 53], [60, 61, 62, 63], [70, 71, 72, 73]]");
+	mv1 -= cmv1;
+	check_test("mv1 -= cmv1", m1.str(), m0.str());
+	
+	m1 = m0;
+	mv1.swap_rows(0,3);
+	check_test("mv1.swap_rows(0,3)", m1.str(), "[[0, 1, 2, 3], [10, 11, 12, 13], [20, 51, 52, 23], [30, 31, 32, 33], [40, 41, 42, 43], [50, 21, 22, 53], [60, 61, 62, 63], [70, 71, 72, 73]]");
+	m1 = m0;
+	mv1.swap_columns(0,1);
+	check_test("mv1.swap_columns(0,3)", m1.str(), "[[0, 1, 2, 3], [10, 11, 12, 13], [20, 22, 21, 23], [30, 32, 31, 33], [40, 42, 41, 43], [50, 52, 51, 53], [60, 61, 62, 63], [70, 71, 72, 73]]");
+	
+	m1 = m0;
+	NL::MatrixView mv4(m1, 0, 0, 4, 4);
+	mv4.transpose();
+	check_test("mv4.transpose()", m1.str(), "[[0, 10, 20, 30], [1, 11, 21, 31], [2, 12, 22, 32], [3, 13, 23, 33], [40, 41, 42, 43], [50, 51, 52, 53], [60, 61, 62, 63], [70, 71, 72, 73]]");
+	
+}
+
+void matrix_test()
+{
+	NL::Matrix m0(8,4);
+	for (size_t i = 0; i < m0.rows(); ++i)
+	{
+		for (size_t j = 0; j < m0.columns(); ++j)
+		{
+			m0(i,j) = 10 * i + j;
+		}
+	}
+	std::cout << "m0 = " << m0 << std::endl;
+	
+	// constructor test
+	NL::Matrix m1(m0);
+	check_test("m1(m0)", m1.str(), m0.str());
+	NL::MatrixView mv1(m0, 2, 1, 4, 2);
+	NL::Matrix m2(mv1);
+	check_test("m2(mv1)", m2.str(), mv1.str());
+	NL::MatrixView cmv1(m0, 2, 1, 4, 2);
+	NL::Matrix m3(cmv1);
+	check_test("m3(cmv1)", m3.str(), cmv1.str());
+	
+	// operator = and operator == test
+	m1.set_all(0);
+	m1 = m0;
+	check_test("m1 = m0", m1.str(), m0.str());
+	bool value = (m1 == m0);
+	check_test("m1 == m0", value, true);
+	m2.set_all(0);
+	m2 = mv1;
+	check_test("m2 = mv1", m2.str(), mv1.str());
+	value = (m2 == mv1);
+	check_test("m2 == mv1", value, true);
+	m2.set_all(0);
+	m2 = cmv1;
+	check_test("m2 = cmv1", m2.str(), cmv1.str());
+	value = (m2 == cmv1);
+	check_test("m2 == cmv1", value, true);
+
+	// row and column view test
+	NL::ConstVectorView cvv1 = m2.row_const_view(2);
+	check_test("cvv1 = m2.row_const_view(2)", cvv1.str(), "[41, 42]");
+	NL::ConstVectorView cvv2 = m2.column_const_view(0);
+	check_test("cvv2 = m2.column_const_view(0)", cvv2.str(), "[21, 31, 41, 51]");
+	NL::VectorView vv1 = m2.row_view(2);
+	check_test("vv1 = m2.row_view(2)", vv1.str(), "[41, 42]");
+	NL::VectorView vv2 = m2.column_view(0);
+	check_test("vv2 = m2.column_view(0)", vv2.str(), "[21, 31, 41, 51]");
+	
+	
+	// modifying operations test
+	NL::Matrix m4(8,4);
+	m4.set_all(0);
+	m1.set_all(0);
+	m1 += m0;
+	check_test("m1 += m0", m1.str(), m0.str());
+	m1 -= m0;
+	check_test("m1 -= m0", m1.str(), m4.str());
+	NL::Matrix m5(4,2);
+	m5.set_all(0);
+	m2.set_all(0);
+	m2 += mv1;
+	check_test("m2 += mv1", m2.str(), mv1.str());
+	m2 -= mv1;
+	check_test("m2 -= mv1", m2.str(), m5.str());
+	m2.set_all(0);
+	m2 += cmv1;
+	check_test("m2 += cmv1", m2.str(), cmv1.str());
+	m2 -= cmv1;
+	check_test("m2 -= cmv1", m2.str(), m5.str());
+	
+	// swap test	
+	m3.set_identity();
+	m5.set_identity();
+	m1 = m0;
+	m2 = mv1;
+	swap(m2, m3);
+	check_test("swap(m2, m3) : m2", m2.str(), m5.str());
+	check_test("             : m3", m3.str(), mv1.str());
+
+}
+
+int main(int argc, char **argv) 
+{	
+    //const_vector_view_test();
+    //vector_view_test();
+	const_matrix_view_test();
+	//matrix_view_test();
+	//matrix_test();
+    return 0;
+}
+
+
diff --git a/tests/line-test.cpp b/tests/line-test.cpp
new file mode 100644
index 0000000..0625566
--- /dev/null
+++ b/tests/line-test.cpp
@@ -0,0 +1,185 @@
+/** @file
+ * @brief Unit tests for Line and related functions
+ * Uses the Google Testing Framework
+ *//*
+ * Authors:
+ *   Krzysztof Kosiński <tweenk.pl@gmail.com>
+ * 
+ * Copyright 2015 Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include "testing.h"
+#include <iostream>
+#include <glib.h>
+
+#include <2geom/line.h>
+#include <2geom/affine.h>
+
+using namespace Geom;
+
+TEST(LineTest, VectorAndVersor) {
+    Line a(Point(10, 10), Point(-10, 20));
+    Line b(Point(10, 10), Point(15, 15));
+    EXPECT_EQ(a.vector(), Point(-20, 10));
+    EXPECT_EQ(b.vector(), Point(5, 5));
+    EXPECT_EQ(a.versor(), a.vector().normalized());
+    EXPECT_EQ(b.versor(), b.vector().normalized());
+}
+
+TEST(LineTest, AngleBisector) {
+    Point o(0,0), a(1,1), b(3,0), c(-4, 0);
+    Point d(0.5231, 0.75223);
+
+    // normal
+    Line ab1 = make_angle_bisector_line(a + d, o + d, b + d);
+    Line ab2 = make_angle_bisector_line(a - d, o - d, b - d);
+    EXPECT_FLOAT_EQ(ab1.angle(), Angle::from_degrees(22.5));
+    EXPECT_FLOAT_EQ(ab2.angle(), Angle::from_degrees(22.5));
+
+    // half angle
+    Line bc1 = make_angle_bisector_line(b + d, o + d, c + d);
+    Line bc2 = make_angle_bisector_line(b - d, o - d, c - d);
+    EXPECT_FLOAT_EQ(bc1.angle(), Angle::from_degrees(90));
+    EXPECT_FLOAT_EQ(bc2.angle(), Angle::from_degrees(90));
+
+    // zero angle
+    Line aa1 = make_angle_bisector_line(a + d, o + d, a + d);
+    Line aa2 = make_angle_bisector_line(a - d, o - d, a - d);
+    EXPECT_FLOAT_EQ(aa1.angle(), Angle::from_degrees(45));
+    EXPECT_FLOAT_EQ(aa2.angle(), Angle::from_degrees(45));
+}
+
+TEST(LineTest, Equality) {
+    Line a(Point(0,0), Point(2,2));
+    Line b(Point(2,2), Point(5,5));
+
+    EXPECT_EQ(a, a);
+    EXPECT_EQ(b, b);
+    EXPECT_EQ(a, b);
+}
+
+TEST(LineTest, Reflection) {
+    Line a(Point(10, 0), Point(15,5));
+    Point pa(10,5), ra(15,0);
+
+    Line b(Point(1,-2), Point(2,0));
+    Point pb(5,1), rb(1,3);
+    Affine reflecta = a.reflection(), reflectb = b.reflection();
+
+    Point testra = pa * reflecta;
+    Point testrb = pb * reflectb;
+
+    constexpr Coord eps{1e-12};
+    EXPECT_near(testra[X], ra[X], eps);
+    EXPECT_near(testra[Y], ra[Y], eps);
+    EXPECT_near(testrb[X], rb[X], eps);
+    EXPECT_near(testrb[Y], rb[Y], eps);
+}
+
+TEST(LineTest, RotationToZero) {
+    Line a(Point(-5,23), Point(15,27));
+    Affine mx = a.rotationToZero(X);
+    Affine my = a.rotationToZero(Y);
+
+    for (unsigned i = 0; i <= 12; ++i) {
+        double t = -1 + 0.25 * i;
+        Point p = a.pointAt(t);
+        Point rx = p * mx;
+        Point ry = p * my;
+        //std::cout << rx[X] << " " << ry[Y] << std::endl;
+        // unfortunately this is precise only to about 1e-14
+        EXPECT_NEAR(rx[X], 0, 1e-14);
+        EXPECT_NEAR(ry[Y], 0, 1e-14);
+    }
+}
+
+TEST(LineTest, Coefficients) {
+    std::vector<Line> lines;
+    lines.emplace_back(Point(1e3,1e3), Point(1,1));
+    //the case below will never work without normalizing the line
+    //lines.emplace_back(Point(1e5,1e5), Point(1e-15,0));
+    lines.emplace_back(Point(1e5,1e5), Point(1e5,-1e5));
+    lines.emplace_back(Point(-3,10), Point(3,10));
+    lines.emplace_back(Point(250,333), Point(-72,121));
+
+    for (auto & line : lines) {
+        Coord a, b, c, A, B, C;
+        line.coefficients(a, b, c);
+        /*std::cout << format_coord_nice(a) << " "
+                  << format_coord_nice(b) << " "
+                  << format_coord_nice(c) << std::endl;*/
+        Line k(a, b, c);
+        //std::cout << k.initialPoint() << " " << k.finalPoint() << std::endl;
+        k.coefficients(A, B, C);
+        /*std::cout << format_coord_nice(A) << " "
+                  << format_coord_nice(B) << " "
+                  << format_coord_nice(C) << std::endl;*/
+        EXPECT_DOUBLE_EQ(a, A);
+        EXPECT_DOUBLE_EQ(b, B);
+        EXPECT_DOUBLE_EQ(c, C);
+
+        for (unsigned j = 0; j <= 10; ++j) {
+            double t = j / 10.;
+            Point p = line.pointAt(t);
+            /*std::cout << t << " " << p << " "
+                      << A*p[X] + B*p[Y] + C << " "
+                      << A*(p[X]-1) + B*(p[Y]+1) + C << std::endl;*/
+            EXPECT_near(A*p[X] + B*p[Y] + C, 0., 2e-11);
+            EXPECT_not_near(A*(p[X]-1) + B*(p[Y]+1) + C, 0., 1e-6);
+        }
+    }
+}
+
+TEST(LineTest, Intersection) {
+    Line a(Point(0,3), Point(1,2));
+    Line b(Point(0,-3), Point(1,-2));
+    LineSegment lsa(Point(0,3), Point(1,2));
+    LineSegment lsb(Point(0,-3), Point(1,-2));
+    LineSegment lsc(Point(3,1), Point(3, -1));
+
+    std::vector<ShapeIntersection> r1, r2, r3;
+
+    r1 = a.intersect(b);
+    ASSERT_EQ(r1.size(), 1u);
+    EXPECT_EQ(r1[0].point(), Point(3,0));
+    EXPECT_intersections_valid(a, b, r1, 1e-15);
+
+    r2 = a.intersect(lsc);
+    ASSERT_EQ(r2.size(), 1u);
+    EXPECT_EQ(r2[0].point(), Point(3,0));
+    EXPECT_intersections_valid(a, lsc, r2, 1e-15);
+
+    r3 = b.intersect(lsc);
+    ASSERT_EQ(r3.size(), 1u);
+    EXPECT_EQ(r3[0].point(), Point(3,0));
+    EXPECT_intersections_valid(a, lsc, r3, 1e-15);
+
+    EXPECT_TRUE(lsa.intersect(lsb).empty());
+    EXPECT_TRUE(lsa.intersect(lsc).empty());
+    EXPECT_TRUE(lsb.intersect(lsc).empty());
+    EXPECT_TRUE(a.intersect(lsb).empty());
+    EXPECT_TRUE(b.intersect(lsa).empty());
+}
diff --git a/tests/mersennetwister.h b/tests/mersennetwister.h
new file mode 100644
index 0000000..bc19d8e
--- /dev/null
+++ b/tests/mersennetwister.h
@@ -0,0 +1,427 @@
+/**
+ * 2Geom developers: 
+ *   For licence reasons, Do not copy code from this header into other files
+ * */
+// MersenneTwister.h
+// Mersenne Twister random number generator -- a C++ class MTRand
+// Based on code by Makoto Matsumoto, Takuji Nishimura, and Shawn Cokus
+// Richard J. Wagner  v1.0  15 May 2003  rjwagner@writeme.com
+
+// The Mersenne Twister is an algorithm for generating random numbers.  It
+// was designed with consideration of the flaws in various other generators.
+// The period, 2^19937-1, and the order of equidistribution, 623 dimensions,
+// are far greater.  The generator is also fast; it avoids multiplication and
+// division, and it benefits from caches and pipelines.  For more information
+// see the inventors' web page at http://www.math.keio.ac.jp/~matumoto/emt.html
+
+// Reference
+// M. Matsumoto and T. Nishimura, "Mersenne Twister: A 623-Dimensionally
+// Equidistributed Uniform Pseudo-Random Number Generator", ACM Transactions on
+// Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
+
+// Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+// Copyright (C) 2000 - 2003, Richard J. Wagner
+// All rights reserved.                          
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//   1. Redistributions of source code must retain the above copyright
+//      notice, this list of conditions and the following disclaimer.
+//
+//   2. Redistributions in binary form must reproduce the above copyright
+//      notice, this list of conditions and the following disclaimer in the
+//      documentation and/or other materials provided with the distribution.
+//
+//   3. The names of its contributors may not be used to endorse or promote 
+//      products derived from this software without specific prior written 
+//      permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The original code included the following notice:
+//
+//     When you use this, send an email to: matumoto@math.keio.ac.jp
+//     with an appropriate reference to your work.
+//
+// It would be nice to CC: rjwagner@writeme.com and Cokus@math.washington.edu
+// when you write.
+
+#ifndef MERSENNETWISTER_H
+#define MERSENNETWISTER_H
+
+// Not thread safe (unless auto-initialization is avoided and each thread has
+// its own MTRand object)
+
+#include <iostream>
+#include <limits.h>
+#include <stdio.h>
+#include <time.h>
+#include <math.h>
+
+class MTRand {
+  // Data
+ public:
+  typedef unsigned long uint32;  // unsigned integer type, at least 32 bits
+	
+  enum { N = 624 };       // length of state vector
+  enum { SAVE = N + 1 };  // length of array for save()
+
+ protected:
+  enum { M = 397 };  // period parameter
+	
+  uint32 state[N];   // internal state
+  uint32 *pNext;     // next value to get from state
+  int left;          // number of values left before reload needed
+
+
+  //Methods
+ public:
+  MTRand( const uint32& oneSeed );  // initialize with a simple uint32
+  MTRand( uint32 *const bigSeed, uint32 const seedLength = N );  // or an array
+  MTRand();  // auto-initialize with /dev/urandom or time() and clock()
+	
+  // Do NOT use for CRYPTOGRAPHY without securely hashing several returned
+  // values together, otherwise the generator state can be learned after
+  // reading 624 consecutive values.
+	
+  // Access to 32-bit random numbers
+  double rand();                          // real number in [0,1]
+  double rand( const double& n );         // real number in [0,n]
+  double randExc();                       // real number in [0,1)
+  double randExc( const double& n );      // real number in [0,n)
+  double randDblExc();                    // real number in (0,1)
+  double randDblExc( const double& n );   // real number in (0,n)
+  uint32 randInt();                       // integer in [0,2^32-1]
+  uint32 randInt( const uint32& n );      // integer in [0,n] for n < 2^32
+  double operator()() { return rand(); }  // same as rand()
+	
+  // Access to 53-bit random numbers (capacity of IEEE double precision)
+  double rand53();  // real number in [0,1)
+	
+  // Access to nonuniform random number distributions
+  double randNorm( const double& mean = 0.0, const double& variance = 1.0 );
+	
+  // Re-seeding functions with same behavior as initializers
+  void seed( const uint32 oneSeed );
+  void seed( uint32 *const bigSeed, const uint32 seedLength = N );
+  void seed();
+	
+  // Saving and loading generator state
+  void save( uint32* saveArray ) const;  // to array of size SAVE
+  void load( uint32 *const loadArray );  // from such array
+  friend std::ostream& operator<<( std::ostream& os, const MTRand& mtrand );
+  friend std::istream& operator>>( std::istream& is, MTRand& mtrand );
+
+ protected:
+  void initialize( const uint32 oneSeed );
+  void reload();
+  uint32 hiBit( const uint32& u ) const { return u & 0x80000000UL; }
+  uint32 loBit( const uint32& u ) const { return u & 0x00000001UL; }
+  uint32 loBits( const uint32& u ) const { return u & 0x7fffffffUL; }
+  uint32 mixBits( const uint32& u, const uint32& v ) const
+  { return hiBit(u) | loBits(v); }
+  uint32 twist( const uint32& m, const uint32& s0, const uint32& s1 ) const
+  { return m ^ (mixBits(s0,s1)>>1) ^ (-loBit(s1) & 0x9908b0dfUL); }
+  static uint32 hash( time_t t, clock_t c );
+};
+
+
+inline MTRand::MTRand( const uint32& oneSeed )
+{ seed(oneSeed); }
+
+inline MTRand::MTRand( uint32 *const bigSeed, const uint32 seedLength )
+{ seed(bigSeed,seedLength); }
+
+inline MTRand::MTRand()
+{ seed(); }
+
+inline double MTRand::rand()
+{ return double(randInt()) * (1.0/4294967295.0); }
+
+inline double MTRand::rand( const double& n )
+{ return rand() * n; }
+
+inline double MTRand::randExc()
+{ return double(randInt()) * (1.0/4294967296.0); }
+
+inline double MTRand::randExc( const double& n )
+{ return randExc() * n; }
+
+inline double MTRand::randDblExc()
+{ return ( double(randInt()) + 0.5 ) * (1.0/4294967296.0); }
+
+inline double MTRand::randDblExc( const double& n )
+{ return randDblExc() * n; }
+
+inline double MTRand::rand53()
+{
+  uint32 a = randInt() >> 5, b = randInt() >> 6;
+  return ( a * 67108864.0 + b ) * (1.0/9007199254740992.0);  // by Isaku Wada
+}
+
+inline double MTRand::randNorm( const double& mean, const double& variance )
+{
+  // Return a real number from a normal (Gaussian) distribution with given
+  // mean and variance by Box-Muller method
+  double r = sqrt( -2.0 * log( 1.0-randDblExc()) ) * variance;
+  double phi = 2.0 * 3.14159265358979323846264338328 * randExc();
+  return mean + r * cos(phi);
+}
+
+inline MTRand::uint32 MTRand::randInt()
+{
+  // Pull a 32-bit integer from the generator state
+  // Every other access function simply transforms the numbers extracted here
+	
+  if( left == 0 ) reload();
+  --left;
+		
+  register uint32 s1;
+  s1 = *pNext++;
+  s1 ^= (s1 >> 11);
+  s1 ^= (s1 <<  7) & 0x9d2c5680UL;
+  s1 ^= (s1 << 15) & 0xefc60000UL;
+  return ( s1 ^ (s1 >> 18) );
+}
+
+inline MTRand::uint32 MTRand::randInt( const uint32& n )
+{
+  // Find which bits are used in n
+  // Optimized by Magnus Jonsson (magnus@smartelectronix.com)
+  uint32 used = n;
+  used |= used >> 1;
+  used |= used >> 2;
+  used |= used >> 4;
+  used |= used >> 8;
+  used |= used >> 16;
+	
+  // Draw numbers until one is found in [0,n]
+  uint32 i;
+  do
+    i = randInt() & used;  // toss unused bits to shorten search
+  while( i > n );
+  return i;
+}
+
+
+inline void MTRand::seed( const uint32 oneSeed )
+{
+  // Seed the generator with a simple uint32
+  initialize(oneSeed);
+  reload();
+}
+
+
+inline void MTRand::seed( uint32 *const bigSeed, const uint32 seedLength )
+{
+  // Seed the generator with an array of uint32's
+  // There are 2^19937-1 possible initial states.  This function allows
+  // all of those to be accessed by providing at least 19937 bits (with a
+  // default seed length of N = 624 uint32's).  Any bits above the lower 32
+  // in each element are discarded.
+  // Just call seed() if you want to get array from /dev/urandom
+  initialize(19650218UL);
+  register int i = 1;
+  register uint32 j = 0;
+  register int k = ( uint32(N) > seedLength ?  uint32(N) : seedLength );
+  for( ; k; --k )
+    {
+      state[i] =
+	state[i] ^ ( (state[i-1] ^ (state[i-1] >> 30)) * 1664525UL );
+      state[i] += ( bigSeed[j] & 0xffffffffUL ) + j;
+      state[i] &= 0xffffffffUL;
+      ++i;  ++j;
+      if( i >= N ) { state[0] = state[N-1];  i = 1; }
+      if( j >= seedLength ) j = 0;
+    }
+  for( k = N - 1; k; --k )
+    {
+      state[i] =
+	state[i] ^ ( (state[i-1] ^ (state[i-1] >> 30)) * 1566083941UL );
+      state[i] -= i;
+      state[i] &= 0xffffffffUL;
+      ++i;
+      if( i >= N ) { state[0] = state[N-1];  i = 1; }
+    }
+  state[0] = 0x80000000UL;  // MSB is 1, assuring non-zero initial array
+  reload();
+}
+
+
+inline void MTRand::seed()
+{
+  // Seed the generator with an array from /dev/urandom if available
+  // Otherwise use a hash of time() and clock() values
+	
+  // First try getting an array from /dev/urandom
+  FILE* urandom = fopen( "/dev/urandom", "rb" );
+  if( urandom )
+    {
+      uint32 bigSeed[N];
+      register uint32 *s = bigSeed;
+      register int i = N;
+      register bool success = true;
+      while( success && i-- )
+	success = fread( s++, sizeof(uint32), 1, urandom );
+      fclose(urandom);
+      if( success ) { seed( bigSeed, N );  return; }
+    }
+	
+  // Was not successful, so use time() and clock() instead
+  seed( hash( time(NULL), clock() ) );
+}
+
+
+inline void MTRand::initialize( const uint32 seed )
+{
+  // Initialize generator state with seed
+  // See Knuth TAOCP Vol 2, 3rd Ed, p.106 for multiplier.
+  // In previous versions, most significant bits (MSBs) of the seed affect
+  // only MSBs of the state array.  Modified 9 Jan 2002 by Makoto Matsumoto.
+  register uint32 *s = state;
+  register uint32 *r = state;
+  register int i = 1;
+  *s++ = seed & 0xffffffffUL;
+  for( ; i < N; ++i )
+    {
+      *s++ = ( 1812433253UL * ( *r ^ (*r >> 30) ) + i ) & 0xffffffffUL;
+      r++;
+    }
+}
+
+
+inline void MTRand::reload()
+{
+  // Generate N new values in state
+  // Made clearer and faster by Matthew Bellew (matthew.bellew@home.com)
+  register uint32 *p = state;
+  register int i;
+  for( i = N - M; i--; ++p )
+    *p = twist( p[M], p[0], p[1] );
+  for( i = M; --i; ++p )
+    *p = twist( p[M-N], p[0], p[1] );
+  *p = twist( p[M-N], p[0], state[0] );
+
+  left = N, pNext = state;
+}
+
+
+inline MTRand::uint32 MTRand::hash( time_t t, clock_t c )
+{
+  // Get a uint32 from t and c
+  // Better than uint32(x) in case x is floating point in [0,1]
+  // Based on code by Lawrence Kirby (fred@genesis.demon.co.uk)
+
+  static uint32 differ = 0;  // guarantee time-based seeds will change
+
+  uint32 h1 = 0;
+  unsigned char *p = (unsigned char *) &t;
+  for( size_t i = 0; i < sizeof(t); ++i )
+    {
+      h1 *= UCHAR_MAX + 2U;
+      h1 += p[i];
+    }
+  uint32 h2 = 0;
+  p = (unsigned char *) &c;
+  for( size_t j = 0; j < sizeof(c); ++j )
+    {
+      h2 *= UCHAR_MAX + 2U;
+      h2 += p[j];
+    }
+  return ( h1 + differ++ ) ^ h2;
+}
+
+
+inline void MTRand::save( uint32* saveArray ) const
+{
+  register uint32 *sa = saveArray;
+  register const uint32 *s = state;
+  register int i = N;
+  for( ; i--; *sa++ = *s++ ) {}
+  *sa = left;
+}
+
+
+inline void MTRand::load( uint32 *const loadArray )
+{
+  register uint32 *s = state;
+  register uint32 *la = loadArray;
+  register int i = N;
+  for( ; i--; *s++ = *la++ ) {}
+  left = *la;
+  pNext = &state[N-left];
+}
+
+
+inline std::ostream& operator<<( std::ostream& os, const MTRand& mtrand )
+{
+  register const MTRand::uint32 *s = mtrand.state;
+  register int i = mtrand.N;
+  for( ; i--; os << *s++ << "\t" ) {}
+  return os << mtrand.left;
+}
+
+
+inline std::istream& operator>>( std::istream& is, MTRand& mtrand )
+{
+  register MTRand::uint32 *s = mtrand.state;
+  register int i = mtrand.N;
+  for( ; i--; is >> *s++ ) {}
+  is >> mtrand.left;
+  mtrand.pNext = &mtrand.state[mtrand.N-mtrand.left];
+  return is;
+}
+
+#endif  // MERSENNETWISTER_H
+
+// Change log:
+//
+// v0.1 - First release on 15 May 2000
+//      - Based on code by Makoto Matsumoto, Takuji Nishimura, and Shawn Cokus
+//      - Translated from C to C++
+//      - Made completely ANSI compliant
+//      - Designed convenient interface for initialization, seeding, and
+//        obtaining numbers in default or user-defined ranges
+//      - Added automatic seeding from /dev/urandom or time() and clock()
+//      - Provided functions for saving and loading generator state
+//
+// v0.2 - Fixed bug which reloaded generator one step too late
+//
+// v0.3 - Switched to clearer, faster reload() code from Matthew Bellew
+//
+// v0.4 - Removed trailing newline in saved generator format to be consistent
+//        with output format of built-in types
+//
+// v0.5 - Improved portability by replacing static const int's with enum's and
+//        clarifying return values in seed(); suggested by Eric Heimburg
+//      - Removed MAXINT constant; use 0xffffffffUL instead
+//
+// v0.6 - Eliminated seed overflow when uint32 is larger than 32 bits
+//      - Changed integer [0,n] generator to give better uniformity
+//
+// v0.7 - Fixed operator precedence ambiguity in reload()
+//      - Added access for real numbers in (0,1) and (0,n)
+//
+// v0.8 - Included time.h header to properly support time_t and clock_t
+//
+// v1.0 - Revised seeding to match 26 Jan 2002 update of Nishimura and Matsumoto
+//      - Allowed for seeding with arrays of any length
+//      - Added access for real numbers in [0,1) with 53-bit resolution
+//      - Added access for real numbers from normal (Gaussian) distributions
+//      - Increased overall speed by optimizing twist()
+//      - Doubled speed of integer [0,n] generation
+//      - Fixed out-of-range number generation on 64-bit machines
+//      - Improved portability by substituting literal constants for long enum's
+//      - Changed license from GNU LGPL to BSD
diff --git a/tests/nl-vector-test.cpp b/tests/nl-vector-test.cpp
new file mode 100644
index 0000000..53e8eaa
--- /dev/null
+++ b/tests/nl-vector-test.cpp
@@ -0,0 +1,333 @@
+/** @file
+ * @brief Unit tests for Vector, VectorView
+ *//*
+ * Authors:
+ *   Olof Bjarnason <olof.bjarnason@gmail.com>
+ * 
+ * Copyright 2015 Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include <gtest/gtest.h>
+
+#include <2geom/numeric/vector.h>
+
+namespace Geom {
+
+////
+// Test fixture used in many tests.
+// v1 = [0, 1, ..., 8, 9]
+////
+class CountingVectorFixture : public ::testing::Test {
+public:
+	CountingVectorFixture() : v1(10) { }
+
+protected:
+  void SetUp() override {
+	for (unsigned int i = 0; i < this->v1.size(); ++i)
+		this->v1[i] = i;
+  }
+
+  NL::Vector v1;
+};
+
+// These types are only here to differentiate
+// between categories of tests - they both use
+// the same v1 test fixture variable.
+class VectorTest : public CountingVectorFixture { };
+class VectorViewTest : public CountingVectorFixture { };
+
+////
+// Helper method to write simple tests
+////
+NL::Vector V3(double a, double b, double c) {
+	NL::Vector v(3);
+	v[0] = a;
+	v[1] = b;
+	v[2] = c;
+	return v;
+}
+
+////
+// ** Vector examples **
+////
+
+TEST_F(VectorTest, VectorStringRepresentation) {
+	EXPECT_EQ(v1.str(), "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
+}
+
+TEST_F(VectorTest, VectorConstructFromAnother) {
+	NL::Vector v2(v1);
+	EXPECT_EQ(v1.str(), v2.str());
+}
+
+TEST_F(VectorTest, OperatorEqualIsDefined) {
+	EXPECT_TRUE(v1 == v1);
+	NL::Vector v2(v1);
+	EXPECT_TRUE(v1 == v2);
+	// TODO: This operation compares doubles
+	// with operator ==. Should it use a distance
+	// threshold instead?
+}
+
+TEST_F(VectorTest, OperatorNotEqualIsntDefined) {
+	SUCCEED();
+	//NL::Vector v3(4);
+	//EXPECT_TRUE(v1 != v3); // Not expressible in C++;
+	// gives compile time error
+}
+
+TEST_F(VectorTest, VectorAssignment) {
+	NL::Vector v2(v1.size());
+	v2 = v1;
+	EXPECT_EQ(v1, v2);
+}
+
+#ifndef NDEBUG
+TEST_F(VectorTest, AssignedVectorMustBeSameSize) {
+	NL::Vector v2(5);
+	// On Linux, the assertion message is:
+	// Assertion ... failed ...
+	// On OSX, it is:
+	// Assertion failed: (...), function ..., file ..., line ...
+	// Thus we just look for the word "Assertion".
+	EXPECT_DEATH({v2 = v1;}, "Assertion");
+}
+#endif
+
+TEST_F(VectorTest, VectorScalesInplace) {
+	v1.scale(2);
+	EXPECT_EQ(v1.str(), "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]");
+}
+
+TEST_F(VectorTest, VectorTranslatesInplace) {
+	v1.translate(1);
+	EXPECT_EQ(v1.str(), "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]");
+}
+
+TEST_F(VectorTest, ScaleAndTranslateUsesFluentSyntax) {
+	NL::VectorView vv(v1, 3);
+	EXPECT_EQ(vv.translate(5).scale(10).str(), "[50, 60, 70]");
+}
+
+TEST_F(VectorTest, AddAssignment) {
+	NL::Vector v2(v1);
+	v2 += v1;
+	EXPECT_EQ(v2.str(), "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]");
+}
+
+TEST_F(VectorTest, SubtractAssignment) {
+	NL::Vector v2(v1);
+	v2 -= v1;
+	EXPECT_EQ(v2.str(), "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]");
+}
+
+TEST_F(VectorTest, SwappingElements) {
+	v1.swap_elements(0, 9);
+	EXPECT_EQ(v1.str(), "[9, 1, 2, 3, 4, 5, 6, 7, 8, 0]");
+}
+
+TEST_F(VectorTest, Reverse) {
+	v1.reverse();
+	EXPECT_EQ(v1.str(), "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]");
+}
+
+TEST(Vector, IsPositive) {
+	EXPECT_TRUE(V3(1, 1, 1).is_positive());
+	EXPECT_FALSE(V3(0, 0, 0).is_positive());
+	EXPECT_FALSE(V3(-1, 0, 1).is_positive());
+}
+
+TEST_F(VectorTest, IsZero) {
+	EXPECT_FALSE(v1.is_zero());
+	EXPECT_TRUE(V3(0, 0, 0).is_zero());
+}
+
+TEST_F(VectorTest, IsNonNegative) {
+	EXPECT_TRUE(V3(1, 1, 1).is_non_negative());
+	EXPECT_TRUE(V3(0, 0, 0).is_non_negative());
+	EXPECT_FALSE(V3(-1, 1, 1).is_non_negative());
+}
+
+TEST(Vector, Max) {
+	EXPECT_EQ(V3(1, 5, 3).max(), 5);
+}
+
+TEST(Vector, MaxIndex) {
+	EXPECT_EQ(V3(1, 5, 3).max_index(), 1u);
+}
+
+TEST(Vector, Min) {
+	EXPECT_EQ(V3(1, -5, -300).min(), -300);
+}
+
+TEST(Vector, MinIndex) {
+	EXPECT_EQ(V3(1, 5, 3).min_index(), 0u);
+}
+
+TEST_F(VectorTest, SetAll) {
+	v1.set_all(5);
+	EXPECT_EQ(v1.str(), "[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]");
+}
+
+TEST_F(VectorTest, SetBasis) {
+	v1.set_basis(1);
+	EXPECT_EQ(v1.str(), "[0, 1, 0, 0, 0, 0, 0, 0, 0, 0]");
+}
+
+TEST(Vector, SwappingVectors) {
+	NL::Vector a(V3(1, 2, 3));
+	NL::Vector b(V3(7, 7, 7));
+	NL::swap(a, b);
+	EXPECT_EQ(V3(7, 7, 7), a);
+	EXPECT_EQ(V3(1, 2, 3), b);
+}
+
+////
+// ** VectorView tests **
+////
+
+// Construction examples
+
+TEST_F(VectorViewTest, ViewCountOnly) {
+	// VectorView(vector, showCount)
+	EXPECT_EQ(NL::VectorView(v1, 5).str(), "[0, 1, 2, 3, 4]");
+}
+
+TEST_F(VectorViewTest, SkipSomeInitialElements) {
+	// VectorView(vector, showCount, startIndex)
+	EXPECT_EQ(NL::VectorView(v1, 5, 3).str(), "[3, 4, 5, 6, 7]");
+}
+
+TEST_F(VectorViewTest, SparseViewConstruction) {
+	// VectorView(vector, showCount, startIndex, step)
+	EXPECT_EQ(NL::VectorView(v1, 5, 0, 2).str(), "[0, 2, 4, 6, 8]");
+	EXPECT_EQ(NL::VectorView(v1, 5, 1, 2).str(), "[1, 3, 5, 7, 9]");
+}
+
+TEST_F(VectorViewTest, ConstructFromAnotherView) {
+	// VectorView(vectorview, showCount, startIndex, step)
+	NL::VectorView vv(v1, 5, 1, 2);
+	NL::VectorView view(vv, 3, 0, 2);
+	EXPECT_EQ(view.str(), "[1, 5, 9]");
+}
+
+// Operations modify source vectors
+
+TEST_F(VectorViewTest, PartialSourceModification) {
+	NL::VectorView vv(v1, 3);
+	vv.translate(10);
+	EXPECT_EQ(v1.str(),
+			  "[10, 11, 12, 3, 4, 5, 6, 7, 8, 9]");
+	EXPECT_EQ(vv.str(),
+			  "[10, 11, 12]");
+}
+
+// Scale and translate examples
+
+TEST_F(VectorViewTest, ViewScalesInplace) {
+	v1.scale(10);
+	EXPECT_EQ(NL::VectorView(v1, 3).str(), "[0, 10, 20]");
+}
+
+TEST_F(VectorViewTest, ViewScaleAndTranslateUsesFluentSyntax) {
+	EXPECT_EQ(NL::VectorView(v1, 3).scale(10).translate(1).str(),
+		      "[1, 11, 21]");
+}
+
+// Assignment
+
+TEST_F(VectorViewTest, AssignmentFromVectorAvailableForViews) {
+	NL::VectorView vv(v1, v1.size());
+	vv = v1;
+	EXPECT_EQ(vv.str(), v1.str());
+}
+
+#ifndef NDEBUG
+TEST_F(VectorViewTest, AssignmentFromVectorMustBeSameSize) {
+	NL::VectorView vv(v1, 5);
+	EXPECT_DEATH({vv = v1;}, "Assertion");
+}
+#endif
+
+TEST_F(VectorViewTest, AssignmentFromViewAvailableForViews) {
+	NL::VectorView view1(v1, v1.size());
+	view1 = v1;
+	NL::VectorView view2(view1);
+	view2 = view1;
+	EXPECT_EQ(view1.str(), view2.str());
+}
+
+#ifndef NDEBUG
+TEST_F(VectorViewTest, AssignmentFromViewMustBeSameSize) {
+	NL::VectorView view1(v1, v1.size());
+	NL::VectorView view2(view1, view1.size() - 1);
+	EXPECT_DEATH({view2 = view1;}, "Assertion");
+}
+#endif
+
+// Add- and subtract assignment
+
+TEST_F(VectorViewTest, AddAssignAvailableForViews) {
+	NL::VectorView v2(v1);
+	v1 += v2;
+	EXPECT_EQ(v1.str(), "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]");
+}
+
+TEST_F(VectorViewTest, SubtractAssignAvailableForViews) {
+	NL::Vector v2(v1);
+	v1 -= v2;
+	EXPECT_TRUE(v1.is_zero());
+}
+
+// View swapping
+
+TEST_F(VectorViewTest, SwappingFromSameSourceVectorDoesNotModifySource) {
+	NL::VectorView vv1(v1, 2, 0);
+	NL::VectorView vv2(v1, 2, 8);
+	NL::swap_view(vv1, vv2);
+	EXPECT_EQ(v1.str(), "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
+}
+
+TEST_F(VectorViewTest, SwappingFromSameSourceVectorModifiesViews) {
+	NL::VectorView viewStart(v1, 2, 0);
+	NL::VectorView viewEnd(v1, 2, 8);
+	EXPECT_EQ(viewStart.str(), "[0, 1]");
+	EXPECT_EQ(viewEnd.str(), "[8, 9]");
+	NL::swap_view(viewStart, viewEnd);
+	EXPECT_EQ(viewStart.str(), "[8, 9]");
+	EXPECT_EQ(viewEnd.str(), "[0, 1]");
+}
+
+#ifndef NDEBUG
+TEST_F(VectorViewTest, SwappingDifferentLengthViewFails) {
+	NL::VectorView vv1(v1, 4);
+	NL::VectorView vv2(v1, 3);
+	EXPECT_DEATH({NL::swap_view(vv1, vv2);}, "Assertion");
+}
+#endif
+
+
+} // namespace Geom
diff --git a/tests/parallelogram-test.cpp b/tests/parallelogram-test.cpp
new file mode 100644
index 0000000..70ccea1
--- /dev/null
+++ b/tests/parallelogram-test.cpp
@@ -0,0 +1,161 @@
+/** @file
+ * @brief Unit tests for Parallelogram
+ *
+ * Includes all tests from RotatedRect to demonstrate that it is a generalized
+ * version of the rotated rectangle.
+ */
+/*
+ * Authors:
+ *   Thomas Holder
+ *   Sergei Izmailov
+ *
+ * SPDX-License-Identifier: LGPL-2.1 or MPL-1.1
+ */
+
+#include <2geom/coord.h>
+#include <2geom/parallelogram.h>
+#include <2geom/transforms.h>
+
+#include <gtest/gtest.h>
+
+using namespace Geom;
+
+// Analogous to RotatedRect::from_rect_rotate
+static Parallelogram parallelogram_from_rect_rotate(Rect const &rect, Rotate const &rotate, Point const &point)
+{
+    Affine affine = Translate(-point) * rotate * Translate(point);
+    return Parallelogram(rect) * affine;
+}
+static Parallelogram parallelogram_from_rect_rotate(Rect const &rect, Rotate const &rotate)
+{
+    return parallelogram_from_rect_rotate(rect, rotate, rect.midpoint());
+}
+
+TEST(ParallelogramTest, midpoint)
+{
+    Rect r(-0.5, -0.5, 5.5, 5.5);
+    auto center = Point(2.5, 2.5);
+
+    EXPECT_EQ(r.midpoint(), center);
+    for (double angle : { 0, 1, 25, 45, 90, 135 }) {
+        auto rotated_rect = parallelogram_from_rect_rotate(r, Rotate::from_degrees(angle), Point(0, 0));
+        auto rotated_center = center * Rotate(angle / 180.0 * M_PI);
+        EXPECT_TRUE(Geom::are_near(rotated_rect.midpoint(), rotated_center, 1e-6)) << "Angle = " << angle << " deg";
+    }
+}
+
+TEST(ParallelogramTest, containsPoint1)
+{
+    Rect r(0, 0, 1, 1);
+    auto rotated_rect = r;
+    EXPECT_TRUE(rotated_rect.contains(Point(0, 0)));
+    EXPECT_TRUE(rotated_rect.contains(Point(1, 1)));
+    EXPECT_TRUE(rotated_rect.contains(Point(0.5, 0.5)));
+    EXPECT_FALSE(rotated_rect.contains(Point(1.1, 0.5)));
+    EXPECT_FALSE(rotated_rect.contains(Point(0.5, 1.1)));
+}
+
+TEST(ParallelogramTest, containsPoint2)
+{
+    Rect r(0, 0, 1, 1);
+    auto rotated_rect = parallelogram_from_rect_rotate(r, Rotate::from_degrees(45), Point(0, 0));
+    EXPECT_TRUE(rotated_rect.contains(Point(0, 0)));
+    EXPECT_TRUE(rotated_rect.contains(Point(0, 1.2)));
+    EXPECT_TRUE(rotated_rect.contains(Point(0.5, 0.9)));
+    EXPECT_FALSE(rotated_rect.contains(Point(1, 1)));
+    EXPECT_FALSE(rotated_rect.contains(Point(0.1, 0)));
+}
+
+TEST(ParallelogramTest, intersects_aligned)
+{
+    Rect r(0, 0, 1, 1);
+    auto rotated_rect = r;
+    // point within rect
+    EXPECT_TRUE(rotated_rect.intersects(Rect(-1, -1, 2, 2)));
+    EXPECT_TRUE(rotated_rect.intersects(Rect(0.1, 0.1, 0.2, 0.2)));
+    EXPECT_TRUE(rotated_rect.intersects(Rect(-0.1, -0.1, 0.1, 0.1)));
+    EXPECT_FALSE(rotated_rect.intersects(Rect(-0.2, -0.2, -0.1, -0.1)));
+    EXPECT_FALSE(rotated_rect.intersects(Rect(1.1, 1.1, 1.2, 1.2)));
+    // edge intersection
+    EXPECT_TRUE(rotated_rect.intersects(Rect(0.5, -0.1, 0.6, 1.2)));
+    EXPECT_TRUE(rotated_rect.intersects(Rect(-0.1, 0.5, 1.2, 0.6)));
+}
+
+TEST(ParallelogramTest, bounds)
+{
+    auto r = Rect::from_xywh(1.260, 0.547, 8.523, 11.932);
+    auto rrect = parallelogram_from_rect_rotate(r, Rotate::from_degrees(15.59));
+    auto bbox = rrect.bounds();
+    auto expected_bbox = Rect::from_xywh(-0.186, -0.378, 11.415, 13.783);
+    for (int i = 0; i < 4; i++) {
+        EXPECT_TRUE(Geom::are_near(bbox.corner(i), expected_bbox.corner(i), 1e-3));
+    }
+}
+
+TEST(ParallelogramTest, isSheared)
+{
+    Parallelogram p(Rect(2, 4, 7, 8));
+    EXPECT_FALSE(p.isSheared());
+    p *= Rotate(M_PI / 4.0); // 45°
+    EXPECT_FALSE(p.isSheared());
+    p *= HShear(2);
+    EXPECT_TRUE(p.isSheared());
+}
+
+TEST(ParallelogramTest, area)
+{
+    Rect r(2, 4, 7, 8);
+    Parallelogram p(r);
+    EXPECT_DOUBLE_EQ(p.area(), r.area());
+    p *= Rotate(M_PI / 4.0); // 45°
+    EXPECT_DOUBLE_EQ(p.area(), r.area());
+    p *= HShear(2);
+    EXPECT_DOUBLE_EQ(p.area(), r.area());
+    p *= Scale(2);
+    EXPECT_DOUBLE_EQ(p.area(), r.area() * 4);
+}
+
+class ParallelogramTest
+    : public testing::TestWithParam<std::tuple<Rect /*rect*/, double /*degrees*/, bool /*intersects*/>> {
+
+    void SetUp() override { target = Rect::from_xywh(0, 0, 11, 13); }
+
+  public:
+    Rect target;
+};
+
+TEST_P(ParallelogramTest, intersects)
+{
+    Rect rect;
+    double degrees;
+    bool intersects;
+    std::tie(rect, degrees, intersects) = GetParam();
+    EXPECT_EQ(parallelogram_from_rect_rotate(rect, Rotate::from_degrees(degrees)).intersects(target), intersects)
+        << "ERROR: rect {" << rect << "} rotated by {" << degrees << "} degrees " << (!intersects ? "" : "NOT ")
+        << "intersects with {" << target << "} but MUST " << (intersects ? "" : "NOT");
+}
+
+// clang-format off
+INSTANTIATE_TEST_CASE_P(intesect_non_aligned, ParallelogramTest,
+    testing::Values(
+      std::make_tuple(Rect::from_xywh(10.456, -4.479, 7, 5), 0, true),
+      std::make_tuple(Rect::from_xywh(10.456, -4.479, 7, 5), 15, false),
+      std::make_tuple(Rect::from_xywh(9.929, 12.313, 7, 5), 93.2, false),
+      std::make_tuple(Rect::from_xywh(9.929, 12.313, 7, 5), 91.37, true),
+      std::make_tuple(Rect::from_xywh(-1, 4, 13, 3), 0, true),
+      std::make_tuple(Rect::from_xywh(4, -2, 3, 16), 0, true),
+      std::make_tuple(Rect::from_xywh(-5.113, -3.283, 5.000, 7.000), 11.81, false),
+      std::make_tuple(Rect::from_xywh(-5.113, -3.283, 5.000, 7.000), 13.35, true),
+      std::make_tuple(Rect::from_xywh(1.260, 0.547, 8.523, 11.932), 15.59, true),
+      std::make_tuple(Rect::from_xywh(5.328, 0.404, 11, 2), 28.16, true),
+      std::make_tuple(Rect::from_xywh(4.853, 10.691, 11, 2), -30.4, true),
+      std::make_tuple(Rect::from_xywh(-4.429, 10.752, 11, 2), 29.7, true),
+      std::make_tuple(Rect::from_xywh(-4.538, 0.314, 11, 2), -34.19, true),
+      std::make_tuple(Rect::from_xywh(8.398, -3.790, 2, 11), -34, true),
+      std::make_tuple(Rect::from_xywh(8.614, 6.163, 2, 11), 30.38, true),
+      std::make_tuple(Rect::from_xywh(0.492, 6.904, 2, 11), -37.29, true),
+      std::make_tuple(Rect::from_xywh(0.202, -3.148, 2, 11), 31.12, true)));
+
+// clang-format on
+
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/parser-test.py b/tests/parser-test.py
new file mode 100644
index 0000000..86b2deb
--- /dev/null
+++ b/tests/parser-test.py
@@ -0,0 +1,94 @@
+# * A simple toy to test the parser
+# *
+# * Copyright 2008 Aaron Spike <aaron@ekips.org>
+# *
+# * This library is free software; you can redistribute it and/or
+# * modify it either under the terms of the GNU Lesser General Public
+# * License version 2.1 as published by the Free Software Foundation
+# * (the "LGPL") or, at your option, under the terms of the Mozilla
+# * Public License Version 1.1 (the "MPL"). If you do not alter this
+# * notice, a recipient may use your version of this file under either
+# * the MPL or the LGPL.
+# *
+# * You should have received a copy of the LGPL along with this library
+# * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+# * You should have received a copy of the MPL along with this library
+# * in the file COPYING-MPL-1.1
+# *
+# * The contents of this file are subject to the Mozilla Public License
+# * Version 1.1 (the "License"); you may not use this file except in
+# * compliance with the License. You may obtain a copy of the License at
+# * http://www.mozilla.org/MPL/
+# *
+# * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+# * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+# * the specific language governing rights and limitations.
+
+import sys
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", "py2geom"))
+import py2geom
+
+class TestSink(py2geom.SVGPathSink):
+    def __init__(self):
+        py2geom.SVGPathSink.__init__(self)
+        self.data = []
+    def __str__(self):
+        return ' '.join(self.data)
+    def moveTo(self, p):
+        x,y = p
+        self.data.append('M %s, %s' % (x,y))
+    def lineTo(self, p):
+        x,y = p
+        self.data.append('L %s, %s' % (x,y))
+    def curveTo(self, c0, c1, p): 
+        c0x,c0y = c0
+        c1x,c1y = c1
+        x,y = p
+        self.data.append('C %s, %s %s, %s %s, %s' % (c0x,c0y,c1x,c1y,x,y))
+    def quadTo(self, c, p): 
+        cx,cy = c
+        x,y = p
+        self.data.append('Q %s, %s %s, %s' % (cx,cy,x,y))
+    def arcTo(self, rx, ry, angle, large_arc, sweep, p): 
+        x,y = p
+        self.data.append('A %s, %s %s %i %i %s, %s' % (rx,ry,angle,large_arc,sweep,x,y))
+    def closePath(self): 
+        self.data.append('Z')
+    def flush(self): 
+        pass
+
+def test_path(description, in_path, out_path):
+    s = TestSink()
+    py2geom.parse_svg_path(in_path, s)
+    if str(s) == out_path:
+        print 'Success: %s' % description
+        return True
+    else:
+        print 'Error: %s' % description
+        print '    given    "%s"' % in_path
+        print '    got      "%s"' % str(s)
+        print '    expected "%s"' % out_path
+        return False
+
+def run_tests(tests):
+    successes = 0
+    failures = 0 
+    for description, in_path, out_path in tests:
+        if test_path(description, in_path, out_path):
+            successes += 1
+        else:
+            failures += 1
+    print '=' * 20
+    print 'Tests: %s' % (successes + failures)
+    print 'Good:  %s' % successes
+    print 'Bad:   %s' % failures
+
+if __name__=='__main__':
+    tests = [
+        ('lineto', 'M 10,10 L 4,4', 'M 10.0, 10.0 L 4.0, 4.0'),
+        ('implicit lineto', 'M 10,10 L 4,4 5,5 6,6', 'M 10.0, 10.0 L 4.0, 4.0 L 5.0, 5.0 L 6.0, 6.0'),
+        ('implicit lineto after moveto', 'M1.2.3.4.5.6.7', 'M 1.2, 0.3 L 0.4, 0.5 L 0.6, 0.7'),
+        ('arcto', 'M 300 150 A 150, 120, 30, 1, 0, 200 100', 'M 300.0, 150.0 A 150.0, 120.0 30.0 1 0 200.0, 100.0'),
+    ]
+    run_tests(tests)
diff --git a/tests/path-test.cpp b/tests/path-test.cpp
new file mode 100644
index 0000000..dd6f347
--- /dev/null
+++ b/tests/path-test.cpp
@@ -0,0 +1,991 @@
+#include <cmath>
+#include <vector>
+#include <iterator>
+#include <iostream>
+
+#include <glib.h>
+
+#include <2geom/bezier.h>
+#include <2geom/path.h>
+#include <2geom/pathvector.h>
+#include <2geom/path-intersection.h>
+#include <2geom/svg-path-parser.h>
+#include <2geom/svg-path-writer.h>
+
+#include "testing.h"
+
+using namespace std;
+using namespace Geom;
+
+Path string_to_path(const char* s) {
+    PathVector pv = parse_svg_path(s);
+    assert(pv.size() == 1);
+    return pv[0];
+}
+
+// Path fixture
+class PathTest : public ::testing::Test {
+protected:
+    PathTest() {
+        line.append(LineSegment(Point(0,0), Point(1,0)));
+        square = string_to_path("M 0,0 1,0 1,1 0,1 z");
+        circle = string_to_path("M 0,0 a 4.5,4.5 0 1 1 -9,0 4.5,4.5 0 1 1 9,0 z");
+        arcs = string_to_path("M 0,0 a 5,10 45 0 1 10,10 a 5,10 45 0 1 0,0 z");
+        diederik = string_to_path("m 262.6037,35.824151 c 0,0 -92.64892,-187.405851 30,-149.999981 104.06976,31.739531 170,109.9999815 170,109.9999815 l -10,-59.9999905 c 0,0 40,79.99999 -40,79.99999 -80,0 -70,-129.999981 -70,-129.999981 l 50,0 C 435.13571,-131.5667 652.76275,126.44872 505.74322,108.05672 358.73876,89.666591 292.6037,-14.175849 292.6037,15.824151 c 0,30 -30,20 -30,20 z");
+        cmds = string_to_path("M 0,0 V 100 H 100 Q 100,0 0,0 L 200,0 C 200,100 300,100 300,0 S 200,-100 200,0");
+
+        p_open = string_to_path("M 0,0 L 0,5 5,5 5,0");
+        p_closed = p_open;
+        p_closed.close(true);
+        p_add = string_to_path("M -1,6 L 6,6");
+
+        p_open.setStitching(true);
+        p_closed.setStitching(true);
+    }
+
+    // Objects declared here can be used by all tests in the test case for Foo.
+    Path line, square, circle, arcs, diederik, cmds;
+    Path p_open, p_closed, p_add;
+};
+
+TEST_F(PathTest, CopyConstruction) {
+    Path pa = p_closed;
+    Path pc(p_closed);
+    EXPECT_EQ(pa, p_closed);
+    EXPECT_EQ(pa.closed(), p_closed.closed());
+    EXPECT_EQ(pc, p_closed);
+    EXPECT_EQ(pc.closed(), p_closed.closed());
+
+    Path poa = cmds;
+    Path poc(cmds);
+    EXPECT_EQ(poa, cmds);
+    EXPECT_EQ(poa.closed(), cmds.closed());
+    EXPECT_EQ(poc, cmds);
+    EXPECT_EQ(poc.closed(), cmds.closed());
+
+    PathVector pvc(pa);
+    EXPECT_EQ(pvc[0], pa);
+    PathVector pva((Geom::Path()));
+    pva[0] = pa;
+    EXPECT_EQ(pva[0], pa);
+}
+
+TEST_F(PathTest, PathInterval) {
+    PathTime n2_before(1, 0.9995), n2_after(2, 0.0005),
+                 n3_before(2, 0.9995), n3_after(3, 0.0005),
+                 mid2(2, 0.5), mid3(3, 0.5);
+
+    // ival[x][0] - normal
+    // ival[x][1] - reversed
+    // ival[x][2] - crosses start
+    // ival[x][3] - reversed, crosses start
+    PathInterval ival[5][4];
+
+    ival[0][0] = PathInterval(n2_before, n2_after, false, 4);
+    ival[0][1] = PathInterval(n2_after, n2_before, false, 4);
+    ival[0][2] = PathInterval(n2_before, n2_after, true, 4);
+    ival[0][3] = PathInterval(n2_after, n2_before, true, 4);
+    ival[1][0] = PathInterval(n2_before, n3_after, false, 4);
+    ival[1][1] = PathInterval(n3_after, n2_before, false, 4);
+    ival[1][2] = PathInterval(n2_before, n3_after, true, 4);
+    ival[1][3] = PathInterval(n3_after, n2_before, true, 4);
+    ival[2][0] = PathInterval(n2_before, mid2, false, 4);
+    ival[2][1] = PathInterval(mid2, n2_before, false, 4);
+    ival[2][2] = PathInterval(n2_before, mid2, true, 4);
+    ival[2][3] = PathInterval(mid2, n2_before, true, 4);
+    ival[3][0] = PathInterval(mid2, mid3, false, 4);
+    ival[3][1] = PathInterval(mid3, mid2, false, 4);
+    ival[3][2] = PathInterval(mid2, mid3, true, 4);
+    ival[3][3] = PathInterval(mid3, mid2, true, 4);
+    ival[4][0] = PathInterval(n2_after, n3_before, false, 4);
+    ival[4][1] = PathInterval(n3_before, n2_after, false, 4);
+    ival[4][2] = PathInterval(n2_after, n3_before, true, 4);
+    ival[4][3] = PathInterval(n3_before, n2_after, true, 4);
+
+    EXPECT_TRUE(ival[0][0].contains(n2_before));
+    EXPECT_TRUE(ival[0][0].contains(n2_after));
+    EXPECT_TRUE(ival[0][1].contains(n2_before));
+    EXPECT_TRUE(ival[0][1].contains(n2_after));
+
+    for (unsigned i = 0; i <= 4; ++i) {
+        EXPECT_FALSE(ival[i][0].reverse());
+        EXPECT_TRUE(ival[i][1].reverse());
+        EXPECT_TRUE(ival[i][2].reverse());
+        EXPECT_FALSE(ival[i][3].reverse());
+    }
+
+    for (unsigned i = 0; i <= 4; ++i) {
+        for (unsigned j = 0; j <= 3; ++j) {
+            //std::cout << i << " " << j << " " << ival[i][j] << std::endl;
+            EXPECT_TRUE(ival[i][j].contains(ival[i][j].inside(1e-3)));
+        }
+    }
+
+    PathTime n1(1, 0.0), n1x(0, 1.0),
+                 n2(2, 0.0), n2x(1, 1.0),
+                 n3(3, 0.0), n3x(2, 1.0);
+    PathTime tests[8] = { n1, n1x, n2, n2x, n3, n3x, mid2, mid3 };
+
+    // 0: false for both
+    // 1: true for normal, false for cross_start
+    // 2: false for normal, true for cross_start
+    // 3: true for both
+
+    int const NORMAL = 1, CROSS = 2, BOTH = 3;
+
+    int includes[5][8] = {
+        { CROSS,  CROSS,  NORMAL, NORMAL, CROSS,  CROSS,  CROSS,  CROSS  },
+        { CROSS,  CROSS,  NORMAL, NORMAL, NORMAL, NORMAL, NORMAL, CROSS  },
+        { CROSS,  CROSS,  NORMAL, NORMAL, CROSS,  CROSS,  BOTH,   CROSS  },
+        { CROSS,  CROSS,  CROSS,  CROSS,  NORMAL, NORMAL, BOTH,   BOTH   },
+        { CROSS,  CROSS,  CROSS,  CROSS,  CROSS,  CROSS,  NORMAL, CROSS  }
+    };
+    unsigned sizes[5][2] = {
+        { 2, 4 },
+        { 3, 3 },
+        { 2, 4 },
+        { 2, 4 },
+        { 1, 5 }
+    };
+
+    for (unsigned i = 0; i < 5; ++i) {
+        for (unsigned j = 0; j < 8; ++j) {
+            EXPECT_EQ(ival[i][0].contains(tests[j]), bool(includes[i][j] & NORMAL));
+            EXPECT_EQ(ival[i][1].contains(tests[j]), bool(includes[i][j] & NORMAL));
+            EXPECT_EQ(ival[i][2].contains(tests[j]), bool(includes[i][j] & CROSS));
+            EXPECT_EQ(ival[i][3].contains(tests[j]), bool(includes[i][j] & CROSS));
+        }
+        EXPECT_EQ(ival[i][0].curveCount(), sizes[i][0]);
+        EXPECT_EQ(ival[i][1].curveCount(), sizes[i][0]);
+        EXPECT_EQ(ival[i][2].curveCount(), sizes[i][1]);
+        EXPECT_EQ(ival[i][3].curveCount(), sizes[i][1]);
+    }
+}
+
+TEST_F(PathTest, Continuity) {
+    line.checkContinuity();
+    square.checkContinuity();
+    circle.checkContinuity();
+    diederik.checkContinuity();
+    cmds.checkContinuity();
+}
+
+TEST_F(PathTest, RectConstructor) {
+    Rect r(Point(0,0), Point(10,10));
+    Path rpath(r);
+
+    EXPECT_EQ(rpath.size(), 4u);
+    EXPECT_TRUE(rpath.closed());
+    for (unsigned i = 0; i < 4; ++i) {
+        EXPECT_TRUE(dynamic_cast<LineSegment const *>(&rpath[i]) != NULL);
+        EXPECT_EQ(rpath[i].initialPoint(), r.corner(i));
+    }
+}
+
+TEST_F(PathTest, Reversed) {
+    std::vector<Path> a, r;
+    a.push_back(p_open);
+    a.push_back(p_closed);
+    a.push_back(circle);
+    a.push_back(diederik);
+    a.push_back(cmds);
+
+    for (auto & i : a) {
+        r.push_back(i.reversed());
+    }
+
+    for (unsigned i = 0; i < a.size(); ++i) {
+        EXPECT_EQ(r[i].size(), a[i].size());
+        EXPECT_EQ(r[i].initialPoint(), a[i].finalPoint());
+        EXPECT_EQ(r[i].finalPoint(), a[i].initialPoint());
+        EXPECT_EQ(r[i].reversed(), a[i]);
+        Point p1 = r[i].pointAt(0.75);
+        Point p2 = a[i].pointAt(a[i].size() - 0.75);
+        EXPECT_FLOAT_EQ(p1[X], p2[X]);
+        EXPECT_FLOAT_EQ(p1[Y], p2[Y]);
+        EXPECT_EQ(r[i].closed(), a[i].closed());
+        a[i].checkContinuity();
+    }
+}
+
+TEST_F(PathTest, ValueAt) {
+    EXPECT_EQ(Point(0,0), line.initialPoint());
+    EXPECT_EQ(Point(1,0), line.finalPoint());
+
+    EXPECT_EQ(Point(0.5, 0.0), line.pointAt(0.5));
+
+    EXPECT_EQ(Point(0,0), square.initialPoint());
+    EXPECT_EQ(Point(0,0), square.finalPoint());
+    EXPECT_EQ(Point(1,0), square.pointAt(1));
+    EXPECT_EQ(Point(0.5,1), square.pointAt(2.5));
+    EXPECT_EQ(Point(0,0.5), square.pointAt(3.5));
+    EXPECT_EQ(Point(0,0), square.pointAt(4));
+}
+
+TEST_F(PathTest, NearestPoint) {
+    EXPECT_EQ(0, line.nearestTime(Point(0,0)).asFlatTime());
+    EXPECT_EQ(0.5, line.nearestTime(Point(0.5,0)).asFlatTime());
+    EXPECT_EQ(0.5, line.nearestTime(Point(0.5,1)).asFlatTime());
+    EXPECT_EQ(1, line.nearestTime(Point(100,0)).asFlatTime());
+    EXPECT_EQ(0, line.nearestTime(Point(-100,1000)).asFlatTime());
+
+    EXPECT_EQ(0, square.nearestTime(Point(0,0)).asFlatTime());
+    EXPECT_EQ(1, square.nearestTime(Point(1,0)).asFlatTime());
+    EXPECT_EQ(3, square.nearestTime(Point(0,1)).asFlatTime());
+
+    //cout << diederik.nearestTime(Point(247.32293,-43.339507)) << endl;
+
+    Point p(511.75,40.85);
+    EXPECT_FLOAT_EQ(6.5814033, diederik.nearestTime(p).asFlatTime());
+    /*cout << diederik.pointAt(diederik.nearestTime(p)) << endl
+         << diederik.pointAt(6.5814033) << endl
+         << distance(diederik.pointAt(diederik.nearestTime(p)), p) << "  "
+         << distance(diederik.pointAt(6.5814033), p) << endl;*/
+
+}
+
+TEST_F(PathTest, Winding) {
+    // test points in special positions
+    EXPECT_EQ(line.winding(Point(-1, 0)), 0);
+    EXPECT_EQ(line.winding(Point(2, 0)), 0);
+    EXPECT_EQ(line.winding(Point(0, 1)), 0);
+    EXPECT_EQ(line.winding(Point(0, -1)), 0);
+    EXPECT_EQ(line.winding(Point(1, 1)), 0);
+    EXPECT_EQ(line.winding(Point(1, -1)), 0);
+
+    EXPECT_EQ(square.winding(Point(0, -1)), 0);
+    EXPECT_EQ(square.winding(Point(1, -1)), 0);
+    EXPECT_EQ(square.winding(Point(0, 2)), 0);
+    EXPECT_EQ(square.winding(Point(1, 2)), 0);
+    EXPECT_EQ(square.winding(Point(-1, 0)), 0);
+    EXPECT_EQ(square.winding(Point(-1, 1)), 0);
+    EXPECT_EQ(square.winding(Point(2, 0)), 0);
+    EXPECT_EQ(square.winding(Point(2, 1)), 0);
+    EXPECT_EQ(square.winding(Point(0.5, 0.5)), 1);
+
+    EXPECT_EQ(circle.winding(Point(-4.5,0)), 1);
+    EXPECT_EQ(circle.winding(Point(-3.5,0)), 1);
+    EXPECT_EQ(circle.winding(Point(-4.5,1)), 1);
+    EXPECT_EQ(circle.winding(Point(-10,0)), 0);
+    EXPECT_EQ(circle.winding(Point(1,0)), 0);
+
+    Path yellipse = string_to_path("M 0,0 A 40 20 90 0 0 0,-80 40 20 90 0 0 0,0 z");
+    EXPECT_EQ(yellipse.winding(Point(-1, 0)), 0);
+    EXPECT_EQ(yellipse.winding(Point(-1, -80)), 0);
+    EXPECT_EQ(yellipse.winding(Point(1, 0)), 0);
+    EXPECT_EQ(yellipse.winding(Point(1, -80)), 0);
+    EXPECT_EQ(yellipse.winding(Point(0, -40)), -1);
+    std::vector<double> r[4];
+    r[0] = yellipse[0].roots(0, Y);
+    r[1] = yellipse[0].roots(-80, Y);
+    r[2] = yellipse[1].roots(0, Y);
+    r[3] = yellipse[1].roots(-80, Y);
+    for (auto & i : r) {
+        for (double j : i) {
+            std::cout << format_coord_nice(j) << " ";
+        }
+        std::cout << std::endl;
+    }
+    std::cout << yellipse[0].unitTangentAt(0) << " "
+              << yellipse[0].unitTangentAt(1) << " "
+              << yellipse[1].unitTangentAt(0) << " "
+              << yellipse[1].unitTangentAt(1) << std::endl;
+
+    Path half_ellipse = string_to_path("M 0,0 A 40 20 90 0 0 0,-80 L -20,-40 z");
+    EXPECT_EQ(half_ellipse.winding(Point(-1, 0)), 0);
+    EXPECT_EQ(half_ellipse.winding(Point(-1, -80)), 0);
+    EXPECT_EQ(half_ellipse.winding(Point(1, 0)), 0);
+    EXPECT_EQ(half_ellipse.winding(Point(1, -80)), 0);
+    EXPECT_EQ(half_ellipse.winding(Point(0, -40)), -1);
+
+    // extra nasty cases with exact double roots
+    Path hump = string_to_path("M 0,0 Q 1,1 2,0 L 2,2 0,2 Z");
+    EXPECT_EQ(hump.winding(Point(0.25, 0.5)), 1);
+    EXPECT_EQ(hump.winding(Point(1.75, 0.5)), 1);
+
+    Path hump2 = string_to_path("M 0,0 L 2,0 2,2 Q 1,1 0,2 Z");
+    EXPECT_EQ(hump2.winding(Point(0.25, 1.5)), 1);
+    EXPECT_EQ(hump2.winding(Point(1.75, 1.5)), 1);
+}
+
+/// Regression test for issue https://gitlab.com/inkscape/lib2geom/-/issues/58
+TEST_F(PathTest, Issue58)
+{
+    auto const random_point_in = [](Geom::Rect const &box) -> Point {
+        Coord const x = g_random_double_range(box[X].min(), box[X].max());
+        Coord const y = g_random_double_range(box[Y].min(), box[Y].max());
+        return {x, y};
+    };
+
+    auto const verify_windings = [](Ellipse const &e, Path const &path, Point const &pt) {
+        int const winding = path.winding(pt);
+        if (e.contains(pt)) {
+            EXPECT_EQ(winding, 1);
+        } else {
+            EXPECT_EQ(winding, 0);
+        }
+    };
+
+    // Example elliptical path from issue https://gitlab.com/inkscape/lib2geom/-/issues/58
+    char const *const issue_d = "M 495.8157837290847 280.07459226562503"
+                                "A 166.63407933993605 132.04407218873035 0 0 1 329.1817043891487 412.11866445435544"
+                                "A 166.63407933993605 132.04407218873035 0 0 1 162.54762504921263 280.07459226562503"
+                                "A 166.63407933993605 132.04407218873035 0 0 1 329.1817043891487 148.0305200768947"
+                                "A 166.63407933993605 132.04407218873035 0 0 1 495.8157837290847 280.07459226562503"
+                                "z";
+    auto const pv = parse_svg_path(issue_d);
+    auto const issue_ellipse = Ellipse(Point(329.1817043891487, 280.07459226562503),
+                                       Point(166.63407933993605, 132.04407218873035), 0);
+
+    auto box = issue_ellipse.boundsExact();
+    box.expandBy(1.0);
+
+    g_random_set_seed(0xE111BB5E);
+    for (size_t _ = 0; _ < 10'000; _++) {
+        verify_windings(issue_ellipse, pv[0], random_point_in(box));
+    }
+}
+
+TEST_F(PathTest, SVGRoundtrip) {
+    SVGPathWriter sw;
+
+    Path transformed = diederik * (Rotate(1.23456789) * Scale(1e-8) * Translate(1e-9, 1e-9));
+
+    for (unsigned i = 0; i < 4; ++i) {
+        sw.setOptimize(i & 1);
+        sw.setUseShorthands(i & 2);
+
+        sw.feed(line);
+        //cout << sw.str() << endl;
+        Path line_svg = string_to_path(sw.str().c_str());
+        EXPECT_TRUE(line_svg == line);
+        sw.clear();
+
+        sw.feed(square);
+        //cout << sw.str() << endl;
+        Path square_svg = string_to_path(sw.str().c_str());
+        EXPECT_TRUE(square_svg == square);
+        sw.clear();
+
+        sw.feed(circle);
+        //cout << sw.str() << endl;
+        Path circle_svg = string_to_path(sw.str().c_str());
+        EXPECT_TRUE(circle_svg == circle);
+        sw.clear();
+
+        sw.feed(arcs);
+        //cout << sw.str() << endl;
+        Path arcs_svg = string_to_path(sw.str().c_str());
+        EXPECT_TRUE(arcs_svg == arcs);
+        sw.clear();
+
+        sw.feed(diederik);
+        //cout << sw.str() << endl;
+        Path diederik_svg = string_to_path(sw.str().c_str());
+        EXPECT_TRUE(diederik_svg == diederik);
+        sw.clear();
+
+        sw.feed(transformed);
+        //cout << sw.str() << endl;
+        Path transformed_svg = string_to_path(sw.str().c_str());
+        EXPECT_TRUE(transformed_svg == transformed);
+        sw.clear();
+
+        sw.feed(cmds);
+        //cout << sw.str() << endl;
+        Path cmds_svg = string_to_path(sw.str().c_str());
+        EXPECT_TRUE(cmds_svg == cmds);
+        sw.clear();
+    }
+}
+
+TEST_F(PathTest, Portion) {
+    PathTime a(0, 0.5), b(3, 0.5);
+    PathTime c(1, 0.25), d(1, 0.75);
+
+    EXPECT_EQ(square.portion(a, b), string_to_path("M 0.5, 0 L 1,0 1,1 0,1 0,0.5"));
+    EXPECT_EQ(square.portion(b, a), string_to_path("M 0,0.5 L 0,1 1,1 1,0 0.5,0"));
+    EXPECT_EQ(square.portion(a, b, true), string_to_path("M 0.5,0 L 0,0 0,0.5"));
+    EXPECT_EQ(square.portion(b, a, true), string_to_path("M 0,0.5 L 0,0 0.5,0"));
+    EXPECT_EQ(square.portion(c, d), string_to_path("M 1,0.25 L 1,0.75"));
+    EXPECT_EQ(square.portion(d, c), string_to_path("M 1,0.75 L 1,0.25"));
+    EXPECT_EQ(square.portion(c, d, true), string_to_path("M 1,0.25 L 1,0 0,0 0,1 1,1 1,0.75"));
+    EXPECT_EQ(square.portion(d, c, true), string_to_path("M 1,0.75 L 1,1 0,1 0,0 1,0 1,0.25"));
+
+    // verify that no matter how an endpoint is specified, the result is the same
+    PathTime a1(0, 1.0), a2(1, 0.0);
+    PathTime b1(2, 1.0), b2(3, 0.0);
+    Path result = string_to_path("M 1,0 L 1,1 0,1");
+    EXPECT_EQ(square.portion(a1, b1), result);
+    EXPECT_EQ(square.portion(a1, b2), result);
+    EXPECT_EQ(square.portion(a2, b1), result);
+    EXPECT_EQ(square.portion(a2, b2), result);
+}
+
+TEST_F(PathTest, AppendSegment) {
+    Path p_open = line, p_closed = line;
+    p_open.setStitching(true);
+    p_open.append(new LineSegment(Point(10,20), Point(10,25)));
+    EXPECT_EQ(p_open.size(), 3u);
+    EXPECT_NO_THROW(p_open.checkContinuity());
+
+    p_closed.setStitching(true);
+    p_closed.close(true);
+    p_closed.append(new LineSegment(Point(10,20), Point(10,25)));
+    EXPECT_EQ(p_closed.size(), 4u);
+    EXPECT_NO_THROW(p_closed.checkContinuity());
+}
+
+TEST_F(PathTest, AppendPath) {
+    p_open.append(p_add);
+    Path p_expected = string_to_path("M 0,0 L 0,5 5,5 5,0 -1,6 6,6");
+    EXPECT_EQ(p_open.size(), 5u);
+    EXPECT_EQ(p_open, p_expected);
+    EXPECT_NO_THROW(p_open.checkContinuity());
+
+    p_expected.close(true);
+    p_closed.append(p_add);
+    EXPECT_EQ(p_closed.size(), 6u);
+    EXPECT_EQ(p_closed, p_expected);
+    EXPECT_NO_THROW(p_closed.checkContinuity());
+}
+
+TEST_F(PathTest, AppendPortion) {
+    // A closed path with two curves:
+    Path bigon = string_to_path("M 0,0 Q 1,1 2,0 Q 1,-1 0,0 Z");
+    Path target{Point(0, 0)};
+
+    PathTime end_time{1, 1.0}; // End of the closed path
+    PathTime mid_time{1, 0.0}; // Middle of the closed path (juncture between the two curves)
+    bigon.appendPortionTo(target, end_time, mid_time, true /* do cross start */);
+
+    // We expect that the target path now contains the entire first curve "M 0,0 Q 1,1 2,0",
+    // since we started at the end of a closed path and requested to cross its start.
+    EXPECT_EQ(target.size(), 1);
+    EXPECT_EQ(target, string_to_path("M 0,0 Q 1,1 2,0"));
+
+    // Similar test but with reversal (swapped times)
+    Path target_reverse{Point(2, 0)};
+    bigon.appendPortionTo(target_reverse, mid_time, end_time, true /* do cross start please */);
+    // What do we expect? To cross start going from the midpoint to the endpoint requires
+    // not taking the obvious route (bigon[1]) but rather taking bigon[0] in reverse.
+    EXPECT_EQ(target_reverse.size(), 1);
+    EXPECT_EQ(target_reverse, string_to_path("M 2,0 Q 1,1 0,0"));
+
+    // Similar test but using start time
+    PathTime start_time{0, 0.0};
+    Path mid_target{Point(2, 0)};
+    bigon.appendPortionTo(mid_target, mid_time, start_time, true /* cross start to 0:0 */);
+    // We expect to go forward from mid_time and cross over the start to start_time.
+    EXPECT_EQ(mid_target.size(), 1);
+    EXPECT_EQ(mid_target, string_to_path("M 2,0 Q 1,-1 0,0"));
+
+    // Use start time with reversal
+    Path mid_reverse{Point(0, 0)};
+    bigon.appendPortionTo(mid_reverse, start_time, mid_time, true /* Cross start, going backwards. */);
+    // We expect that we don't go forwards from start_time to mid_time, but rather cross over the starting
+    // point and backtrack over bigon[1] to the midpoint.
+    EXPECT_EQ(mid_reverse.size(), 1);
+    EXPECT_EQ(mid_reverse, string_to_path("M 0,0 Q 1,-1 2,0"));
+}
+
+TEST_F(PathTest, ReplaceMiddle) {
+    p_open.replace(p_open.begin() + 1, p_open.begin() + 2, p_add);
+    EXPECT_EQ(p_open.size(), 5u);
+    EXPECT_NO_THROW(p_open.checkContinuity());
+
+    p_closed.replace(p_closed.begin() + 1, p_closed.begin() + 2, p_add);
+    EXPECT_EQ(p_closed.size(), 6u);
+    EXPECT_NO_THROW(p_closed.checkContinuity());
+}
+
+TEST_F(PathTest, ReplaceStart) {
+    p_open.replace(p_open.begin(), p_open.begin() + 2, p_add);
+    EXPECT_EQ(p_open.size(), 3u);
+    EXPECT_NO_THROW(p_open.checkContinuity());
+
+    p_closed.replace(p_closed.begin(), p_closed.begin() + 2, p_add);
+    EXPECT_EQ(p_closed.size(), 5u);
+    EXPECT_NO_THROW(p_closed.checkContinuity());
+}
+
+TEST_F(PathTest, ReplaceEnd) {
+    p_open.replace(p_open.begin() + 1, p_open.begin() + 3, p_add);
+    EXPECT_EQ(p_open.size(), 3u);
+    EXPECT_NO_THROW(p_open.checkContinuity());
+
+    p_closed.replace(p_closed.begin() + 1, p_closed.begin() + 3, p_add);
+    EXPECT_EQ(p_closed.size(), 5u);
+    EXPECT_NO_THROW(p_closed.checkContinuity());
+}
+
+TEST_F(PathTest, ReplaceClosing) {
+    p_open.replace(p_open.begin() + 1, p_open.begin() + 4, p_add);
+    EXPECT_EQ(p_open.size(), 3u);
+    EXPECT_NO_THROW(p_open.checkContinuity());
+
+    p_closed.replace(p_closed.begin() + 1, p_closed.begin() + 4, p_add);
+    EXPECT_EQ(p_closed.size(), 4u);
+    EXPECT_NO_THROW(p_closed.checkContinuity());
+}
+
+TEST_F(PathTest, ReplaceEverything) {
+    p_open.replace(p_open.begin(), p_open.end(), p_add);
+    EXPECT_EQ(p_open.size(), 1u);
+    EXPECT_NO_THROW(p_open.checkContinuity());
+
+    // TODO: in this specific case, it may make sense to set the path to open...
+    // Need to investigate what behavior is sensible here
+    p_closed.replace(p_closed.begin(), p_closed.end(), p_add);
+    EXPECT_EQ(p_closed.size(), 2u);
+    EXPECT_NO_THROW(p_closed.checkContinuity());
+}
+
+TEST_F(PathTest, EraseLast) {
+    p_open.erase_last();
+    Path p_expected = string_to_path("M 0,0 L 0,5 5,5");
+    EXPECT_EQ(p_open, p_expected);
+    EXPECT_NO_THROW(p_open.checkContinuity());
+}
+
+TEST_F(PathTest, AreNear) {
+    Path nudged_arcs1 = string_to_path("M 0,0 a 5,10 45 0 1 10,10.0000005 a 5,10 45 0 1 0,0 z");
+    Path nudged_arcs2 = string_to_path("M 0,0 a 5,10 45 0 1 10,10.00005 a 5,10 45 0 1 0,0 z");
+    EXPECT_EQ(are_near(diederik, diederik, 0), true);
+    EXPECT_EQ(are_near(cmds, diederik, 1e-6), false);
+    EXPECT_EQ(are_near(arcs, nudged_arcs1, 1e-6), true);
+    EXPECT_EQ(are_near(arcs, nudged_arcs2, 1e-6), false);
+}
+
+TEST_F(PathTest, Roots) {
+    Path path;
+    path.start(Point(0, 0));
+    path.appendNew<Geom::LineSegment>(Point(1, 1));
+    path.appendNew<Geom::LineSegment>(Point(2, 0));
+
+    EXPECT_FALSE(path.closed());
+
+    // Trivial case: make sure that path is not closed
+    std::vector<PathTime> roots = path.roots(0.5, Geom::X);
+    EXPECT_EQ(roots.size(), 1u);
+    EXPECT_EQ(path.valueAt(roots[0], Geom::Y), 0.5);
+
+    // Now check that it is closed if we make it so
+    path.close(true);
+    roots = path.roots(0.5, Geom::X);
+    EXPECT_EQ(roots.size(), 2u);
+}
+
+TEST_F(PathTest, PartingPoint)
+{
+    // === Test complete overlaps between identical curves ===
+    // Line segment
+    auto line = string_to_path("M 0,0 L 3.33, 7.77");
+    auto pt = parting_point(line, line);
+    EXPECT_TRUE(are_near(pt.point(), line.finalPoint()));
+    EXPECT_TRUE(are_near(pt.first.t, 1.0));
+
+    // Cubic Bézier
+    auto bezier = string_to_path("M 0,0 C 1,1 14,1 15,0");
+    pt = parting_point(bezier, bezier);
+    EXPECT_TRUE(are_near(pt.point(), bezier.finalPoint()));
+    EXPECT_TRUE(are_near(pt.first.t, 1.0));
+
+    // Eliptical arc
+    auto const arc = string_to_path("M 0,0 A 100,20 0,0,0 200,0");
+    pt = parting_point(arc, arc);
+    EXPECT_TRUE(are_near(pt.point(), arc.finalPoint()));
+    EXPECT_TRUE(are_near(pt.first.t, 1.0));
+
+    // === Test complete overlap between degree-elevated and degree-shrunk Béziers ===
+    auto artificially_cubic = string_to_path("M 0,0 C 10,10 20,10 30,0");
+    auto really_quadratic = string_to_path("M 0,0 Q 15,15 30,0");
+    pt = parting_point(artificially_cubic, really_quadratic);
+    EXPECT_TRUE(are_near(pt.point(), artificially_cubic.finalPoint()));
+    EXPECT_TRUE(are_near(pt.first.asFlatTime(), 1.0));
+    EXPECT_TRUE(are_near(pt.second.asFlatTime(), 1.0));
+
+    // === Test complete overlaps between a curve and its subdivision ===
+    // Straight line
+    line = string_to_path("M 0,0 L 15,15");
+    auto subdivided_line = string_to_path("M 0,0 L 3,3 L 4,4 L 9,9 L 15,15");
+    pt = parting_point(line, subdivided_line);
+    EXPECT_TRUE(are_near(pt.point(), line.finalPoint()));
+    EXPECT_TRUE(are_near(pt.first.t, 1.0));
+
+    // Cubic Bézier
+    bezier = string_to_path("M 0,0 C 0,40 50,40 50,0");
+    auto de_casteljau = string_to_path("M 0,0 C 0,10 3.125,17.5 7.8125,22.5 12.5,27.5 18.75,30 25,30"
+                                       " 31.25,30 37.5,27.5 42.1875,22.5 46.875,17.5 50,10 50,0");
+    pt = parting_point(bezier, de_casteljau);
+    EXPECT_TRUE(are_near(pt.point(), bezier.finalPoint()));
+    EXPECT_TRUE(are_near(pt.first.t, 1.0));
+
+    // Eliptical arc
+    auto subdivided_arc = string_to_path("M 0,0 A 100,20, 0,0,0 100,20 A 100,20 0,0,0 200,0");
+    pt = parting_point(arc, subdivided_arc);
+    EXPECT_TRUE(are_near(pt.point(), arc.finalPoint()));
+    EXPECT_TRUE(are_near(pt.first.t, 1.0));
+
+    // === Test complete overlap between different subdivisions ===
+    auto line1 = string_to_path("M 0,0 L 3,3 L 5,5 L 10,10");
+    auto line2 = string_to_path("M 0,0 L 2,2 L 4.2,4.2 L 4.5,4.5 L 6,6 L 10,10");
+    pt = parting_point(line1, line2);
+    EXPECT_TRUE(are_near(pt.point(), line1.finalPoint()));
+    EXPECT_TRUE(are_near(pt.first.asFlatTime(),  line1.timeRange().max()));
+    EXPECT_TRUE(are_near(pt.second.asFlatTime(), line2.timeRange().max()));
+
+    // === Test complete overlaps in the presence of degenerate segments ===
+    // Straight line
+    line = string_to_path("M 0,0 L 15,15");
+    subdivided_line = string_to_path("M 0,0 L 3,3 H 3 V 3 L 3,3 L 4,4 H 4 V 4 L 4,4 L 9,9 H 9 L 15,15");
+    pt = parting_point(line, subdivided_line);
+    EXPECT_TRUE(are_near(pt.point(), line.finalPoint()));
+    EXPECT_TRUE(are_near(pt.first.asFlatTime(), 1.0));
+
+    // Eliptical arc
+    auto arc_degen = string_to_path("M 0,0 A 100,20, 0,0,0 100,20 H 100 V 20 L 100,20 A 100,20 0,0,0 200,0");
+    pt = parting_point(arc, arc_degen);
+    EXPECT_TRUE(are_near(pt.point(), arc.finalPoint()));
+    EXPECT_TRUE(are_near(pt.first.asFlatTime(), 1.0));
+
+    // === Paths that overlap but one is shorter than the other ===
+    // Straight lines
+    auto long_line = string_to_path("M 0,0 L 20,10");
+    auto short_line = string_to_path("M 0,0 L 4,2");
+    pt = parting_point(long_line, short_line);
+    EXPECT_TRUE(are_near(pt.point(), short_line.finalPoint()));
+    EXPECT_TRUE(are_near(pt.first.t, 0.2));
+    EXPECT_TRUE(are_near(pt.second.t, 1.0));
+
+    // Cubic Bézier
+    auto const s_shape = string_to_path("M 0,0 C 10, 0 0,10 10,10");
+    auto half_s = string_to_path("M 0,0 C 5,0 5,2.5 5,5");
+    pt = parting_point(s_shape, half_s);
+    EXPECT_TRUE(are_near(pt.first.t, 0.5));
+    EXPECT_TRUE(are_near(pt.second.t, 1.0));
+
+    // Elliptical arc
+    auto quarter_ellipse = string_to_path("M 0,0 A 100,20, 0,0,0 100,20");
+    pt = parting_point(arc, quarter_ellipse);
+    EXPECT_TRUE(are_near(pt.point(), quarter_ellipse.finalPoint()));
+    EXPECT_TRUE(are_near(pt.first.t, 0.5));
+    EXPECT_TRUE(are_near(pt.second.t, 1.0));
+
+    // === Paths that overlap initially but then they split ===
+    // Straight lines
+    auto boring_line = string_to_path("M 0,0 L 50,10");
+    auto line_then_arc = string_to_path("M 0,0 L 5,1 A 1,1 0,0,0 7,1");
+    pt = parting_point(boring_line, line_then_arc);
+    EXPECT_TRUE(are_near(pt.point(), Point(5, 1)));
+    EXPECT_TRUE(are_near(pt.first.t, 0.1));
+    EXPECT_TRUE(are_near(pt.second.asFlatTime(), 1.0));
+
+    // Cubic Bézier
+    auto half_s_then_line = string_to_path("M 0,0 C 5,0 5,2.5 5,5 L 10,10");
+    pt = parting_point(s_shape, half_s_then_line);
+    EXPECT_TRUE(are_near(pt.point(), Point(5, 5)));
+    EXPECT_TRUE(are_near(pt.first.t, 0.5));
+    EXPECT_TRUE(are_near(pt.second.asFlatTime(), 1.0));
+
+    // Elliptical arc
+    auto quarter_ellipse_then_quadratic = string_to_path("M 0,0 A 100,20, 0,0,0 100,20 Q 120,40 140,60");
+    pt = parting_point(arc, quarter_ellipse_then_quadratic);
+    EXPECT_TRUE(are_near(pt.point(), Point(100, 20)));
+    EXPECT_TRUE(are_near(pt.first.t, 0.5));
+    EXPECT_TRUE(are_near(pt.second.asFlatTime(), 1.0));
+
+    // === Paths that split at a common node ===
+    // Polylines
+    auto branch_90 = string_to_path("M 0,0 H 3 H 6 V 7");
+    auto branch_45 = string_to_path("M 0,0 H 2 H 6 L 7,7");
+    pt = parting_point(branch_90, branch_45);
+    EXPECT_TRUE(are_near(pt.point(), Point(6, 0)));
+    EXPECT_TRUE(are_near(pt.first.asFlatTime(), 2.0));
+    EXPECT_TRUE(are_near(pt.second.asFlatTime(), 2.0));
+
+    // Arcs
+    auto quarter_circle_then_horiz = string_to_path("M 0,0 A 1,1 0,0,0 1,1 H 10");
+    auto quarter_circle_then_slant = string_to_path("M 0,0 A 1,1 0,0,0 1,1 L 10, 1.1");
+    pt = parting_point(quarter_circle_then_horiz, quarter_circle_then_slant);
+    EXPECT_TRUE(are_near(pt.point(), Point(1, 1)));
+    EXPECT_TRUE(are_near(pt.first.asFlatTime(), 1.0));
+    EXPECT_TRUE(are_near(pt.second.asFlatTime(), 1.0));
+
+    // Last common nodes followed by degenerates
+    auto degen_horiz = string_to_path("M 0,0 A 1,1 0,0,0 1,1 V 1 H 1 L 1,1 H 10");
+    auto degen_slant = string_to_path("M 0,0 A 1,1 0,0,0 1,1 V 1 H 1 L 1,1 L 10, 1.1");
+    pt = parting_point(quarter_circle_then_horiz, quarter_circle_then_slant);
+    EXPECT_TRUE(are_near(pt.point(), Point(1, 1)));
+
+    // === Paths that split at the starting point ===
+    auto vertical = string_to_path("M 0,0 V 1");
+    auto quarter = string_to_path("M 0,0 A 1,1 0,0,0, 1,1");
+    pt = parting_point(vertical, quarter);
+    EXPECT_TRUE(are_near(pt.point(), Point(0, 0)));
+    EXPECT_TRUE(are_near(pt.first.asFlatTime(), 0.0));
+    EXPECT_TRUE(are_near(pt.second.asFlatTime(), 0.0));
+
+    // === Symmetric split (both legs of the same length) ===
+    auto left_leg = string_to_path("M 1,0 L 0,10");
+    auto right_leg = string_to_path("M 1,0 L 2,10");
+    pt = parting_point(left_leg, right_leg);
+    EXPECT_TRUE(are_near(pt.point(), Point(1, 0)));
+    EXPECT_TRUE(are_near(pt.first.asFlatTime(), 0.0));
+    EXPECT_TRUE(are_near(pt.second.asFlatTime(), 0.0));
+
+    // === Different starting points ===
+    auto start_at_0_0 = string_to_path("M 0,0 C 1,0 0,1 1,1");
+    auto start_at_10_10 = string_to_path("M 10,10 L 50,50");
+    pt = parting_point(start_at_0_0, start_at_10_10);
+    EXPECT_TRUE(are_near(pt.point(), Point (5,5)));
+    EXPECT_DOUBLE_EQ(pt.first.t, -1.0);
+    EXPECT_DOUBLE_EQ(pt.second.t, -1.0);
+    EXPECT_EQ(pt.first.curve_index, 0);
+    EXPECT_EQ(pt.second.curve_index, 0);
+}
+
+TEST_F(PathTest, InitialFinalTangents) {
+    // Test tangents for an open path
+    auto L_shape = string_to_path("M 1,1 H 0 V 0");
+    EXPECT_EQ(L_shape.initialUnitTangent(), Point(-1.0, 0.0));
+    EXPECT_EQ(L_shape.finalUnitTangent(), Point(0.0, -1.0));
+
+    // Closed path with non-degenerate closing segment
+    auto triangle = string_to_path("M 0,0 H 2 L 0,3 Z");
+    EXPECT_EQ(triangle.initialUnitTangent(), Point(1.0, 0.0));
+    EXPECT_EQ(triangle.finalUnitTangent(), Point(0.0, -1.0));
+
+    // Closed path with a degenerate closing segment
+    auto full360 = string_to_path("M 0,0 A 1,1, 0,1,1, 0,2 A 1,1 0,1,1 0,0 Z");
+    EXPECT_EQ(full360.initialUnitTangent(), Point(1.0, 0.0));
+    EXPECT_EQ(full360.finalUnitTangent(), Point(1.0, 0.0));
+
+    // Test multiple degenerate segments at the start
+    auto start_degen = string_to_path("M 0,0 L 0,0 H 0 V 0 Q 1,0 1,1");
+    EXPECT_EQ(start_degen.initialUnitTangent(), Point(1.0, 0.0));
+
+    // Test multiple degenerate segments at the end
+    auto end_degen = string_to_path("M 0,0 L 1,1 H 1 V 1 L 1,1");
+    double comp = 1.0 / sqrt(2.0);
+    EXPECT_EQ(end_degen.finalUnitTangent(), Point(comp, comp));
+
+    // Test a long and complicated path with both tangents along the positive x-axis.
+    auto complicated = string_to_path("M 0,0 H 0 L 1,0 C 2,1 3,2 1,0 L 1,0 H 1 Q 2,3 0,5 H 2");
+    EXPECT_EQ(complicated.initialUnitTangent(), Point(1.0, 0.0));
+    EXPECT_EQ(complicated.finalUnitTangent(), Point(1.0, 0.0));
+}
+
+TEST_F(PathTest, WithoutDegenerates) {
+    // Ensure nothing changes when there are no degenerate segments to remove.
+    auto plain_open = string_to_path("M 0,0 Q 5,5 10,10");
+    EXPECT_EQ(plain_open, plain_open.withoutDegenerateCurves());
+
+    auto closed_nondegen_closing = string_to_path("M 0,0 L 5,5 H 0 Z");
+    EXPECT_EQ(closed_nondegen_closing,closed_nondegen_closing.withoutDegenerateCurves());
+
+    // Ensure that a degenerate closing segment is left alone.
+    auto closed_degen_closing = string_to_path("M 0,0 L 2,4 H 0 L 0,0 Z");
+    EXPECT_EQ(closed_degen_closing, closed_degen_closing.withoutDegenerateCurves());
+
+    // Ensure that a trivial path is left alone (both open and closed).
+    auto trivial_open = string_to_path("M 0,0");
+    EXPECT_EQ(trivial_open, trivial_open.withoutDegenerateCurves());
+
+    auto trivial_closed = string_to_path("M 0,0 Z");
+    EXPECT_EQ(trivial_closed, trivial_closed.withoutDegenerateCurves());
+
+    // Ensure that initial degenerate segments are removed
+    auto degen_start = string_to_path("M 0,0 L 0,0 H 0 V 0 Q 5,5 10,10");
+    auto degen_start_cleaned = degen_start.withoutDegenerateCurves();
+    EXPECT_EQ(degen_start_cleaned, string_to_path("M 0,0 Q 5,5 10,10"));
+    EXPECT_NE(degen_start.size(), degen_start_cleaned.size());
+
+    // Ensure that degenerate segments are removed from the middle
+    auto degen_middle = string_to_path("M 0,0 L 1,1 H 1 V 1 L 1,1 Q 6,6 10,10");
+    auto degen_middle_cleaned = degen_middle.withoutDegenerateCurves();
+    EXPECT_EQ(degen_middle_cleaned, string_to_path("M 0,0 L 1,1 Q 6,6 10,10"));
+    EXPECT_NE(degen_middle.size(), degen_middle_cleaned.size());
+
+    // Ensure that degenerate segment are removed from the end of an open path
+    auto end_open = string_to_path("M 0,0 L 1,1 H 1 V 1 L 1,1");
+    auto end_open_cleaned = end_open.withoutDegenerateCurves();
+    EXPECT_EQ(end_open_cleaned, string_to_path("M 0,0 L 1,1"));
+    EXPECT_NE(end_open.size(), end_open_cleaned.size());
+
+    // Ensure removal of degenerates just before the closing segment
+    auto end_nondegen = string_to_path("M 0,0 L 1,1 L 0,1 H 0 V 1 Z");
+    auto end_nondegen_cleaned = end_nondegen.withoutDegenerateCurves();
+    EXPECT_EQ(end_nondegen_cleaned, string_to_path("M 0,0 L 1,1 L 0,1 Z"));
+    EXPECT_NE(end_nondegen.size(), end_nondegen_cleaned.size());
+}
+
+/** Test Path::extrema() */
+TEST_F(PathTest, GetExtrema) {
+
+    // Circle of radius 4.5 centered at (-4.5, 0).
+    auto extrema_x = circle.extrema(X);
+    EXPECT_EQ(extrema_x.min_point, Point(-9, 0));
+    EXPECT_EQ(extrema_x.max_point, Point( 0, 0));
+    EXPECT_DOUBLE_EQ(extrema_x.min_time.asFlatTime(), 1.0);
+    EXPECT_DOUBLE_EQ(extrema_x.max_time.asFlatTime(), 0.0);
+    EXPECT_EQ(extrema_x.glance_direction_at_min, -1.0);
+    EXPECT_EQ(extrema_x.glance_direction_at_max, 1.0);
+
+    auto extrema_y = circle.extrema(Y);
+    EXPECT_EQ(extrema_y.min_point, Point(-4.5, -4.5));
+    EXPECT_EQ(extrema_y.max_point, Point(-4.5,  4.5));
+    EXPECT_DOUBLE_EQ(extrema_y.min_time.asFlatTime(), 1.5);
+    EXPECT_DOUBLE_EQ(extrema_y.max_time.asFlatTime(), 0.5);
+    EXPECT_FLOAT_EQ(extrema_y.glance_direction_at_min,  1.0);
+    EXPECT_FLOAT_EQ(extrema_y.glance_direction_at_max, -1.0);
+
+    // Positively oriented unit square
+    extrema_x = square.extrema(X);
+    EXPECT_DOUBLE_EQ(extrema_x.min_point[X], 0.0);
+    EXPECT_DOUBLE_EQ(extrema_x.max_point[X], 1.0);
+    EXPECT_FLOAT_EQ(extrema_x.glance_direction_at_min, -1.0);
+    EXPECT_FLOAT_EQ(extrema_x.glance_direction_at_max,  1.0);
+
+    extrema_y = square.extrema(Y);
+    EXPECT_DOUBLE_EQ(extrema_y.min_point[Y], 0.0);
+    EXPECT_DOUBLE_EQ(extrema_y.max_point[Y], 1.0);
+    EXPECT_FLOAT_EQ(extrema_y.glance_direction_at_min, 1.0);
+    EXPECT_FLOAT_EQ(extrema_y.glance_direction_at_max, -1.0);
+
+    // Path glancing its min X line while going towards negative Y
+    auto down_glance = string_to_path("M 1,18 L 0,0 1,-20");
+    extrema_x = down_glance.extrema(X);
+    EXPECT_EQ(extrema_x.min_point, Point(0, 0));
+    EXPECT_FLOAT_EQ(extrema_x.glance_direction_at_min, -1.0);
+    EXPECT_DOUBLE_EQ(extrema_x.min_time.asFlatTime(), 1.0);
+
+    // Similar but not at a node
+    auto down_glance_smooth = string_to_path("M 1,20 C 0,20 0,-20 1,-20");
+    extrema_x = down_glance_smooth.extrema(X);
+    EXPECT_TRUE(are_near(extrema_x.min_point[Y], 0.0));
+    EXPECT_FLOAT_EQ(extrema_x.glance_direction_at_min, -1.0);
+    EXPECT_DOUBLE_EQ(extrema_x.min_time.asFlatTime(), 0.5);
+
+    // Path coming down to the min X and then retreating horizontally
+    auto retreat = string_to_path("M 1,20 L 0,0 H 5 L 4,-20");
+    extrema_x = retreat.extrema(X);
+    EXPECT_EQ(extrema_x.min_point, Point(0, 0));
+    EXPECT_EQ(extrema_x.max_point, Point(5, 0));
+    EXPECT_FLOAT_EQ(extrema_x.glance_direction_at_min, -1.0);
+    EXPECT_FLOAT_EQ(extrema_x.glance_direction_at_max, -1.0);
+    EXPECT_DOUBLE_EQ(extrema_x.min_time.asFlatTime(), 1.0);
+    EXPECT_DOUBLE_EQ(extrema_x.max_time.asFlatTime(), 2.0);
+
+    // Perfectly horizontal path
+    auto horizontal = string_to_path("M 0,0 H 12");
+    extrema_x = horizontal.extrema(X);
+    extrema_y = horizontal.extrema(Y);
+    EXPECT_EQ(extrema_x.min_point, Point(0, 0));
+    EXPECT_EQ(extrema_x.max_point, Point(12, 0));
+    EXPECT_DOUBLE_EQ(extrema_y.min_point[Y], 0.0);
+    EXPECT_DOUBLE_EQ(extrema_y.max_point[Y], 0.0);
+    EXPECT_FLOAT_EQ(extrema_x.glance_direction_at_min, 0.0);
+    EXPECT_FLOAT_EQ(extrema_x.glance_direction_at_max, 0.0);
+    EXPECT_FLOAT_EQ(extrema_y.glance_direction_at_min, 1.0);
+    EXPECT_FLOAT_EQ(extrema_y.glance_direction_at_max, 1.0);
+    EXPECT_DOUBLE_EQ(extrema_x.min_time.asFlatTime(), 0.0);
+    EXPECT_DOUBLE_EQ(extrema_x.max_time.asFlatTime(), 1.0);
+
+    // Perfectly vertical path
+    auto vertical = string_to_path("M 0,0 V 42");
+    extrema_y = vertical.extrema(Y);
+    extrema_x = vertical.extrema(X);
+    EXPECT_DOUBLE_EQ(extrema_x.min_point[Y], 0.0);
+    EXPECT_DOUBLE_EQ(extrema_x.max_point[Y], 0.0);
+    EXPECT_EQ(extrema_y.min_point, Point(0, 0));
+    EXPECT_EQ(extrema_y.max_point, Point(0, 42));
+    EXPECT_FLOAT_EQ(extrema_x.glance_direction_at_min, 1.0);
+    EXPECT_FLOAT_EQ(extrema_x.glance_direction_at_max, 1.0);
+    EXPECT_FLOAT_EQ(extrema_y.glance_direction_at_min, 0.0);
+    EXPECT_FLOAT_EQ(extrema_y.glance_direction_at_max, 0.0);
+    EXPECT_DOUBLE_EQ(extrema_y.min_time.asFlatTime(), 0.0);
+    EXPECT_DOUBLE_EQ(extrema_y.max_time.asFlatTime(), 1.0);
+
+    // Detect downward glance at the closing point (degenerate closing segment)
+    auto closed = string_to_path("M 0,0 L 1,-2 H 3 V 5 H 1 L 0,0 Z");
+    extrema_x = closed.extrema(X);
+    EXPECT_EQ(extrema_x.min_point, Point(0, 0));
+    EXPECT_FLOAT_EQ(extrema_x.glance_direction_at_min, -1.0);
+
+    // Same but with a non-degenerate closing segment
+    auto closed_nondegen = string_to_path("M 0,0 L 1,-2 H 3 V 5 H 1 Z");
+    extrema_x = closed_nondegen.extrema(X);
+    EXPECT_EQ(extrema_x.min_point, Point(0, 0));
+    EXPECT_FLOAT_EQ(extrema_x.glance_direction_at_min, -1.0);
+
+    // Collapsed Bezier not glancing up nor down
+    auto collapsed = string_to_path("M 10, 0 Q -10 0 10, 0");
+    extrema_x = collapsed.extrema(X);
+    EXPECT_EQ(extrema_x.min_point, Point(0, 0));
+    EXPECT_EQ(extrema_x.max_point, Point(10, 0));
+    EXPECT_FLOAT_EQ(extrema_x.glance_direction_at_min, 0.0);
+    EXPECT_FLOAT_EQ(extrema_x.glance_direction_at_max, 0.0);
+
+    // Degenerate segments at min X
+    auto degen = string_to_path("M 0.01,20 L 0, 0 H 0 V 0 L 0,0 V 0 L 0.02 -30");
+    extrema_x = degen.extrema(X);
+    EXPECT_EQ(extrema_x.min_point, Point(0, 0));
+    EXPECT_FLOAT_EQ(extrema_x.glance_direction_at_min, -1.0);
+}
+
+/** Regression test for issue https://gitlab.com/inkscape/lib2geom/-/issues/50 */
+TEST_F(PathTest, PizzaSlice)
+{
+    auto pv = parse_svg_path("M 0 0 L 0.30901699437494745 0.9510565162951535 "
+                             "A 1 1 0 0 1 -0.8090169943749473 0.5877852522924732 z");
+    auto &sector = pv[0];
+    Path piece;
+    EXPECT_NO_THROW(piece = sector.portion(PathTime(0, 0.0), PathTime(2, 0.0), false));
+    EXPECT_FALSE(piece.closed());
+    EXPECT_TRUE(piece.size() == 2 ||
+               (piece.size() == 3 && piece[2].isDegenerate()));
+    EXPECT_EQ(piece.finalPoint(), Point(-0.8090169943749473, 0.5877852522924732));
+
+    // Test slicing in the middle of an arc and past its end
+    pv = parse_svg_path("M 0,0 H 1 A 1,1 0 0 1 0.3080657835086775,0.9513650577098072 z");
+    EXPECT_NO_THROW(piece = pv[0].portion(PathTime(1, 0.5), PathTime(2, 1.0)));
+    EXPECT_FALSE(piece.closed());
+    EXPECT_EQ(piece.finalPoint(), pv[0].finalPoint());
+
+    // Test slicing from before the start to a point on the arc
+    EXPECT_NO_THROW(piece = pv[0].portion(PathTime(0, 0.5), PathTime(1, 0.5)));
+    EXPECT_FALSE(piece.closed());
+    EXPECT_EQ(piece.initialPoint(), pv[0].pointAt(PathTime(0, 0.5)));
+    EXPECT_EQ(piece.finalPoint(), pv[0].pointAt(PathTime(1, 0.5)));
+
+    // Test slicing a part of the arc
+    EXPECT_NO_THROW(piece = pv[0].portion(PathTime(1, 0.25), PathTime(1, 0.75)));
+    EXPECT_FALSE(piece.closed());
+    EXPECT_EQ(piece.size(), 1);
+
+    // Test slicing in reverse
+    EXPECT_NO_THROW(piece = pv[0].portion(PathTime(2, 1.0), PathTime(1, 0.5)));
+    EXPECT_FALSE(piece.closed());
+    EXPECT_EQ(piece.finalPoint(), pv[0].pointAt(PathTime(1, 0.5)));
+
+    EXPECT_NO_THROW(piece = pv[0].portion(PathTime(1, 0.5), PathTime(0, 0.5)));
+    EXPECT_FALSE(piece.closed());
+    EXPECT_EQ(piece.initialPoint(), pv[0].pointAt(PathTime(1, 0.5)));
+    EXPECT_EQ(piece.finalPoint(), pv[0].pointAt(PathTime(0, 0.5)));
+
+    EXPECT_NO_THROW(piece = pv[0].portion(PathTime(1, 0.75), PathTime(1, 0.25)));
+    EXPECT_FALSE(piece.closed());
+    EXPECT_EQ(piece.size(), 1);
+}
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/pick.h b/tests/pick.h
new file mode 100644
index 0000000..3e43bd5
--- /dev/null
+++ b/tests/pick.h
@@ -0,0 +1,172 @@
+/*
+ * Routines for generating anything randomly
+ *
+ * Authors:
+ *      Marco Cecchetti <mrcekets at gmail.com>
+ *
+ * Copyright 2008  authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#ifndef _GEOM_SL_PICK_H_
+#define _GEOM_SL_PICK_H_
+
+
+#include <2geom/symbolic/multipoly.h>
+#include <2geom/symbolic/matrix.h>
+
+inline
+size_t pick_uint(size_t max)
+{
+    return (std::rand() % (max+1));
+}
+
+inline
+int pick_int(size_t max)
+{
+    int s = pick_uint(2);
+    if (s == 0) s = -1;
+    return s * (std::rand() % (max+1));
+}
+
+inline
+Geom::SL::multi_index_type pick_multi_index(size_t N, size_t max)
+{
+    Geom::SL::multi_index_type I(N);
+    for (size_t i = 0; i < I.size(); ++i)
+        I[i] = pick_uint(max);
+    return I;
+}
+
+template <size_t N>
+inline
+typename Geom::SL::mvpoly<N, double>::type
+pick_polyN(size_t d, size_t m)
+{
+    typename Geom::SL::mvpoly<N, double>::type  p;
+    size_t d0 = pick_uint(d);
+    for (size_t i = 0; i <= d0; ++i)
+    {
+        p.coefficient(i, pick_polyN<N-1>(d, m));
+    }
+    return p;
+}
+
+template <>
+inline
+double pick_polyN<0>(size_t /*d*/, size_t m)
+{
+    return pick_int(m);
+}
+
+
+template <size_t N>
+inline
+typename Geom::SL::mvpoly<N, double>::type
+pick_poly_max(size_t d, size_t m)
+{
+    typename Geom::SL::mvpoly<N, double>::type  p;
+    for (size_t i = 0; i <= d; ++i)
+    {
+        p.coefficient(i, pick_poly_max<N-1>(d-i, m));
+    }
+    return p;
+}
+
+template <>
+inline
+double pick_poly_max<0>(size_t /*d*/, size_t m)
+{
+    return pick_int(m);
+}
+
+
+template <size_t N>
+inline
+Geom::SL::MultiPoly<N, double>
+pick_multipoly(size_t d, size_t m)
+{
+    return Geom::SL::MultiPoly<N, double>(pick_polyN<N>(d, m));
+}
+
+template <size_t N>
+inline
+Geom::SL::MultiPoly<N, double>
+pick_multipoly_max(size_t d, size_t m)
+{
+    return Geom::SL::MultiPoly<N, double>(pick_poly_max<N>(d, m));
+}
+
+
+
+inline
+Geom::SL::Matrix< Geom::SL::MultiPoly<2, double> >
+pick_matrix(size_t n, size_t d, size_t m)
+{
+    Geom::SL::Matrix< Geom::SL::MultiPoly<2, double> >  M(n, n);
+    for (size_t i = 0; i < n; ++i)
+    {
+        for (size_t j = 0; j < n; ++j)
+        {
+            M(i,j) = pick_multipoly_max<2>(d, m);
+        }
+    }
+    return M;
+}
+
+
+inline
+Geom::SL::Matrix< Geom::SL::MultiPoly<2, double> >
+pick_symmetric_matrix(size_t n, size_t d, size_t m)
+{
+    Geom::SL::Matrix< Geom::SL::MultiPoly<2, double> > M(n, n);
+    for (size_t i = 0; i < n; ++i)
+    {
+        for (size_t j = 0; j < i; ++j)
+        {
+            M(i,j) = M(j,i) = pick_multipoly_max<2>(d, m);
+        }
+    }
+    for (size_t i = 0; i < n; ++i)
+    {
+        M(i,i) = pick_multipoly_max<2>(d, m);
+    }
+    return M;
+}
+
+
+#endif // _GEOM_SL_PICK_H_
+
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/planar-graph-test.cpp b/tests/planar-graph-test.cpp
new file mode 100644
index 0000000..f19e2eb
--- /dev/null
+++ b/tests/planar-graph-test.cpp
@@ -0,0 +1,457 @@
+/** @file
+ * @brief Unit tests for PlanarGraph class template
+ */
+/*
+ * Authors:
+ *   Rafał Siejakowski <rs@rs-math.net>
+ *
+ * Copyright 2022 the Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include <gtest/gtest.h>
+#include <iostream>
+
+#include <2geom/point.h>
+#include <2geom/pathvector.h>
+#include <2geom/svg-path-parser.h>
+#include <2geom/svg-path-writer.h>
+
+#include "planar-graph.h"
+#include "testing.h"
+
+using namespace Geom;
+
+#define PV(d) (parse_svg_path(d))
+#define PTH(d) (std::move(PV(d)[0]))
+#define REV(d) ((PV(d)[0]).reversed())
+
+/** An edge label for the purpose of tests. */
+struct TestLabel
+{
+    unsigned reversal_count = 0, merge_count = 0, detachment_count = 0;
+    void onReverse() { reversal_count++; }
+    void onMergeWith(TestLabel const &) { merge_count++; }
+    void onDetach() { detachment_count++; }
+};
+
+using TestGraph = PlanarGraph<TestLabel>;
+
+static std::vector<TestLabel> extract_labels(TestGraph const &graph)
+{
+    // Find labels of edges remaining in the graph.
+    std::vector<TestLabel> result;
+    for (auto &e : graph.getEdges()) {
+        if (!e.detached) {
+            result.push_back(e.label);
+        }
+    }
+    return result;
+}
+
+class PlanarGraphTest : public ::testing::Test
+{
+};
+
+/** Test edge insertion and vertex clumping to within the tolerance. */
+TEST(PlanarGraphTest, EdgeInsertion)
+{
+    double const precision = 1e-3;
+    auto graph = TestGraph(precision);
+    graph.insertEdge(PTH("M 0, 0 L 1, 0"));
+    graph.insertEdge(PTH("M 0, 1 L 1, 1"));      // } Endpoints near
+    graph.insertEdge(PTH("M 1, 0 L 1, 1.0009")); // } but not exact.
+
+    auto vertices = graph.getVertices();
+
+    // Test vertex clumping within the given precision
+    EXPECT_EQ(vertices.size(), 4);
+    EXPECT_EQ(graph.numEdges(), 3);
+
+    // Test lexicographic vertex position sorting by X and then Y
+    EXPECT_EQ(vertices.front().point(), Point(0, 0));
+    auto after = std::next(vertices.begin());
+    EXPECT_EQ(after->point(), Point(0, 1));
+    ++after;
+    EXPECT_EQ(after->point(), Point(1, 0));
+    EXPECT_TRUE(are_near(vertices.back().point(), Point(1, 1), precision));
+
+    EXPECT_FALSE(graph.isRegularized());
+}
+
+/** Test PlanarGraph<T>::insertDetached(). */
+TEST(PlanarGraphTest, InsertDetached)
+{
+    TestGraph graph;
+    auto detached = graph.insertDetached(PTH("M 0,0 A 1,1 0,0,1 2,0 V -2 H 0 Z"));
+
+    auto const &edges = graph.getEdges();
+    EXPECT_EQ(edges.size(), 1);
+    EXPECT_TRUE(edges.at(detached).detached);
+    EXPECT_TRUE(edges.at(detached).inserted_as_detached);
+
+    EXPECT_EQ(graph.numVertices(), 0);
+    EXPECT_EQ(graph.numEdges(false), 0);
+    EXPECT_TRUE(graph.isRegularized());
+}
+
+/** Test signed area calculation. */
+TEST(PlanarGraphTest, ClosedPathArea)
+{
+    // Square with counter-clockwise oriented boundary, when imagining that the y-axis
+    // points up – expect the area to be +1.
+    auto square_positive = PTH("M 0,0 H 1 V 1 H 0 Z");
+    EXPECT_DOUBLE_EQ(TestGraph::closedPathArea(square_positive), 1.0);
+
+    // Expect negative area for a negatively oriented path.
+    auto triangle_negative = PTH("M 0,0 V 1 L 1,1 Z");
+    EXPECT_DOUBLE_EQ(TestGraph::closedPathArea(triangle_negative), -0.5);
+}
+
+/** Test the detection of direction of deviation of initially tangent paths. */
+TEST(PlanarGraphTest, Deviation)
+{
+    auto vertical_up = PTH("M 0,0 V 1");
+    auto arc_right1 = PTH("M 0,0 A 1,1 0,1,0 2,0");
+    auto arc_left1 = PTH("M 0,0 A 1,1 0,1,1 -2,0");
+    auto arc_right2 = PTH("M 0,0 A 2,2 0,1,0, 4,0");
+    auto arc_left2 = PTH("M 0,0 A 2,2 0,1,1 -4,0");
+    // A very "flat" Bézier curve deviating to the right but slower than the large arc
+    auto bezier_right = PTH("M 0,0 C 0,50 1,20 2,10");
+
+    EXPECT_TRUE(TestGraph::deviatesLeft(arc_left1, arc_left2));
+    EXPECT_TRUE(TestGraph::deviatesLeft(arc_left2, vertical_up));
+    EXPECT_TRUE(TestGraph::deviatesLeft(vertical_up, arc_right2));
+    EXPECT_TRUE(TestGraph::deviatesLeft(vertical_up, bezier_right));
+    EXPECT_TRUE(TestGraph::deviatesLeft(bezier_right, arc_right2));
+    EXPECT_TRUE(TestGraph::deviatesLeft(arc_right2, arc_right1));
+    EXPECT_TRUE(TestGraph::deviatesLeft(arc_left1, arc_right1));
+    EXPECT_TRUE(TestGraph::deviatesLeft(arc_left2, arc_right1));
+
+    EXPECT_FALSE(TestGraph::deviatesLeft(arc_right1, vertical_up));
+    EXPECT_FALSE(TestGraph::deviatesLeft(arc_right1, arc_right2));
+    EXPECT_FALSE(TestGraph::deviatesLeft(vertical_up, arc_left2));
+    EXPECT_FALSE(TestGraph::deviatesLeft(arc_left2, arc_left1));
+    EXPECT_FALSE(TestGraph::deviatesLeft(arc_right1, arc_left1));
+    EXPECT_FALSE(TestGraph::deviatesLeft(arc_right1, arc_left2));
+}
+
+/** Test sorting of incidences at a vertex by the outgoing heading. */
+TEST(PlanarGraphTest, BasicAzimuthalSort)
+{
+    TestGraph graph;
+
+    // Imagine the Y-axis pointing up (as in mathematics)!
+    bool const clockwise = true;
+    unsigned const num_rays = 9;
+    unsigned edges[num_rays];
+
+    // Insert the edges randomly but store them in what we know to be the
+    // clockwise order of outgoing azimuths from the vertex at the origin.
+    edges[7] = graph.insertEdge(PTH("M -0.2, -1 L 0, 0"));
+    edges[1] = graph.insertEdge(PTH("M -1, 0.2 L 0, 0"));
+    edges[4] = graph.insertEdge(PTH("M 0, 0 L 1, 0.2"));
+    edges[6] = graph.insertEdge(PTH("M 0.1, -1 L 0, 0"));
+    edges[2] = graph.insertEdge(PTH("M 0, 0 L -0.3, 1"));
+    edges[0] = graph.insertEdge(PTH("M -1, 0 H 0"));
+    edges[5] = graph.insertEdge(PTH("M 0, 0 L 1, -0.2"));
+    edges[3] = graph.insertEdge(PTH("M 0.2, 1 L 0, 0"));
+    edges[8] = graph.insertEdge(PTH("M -1, -0.1 L 0, 0"));
+
+    // We expect the incidence to edges[0] to be the last one
+    // in the sort order so it should appear first when going clockwise.
+    auto [origin, incidence] = graph.getIncidence(edges[0], TestGraph::Incidence::END);
+    ASSERT_TRUE(origin);
+    ASSERT_TRUE(incidence);
+
+    // Expect ±pi as the azimuth
+    EXPECT_DOUBLE_EQ(std::abs(incidence->azimuth), M_PI);
+
+    // Test sort order
+    for (unsigned i = 0; i < num_rays; i++) {
+        EXPECT_EQ(incidence->index, edges[i]);
+        incidence = (TestGraph::Incidence *)&graph.nextIncidence(*origin, *incidence, clockwise);
+    }
+}
+
+/** Test retrieval of a path inserted as an edge in both orientations. */
+TEST(PlanarGraphTest, PathRetrieval)
+{
+    TestGraph graph;
+
+    Path const path = PTH("M 0,0 L 1,1 C 2,2 4,2 5,1");
+    Path const htap = path.reversed();
+
+    auto edge = graph.insertEdge(path);
+
+    ASSERT_EQ(graph.numEdges(), 1);
+
+    auto [start_point, start_incidence] = graph.getIncidence(edge, TestGraph::Incidence::START);
+    ASSERT_TRUE(start_point);
+    ASSERT_TRUE(start_incidence);
+    EXPECT_EQ(graph.getOutgoingPath(start_incidence), path);
+    EXPECT_EQ(graph.getIncomingPath(start_incidence), htap);
+
+    auto [end_point, end_incidence] = graph.getIncidence(edge, TestGraph::Incidence::END);
+    ASSERT_TRUE(end_point);
+    ASSERT_TRUE(end_incidence);
+    EXPECT_EQ(graph.getIncomingPath(end_incidence), path);
+    EXPECT_EQ(graph.getOutgoingPath(end_incidence), htap);
+}
+
+/** Make sure the edge labels are correctly stored. */
+TEST(PlanarGraphTest, LabelRetrieval)
+{
+    TestGraph graph;
+    TestLabel label;
+
+    label.reversal_count = 420;
+    label.merge_count = 69;
+    label.detachment_count = 111;
+
+    auto edge = graph.insertEdge(PTH("M 0,0 L 1,1"), std::move(label));
+
+    auto retrieved = graph.getEdge(edge).label;
+    EXPECT_EQ(retrieved.reversal_count, 420);
+    EXPECT_EQ(retrieved.merge_count, 69);
+    EXPECT_EQ(retrieved.detachment_count, 111);
+}
+
+/** Regularization of duplicate edges. */
+TEST(PlanarGraphTest, MergeDuplicate)
+{
+    char const *const d =      "M 2,     3 H 0 C 1,4 1,5 0,6 H 10      L 8, 0";
+    char const *const near_d = "M 2.0009,3 H 0 C 1,4 1,5 0,6 H 10.0009 L 8, 0.0005";
+
+    // Test removal of perfect overlap:
+    TestGraph graph;
+    graph.insertEdge(PTH(d));
+    graph.insertEdge(PTH(d)); // exact duplicate
+    graph.regularize();
+
+    EXPECT_TRUE(graph.isRegularized());
+
+    auto remaining = extract_labels(graph);
+
+    // Expect there to be only 1 edge after regularization.
+    ASSERT_EQ(remaining.size(), 1);
+
+    EXPECT_EQ(remaining[0].merge_count, 1); // expect one merge,
+    EXPECT_EQ(remaining[0].reversal_count, 0); // no reversals,
+    EXPECT_EQ(remaining[0].detachment_count, 0); // no detachments.
+
+    // Test removal of imperfect overlaps within numerical precision
+    TestGraph fuzzy{1e-3};
+    fuzzy.insertEdge(PTH(d));
+    fuzzy.insertEdge(PTH(near_d));
+    fuzzy.regularize();
+
+    EXPECT_TRUE(fuzzy.isRegularized());
+
+    auto fuzmaining = extract_labels(fuzzy);
+    ASSERT_EQ(fuzmaining.size(), 1);
+
+    EXPECT_EQ(fuzmaining[0].merge_count, 1); // expect one merge,
+    EXPECT_EQ(fuzmaining[0].reversal_count, 0); // no reversals,
+    EXPECT_EQ(fuzmaining[0].detachment_count, 0); // no detachments.
+
+    // Test overlap of edges with oppositie orientations.
+    TestGraph twoway;
+    twoway.insertEdge(PTH(d));
+    twoway.insertEdge(REV(d));
+    twoway.regularize();
+
+    EXPECT_TRUE(twoway.isRegularized());
+
+    auto left = extract_labels(twoway);
+    ASSERT_EQ(left.size(), 1);
+
+    EXPECT_EQ(left[0].merge_count, 1); // expect one merge,
+    EXPECT_TRUE(left[0].reversal_count == 0 || left[0].reversal_count == 1); // 0 or 1 reversals
+    EXPECT_EQ(left[0].detachment_count, 0); // no detachments.
+}
+
+/** Regularization of a shorter edge overlapping a longer one. */
+TEST(PlanarGraphTest, MergePartial)
+{
+    TestGraph graph;
+    auto longer = graph.insertEdge(PTH("M 0, 0 L 10, 10"));
+    auto shorter = graph.insertEdge(PTH("M 0, 0 L 6, 6"));
+
+    EXPECT_EQ(graph.numVertices(), 3);
+
+    graph.regularize();
+
+    EXPECT_EQ(graph.numVertices(), 3);
+    EXPECT_TRUE(graph.isRegularized());
+
+    auto labels = extract_labels(graph);
+    ASSERT_EQ(labels.size(), 2);
+
+    EXPECT_EQ(labels[longer].merge_count, 0);
+    EXPECT_EQ(labels[longer].reversal_count, 0);
+    EXPECT_EQ(labels[longer].detachment_count, 0);
+
+    EXPECT_EQ(labels[shorter].merge_count, 1);
+    EXPECT_EQ(labels[shorter].reversal_count, 0);
+    EXPECT_EQ(labels[shorter].detachment_count, 0);
+
+    // Now the same thing but with edges of opposite orientations.
+    TestGraph graphopp;
+    longer = graphopp.insertEdge(PTH("M 0, 0 L 10, 0"));
+    shorter = graphopp.insertEdge(PTH("M 10, 0 L 5, 0"));
+
+    EXPECT_EQ(graphopp.numVertices(), 3);
+
+    graphopp.regularize();
+
+    EXPECT_EQ(graphopp.numVertices(), 3);
+    EXPECT_TRUE(graphopp.isRegularized());
+
+    labels = extract_labels(graphopp);
+    ASSERT_EQ(labels.size(), 2);
+
+    EXPECT_EQ(labels[longer].merge_count, 0);
+    EXPECT_EQ(labels[longer].reversal_count, 0);
+    EXPECT_EQ(labels[longer].detachment_count, 0);
+
+    EXPECT_EQ(labels[shorter].merge_count, 1);
+    EXPECT_EQ(labels[shorter].reversal_count, 0);
+    EXPECT_EQ(labels[shorter].detachment_count, 0);
+}
+
+/** Regularization of a Y-split. */
+TEST(PlanarGraphTest, MergeY)
+{
+    TestGraph graph;
+    auto left = graph.insertEdge(PTH("M 1 0 V 1 L 0, 2"));
+    auto right = graph.insertEdge(PTH("M 1,0 V 1 L 2, 2"));
+
+    EXPECT_EQ(graph.numVertices(), 3);
+    graph.regularize();
+    EXPECT_EQ(graph.numVertices(), 4);
+
+    auto edges = graph.getEdges();
+    EXPECT_EQ(edges.size(), 3);
+
+    EXPECT_TRUE(are_near(edges[right].start->point(), Point(1, 1)));
+}
+
+/** Test reversal of a wrongly oriented teardrop */
+TEST(PlanarGraphTest, Teardrop)
+{
+    TestGraph graph;
+    auto loop = graph.insertEdge(PTH("M 1,0 A 1,1, 0,0,1 0,1 L 2,2 V 1 H 1 V 0"));
+    // Insert a few unrelated edges
+    auto before = graph.insertEdge(PTH("M 1,0 H 10"));
+    auto after = graph.insertEdge(PTH("M 1,0 H -10"));
+
+    EXPECT_EQ(graph.numVertices(), 3);
+
+    graph.regularize();
+
+    EXPECT_EQ(graph.numVertices(), 3);
+    auto [start_vertex, start_incidence] = graph.getIncidence(loop, TestGraph::Incidence::START);
+    auto [end_vertex, end_incidence] = graph.getIncidence(loop, TestGraph::Incidence::END);
+
+    EXPECT_EQ(start_vertex, end_vertex);
+    ASSERT_NE(start_vertex, nullptr);
+
+    // Check that the incidences have been swapped
+    EXPECT_EQ(start_vertex->cyclicNextIncidence(end_incidence), start_incidence);
+    EXPECT_EQ(start_vertex->cyclicPrevIncidence(start_incidence), end_incidence);
+    auto [b, before_incidence] = graph.getIncidence(before, TestGraph::Incidence::START);
+    EXPECT_EQ(start_vertex->cyclicNextIncidence(before_incidence), end_incidence);
+    auto [a, after_incidence] = graph.getIncidence(after, TestGraph::Incidence::START);
+    EXPECT_EQ(start_vertex->cyclicPrevIncidence(after_incidence), start_incidence);
+}
+
+/** Test the regularization of a lasso-shaped path. */
+TEST(PlanarGraphTest, ReglueLasso)
+{
+    TestGraph graph;
+    // Insert a lasso-shaped path (a teardrop with initial self-overlap).
+    auto original_lasso = graph.insertEdge(PTH("M 0,0 V 1 C 0,2 1,3 1,4 "
+                                               "A 1,1 0,1,1 -1,4 C -1,3 0,2 0,1 V 0"));
+    EXPECT_EQ(graph.numVertices(), 1);
+
+    graph.regularize();
+    EXPECT_EQ(graph.numVertices(), 2);
+    EXPECT_EQ(graph.numEdges(false), 2);
+    EXPECT_TRUE(graph.getEdge(original_lasso).detached);
+
+    auto const &edges = graph.getEdges();
+    // Find the edge from origin and ensure it got glued.
+    auto from_origin = std::find_if(edges.begin(), edges.end(), [](auto const &edge) -> bool {
+        return !edge.detached && (edge.start->point() == Point(0, 0) ||
+                                    edge.end->point() == Point(0, 0));
+    });
+    ASSERT_NE(from_origin, edges.end());
+    ASSERT_EQ(from_origin->label.merge_count, 1);
+}
+
+/** Test the removal of a collapsed loop. */
+TEST(PlanarGraphTest, RemoveCollapsed)
+{
+    TestGraph graph;
+    // Insert a collapsed loop
+    auto collapsed = graph.insertEdge(PTH("M 0,0 L 1,1 L 0,0"));
+    ASSERT_EQ(graph.numEdges(), 1);
+    graph.regularize();
+    ASSERT_EQ(graph.numEdges(false), 0);
+    ASSERT_TRUE(graph.getEdge(collapsed).detached);
+
+    TestGraph fuzzy(1e-3);
+    // Insert a nearly collapsed loop
+    auto nearly = fuzzy.insertEdge(PTH("M 0,0 H 2 V 0.001 L 1,0 H 0"));
+    ASSERT_EQ(fuzzy.numEdges(), 1);
+    fuzzy.regularize();
+    ASSERT_EQ(fuzzy.numEdges(false), 0);
+    ASSERT_TRUE(fuzzy.getEdge(nearly).detached);
+}
+
+/** Test regularization of straddling runs. */
+TEST(PlanarGraphTest, RemoveWisp)
+{
+    TestGraph graph;
+    // Insert a horizontal segment at the origin towards positive X:
+    graph.insertEdge(PTH("M 0 0 H 1"));
+    // Insert a path with a collapsed Bézier curve towards negative X:
+    graph.insertEdge(PTH("M 0 0 C -1 0 -1 0 0 0"));
+    graph.regularize();
+
+    // Ensure that the folded Bézier is removed (and no segfault occurs).
+    EXPECT_EQ(graph.numEdges(false), 1);
+}
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/point-test.cpp b/tests/point-test.cpp
new file mode 100644
index 0000000..16596a5
--- /dev/null
+++ b/tests/point-test.cpp
@@ -0,0 +1,119 @@
+/** @file
+ * @brief Unit tests for Point, IntPoint and related functions.
+ * Uses the Google Testing Framework
+ *//*
+ * Authors:
+ *   Krzysztof Kosiński <tweenk.pl@gmail.com>
+ * 
+ * Copyright 2014-2015 Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include <gtest/gtest.h>
+#include <2geom/point.h>
+
+namespace Geom {
+
+TEST(PointTest, Normalize) {
+    Point a(1e-18, 0);
+    Point b = a;
+    a.normalize();
+
+    EXPECT_EQ(a, Point(1, 0));
+    EXPECT_EQ(b.normalized(), a);
+    EXPECT_NE(b, a);
+}
+
+TEST(PointTest, ScalarOps) {
+    Point a(1,2);
+    EXPECT_EQ(a * 2, Point(2, 4));
+    EXPECT_EQ(2 * a, Point(2, 4));
+    EXPECT_EQ(a / 2, Point(0.5, 1));
+
+    Point b = a;
+    a *= 2;
+    a /= 2;
+    EXPECT_EQ(a, b);
+}
+
+TEST(PointTest, Rounding) {
+    Point a(-0.7, 0.7);
+    IntPoint aceil(0, 1), afloor(-1, 0), around(-1, 1);
+    EXPECT_TRUE(a.ceil() == aceil);
+    EXPECT_TRUE(a.floor() == afloor);
+    EXPECT_TRUE(a.round() == around);
+}
+
+TEST(PointTest, Near) {
+    EXPECT_TRUE(are_near(Point(), Point(0, 1e-6)));
+    EXPECT_FALSE(are_near(Point(), Point(0, 1e-4)));
+
+    EXPECT_TRUE(are_near_rel(Point(100, 0), Point(100, 1e-4)));
+    EXPECT_FALSE(are_near_rel(Point(100, 0), Point(100, 1e-2)));
+}
+
+TEST(PointTest, Multiplicative) {
+    EXPECT_EQ(Point(2, 3) * Point(4, 5), Point(8, 15));
+    EXPECT_EQ(IntPoint(2, 3) * IntPoint(4, 5), IntPoint(8, 15));
+    EXPECT_EQ(Point(10, 11) / Point(2, 3), Point(5, 11.0 / 3.0));
+    EXPECT_EQ(IntPoint(10, 11) / IntPoint(2, 3), IntPoint(5, 11 / 3));
+}
+
+TEST(PointTest, PointCtors) {
+    Point a(2, 3);
+    EXPECT_EQ(a[X], 2);
+    EXPECT_EQ(a[Y], 3);
+
+    a.~Point();
+    new (&a) Point;
+    EXPECT_EQ(a, Point(0, 0));
+
+    a = Point(IntPoint(4, 5));
+    EXPECT_EQ(a[X], 4);
+    EXPECT_EQ(a[Y], 5);
+}
+
+TEST(PointTest, IntPointCtors) {
+    IntPoint a(2, 3);
+    EXPECT_EQ(a[X], 2);
+    EXPECT_EQ(a[Y], 3);
+
+    a.~IntPoint();
+    new (&a) IntPoint;
+    EXPECT_EQ(a, IntPoint(0, 0));
+}
+
+} // end namespace Geom
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/polybez-cases.svg b/tests/polybez-cases.svg
new file mode 100644
index 0000000..1fa653a
--- /dev/null
+++ b/tests/polybez-cases.svg
@@ -0,0 +1,168 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="1024"
+   height="768"
+   id="svg2"
+   version="1.1"
+   inkscape:version="0.47 r22583"
+   sodipodi:docname="polybez-cases.svg">
+  <defs
+     id="defs4">
+    <inkscape:perspective
+       sodipodi:type="inkscape:persp3d"
+       inkscape:vp_x="0 : 526.18109 : 1"
+       inkscape:vp_y="0 : 1000 : 0"
+       inkscape:vp_z="744.09448 : 526.18109 : 1"
+       inkscape:persp3d-origin="372.04724 : 350.78739 : 1"
+       id="perspective10" />
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="11.2"
+     inkscape:cx="338.56564"
+     inkscape:cy="493.11416"
+     inkscape:document-units="px"
+     inkscape:current-layer="sweep1"
+     showgrid="true"
+     inkscape:snap-grids="true"
+     inkscape:window-width="1440"
+     inkscape:window-height="825"
+     inkscape:window-x="0"
+     inkscape:window-y="24"
+     inkscape:window-maximized="1">
+    <inkscape:grid
+       type="xygrid"
+       id="grid2820"
+       empspacing="5"
+       visible="true"
+       enabled="true"
+       snapvisiblegridlinesonly="false" />
+  </sodipodi:namedview>
+  <metadata
+     id="metadata7">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(0,-284.36218)">
+    <g
+       id="g2829">
+      <path
+         id="path2824"
+         d="m 335,532 0,-15 10,-10 10,0 0,12 -7,0 0,7 7,0 0,6 -20,0 z"
+         style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         id="path2826"
+         d="m 338,524 0,-10 5,-5 12,0 0,15 -17,0 z"
+         style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+    </g>
+    <path
+       style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 370,507 15,0 -15,20 15,0 -15,-20 z"
+       id="path2828" />
+    <g
+       id="g2836">
+      <path
+         id="path2830"
+         d="m 395,507 0,20 15,0 0,-20 -15,0 z"
+         style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         id="path2832"
+         d="m 400,512 0,10 5,0 0,-10 -5,0 z"
+         style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+    </g>
+    <g
+       id="g2840">
+      <path
+         id="path2834"
+         d="m 420,507 0,20 10,0 0,-20 -10,0 z"
+         style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         id="path2838"
+         d="m 420,512 10,0 0,10 -10,0 0,-10 z"
+         style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+    </g>
+    <g
+       id="g2844">
+      <path
+         transform="translate(0,284.36218)"
+         id="path2861"
+         d="m 335,273 5,-10 5,0 -5,10 -5,0 z"
+         style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         transform="translate(0,284.36218)"
+         id="path2863"
+         d="m 335,263 5,10 5,0 -5,-10 -5,0 z"
+         style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+    </g>
+    <g
+       id="g2848">
+      <path
+         transform="translate(0,284.36218)"
+         id="path2865"
+         d="m 355,273 c 0,-10 5,-15 15,-15 10,0 15,15 5,15 -10,0 -19.82143,0 -20,0 z"
+         style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         transform="translate(0,284.36218)"
+         id="path2867"
+         d="m 355,258 15,15 5,0 -15,-15 -5,0 z"
+         style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+    </g>
+    <path
+       style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 390,273 c 0,0 0,-20 0,-15 0,5 5,-5 5,-5 l 5,0 0,20 -10,0 z"
+       id="path2869"
+       transform="translate(0,284.36218)" />
+    <path
+       style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 405,273 c 0,0 0,-10 0,-15 0,-5 0,-5 5,-5 5,0 5,0 5,5 0,5 -10,14.82143 -10,15 z"
+       id="path2871"
+       transform="translate(0,284.36218)" />
+    <path
+       style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 339.46429,565.30861 c -4.5365,-2.22147 -11.77743,5.69134 -5.21169,7.66819 2.96423,0.36599 10.83771,-2.10029 8.78922,3.46024 -1.13154,2.4938 -6.48404,5.18119 -7.60122,3.87235 4.97889,-1.66476 5.51215,4.06019 3.64354,6.27906 2.59991,2.27135 9.90909,-2.08687 10.22789,-0.44567 -5.83309,2.53694 -12.2305,3.77526 -18.58139,3.51925 -5.55304,-1.87666 0.0508,-8.52008 3.64017,-9.2859 3.14953,-0.57328 11.95334,1.68857 9.98614,-3.95731 -2.41191,-3.92307 -8.83522,2.26895 -9.24309,-2.87701 1.90388,-1.51652 8.28914,-1.45159 6.19223,-5.58351 -2.15792,-0.14937 -0.81405,-2.34484 -1.8418,-2.64969 z"
+       id="path2873" />
+    <g
+       id="sweep1">
+      <path
+         id="path2892"
+         style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         d="m 307,259 c 0,0 8,8 -3,11 -5,1 -5,9 -5,9 m 4,-17 1,3 m -6,-8 3,12 m -9,-11 1,4 2,3 -1,4 3,3 -2,5 m -9,-19 4,14"
+         transform="translate(0,284.36218)" />
+      <path
+         style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         d="m 296,280 5,-11"
+         id="path2908"
+         transform="translate(0,284.36218)" />
+      <path
+         style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+         d="m 309,283 -5,-18"
+         id="path2904"
+         transform="translate(0,284.36218)" />
+    </g>
+  </g>
+</svg>
diff --git a/tests/polynomial-test.cpp b/tests/polynomial-test.cpp
new file mode 100644
index 0000000..699820a
--- /dev/null
+++ b/tests/polynomial-test.cpp
@@ -0,0 +1,126 @@
+/** @file
+ * @brief Unit tests for Polynomial and related functions.
+ * Uses the Google Testing Framework
+ *//*
+ * Authors:
+ *   Krzysztof Kosiński <tweenk.pl@gmail.com>
+ *
+ * Copyright 2015-2019 Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include "testing.h"
+#include <iostream>
+#include <glib.h>
+
+#include <2geom/polynomial.h>
+
+using namespace Geom;
+
+TEST(PolynomialTest, SolveQuadratic) {
+    for (unsigned i = 0; i < 1000; ++i) {
+        Coord x1 = g_random_double_range(-100, 100);
+        Coord x2 = g_random_double_range(-100, 100);
+
+        Coord a = g_random_double_range(-10, 10);
+        Coord b = -a * (x1 + x2);
+        Coord c = a * x1 * x2;
+
+        std::vector<Coord> result = solve_quadratic(a, b, c);
+
+        EXPECT_EQ(result.size(), 2u);
+        if (x1 < x2) {
+            EXPECT_FLOAT_EQ(result[0], x1);
+            EXPECT_FLOAT_EQ(result[1], x2);
+        } else {
+            EXPECT_FLOAT_EQ(result[0], x2);
+            EXPECT_FLOAT_EQ(result[1], x1);
+        }
+    }
+}
+
+TEST(PolynomialTest, SolvePathologicalQuadratic) {
+    std::vector<Coord> r;
+
+    r = solve_quadratic(1, -1e9, 1);
+    ASSERT_EQ(r.size(), 2u);
+    EXPECT_FLOAT_EQ(r[0], 1e-9);
+    EXPECT_FLOAT_EQ(r[1], 1e9);
+
+    r = solve_quadratic(1, -4, 3.999999);
+    ASSERT_EQ(r.size(), 2u);
+    EXPECT_FLOAT_EQ(r[0], 1.999);
+    EXPECT_FLOAT_EQ(r[1], 2.001);
+
+    r = solve_quadratic(1, 0, -4);
+    ASSERT_EQ(r.size(), 2u);
+    EXPECT_FLOAT_EQ(r[0], -2);
+    EXPECT_FLOAT_EQ(r[1], 2);
+
+    r = solve_quadratic(1, 0, -16);
+    ASSERT_EQ(r.size(), 2u);
+    EXPECT_FLOAT_EQ(r[0], -4);
+    EXPECT_FLOAT_EQ(r[1], 4);
+
+    r = solve_quadratic(1, 0, -100);
+    ASSERT_EQ(r.size(), 2u);
+    EXPECT_FLOAT_EQ(r[0], -10);
+    EXPECT_FLOAT_EQ(r[1], 10);
+}
+
+TEST(PolynomialTest, SolveCubic) {
+    for (unsigned i = 0; i < 1000; ++i) {
+        Coord x1 = g_random_double_range(-100, 100);
+        Coord x2 = g_random_double_range(-100, 100);
+        Coord x3 = g_random_double_range(-100, 100);
+
+        Coord a = g_random_double_range(-10, 10);
+        Coord b = -a * (x1 + x2 + x3);
+        Coord c = a * (x1*x2 + x2*x3 + x1*x3);
+        Coord d = -a * x1 * x2 * x3;
+
+        std::vector<Coord> result = solve_cubic(a, b, c, d);
+        std::vector<Coord> x(3); x[0] = x1; x[1] = x2; x[2] = x3;
+        std::sort(x.begin(), x.end());
+
+        ASSERT_EQ(result.size(), 3u);
+        EXPECT_FLOAT_EQ(result[0], x[0]);
+        EXPECT_FLOAT_EQ(result[1], x[1]);
+        EXPECT_FLOAT_EQ(result[2], x[2]);
+    }
+
+    // corner cases
+    // (x^2 + 7)(x - 2)
+    std::vector<Coord> r1 = solve_cubic(1, -2, 7, -14);
+    EXPECT_EQ(r1.size(), 1u);
+    EXPECT_FLOAT_EQ(r1[0], 2);
+
+    // (x + 1)^2 (x-2)
+    std::vector<Coord> r2 = solve_cubic(1, 0, -3, -2);
+    ASSERT_EQ(r2.size(), 3u);
+    EXPECT_FLOAT_EQ(r2[0], -1);
+    EXPECT_FLOAT_EQ(r2[1], -1);
+    EXPECT_FLOAT_EQ(r2[2], 2);
+}
diff --git a/tests/rect-test.cpp b/tests/rect-test.cpp
new file mode 100644
index 0000000..93733e5
--- /dev/null
+++ b/tests/rect-test.cpp
@@ -0,0 +1,368 @@
+/** @file
+ * @brief Unit tests for Rect, OptRect, IntRect, and OptIntRect.
+ * Uses the Google Testing Framework
+ *//*
+ * Authors:
+ *   Krzysztof Kosiński <tweenk.pl@gmail.com>
+ * 
+ * Copyright 2010 Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include <gtest/gtest.h>
+#include <2geom/coord.h>
+#include <2geom/rect.h>
+
+namespace Geom {
+
+typedef ::testing::Types<Coord, IntCoord> CoordTypes;
+
+TEST(RectTest, Upconversion) {
+    IntRect ir(0, -27, 10, 202);
+    Rect r_a(ir);
+    Rect r_b = ir;
+    OptIntRect oir_a(ir);
+    OptIntRect oir_b = ir;
+    OptRect or_a(oir_a);
+    OptRect or_b = oir_b;
+
+    EXPECT_EQ(r_a, ir);
+    EXPECT_EQ(r_a, r_b);
+    EXPECT_EQ(r_a, *oir_a);
+    EXPECT_EQ(r_a, *oir_b);
+    EXPECT_EQ(r_a, *or_a);
+    EXPECT_EQ(r_a, *or_b);
+    EXPECT_EQ(oir_a, oir_b);
+    EXPECT_EQ(or_a, or_b);
+}
+
+TEST(RectTest, Rounding) {
+    Rect r(-0.5, -0.5, 5.5, 5.5);
+    Rect r_small(0.3, 0.0, 0.6, 10.0);
+    Rect r_int(0,0,10,10);
+    IntRect out(-1, -1, 6, 6);
+    IntRect out_small(0, 0, 1, 10);
+    IntRect out_int(0,0,10,10);
+    OptIntRect in = IntRect(0, 0, 5, 5);
+    EXPECT_EQ(r.roundOutwards(), out);
+    EXPECT_EQ(r_small.roundOutwards(), out_small);
+    EXPECT_EQ(r_int.roundOutwards(), out_int);
+    EXPECT_EQ(r.roundInwards(), in);
+    EXPECT_EQ(r_small.roundInwards(), OptIntRect());
+}
+
+template <typename C>
+class GenericRectTest : public ::testing::Test {
+public:
+    typedef typename CoordTraits<C>::PointType CPoint;
+    typedef typename CoordTraits<C>::RectType CRect;
+    typedef typename CoordTraits<C>::OptRectType OptCRect;
+    CRect a, a2, b, c, d;
+    CRect int_ab, int_bc, uni_ab, uni_bc;
+    GenericRectTest()
+        : a(0, 0, 10, 10)
+        , a2(0, 0, 10, 10)
+        , b(-5, -5, 5, 5)
+        , c(-10, -10, -1, -1)
+        , d(1, 1, 9, 9)
+        , int_ab(0, 0, 5, 5)
+        , int_bc(-5, -5, -1, -1)
+        , uni_ab(-5, -5, 10, 10)
+        , uni_bc(-10, -10, 5, 5)
+    {}
+};
+
+TYPED_TEST_CASE(GenericRectTest, CoordTypes);
+
+TYPED_TEST(GenericRectTest, EqualityTest) {
+    typename TestFixture::CRect a(0, 0, 10, 10), a2(a), b(-5, -5, 5, 5);
+    typename TestFixture::OptCRect empty, oa = a;
+
+    EXPECT_TRUE (a == a);
+    EXPECT_FALSE(a != a);
+    EXPECT_TRUE (a == a2);
+    EXPECT_FALSE(a != a2);
+    EXPECT_TRUE (empty == empty);
+    EXPECT_FALSE(empty != empty);
+    EXPECT_FALSE(a == empty);
+    EXPECT_TRUE (a != empty);
+    EXPECT_FALSE(empty == a);
+    EXPECT_TRUE (empty != a);
+    EXPECT_FALSE(a == b);
+    EXPECT_TRUE (a != b);
+    EXPECT_TRUE (a == oa);
+    EXPECT_FALSE(a != oa);
+}
+
+TYPED_TEST(GenericRectTest, Intersects) {
+    typename TestFixture::CRect a(0, 0, 10, 10), b(-5, -5, 5, 5), c(-10, -10, -1, -1), d(1, 1, 9, 9);
+    typename TestFixture::OptCRect empty, oa(a), oc(c), od(d);
+    EXPECT_TRUE(a.intersects(a));
+    EXPECT_TRUE(a.intersects(b));
+    EXPECT_TRUE(b.intersects(a));
+    EXPECT_TRUE(b.intersects(c));
+    EXPECT_TRUE(c.intersects(b));
+    EXPECT_TRUE(a.intersects(d));
+    EXPECT_TRUE(d.intersects(a));
+    EXPECT_FALSE(a.intersects(c));
+    EXPECT_FALSE(c.intersects(a));
+    EXPECT_FALSE(c.intersects(d));
+    EXPECT_FALSE(empty.intersects(empty));
+    EXPECT_FALSE(empty.intersects(oa));
+    EXPECT_FALSE(oa.intersects(empty));
+    EXPECT_TRUE(oa.intersects(od));
+    EXPECT_FALSE(oa.intersects(oc));
+}
+
+/**
+ JonCruz failure: (10, 20)-(55,30) and (45,20)-(100,30) should intersect.
+*/
+
+TYPED_TEST(GenericRectTest, JonCruzRect) {
+    typename TestFixture::CRect a(10, 20, 55, 30), b(45, 20, 100,30);
+    typename TestFixture::OptCRect empty, oa(a), ob(b);
+    EXPECT_TRUE(a.intersects(a));
+    EXPECT_TRUE(a.intersects(b));
+    EXPECT_TRUE(b.intersects(a));
+    EXPECT_TRUE(oa.intersects(oa));
+    EXPECT_TRUE(oa.intersects(ob));
+    EXPECT_TRUE(ob.intersects(oa));
+}
+
+TYPED_TEST(GenericRectTest, Intersection) {
+    typename TestFixture::CRect a(0, 0, 10, 10), b(-5, -5, 5, 5), c(-10, -10, -1, -1), d(1, 1, 9, 9);
+    typename TestFixture::CRect int_ab(0, 0, 5, 5), int_bc(-5, -5, -1, -1);
+    typename TestFixture::OptCRect empty, oa(a), ob(b);
+    
+    EXPECT_EQ(a & a, a);
+    EXPECT_EQ(a & b, int_ab);
+    EXPECT_EQ(b & c, int_bc);
+    EXPECT_EQ(intersect(b, c), int_bc);
+    EXPECT_EQ(intersect(a, a), a);
+    EXPECT_EQ(a & c, empty);
+    EXPECT_EQ(a & d, d);
+    EXPECT_EQ(a & empty, empty);
+    EXPECT_EQ(empty & empty, empty);
+
+    oa &= ob;
+    EXPECT_EQ(oa, int_ab);
+    oa = a;
+    oa &= b;
+    EXPECT_EQ(oa, int_ab);
+    oa = a;
+    oa &= empty;
+    EXPECT_EQ(oa, empty);
+}
+
+TYPED_TEST(GenericRectTest, Contains) {
+    typename TestFixture::CRect a(0, 0, 10, 10), b(-5, -5, 5, 5), c(-10, -10, -1, -1), d(1, 1, 9, 9);
+    typename TestFixture::CRect int_ab(0, 0, 5, 5), int_bc(-5, -5, -1, -1);
+    typename TestFixture::OptCRect empty, oa(a), od(d);
+    EXPECT_TRUE(a.contains(a));
+    EXPECT_FALSE(a.contains(b));
+    EXPECT_FALSE(b.contains(a));
+    EXPECT_FALSE(a.contains(c));
+    EXPECT_FALSE(c.contains(a));
+    EXPECT_TRUE(a.contains(d));
+    EXPECT_FALSE(d.contains(a));
+    EXPECT_TRUE(a.contains(int_ab));
+    EXPECT_TRUE(b.contains(int_ab));
+    EXPECT_TRUE(b.contains(int_bc));
+    EXPECT_TRUE(c.contains(int_bc));
+    EXPECT_FALSE(int_ab.contains(a));
+    EXPECT_FALSE(int_ab.contains(b));
+    EXPECT_FALSE(int_bc.contains(b));
+    EXPECT_FALSE(int_bc.contains(c));
+    EXPECT_FALSE(empty.contains(empty));
+    EXPECT_FALSE(empty.contains(od));
+    EXPECT_TRUE(oa.contains(empty));
+    EXPECT_TRUE(oa.contains(od));
+    EXPECT_FALSE(od.contains(oa));
+}
+
+TYPED_TEST(GenericRectTest, Union) {
+    typename TestFixture::CRect a(0, 0, 10, 10), old_a(a), b(-5, -5, 5, 5), c(-10, -10, -1, -1), d(1, 1, 9, 9);
+    typename TestFixture::CRect int_ab(0, 0, 5, 5), int_bc(-5, -5, -1, -1);
+    typename TestFixture::CRect uni_ab(-5, -5, 10, 10), uni_bc(-10, -10, 5, 5);
+    typename TestFixture::OptCRect empty, oa(a), ob(b);
+    EXPECT_EQ(a | b, uni_ab);
+    EXPECT_EQ(b | c, uni_bc);
+    EXPECT_EQ(a | a, a);
+    EXPECT_EQ(a | d, a);
+    EXPECT_EQ(a | int_ab, a);
+    EXPECT_EQ(b | int_ab, b);
+    EXPECT_EQ(uni_ab | a, uni_ab);
+    EXPECT_EQ(uni_bc | c, uni_bc);
+    EXPECT_EQ(a | empty, a);
+    EXPECT_EQ(empty | empty, empty);
+
+    a |= b;
+    EXPECT_EQ(a, uni_ab);
+    a = old_a;
+    a |= ob;
+    EXPECT_EQ(a, uni_ab);
+    a = old_a;
+    a |= empty;
+    EXPECT_EQ(a, old_a);
+    oa |= ob;
+    EXPECT_EQ(oa, uni_ab);
+    oa = old_a;
+    oa |= b;
+    EXPECT_EQ(oa, uni_ab);
+}
+
+TYPED_TEST(GenericRectTest, Area) {
+    typename TestFixture::CRect a(0, 0, 10, 10), b(-5, -5, 5, 5), c(-10, -10, -1, -1), d(1, 1, 9, 9);
+    typename TestFixture::CRect zero(0,0,0,0);
+    EXPECT_EQ(a.area(), 100);
+    EXPECT_EQ(a.area(), a.width() * a.height());
+    EXPECT_EQ(b.area(), 100);
+    EXPECT_EQ(c.area(), 81);
+    EXPECT_EQ(d.area(), 64);
+    EXPECT_FALSE(a.hasZeroArea());
+    EXPECT_TRUE(zero.hasZeroArea());
+}
+
+TYPED_TEST(GenericRectTest, Emptiness) {
+    typename TestFixture::OptCRect empty, oa(0, 0, 10, 10);
+    EXPECT_TRUE(empty.empty());
+    EXPECT_FALSE(empty);
+    EXPECT_TRUE(!empty);
+    EXPECT_FALSE(oa.empty());
+    EXPECT_TRUE(oa);
+    EXPECT_FALSE(!oa);
+}
+
+TYPED_TEST(GenericRectTest, Dimensions) {
+    typedef typename TestFixture::CPoint CPoint;
+    typename TestFixture::CRect a(-10, -20, 10, 20), b(-15, 30, 45, 90);
+    EXPECT_EQ(a.width(), 20);
+    EXPECT_EQ(a.height(), 40);
+    EXPECT_EQ(a.left(), -10);
+    EXPECT_EQ(a.top(), -20);
+    EXPECT_EQ(a.right(), 10);
+    EXPECT_EQ(a.bottom(), 20);
+    EXPECT_EQ(a.min(), CPoint(-10, -20));
+    EXPECT_EQ(a.max(), CPoint(10, 20));
+    EXPECT_EQ(a.minExtent(), a.width());
+    EXPECT_EQ(a.maxExtent(), a.height());
+    EXPECT_EQ(a.dimensions(), CPoint(20, 40));
+    EXPECT_EQ(a.midpoint(), CPoint(0, 0));
+
+    EXPECT_EQ(b.width(), 60);
+    EXPECT_EQ(b.height(), 60);
+    EXPECT_EQ(b.left(), -15);
+    EXPECT_EQ(b.top(), 30);
+    EXPECT_EQ(b.right(), 45);
+    EXPECT_EQ(b.bottom(), 90);
+    EXPECT_EQ(b.min(), CPoint(-15, 30));
+    EXPECT_EQ(b.max(), CPoint(45, 90));
+    EXPECT_EQ(b.minExtent(), b.maxExtent());
+    EXPECT_EQ(b.dimensions(), CPoint(60, 60));
+    EXPECT_EQ(b.midpoint(), CPoint(15, 60));
+}
+
+TYPED_TEST(GenericRectTest, Modification) {
+    typedef typename TestFixture::CRect CRect;
+    typedef typename TestFixture::OptCRect OptCRect;
+    typedef typename TestFixture::CPoint CPoint;
+    CRect a(-1, -1, 1, 1);
+    a.expandBy(9);
+    EXPECT_EQ(a, CRect(-10, -10, 10, 10));
+    a.setMin(CPoint(0, 0));
+    EXPECT_EQ(a, CRect(0, 0, 10, 10));
+    a.setMax(CPoint(20, 30));
+    EXPECT_EQ(a, CRect(0, 0, 20, 30));
+    a.setMax(CPoint(-5, -5));
+    EXPECT_EQ(a, CRect(-5, -5, -5, -5));
+    a.expandTo(CPoint(5, 5));
+    EXPECT_EQ(a, CRect(-5, -5, 5, 5));
+    a.expandTo(CPoint(0, 0));
+    EXPECT_EQ(a, CRect(-5, -5, 5, 5));
+    a.expandTo(CPoint(0, 15));
+    EXPECT_EQ(a, CRect(-5, -5, 5, 15));
+    a.expandBy(-10);
+    EXPECT_EQ(a, CRect(0, 5, 0, 5));
+    EXPECT_EQ(a.midpoint(), CPoint(0, 5));
+    a.unionWith(CRect(-20, 0, -10, 20));
+    EXPECT_EQ(a, CRect(-20, 0, 0, 20));
+    OptCRect oa(a);
+    oa.intersectWith(CRect(-10, -5, 5, 15));
+    EXPECT_EQ(oa, OptCRect(-10, 0, 0, 15));
+}
+
+TYPED_TEST(GenericRectTest, OptRectDereference) {
+    typename TestFixture::CRect a(0, 0, 5, 5);
+    typename TestFixture::OptCRect oa(0, 0, 10, 10);
+    EXPECT_NE(a, oa);
+    a = *oa;
+    EXPECT_EQ(a, oa);
+}
+
+TYPED_TEST(GenericRectTest, Offset) {
+    typename TestFixture::CRect a(0, 0, 5, 5), old_a(a), app1(-5, 0, 0, 5), amp1(5, 0, 10, 5),
+        app2(5, -10, 10, -5), amp2(-5, 10, 0, 15);
+    typename TestFixture::CPoint p1(-5, 0), p2(5, -10);
+    EXPECT_EQ(a + p1, app1);
+    EXPECT_EQ(a + p2, app2);
+    EXPECT_EQ(a - p1, amp1);
+    EXPECT_EQ(a - p2, amp2);
+
+    a += p1;
+    EXPECT_EQ(a, app1);
+    a = old_a;
+    a += p2;
+    EXPECT_EQ(a, app2);
+    a = old_a;
+    a -= p1;
+    EXPECT_EQ(a, amp1);
+    a = old_a;
+    a -= p2;
+    EXPECT_EQ(a, amp2);
+}
+
+TYPED_TEST(GenericRectTest, NearestEdgePoint) {
+    typename TestFixture::CRect a(0, 0, 10, 10);
+    typename TestFixture::CPoint p1(-5, 5), p2(15, 17), p3(6, 5),  p4(3, 9);
+    typename TestFixture::CPoint r1(0, 5),  r2(10, 10), r3(10, 5), r4(3, 10);
+
+    EXPECT_EQ(a.nearestEdgePoint(p1), r1);
+    EXPECT_EQ(a.nearestEdgePoint(p2), r2);
+    EXPECT_EQ(a.nearestEdgePoint(p3), r3);
+    EXPECT_EQ(a.nearestEdgePoint(p4), r4);
+}
+
+} // end namespace Geom
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/root-find-test.cpp b/tests/root-find-test.cpp
new file mode 100644
index 0000000..b866f66
--- /dev/null
+++ b/tests/root-find-test.cpp
@@ -0,0 +1,156 @@
+#include <2geom/polynomial.h>
+#include <vector>
+#include <iterator>
+
+#include <2geom/sbasis.h>
+#include <2geom/sbasis-poly.h>
+#include <2geom/sbasis-to-bezier.h>
+#include <2geom/solver.h>
+#include <time.h>
+
+using namespace std;
+using namespace Geom;
+
+Poly lin_poly(double a, double b) { // ax + b
+    Poly p;
+    p.push_back(b);
+    p.push_back(a);
+    return p;
+}
+
+Linear linear(double ax, double b) {
+    return Linear(b, ax+b);
+}
+
+double uniform() {
+    return double(rand()) / RAND_MAX;
+}
+
+int main() {
+    Poly a, b, r;
+    double timer_precision = 0.01;
+    double units = 1e6; // us
+    
+    a = Poly::linear(1, -0.3)*Poly::linear(1, -0.25)*Poly::linear(1, -0.2);
+    
+    std::cout << a <<std::endl;
+    SBasis B = poly_to_sbasis(a);
+    std::cout << B << std::endl;
+    Bezier bez;
+    sbasis_to_bezier(bez, B);
+    cout << bez << endl;
+    //copy(bez.begin(), bez.end(), ostream_iterator<double>(cout, ", "));
+    cout << endl;
+    cout << endl;
+    cout << endl;
+    
+    std::vector<std::vector<double> > trials;
+    
+    // evenly spaced roots
+    for(int N = 2; N <= 5; N++)
+    {
+        std::vector<double> r;
+        for(int i = 0; i < N; i++)
+            r.push_back(double(i)/(N-1));
+        trials.push_back(r);
+    }
+    // sort of evenish
+    for(int N = 0; N <= 5; N++)
+    {
+        std::vector<double> r;
+        for(int i = 0; i < N; i++)
+            r.push_back(double(i+0.5)/(2*N));
+        trials.push_back(r);
+    }
+    // one at 0.1
+    for(int N = 0; N <= 5; N++)
+    {
+        std::vector<double> r;
+        for(int i = 0; i < N; i++)
+            r.push_back(i+0.1);
+        trials.push_back(r);
+    }
+    for(int N = 0; N <= 6; N++)
+    {
+        std::vector<double> r;
+        for(int i = 0; i < N; i++)
+            r.push_back(i*0.8+0.1);
+        trials.push_back(r);
+    }
+    for(int N = 0; N <= 20; N++)
+    {
+        std::vector<double> r;
+        for(int i = 0; i < N/2; i++) {
+            r.push_back(0.1);
+            r.push_back(0.9);
+        }
+        trials.push_back(r);
+    }
+    for(int i = 0; i <= 20; i++)
+    {
+        std::vector<double> r;
+        for(int i = 0; i < 4; i++) {
+            r.push_back(uniform()*5 - 2.5);
+            r.push_back(0.9);
+        }
+        trials.push_back(r);
+    }
+    double ave_left = 0;
+    cout << "err from exact\n";
+    for(auto & trial : trials) {
+        SBasis B = Linear(1.,1);
+        sort(trial.begin(), trial.end());
+        for(double j : trial) {
+            B = B*linear(1, -j);
+        }
+        double left_time;
+        clock_t end_t = clock()+clock_t(timer_precision*CLOCKS_PER_SEC);
+        unsigned iterations = 0;
+        while(end_t > clock()) {
+            roots(B);
+            iterations++;
+        }
+        left_time = timer_precision*units/iterations;
+        vector<double> rt = roots(B);
+        double err = 0;
+        for(double r : rt) {
+            double best = fabs(r - trial[0]);
+            for(unsigned j = 1; j < trial.size(); j++) {
+                if(fabs(r - trial[j]) < best)
+                    best = fabs(r - trial[j]);
+            }
+            err += best;
+        }
+        if(err > 1e-8){
+            for(double j : trial) {
+                cout << j << ", ";
+            }
+            cout << endl;
+        }
+        cout << " e: " << err << std::endl;
+        ave_left += left_time;
+    }
+    cout << "average time = " << ave_left/trials.size() << std::endl;
+    
+    for(int i = 10; i >= 0; i--) {
+        vector<double> rt = roots(Linear(i,-1));
+        for(double j : rt) {
+            cout << j << ", ";
+        }
+        cout << endl;
+    }
+
+    return 0;
+}
+
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/rtree-performance-test.cpp b/tests/rtree-performance-test.cpp
new file mode 100644
index 0000000..cf4bcd7
--- /dev/null
+++ b/tests/rtree-performance-test.cpp
@@ -0,0 +1,361 @@
+/*
+ * Copyright 2010  Evangelos Katsikaros <vkatsikaros at yahoo dot gr>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include <2geom/toys/toy-framework-2.h>
+
+#include <sstream>
+#include <getopt.h>
+
+#include <SpatialIndex.h>
+#include <glib.h>
+//#include <glib/gtypes.h>
+
+using namespace Geom;
+
+// cmd argument stuff
+char* arg_area_limit = NULL;
+bool arg_area_limit_set = false;
+bool arg_debug = false;
+
+int limit = 0;
+
+// spatial index ID management
+SpatialIndex::id_type indexID;
+
+// list of rectangles
+GList *items = NULL;
+
+// tree of rectangles
+SpatialIndex::ISpatialIndex *tree;
+
+SpatialIndex::id_type test_indexID;
+
+void add_rectangle( int x, int y );
+
+/* Simple Visitor used to search the tree. When Data is encountered
+ * we are supposed to call the render function of the Data
+ * */
+class SearchVisitor : public SpatialIndex::IVisitor {
+public:
+        
+    void visitNode(const SpatialIndex::INode& n){
+    }
+            
+    void visitData(const SpatialIndex::IData& d){
+        /* this prototype: do nothing
+         * otherwise, render on buffer
+         * */
+    }
+        
+    void visitData(std::vector<const SpatialIndex::IData*>& v) {
+    }
+};
+
+
+/* we use the this visitor after each insertion in the tree
+ * The purpose is to validate that everything was stored properly
+ * and test the GList pointer storage. It has no other functional
+ * purpose.
+ * */
+class TestSearchVisitor : public SpatialIndex::IVisitor {
+public:
+        
+    void visitNode(const SpatialIndex::INode& n) {
+    }
+        
+    void visitData(const SpatialIndex::IData& d){
+        if( test_indexID == d.getIdentifier() ){
+            byte* pData = 0;
+            uint32_t cLen = sizeof(GList*);
+            d.getData(cLen, &pData);
+            //do something...
+            GList* gl = reinterpret_cast<GList*>(pData);
+            Geom::Rect *member_data = (Geom::Rect *)gl->data;
+            double lala = member_data->bottom();            
+            std::cout << "   Tree: " << lala << std::endl;
+            
+            delete[] pData;           
+        }
+    }
+        
+    void visitData(std::vector<const SpatialIndex::IData*>& v) {
+    }
+};
+
+
+int main(int argc, char **argv) {
+   
+    int c;
+
+    //--------------------------------------------------------------------------
+    // read cmd options
+    while (1) {
+        static struct option long_options[] =
+            {
+                /* These options set a flag. */
+                /* These options don't set a flag.
+                   We distinguish them by their indices. */
+                {"area-limit",	required_argument,	0, 'l'},
+                {"help",		no_argument,		0, 'h'},
+                {"debug",	no_argument,	0, 'd'},
+                {0, 0, 0, 0}
+            };
+        /* getopt_long stores the option index here. */
+        int option_index = 0;
+    
+        c = getopt_long (argc, argv, "l:h:d",
+                         long_options, &option_index);
+
+        /* Detect the end of the options. */
+        if (c == -1){
+            break;
+        }
+    
+        switch (c)
+        {
+            case 'l':
+                arg_area_limit = optarg;
+                arg_area_limit_set = true;
+                break;
+            case 'h':
+                std::cerr << "Usage:  " << argv[0] << " options\n" << std::endl ;
+                std::cerr << 
+                    "  -l  --area-limit=NUMBER  minimum number in node.\n" <<
+                    "  -d  --debug              Enable debug info (list/tree related).\n" <<
+                    "  -h  --help               Print this help.\n" << std::endl;
+                exit(1);
+                break;
+            case 'd':
+                arg_debug = true;
+                break;                
+            case '?':
+                /* getopt_long already printed an error message. */
+                break;
+        
+            default:
+                abort ();
+        }
+    }
+
+    // use some of the cmd options
+    if(  arg_area_limit_set  ) {
+        std::stringstream s1( arg_area_limit );
+        s1 >> limit;
+    }
+    else {
+        limit = 100;
+    }
+    // end cmd options
+    //--------------------------------------------------------------------------
+
+
+    double plow[2], phigh[2];
+    // spatial index memory storage manager
+    SpatialIndex::IStorageManager *mem_mngr;
+    // initialize spatial indexing stuff
+    mem_mngr = SpatialIndex::StorageManager::createNewMemoryStorageManager();
+    // fillFactor, indexCapacity, leafCapacity, dimensionality=2, variant=R*, indexIdentifier
+    tree = SpatialIndex::RTree::createNewRTree(*mem_mngr, 0.7, 25, 25, 2, SpatialIndex::RTree::RV_RSTAR, indexID);    
+
+    //-------------------------------------------
+    /* generate items. add_rectangle() stores them in both list and tree
+     * add rect every (20, 20).
+     * In area ((0,0), (1000, 1000)) add every (100,100)
+     * */
+    for( int x_coord = -limit; x_coord <= limit; x_coord += 20 ) {
+        for( int y_coord = -limit; y_coord <= limit; y_coord += 20 ) {
+            if( x_coord >= 0 && x_coord <= 1000 &&
+                y_coord >= 0 && y_coord <= 1000 )
+            {
+                if( x_coord % 100 == 0 && y_coord % 100 == 0) {
+                    add_rectangle( x_coord, y_coord );
+                }
+                else{
+                    add_rectangle( x_coord, y_coord );
+                }
+            }
+            else{
+                add_rectangle( x_coord, y_coord );
+            }
+        
+        }
+    }
+    std::cout << "Area of objects: ( -" << limit
+              << ", -" << limit
+              << " ), ( " << limit
+              << ", " << limit
+              << " )" << std::endl;
+    std::cout << "Number of Objects (indexID): " << indexID << std::endl;
+    // std::cout << "GListElements: " << g_list_length << std::endl;
+   
+    //-------------------------------------------
+    // Traverse list
+    Geom::Point sa_start = Point( 0, 0 );
+    Geom::Point sa_end = Point( 1000, 1000 );
+    Geom::Rect search_area = Rect( sa_start, sa_end );
+
+    Timer list_timer;
+    list_timer.ask_for_timeslice();
+    list_timer.start();
+    
+    for (GList *list = items; list; list = list->next) {
+        Geom::Rect *child = (Geom::Rect *)list->data;
+        if ( search_area.intersects( *child ) )
+        {
+            /* this prototype: do nothing
+             * otherwise, render on buffer
+             * */
+        }          
+    }  
+    Timer::Time the_list_time = list_timer.lap();
+    
+    std::cout << std::endl;
+    std::cout << "GList (full scan): " << the_list_time << std::endl;
+    
+    //-------------------------------------------
+    // Search tree - good case
+    Timer tree_timer;
+    tree_timer.ask_for_timeslice();
+    tree_timer.start();
+
+    /* We search only the (0,0), (1000, 1000) where the items are less dense.
+     * We expect a good performance versus the list
+     * */
+    // TODO IMPORTANT !!! check the plow, phigh
+    // plow[0] = x1; plow[1] = y1;
+    // phigh[0] = x2; phigh[1] = y2;
+
+    plow[0] = 0;
+    plow[1] = 0;
+    phigh[0] = 1000;
+    phigh[1] = 1000;
+    
+    SpatialIndex::Region search_region = SpatialIndex::Region(plow, phigh, 2);
+    SearchVisitor vis = SearchVisitor();
+    tree->intersectsWithQuery( search_region, vis );
+    
+    Timer::Time the_tree_time = tree_timer.lap();
+    std::cout << "Rtree (good): " << the_tree_time << std::endl;
+
+
+    //-------------------------------------------
+    // Search tree - worst case
+    Timer tree_timer_2;
+    tree_timer_2.ask_for_timeslice();
+    tree_timer_2.start();
+
+    /* search the whole area, so all items are returned */
+    plow[0] = -limit - 100;
+    plow[1] = -limit - 100;
+    phigh[0] = limit + 100;
+    phigh[1] = limit + 100;
+    
+    SpatialIndex::Region search_region_2 = SpatialIndex::Region(plow, phigh, 2);
+    SearchVisitor vis_2 = SearchVisitor();
+    tree->intersectsWithQuery( search_region_2, vis_2 );
+    
+    Timer::Time the_tree_time_2 = tree_timer_2.lap();
+    std::cout << "Rtree (full scan): " << the_tree_time_2 << std::endl;
+    
+    return 0;
+}
+
+
+
+/* Adds rectangles in a GList and a SpatialIndex rtree
+ * */
+void add_rectangle( int x, int y ) {
+    
+    Geom::Point starting_point = Point( x, y );
+    Geom::Point ending_point = Point( x + 10, y + 10 );
+    Geom::Rect rect_to_add = Rect( starting_point, ending_point );
+    items = g_list_append( items, &rect_to_add );
+
+    if( arg_debug ) {
+        // fetch the last rect from the list
+        Geom::Rect *member_data = (Geom::Rect *)( g_list_last( items ) )->data;
+        double lala = member_data->bottom();
+        std::cout << "List (" << indexID << "): "  << lala;
+    }
+
+    /* Create a SpatialIndex region
+     * plow = left-bottom corner
+     * phigh = top-right corner
+     * [0] = dimension X
+     * [1] = dimension Y
+     * */    
+    double plow[2], phigh[2];    
+
+    plow[0] = rect_to_add.left() ;
+    plow[1] = rect_to_add.bottom();    
+    phigh[0] = rect_to_add.right();
+    phigh[1] = rect_to_add.top();
+    
+    SpatialIndex::Region r = SpatialIndex::Region(plow, phigh, 2);
+    /* Store Glist pointer size and GList pointer as the associated data
+     * In inkscape this can be used to directly call render hooked functions
+     * from SPCanvasItems
+     * */
+    tree->insertData( sizeof(GList*), reinterpret_cast<const byte*>( g_list_last( items ) ), r, indexID);
+
+    // tree->insertData(0, 0, r, indexID);
+    /* not used. Store zero size and a null pointer as the associated data.
+     * indexId is used to retrieve from a mapping each rect
+     * (example a hash map, or the indexID is also vector index)
+     * */
+
+    if( arg_debug ) {
+        test_indexID = indexID;
+        /* every time we add a rect, search all the tree to find the last
+         * inserted ID. This is not performance-wise good (rtree only good for
+         * spatial queries) this is just used for debugging reasons
+         * */
+        plow[0] = -limit - 100;
+        plow[1] = -limit - 100;
+        phigh[0] = limit + 100;
+        phigh[1] = limit + 100;
+    
+        SpatialIndex::Region test_search_region = SpatialIndex::Region(plow, phigh, 2);
+        TestSearchVisitor test_vis = TestSearchVisitor();
+        // search the tree for the region. Visitor implements the search function hooks
+        tree->intersectsWithQuery( test_search_region, test_vis );
+    }
+
+    indexID++;
+}
+
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)(c-basic-offset . 4))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/rtree-test.cpp b/tests/rtree-test.cpp
new file mode 100644
index 0000000..f01007a
--- /dev/null
+++ b/tests/rtree-test.cpp
@@ -0,0 +1,158 @@
+/*
+ * Copyright 2009  Evangelos Katsikaros <vkatsikaros at yahoo dot gr>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+/*
+ initial toy for redblack trees
+*/
+
+
+#include <2geom/rtree.h>
+
+#include <time.h>
+#include <vector>
+
+#include <sstream>
+#include <getopt.h>
+
+
+
+
+//using std::vector;
+using namespace Geom;
+using namespace std;
+
+sadfsdfasdfasdfa
+
+int main(int argc, char **argv) {
+
+	long test_seed = 1243716824;
+
+	char* min_arg = NULL;
+	char* max_arg = NULL;
+	char* filename_arg = NULL;
+
+	int set_min_max = 0;
+
+	int c;
+
+	while (1)
+	{
+		static struct option long_options[] =
+		{
+			/* These options set a flag. */
+			/* These options don't set a flag.
+			We distinguish them by their indices. */
+			{"min-nodes",	required_argument,	0, 'n'},
+			{"max-nodes",	required_argument,	0, 'm'},
+			{"input-file",	required_argument,	0, 'f'},
+			{"help",		no_argument,		0, 'h'},
+			{0, 0, 0, 0}
+		};
+		/* getopt_long stores the option index here. */
+		int option_index = 0;
+
+		c = getopt_long (argc, argv, "n:m:f:h",
+			long_options, &option_index);
+
+		/* Detect the end of the options. */
+		if (c == -1){
+			break;
+		}
+
+		switch (c)
+		{
+			case 'n':
+			min_arg = optarg;
+			set_min_max += 1;
+			break;
+
+
+			case 'm':
+			max_arg = optarg;	
+			set_min_max += 2;
+			break;
+
+			case 'f':
+			filename_arg = optarg;	
+			set_min_max += 3;
+			break;
+
+
+			case 'h':
+			std::cerr << "Usage:  " << argv[0] << " options\n" << std::endl ;
+			std::cerr << 
+				   "  -n  --min-nodes=NUMBER   minimum number in node.\n" <<
+				   "  -m  --max-nodes=NUMBER   maximum number in node.\n" <<
+				   "  -f  --max-nodes=NUMBER   maximum number in node.\n" <<
+				   "  -h  --help               Print this help.\n" << std::endl;
+			exit(1);
+			break;
+
+
+			case '?':
+			/* getopt_long already printed an error message. */
+			break;
+
+			default:
+			abort ();
+		}
+	}
+
+	unsigned rmin = 0;
+	unsigned rmax = 0;
+
+	if(	set_min_max == 6 ){
+		stringstream s1( min_arg );
+		s1 >> rmin;
+
+		stringstream s2( max_arg );
+		s2 >> rmax;
+
+
+		if( rmax <= rmin || rmax < 2 || rmin < 1 ){
+			std::cerr << "Rtree set to 2, 3" << std::endl ;
+			rmin = 2;
+			rmax = 3;			
+		}
+	}
+	else{
+		std::cerr << "Rtree set to 2, 3 ." << std::endl ;
+		rmin = 2;
+		rmax = 3;
+	}
+
+
+
+	std::cout << "rmin: " << rmin << "  rmax:" << rmax << "  filename_arg:" << filename_arg << std::endl;
+
+	RTree rtree( rmin, rmax, QUADRATIC_SPIT );
+
+	srand(1243716824);	
+	rand() % 10;
+
+    return 0;
+}
diff --git a/tests/sbasis-test.cpp b/tests/sbasis-test.cpp
new file mode 100644
index 0000000..045d409
--- /dev/null
+++ b/tests/sbasis-test.cpp
@@ -0,0 +1,268 @@
+#include "testing.h"
+#include <iostream>
+
+#include <2geom/bezier.h>
+#include <2geom/sbasis.h>
+#include <2geom/sbasis-to-bezier.h>
+#include <vector>
+#include <iterator>
+#include <glib.h>
+
+using namespace std;
+using namespace Geom;
+
+bool are_equal(SBasis const &A, SBasis const &B) {
+    int maxSize = max(A.size(), B.size());
+    double t = 0., dt = 1./maxSize;
+    
+    for(int i = 0; i <= maxSize; i++) {
+        EXPECT_FLOAT_EQ(A.valueAt(t), B.valueAt(t));// return false;
+        t += dt;
+    }
+    return true;
+}
+
+class SBasisTest : public ::testing::Test {
+protected:
+    friend class Geom::SBasis;
+    SBasisTest()
+        : zero(fragments[0])
+        , unit(fragments[1])
+        , hump(fragments[2])
+        , wiggle(fragments[3])
+    {
+        zero = SBasis(Bezier(0.0).toSBasis());
+        unit = SBasis(Bezier(0.0,1.0).toSBasis());
+        hump = SBasis(Bezier(0,1,0).toSBasis());
+        wiggle = SBasis(Bezier(0,1,-2,3).toSBasis());
+    }
+
+    SBasis fragments[4];
+    SBasis &zero, &unit, &hump, &wiggle;
+};
+
+TEST_F(SBasisTest, UnitTests) {
+    EXPECT_TRUE(Bezier(0,0,0,0).toSBasis().isZero());
+    EXPECT_TRUE(Bezier(0,1,2,3).toSBasis().isFinite());
+
+    // note: "size" of sbasis equals half the number of coefficients
+    EXPECT_EQ(2u, Bezier(0,2,4,5).toSBasis().size());
+    EXPECT_EQ(2u, hump.size());
+}
+
+TEST_F(SBasisTest, ValueAt) {
+    EXPECT_EQ(0.0, wiggle.at0());
+    EXPECT_EQ(3.0, wiggle.at1());
+    EXPECT_EQ(0.0, wiggle.valueAt(0.5));
+    EXPECT_EQ(0.0, wiggle(0.5));
+}
+
+TEST_F(SBasisTest, MultiDerivative) {
+    vector<double> vnd = wiggle.valueAndDerivatives(0.5, 5);
+    expect_array((const double[]){0,0,12,72,0,0}, vnd);
+}
+  /*
+TEST_F(SBasisTest, DegreeElevation) {
+    EXPECT_TRUE(are_equal(wiggle, wiggle));
+    SBasis Q = wiggle;
+    SBasis P = Q.elevate_degree();
+    EXPECT_EQ(P.size(), Q.size()+1);
+    //EXPECT_EQ(0, P.forward_difference(1)[0]);
+    EXPECT_TRUE(are_equal(Q, P));
+    Q = wiggle;
+    P = Q.elevate_to_degree(10);
+    EXPECT_EQ(10, P.order());
+    EXPECT_TRUE(are_equal(Q, P));
+    //EXPECT_EQ(0, P.forward_difference(10)[0]);
+}*/
+//std::pair<SBasis, SBasis > subdivide(Coord t);
+
+SBasis linear_root(double t) {
+  return SBasis(Linear(0-t, 1-t));
+}
+
+SBasis array_roots(vector<double> x) {
+    SBasis b(1);
+    for(double i : x) {
+        b = multiply(b, linear_root(i));
+    }
+    return b;
+}
+
+  /*TEST_F(SBasisTest, Deflate) {
+    SBasis b = array_roots(vector_from_array((const double[]){0,0.25,0.5}));
+    EXPECT_FLOAT_EQ(0, b.at0());
+    b = b.deflate();
+    EXPECT_FLOAT_EQ(0, b.valueAt(0.25));
+    b = b.subdivide(0.25).second;
+    EXPECT_FLOAT_EQ(0, b.at0());
+    b = b.deflate();
+    const double rootposition = (0.5-0.25) / (1-0.25);
+    EXPECT_FLOAT_EQ(0, b.valueAt(rootposition));
+    b = b.subdivide(rootposition).second;
+    EXPECT_FLOAT_EQ(0, b.at0());
+}*/
+
+TEST_F(SBasisTest, Roots) {
+    expect_array((const double[]){0, 0.5, 0.5}, roots(wiggle));
+    
+    // The results of our rootfinding are at the moment fairly inaccurate.
+    double eps = 5e-4;
+
+    vector<vector<double> > tests;
+    tests.push_back(vector_from_array((const double[]){0}));
+    tests.push_back(vector_from_array((const double[]){0.5}));
+    tests.push_back(vector_from_array((const double[]){0.25,0.75}));
+    tests.push_back(vector_from_array((const double[]){0.5,0.5}));
+    tests.push_back(vector_from_array((const double[]){0, 0.2, 0.6,0.6, 1}));
+    tests.push_back(vector_from_array((const double[]){.1,.2,.3,.4,.5,.6}));
+    tests.push_back(vector_from_array((const double[]){0.25,0.25,0.25,0.75,0.75,0.75}));
+    
+    for(auto & test : tests) {
+        SBasis b = array_roots(test);
+        std::cout << test << ": " << b << std::endl;
+        std::cout << roots(b) << std::endl;
+        EXPECT_vector_near(test, roots(b), eps);
+    }
+
+    vector<Linear> broken;
+    broken.emplace_back(0, 42350.1);
+    broken.emplace_back(-71082.3, -67071.5);
+    broken.emplace_back(1783.41, 796047);
+    SBasis b(broken);
+    Bezier bz;
+    sbasis_to_bezier(bz, b);
+    cout << "roots(SBasis(broken))\n";
+    for(int i = 0; i < 10; i++) {
+      double t = i*0.01 + 0.1;
+      cout << b(t) << "," << bz(t) << endl;
+    }
+    cout << roots(b) << endl;
+    EXPECT_EQ(0, bz[0]);
+    //bz = bz.deflate();
+    cout << bz << endl;
+    cout << bz.roots() << endl;
+}
+
+TEST_F(SBasisTest, Subdivide) {
+    std::vector<std::pair<SBasis, double> > errors;
+    for (unsigned i = 0; i < 10000; ++i) {
+        double t = g_random_double_range(0, 1e-6);
+        for (auto & input : fragments) {
+            std::pair<SBasis, SBasis> result;
+            result.first = portion(input, 0, t);
+            result.second = portion(input, t, 1);
+
+            // the endpoints must correspond exactly
+            EXPECT_EQ(result.first.at0(), input.at0());
+            EXPECT_EQ(result.first.at1(), result.second.at0());
+            EXPECT_EQ(result.second.at1(), input.at1());
+
+            // ditto for valueAt
+            EXPECT_EQ(result.first.valueAt(0), input.valueAt(0));
+            EXPECT_EQ(result.first.valueAt(1), result.second.valueAt(0));
+            EXPECT_EQ(result.second.valueAt(1), input.valueAt(1));
+
+            if (result.first.at1() != result.second.at0()) {
+                errors.emplace_back(input, t);
+            }
+        }
+    }
+    if (!errors.empty()) {
+        std::cout << "Found " << errors.size() << " subdivision errors" << std::endl;
+        for (unsigned i = 0; i < errors.size(); ++i) {
+            std::cout << "Error #" << i << ":\n"
+                          << "SBasis: " << errors[i].first << "\n"
+                          << "t: " << format_coord_nice(errors[i].second) << std::endl;
+        }
+    }
+}
+
+TEST_F(SBasisTest, Reverse) {
+    SBasis reverse_wiggle = reverse(wiggle);
+    EXPECT_EQ(reverse_wiggle.at0(), wiggle.at1());
+    EXPECT_EQ(reverse_wiggle.at1(), wiggle.at0());
+    EXPECT_EQ(reverse_wiggle.valueAt(0.5), wiggle.valueAt(0.5));
+    EXPECT_EQ(reverse_wiggle.valueAt(0.25), wiggle.valueAt(0.75));
+    EXPECT_TRUE(are_equal(reverse(reverse_wiggle), wiggle));
+}
+
+TEST_F(SBasisTest,Operators) {
+    //cout << "scalar operators\n";
+    //cout << hump + 3 << endl;
+    //cout << hump - 3 << endl;
+    //cout << hump*3 << endl;
+    //cout << hump/3 << endl;
+
+    //cout << "SBasis derivative(const SBasis & a);\n";
+    //std::cout << derivative(hump) <<std::endl;
+    //std::cout << integral(hump) <<std::endl;
+
+    EXPECT_TRUE(are_equal(derivative(integral(wiggle)), wiggle));
+    //std::cout << derivative(integral(hump)) << std::endl;
+    expect_array((const double []){0.5}, roots(derivative(hump)));
+
+    EXPECT_TRUE(bounds_fast(hump)->contains(Interval(0,hump.valueAt(0.5))));
+
+    EXPECT_EQ(Interval(0,hump.valueAt(0.5)), *bounds_exact(hump));
+
+    Interval tight_local_bounds(min(hump.valueAt(0.3),hump.valueAt(0.6)),
+             hump.valueAt(0.5));
+    EXPECT_TRUE(bounds_local(hump, Interval(0.3, 0.6))->contains(tight_local_bounds));
+
+    SBasis Bs[] = {unit, hump, wiggle};
+    for(auto B : Bs) {
+        SBasis product = multiply(B, B);
+        for(int i = 0; i <= 16; i++) {
+            double t = i/16.0;
+            double b = B.valueAt(t);
+            EXPECT_FLOAT_EQ(b*b, product.valueAt(t));
+        }
+    }
+}
+
+TEST_F(SBasisTest, ToCubicBezier)
+{
+    vector<double> params = { 0, 1, -2, 3 };
+
+    D2<SBasis> sb(wiggle, wiggle);
+    vector<Point> bz;
+    sbasis_to_cubic_bezier(bz, sb);
+    for (int i = 0; i < params.size(); i++) {
+        EXPECT_FLOAT_EQ(bz[i][0], params[i]);
+        EXPECT_FLOAT_EQ(bz[i][1], params[i]);
+    }
+}
+
+TEST_F(SBasisTest, Roundtrip)
+{
+    auto bz1 = Bezier(1, -2, 3, 7, 11, -24, 42, -1, 9, 1);
+    auto sbasis = bz1.toSBasis();
+    Bezier bz2;
+    sbasis_to_bezier(bz2, sbasis);
+    ASSERT_EQ(bz1, bz2);
+
+    std::vector<Point> pts;
+    for (int i = 0; i < bz1.size(); i++) {
+        pts.emplace_back(bz1[i], bz1[i]);
+    }
+    D2<SBasis> sbasis_d2;
+    bezier_to_sbasis(sbasis_d2, pts);
+    ASSERT_EQ(sbasis_d2[X], sbasis);
+    ASSERT_EQ(sbasis_d2[Y], sbasis);
+    D2<Bezier> bz2_d2;
+    sbasis_to_bezier(bz2_d2, sbasis_d2);
+    ASSERT_EQ(bz2_d2[X], bz1);
+    ASSERT_EQ(bz2_d2[Y], bz1);
+}
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/sbasis-text-test.cpp b/tests/sbasis-text-test.cpp
new file mode 100644
index 0000000..ef96407
--- /dev/null
+++ b/tests/sbasis-text-test.cpp
@@ -0,0 +1,225 @@
+#include <iostream>
+#include <math.h>
+#include <cassert>
+#include <2geom/sbasis.h>
+#include <2geom/sbasis-poly.h>
+#include <iterator>
+#include <2geom/point.h>
+#include <2geom/sbasis-to-bezier.h>
+#include <2geom/solver.h>
+
+using namespace Geom;
+
+Poly roots_to_poly(double *a, unsigned n) {
+    Poly r;
+    r.push_back(1);
+    
+    for(unsigned i = 0; i < n; i++) {
+        Poly p;
+        p.push_back(-a[i]);
+        p.push_back(1);
+        r = r*p;
+    }
+    return r;
+}
+
+unsigned small_rand() {
+    return (rand() & 0xff) + 1;
+}
+
+double uniform() {
+    return double(rand()) / RAND_MAX;
+}
+
+int main() {
+    SBasis P0(Linear(0.5, -1)), P1(Linear(3, 1));
+    Linear one(1,1);
+
+    std::cout << "round tripping of poly conversions\n";
+    std::cout << P0 
+              << "=>" << sbasis_to_poly(P0) 
+              << "=>" << poly_to_sbasis(sbasis_to_poly(P0)) 
+              << std::endl;
+    
+    std::cout << "derivatives and integrals\n";
+    
+    Poly test;
+    for(int i = 0; i < 4; i++)
+        test.push_back(1);
+    
+    SBasis test_sb = poly_to_sbasis(test);
+    std::cout << test << "(" << test.size() << ")"
+              << "   ==   "
+              << test_sb << "(" << test_sb.size() << ")"
+              << std::endl;
+    std::cout << "derivative\n";
+    std::cout << derivative(test)
+              << "   ==   "
+              << sbasis_to_poly(derivative(test_sb))
+              << std::endl;
+    
+    std::cout << "integral\n";
+    std::cout << integral(test)
+              << "   ==   "
+              << sbasis_to_poly(integral(test_sb))
+              << std::endl;
+    
+    std::cout << "evaluation\n";
+    std::cout << integral(test)(0.3) - integral(test)(0.)
+              << "   ==   "
+              << integral(test_sb)(0.3) - integral(test_sb)(0.)
+              << std::endl;
+    
+    std::cout << "multiplication\n";
+    std::cout << (test*test)
+              << "\n   ==   \n"
+              << sbasis_to_poly(multiply(test_sb,test_sb))
+              << std::endl;
+    std::cout << poly_to_sbasis(test*test)
+              << "\n   ==   \n"
+              << multiply(test_sb,test_sb)
+              << std::endl;
+    
+    std::cout << "sqrt\n";
+    std::cout << test
+              << "\n   ==   \n"
+              << sbasis_to_poly(sqrt(multiply(test_sb,test_sb),10))
+              << std::endl;
+    SBasis radicand = sqrt(test_sb,10);
+    std::cout << sbasis_to_poly(truncate(multiply(radicand, radicand),5))
+              << "\n   ==   \n"
+              << test
+              << std::endl;
+    
+    std::cout << "division\n";
+    std::cout << test
+              << "\n   ==   \n"
+              << sbasis_to_poly(divide(multiply(test_sb,test_sb),test_sb, 20))
+              << std::endl;
+    std::cout << divide(test_sb, radicand,5)
+              << "\n   ==   \n"
+              << truncate(radicand,6)
+              << std::endl;
+    
+    std::cout << "composition\n";
+    std::cout << (compose(test,sbasis_to_poly(Linear(0.5,1))))
+              << "\n   ==   \n"
+              << sbasis_to_poly(compose(test_sb,Linear(0.5,1)))
+              << std::endl;
+    std::cout << poly_to_sbasis(compose(test,test))
+              << "\n   ==   \n"
+              << compose(test_sb,test_sb)
+              << std::endl
+              << std::endl;
+    std::cout << (compose(sbasis_to_poly(Linear(1,2)),sbasis_to_poly(Linear(-1,0))))
+              << std::endl;
+    std::cout << (compose(SBasis(Linear(1,2)),SBasis(Linear(-1,0))))
+              << std::endl;
+
+    std::cout << "inverse of x - 1\n";
+    std::cout << sbasis_to_poly(inverse(Linear(-1,0),2))
+              << "   ==   y + 1\n";
+    std::cout << "f^-1(f(x)) = " 
+              << sbasis_to_poly(compose(inverse(Linear(-1,0),2), 
+                                        Linear(-1,0))) 
+              << std::endl
+              << std::endl;
+    
+    std::cout << "inverse of 3x - 2\n";
+    std::cout << sbasis_to_poly(inverse(Linear(-2,1),2))
+              << "   ==   (y + 2)/3\n";
+    std::cout << "f^-1(f(x)) = " 
+              << sbasis_to_poly(compose(inverse(Linear(-2,1),2), 
+                                        Linear(-2,1))) 
+              << std::endl
+              << std::endl;
+    
+    
+    std::cout << "inverse of sqrt(" << sbasis_to_poly(Linear(1,4)) << ") - 1\n";
+    SBasis A = sqrt(Linear(1,4), 5) - one;
+    Poly P;
+    P.push_back(0);
+    P.push_back(2./3);
+    P.push_back(1./3);
+    
+    std::cout << "2 term approximation\n";
+    std::cout << sbasis_to_poly(inverse(A,2))
+              << "\n   ==   \n"
+              << P
+              << std::endl;
+    std::cout << "general approximation\n";
+    std::cout << sbasis_to_poly(inverse(A,5))
+              << "\n   ==   \n"
+              << P
+              << std::endl;
+    
+    {
+    std::cout << "inverse of (x^2+2x)/3\n";
+    SBasis A = poly_to_sbasis(P);
+    SBasis I = inverse(A,10);
+    std::cout << sbasis_to_poly(truncate(compose(A, I), 10))
+              << "   ==   x\n"
+              << std::endl;
+    std::cout << sbasis_to_poly(truncate(compose(I, A), 10))
+              << "   ==   x\n"
+              << std::endl;
+    std::cout << sbasis_to_poly(truncate(I - (sqrt(Linear(1,4), 10) - one), 10))
+              << std::endl;
+    }
+#ifdef HAVE_GSL
+    for(int i = 0 ; i < 10; i++) {
+        Poly P;
+        P.push_back(0);
+        P.push_back(1);
+        for(int j = 0 ; j < 2; j++) {
+            P.push_back((uniform()-0.5)/10);
+        }
+        std::vector<std::complex<double> > prod_root = solve(derivative(P));
+        copy(prod_root.begin(), prod_root.end(), 
+             std::ostream_iterator<std::complex<double> >(std::cout, ",\t"));
+        std::cout << std::endl;
+        std::cout << "inverse of (" << P << " )\n";
+        for(int k = 1; k < 30; k++) {
+            SBasis A = poly_to_sbasis(P);
+            SBasis I = inverse(A,k);
+            SBasis err = compose(A, I) - Linear(0,1); // ideally is 0
+            std::cout << truncate(err, k).tailError(0)
+                      << std::endl;
+            /*std::cout << sbasis_to_poly(err)
+                      << "   ==   x\n"
+                      << std::endl;*/
+        }
+    }
+#endif
+    /*double roots[] = {0.1,0.2,0.6};
+    Poly prod = roots_to_poly(roots, sizeof(roots)/sizeof(double));
+    std::cout << "real solve\n";
+    std::cout << prod 
+              << " solves as ";
+    std::vector<std::complex<double> > prod_root = solve(prod);
+    copy(prod_root.begin(), prod_root.end(), 
+         std::ostream_iterator<std::complex<double> >(std::cout, ",\t"));
+    std::cout << std::endl;
+    
+    SBasis prod_sb = poly_to_sbasis(prod);
+    std::vector<double> bez = sbasis_to_bezier(prod_sb, prod_sb.size());
+    
+    copy(bez.begin(), bez.end(), 
+         std::ostream_iterator<double>(std::cout, ",\t"));
+         std::cout << std::endl;*/
+    
+    /*std::cout << "crossing count = " 
+              << crossing_count(bez, bez.size())
+              << std::endl;*/
+}
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/self-intersections-test.cpp b/tests/self-intersections-test.cpp
new file mode 100644
index 0000000..268273f
--- /dev/null
+++ b/tests/self-intersections-test.cpp
@@ -0,0 +1,219 @@
+/** @file
+ * @brief Unit tests for PathVector::intersectSelf()
+ */
+/*
+ * Authors:
+ *   Rafał Siejakowski <rs@rs-math.net>
+ *
+ * Copyright 2022 Authors
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it either under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation
+ * (the "LGPL") or, at your option, under the terms of the Mozilla
+ * Public License Version 1.1 (the "MPL"). If you do not alter this
+ * notice, a recipient may use your version of this file under either
+ * the MPL or the LGPL.
+ *
+ * You should have received a copy of the LGPL along with this library
+ * in the file COPYING-LGPL-2.1; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * You should have received a copy of the MPL along with this library
+ * in the file COPYING-MPL-1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+ * OF ANY KIND, either express or implied. See the LGPL or the MPL for
+ * the specific language governing rights and limitations.
+ */
+
+#include <gtest/gtest.h>
+#include <2geom/pathvector.h>
+#include <2geom/svg-path-parser.h>
+
+using namespace Geom;
+
+#define PV(d) (parse_svg_path(d))
+#define PTH(d) (PV(d)[0])
+
+class PVSelfIntersections : public testing::Test
+{
+protected:
+    PathVector const _rectangle, _bowtie, _bowtie_curved, _bowtie_node, _openpath,
+        _open_closed_nonintersecting, _open_closed_intersecting, _tangential, _degenerate_segments,
+        _degenerate_closing, _degenerate_multiple;
+
+    PVSelfIntersections()
+        // A simple rectangle.
+        : _rectangle{PV("M 0,0 L 5,0 5,8 0,8 Z")}
+        // A polyline path with a self-intersection @(2,1).
+        , _bowtie{PV("M 0,0 L 4,2 V 0 L 0,2 Z")}
+        // A curved bow-tie path with a self-intersection @(10,5) between cubic Béziers.
+        , _bowtie_curved{PV("M 0,0 V 10 C 10,10 10,0 20,0 V 10 C 10,10 10,0 0,0 Z")}
+        // As above, but twice as large and the self-intersection @(20,10) happens at a node.
+        , _bowtie_node{PV("M 0,0 V 20 C 0,20 10,20 20,10 25,5 30,0 40,0 V 20 "
+                          "C 30,20 25,15 20,10 10,0 0,0 0,0 Z")}
+        // An open path with no self-intersections ◠―◡
+        , _openpath{PV("M 0,0 A 10,10 0,0,1 20,0 L 40,0 Q 50,10 60,0")}
+        // A line and a square with no intersections | □
+        , _open_closed_nonintersecting{PV("M 0,0 V 20 M 10,0 V 20 H 30 V 0 Z")}
+        // A line slicing through a square; two self-intersections ⎅
+        , _open_closed_intersecting{PV("M 10,0 V 40 M 0,10 V 30 H 20 V 10 Z")}
+        // A circle whose diameter precisely coincides with the top side of a rectangle.
+        , _tangential{PV("M 0,0 A 10,10 0,0,1 20,0 A 10,10, 0,0,1 0,0 Z M 0,0 H 20 V 30 H 0 Z")}
+        // A rectangle containing degenerate segments.
+        , _degenerate_segments{PV("M 0,0 H 5 V 4 L 5,4 V 8 H 5 L 5,8 H 0 Z")}
+        // A rectangle with a degenerate closing segment.
+        , _degenerate_closing{PV("M 0,0 H 5 V 8 H 0 L 0,0 Z")}
+        // Multiple consecutive degenerate segments, with a degenerate closing segment in the middle.
+        , _degenerate_multiple{PV("M 0,0 L 0,0 V 0 H 0 L 5,0 V 8 H 0 L 0,0 V 0 H 0 Z")}
+    {
+    }
+};
+
+/* Ensure that no spurious intersections are returned. */
+TEST_F(PVSelfIntersections, NoSpurious)
+{
+    auto empty = PathVector();
+    EXPECT_EQ(empty.intersectSelf().size(), 0u);
+
+    auto r = _rectangle.intersectSelf();
+    EXPECT_EQ(r.size(), 0u);
+
+    auto o = _openpath.intersectSelf();
+    EXPECT_EQ(o.size(), 0u);
+
+    auto n = _open_closed_nonintersecting.intersectSelf();
+    EXPECT_EQ(n.size(), 0u);
+
+    auto d = _degenerate_segments.intersectSelf();
+    EXPECT_EQ(d.size(), 0u);
+
+    auto dc = _degenerate_closing.intersectSelf();
+    EXPECT_EQ(dc.size(), 0u);
+
+    auto dm = _degenerate_multiple.intersectSelf();
+    EXPECT_EQ(dm.size(), 0u);
+
+    auto cusp_node = PTH("M 1 3 C 12 8 42 101 86 133 C 78 168 136 83 80 64");
+    EXPECT_EQ(cusp_node.intersectSelf().size(), 0u);
+}
+
+/* Test figure-eight shaped paths */
+TEST_F(PVSelfIntersections, Bowties)
+{
+    // Simple triangular bowtie: intersection between straight lines
+    auto triangular = _bowtie.intersectSelf();
+    EXPECT_EQ(triangular.size(), 1u);
+    ASSERT_GT(triangular.size(), 0u); // To ensure access to [0]
+    EXPECT_TRUE(are_near(triangular[0].point(), Point(2, 1)));
+
+    // Curved bowtie: intersection between cubic Bézier curves
+    auto curved_intersections = _bowtie_curved.intersectSelf();
+    EXPECT_EQ(curved_intersections.size(), 1u);
+    ASSERT_GT(curved_intersections.size(), 0u);
+    EXPECT_TRUE(are_near(curved_intersections[0].point(), Point(10, 5)));
+
+    // Curved bowtie but the intersection point is a node on both paths
+    auto node_case_intersections = _bowtie_node.intersectSelf();
+    EXPECT_EQ(node_case_intersections.size(), 1u);
+    ASSERT_GT(node_case_intersections.size(), 0u);
+    EXPECT_TRUE(are_near(node_case_intersections[0].point(), Point(20, 10)));
+}
+
+/* Test intersecting an open path with a closed one */
+TEST_F(PVSelfIntersections, OpenClosed)
+{
+    // Square cut by a vertical line
+    auto open_closed = _open_closed_intersecting.intersectSelf();
+    auto const P1 = Point(10, 10);
+    auto const P2 = Point(10, 30);
+
+    ASSERT_EQ(open_closed.size(), 2u); // Prevent crash on out-of-bounds access
+    // This test doesn't care about how the intersections are ordered.
+    bool points_as_expected = (are_near(open_closed[0].point(), P1) && are_near(open_closed[1].point(), P2))
+            || (are_near(open_closed[0].point(), P2) && are_near(open_closed[1].point(), P1));
+    EXPECT_TRUE(points_as_expected);
+}
+
+/* Test some nasty, tangential crossings: a circle with a rectangle built on its diameter. */
+TEST_F(PVSelfIntersections, Tangential)
+{
+    auto circle_x_rect = _tangential.intersectSelf();
+    auto const P1 = Point(0, 0);
+    auto const P2 = Point(20, 0);
+
+    ASSERT_EQ(circle_x_rect.size(), 2u); // Prevent crash on out-of-bounds access
+    // This test doesn't care how the intersections are ordered.
+    bool points_as_expected = (are_near(circle_x_rect[0].point(), P1) && are_near(circle_x_rect[1].point(), P2))
+            || (are_near(circle_x_rect[0].point(), P2) && are_near(circle_x_rect[1].point(), P1));
+    EXPECT_TRUE(points_as_expected);
+}
+
+/* Regression test for issue https://gitlab.com/inkscape/lib2geom/-/issues/33 */
+TEST_F(PVSelfIntersections, Regression33)
+{
+    // Test case provided by Pascal Bies in the issue description.
+    auto const line = LineSegment(Point(486, 597), Point(313, 285));
+    Point const c{580.1377046525328, 325.5830744834947};
+    Point const d{289.35338528516013, 450.62476639303753};
+    auto const curve = CubicBezier(c, c, d, d);
+
+    EXPECT_EQ(curve.intersect(line).size(), 1);
+}
+
+/* Regression test for issue https://gitlab.com/inkscape/lib2geom/-/issues/46 */
+TEST_F(PVSelfIntersections, NumericalInstability)
+{
+    // Test examples provided by M.B. Fraga in the issue report.
+    auto missing_intersection = PTH("M 138 237 C 293 207 129 12 167 106 Q 205 200 309 198 z");
+    auto missing_xings = missing_intersection.intersectSelf();
+    EXPECT_EQ(missing_xings.size(), 2);
+
+    auto duplicate_intersection = PTH("M 60 280 C 60 213 236 227 158 178 S 174 306 127 310 Q 80 314 60 280 z");
+    auto const only_expected = Point(130.9693916417836, 224.587385497877);
+    auto duplicate_xings = duplicate_intersection.intersectSelf();
+    ASSERT_EQ(duplicate_xings.size(), 1);
+    EXPECT_TRUE(are_near(duplicate_xings[0].point(), only_expected));
+}
+
+/* Check various numerically challenging paths consisting of 2 cubic Béziers. */
+TEST_F(PVSelfIntersections, NumericallyChallenging)
+{
+    auto two_kinks = PTH("M 85 88 C 4 425 19 6 72 426 C 128 6 122 456 68 96");
+    EXPECT_EQ(two_kinks.intersectSelf().size(), 3);
+
+    auto omega = PTH("M 47 132 C 179 343 0 78 106 74 C 187 74 0 358 174 106");
+    EXPECT_EQ(omega.intersectSelf().size(), 0);
+
+    auto spider = PTH("M 47 132 C 203 339 0 78 106 74 C 187 74 0 358 174 106");
+    EXPECT_EQ(spider.intersectSelf().size(), 4);
+
+    auto egret = PTH("M 38 340 C 183 141 16 76 255 311 C 10 79 116 228 261 398");
+    EXPECT_EQ(egret.intersectSelf().size(), 0);
+}
+
+/* Test a regression from 88040ea2aeab8ccec2b0e96c7bda2fc7d500d5ec */
+TEST_F(PVSelfIntersections, BigonFiltering)
+{
+    auto const lens = PTH("M 0,0 C 2,1 3,1 5,0 A 2.5,1 0 1 0 0,0 Z");
+    auto const xings = lens.intersectSelf();
+    // This is a simple closed path, so we expect that no self-intersections are reported.
+    EXPECT_EQ(xings.size(), 0);
+}
+
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/tests/test_pwsb.py b/tests/test_pwsb.py
new file mode 100644
index 0000000..6182d40
--- /dev/null
+++ b/tests/test_pwsb.py
@@ -0,0 +1,67 @@
+#!/usr/bin/python
+
+import sys
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", "py2geom"))
+
+from  py2geom import *
+import py2geom
+import numpy
+import random
+from py2geom_glue import *
+
+def poly_to_sbasis(p):
+    sb = SBasis()
+    s = numpy.poly1d([-1, 1, 0])
+    while True:
+        q,r = p / s
+        x = Linear(r[0],r[1]+r[0])
+        sb.append(x)
+        p = q
+        if len(list(p)) <= 1 and p[0] == 0:
+            return sb
+
+def sbasis_to_poly(sb):
+    p = numpy.poly1d([0])
+    s = numpy.poly1d([-1, 1, 0])
+    sp = numpy.poly1d([1])
+    for sbt in sb:
+        p += sp*(sbt[0]*(numpy.poly1d([-1,1])) + sbt[1]*(numpy.poly1d([1,0])))
+        sp *= s
+    return p
+
+random.seed(1)
+trial = numpy.poly1d([random.randrange(0,10) for x in range(6)])
+
+sb = poly_to_sbasis(trial)
+
+pwsb = PiecewiseSBasis()
+pwsb.push_seg(sb)
+pwsb.push_cut(0)
+pwsb.push_cut(1)
+print pwsb.size()
+print "invariants:", pwsb.invariants()
+print pwsb(0)
+
+def l2s(l):
+    sb = py2geom.SBasis()
+    sb.append(l)
+    return sb
+
+X = l2s(py2geom.Linear(0, 1))
+OmX = l2s(py2geom.Linear(1, 0))
+def bezier_to_sbasis(handles, order):
+    print "b2s:", handles, order
+    if(order == 0):
+        return l2s(py2geom.Linear(handles[0]))
+    elif(order == 1):
+        return l2s(py2geom.Linear(handles[0], handles[1]))
+    else:
+        return (py2geom.multiply(OmX, bezier_to_sbasis(handles[:-1], order-1)) +
+                py2geom.multiply(X, bezier_to_sbasis(handles[1:], order-1)))
+
+
+for bz in [[0,1,0], [0,1,2,3]]:
+    sb = bezier_to_sbasis(bz, len(bz)-1)
+    print bz
+    print sb
+    print sbasis_to_bezier(sb,0)
diff --git a/tests/test_py2geom.py b/tests/test_py2geom.py
new file mode 100644
index 0000000..d6ec83e
--- /dev/null
+++ b/tests/test_py2geom.py
@@ -0,0 +1,75 @@
+#!/usr/bin/python
+
+import sys
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", "py2geom"))
+
+from  py2geom import *
+import py2geom
+
+P = Point(1,2)
+Q = Point(3,5)
+print P, Q, P+Q
+
+print L2(P)
+print cross(P,Q)
+#print dir(py2geom)
+
+import numpy
+
+ply = numpy.poly1d([1,0,2])
+
+print ply(0.5)
+t = numpy.poly1d([1,0])
+q,r = ply / t
+print q,r
+
+print ply 
+print q*t + r
+print ply
+
+def poly_to_sbasis(p):
+    sb = SBasis()
+    s = numpy.poly1d([-1, 1, 0])
+    while True:
+        q,r = p / s
+        #print "r:", r
+        print "r:", repr(r)
+        x = Linear(r[0],r[1]+r[0])
+        sb.append(x)
+        p = q
+        print "q:", repr(p), len(list(p))
+        if len(list(p)) <= 1 and p[0] == 0:
+            return sb
+
+def sbasis_to_poly(sb):
+    p = numpy.poly1d([0])
+    s = numpy.poly1d([-1, 1, 0])
+    sp = numpy.poly1d([1])
+    for sbt in sb:
+        p += sp*(sbt[0]*(numpy.poly1d([-1,1])) + sbt[1]*(numpy.poly1d([1,0])))
+        sp *= s
+    return p
+
+trial = numpy.poly1d([1,0,2])
+sb = poly_to_sbasis(trial)
+print repr(trial),"p2sb:", sb
+print "and back again:", repr(sbasis_to_poly(sb))
+print repr(sbasis_to_poly(derivative(sb))), repr(trial.deriv())
+
+print "unit tests:"
+x = Linear(0,1)
+sb = SBasis()
+sb.append(x)
+print sb
+sb = sb*sb
+print sb
+print sb[0]
+
+print "terms"
+for i in range(6):
+    sb = SBasis()
+    for j in range(3):
+        sb.append(Linear(i==2*j,i==2*j+1))
+    print sb
+    
+    print sbasis_to_poly(sb)
diff --git a/tests/testing.h b/tests/testing.h
new file mode 100644
index 0000000..40a588d
--- /dev/null
+++ b/tests/testing.h
@@ -0,0 +1,186 @@
+#include "gtest/gtest.h"
+#include <vector>
+#include <2geom/coord.h>
+#include <2geom/interval.h>
+#include <2geom/intersection.h>
+
+// streams out a vector
+template <class T>
+std::ostream&
+operator<< (std::ostream &out, const std::vector<T,
+             std::allocator<T> > &v)
+{
+    typedef std::ostream_iterator<T, char,
+    std::char_traits<char> > Iter;
+
+    std::copy (v.begin (), v.end (), Iter (out, " "));
+
+    return out;
+}
+
+template <typename T, unsigned xn>
+std::vector<T> vector_from_array(const T (&x)[xn]) {
+    std::vector<T> v;
+    for(unsigned i = 0; i < xn; i++) {
+        v.push_back(x[i]);
+    }
+    return v;
+}
+
+template <typename T, unsigned xn>
+void expect_array(const T (&x)[xn], std::vector<T> y) {
+    EXPECT_EQ(xn, y.size());
+    for(unsigned i = 0; i < y.size(); i++) {
+        EXPECT_EQ(x[i], y[i]);
+    }
+}
+
+Geom::Interval bound_vector(std::vector<double> const &v) {
+    double low = v[0];
+    double high = v[0];
+    for(double i : v) {
+      low = std::min(i, low);
+      high = std::max(i, high);
+    }
+    return Geom::Interval(low-1, high-1);
+}
+
+
+// Custom assertion formatting predicates
+
+template <typename T>
+::testing::AssertionResult ObjectNear(char const *l_expr,
+                                      char const *r_expr,
+                                      char const */*eps_expr*/,
+                                      T const &l,
+                                      T const &r,
+                                      Geom::Coord eps)
+{
+    if (!Geom::are_near(l, r, eps)) {
+        return ::testing::AssertionFailure() << "Objects are not near\n"
+            << "First object: " << l_expr << "\n"
+            << "Value: " << l << "\n"
+            << "Second object: " << r_expr << "\n"
+            << "Value: " << r << "\n"
+            << "Threshold: " << Geom::format_coord_nice(eps) << std::endl;
+    }
+    return ::testing::AssertionSuccess();
+}
+
+template <typename T>
+::testing::AssertionResult ObjectNotNear(char const *l_expr,
+                                         char const *r_expr,
+                                         char const */*eps_expr*/,
+                                         T const &l,
+                                         T const &r,
+                                         Geom::Coord eps)
+{
+    if (Geom::are_near(l, r, eps)) {
+        return ::testing::AssertionFailure() << "Objects are near\n"
+            << "First object: " << l_expr << "\n"
+            << "Value: " << l << "\n"
+            << "Second object: " << r_expr << "\n"
+            << "Value: " << r << "\n"
+            << "Threshold: " << Geom::format_coord_nice(eps) << std::endl;
+    }
+    return ::testing::AssertionSuccess();
+}
+
+#define EXPECT_near(a, b, eps) EXPECT_PRED_FORMAT3(ObjectNear, a, b, eps)
+#define EXPECT_not_near(a, b, eps) EXPECT_PRED_FORMAT3(ObjectNotNear, a, b, eps)
+
+
+
+template <typename T>
+::testing::AssertionResult VectorEqual(char const *l_expr,
+                                       char const *r_expr,
+                                       std::vector<T> const &l,
+                                       std::vector<T> const &r)
+{
+    if (l.size() != r.size()) {
+        return ::testing::AssertionFailure() << "Vectors differ in size\n"
+            << l_expr << " has size " << l.size() << "\n"
+            << r_expr << " has size " << r.size() << std::endl;
+    }
+    for (unsigned i = 0; i < l.size(); ++i) {
+        if (!(l[i] == r[i])) {
+            return ::testing::AssertionFailure() << "Vectors differ"
+                << "\nVector: " << l_expr
+                << "\nindex " << i << " contains: " << l[i]
+                << "\nVector:" << r_expr
+                << "\nindex " << i << " contains: " << r[i] << std::endl;
+        }
+    }
+    return ::testing::AssertionSuccess();
+}
+
+template <typename T>
+::testing::AssertionResult VectorNear(char const *l_expr,
+                                      char const *r_expr,
+                                      char const */*eps_expr*/,
+                                      std::vector<T> const &l,
+                                      std::vector<T> const &r,
+                                      Geom::Coord eps)
+{
+    if (l.size() != r.size()) {
+        return ::testing::AssertionFailure() << "Vectors differ in size\n"
+            << l_expr << "has size " << l.size() << "\n"
+            << r_expr << "has size " << r.size() << std::endl;
+    }
+    for (unsigned i = 0; i < l.size(); ++i) {
+        if (!Geom::are_near(l[i], r[i], eps)) {
+            return ::testing::AssertionFailure() << "Vectors differ by more than "
+                << Geom::format_coord_nice(eps)
+                << "\nVector: " << l_expr
+                << "\nindex " << i << " contains: " << l[i]
+                << "\nVector:" << r_expr
+                << "\nindex " << i << " contains: " << r[i] << std::endl;
+        }
+    }
+    return ::testing::AssertionSuccess();
+}
+
+#define EXPECT_vector_equal(a, b) EXPECT_PRED_FORMAT2(VectorEqual, a, b)
+#define EXPECT_vector_near(a, b, eps) EXPECT_PRED_FORMAT3(VectorNear, a, b, eps)
+
+
+
+template <typename TA, typename TB>
+::testing::AssertionResult IntersectionsValid(
+    char const *l_expr, char const *r_expr, const char */*xs_expr*/, const char */*eps_expr*/,
+    TA const &shape_a, TB const &shape_b,
+    std::vector<Geom::Intersection<typename Geom::ShapeTraits<TA>::TimeType,
+                                   typename Geom::ShapeTraits<TB>::TimeType> > const &xs,
+    Geom::Coord eps)
+{
+    std::ostringstream os;
+    bool failed = false;
+
+    for (unsigned i = 0; i < xs.size(); ++i) {
+        Geom::Point pa = shape_a.pointAt(xs[i].first);
+        Geom::Point pb = shape_b.pointAt(xs[i].second);
+        if (!Geom::are_near(pa, xs[i].point(), eps) ||
+            !Geom::are_near(pb, xs[i].point(), eps) ||
+            !Geom::are_near(pb, pa, eps))
+        {
+            os << "Intersection " << i << " does not match\n"
+               << Geom::format_coord_nice(xs[i].first) << " evaluates to " << pa << "\n"
+               << Geom::format_coord_nice(xs[i].second) << " evaluates to " << pb << "\n"
+               << "Reported intersection point is " << xs[i].point() << std::endl;
+            failed = true;
+        }
+    }
+
+    if (failed) {
+        return ::testing::AssertionFailure()
+            << "Intersections do not match\n"
+            << "Shape A: " << l_expr << "\n"
+            << "Shape B: " << r_expr << "\n"
+            << os.str()
+            << "Threshold: " << Geom::format_coord_nice(eps) << std::endl;
+    }
+
+    return ::testing::AssertionSuccess();
+}
+
+#define EXPECT_intersections_valid(a, b, xs, eps) EXPECT_PRED_FORMAT4(IntersectionsValid, a, b, xs, eps)
diff --git a/tests/timing-test.cpp b/tests/timing-test.cpp
new file mode 100644
index 0000000..b5714f7
--- /dev/null
+++ b/tests/timing-test.cpp
@@ -0,0 +1,270 @@
+#include <sys/time.h>
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <algorithm>
+#include <assert.h>
+#include <time.h>
+#include <sched.h>
+#include <math.h>
+
+const long long US_PER_SECOND = 1000000L;
+const long long NS_PER_US = 1000L;
+
+using namespace std;
+
+class Timer{
+public:
+  Timer() {}
+  // note that CPU time is tracked per-thread, so the timer is only useful
+  // in the thread it was start()ed from.
+  void start() {
+    usec(start_time);
+  }
+  void lap(long long &us) {
+    usec(us);
+    us -= start_time;
+  }
+  long long lap() {
+    long long us;
+    usec(us);
+    return us - start_time;
+  }
+  void usec(long long &us) {
+    clock_gettime(clock, &ts);
+    us = ts.tv_sec * US_PER_SECOND + ts.tv_nsec / NS_PER_US;
+  }
+  /** Ask the OS nicely for a big time slice */
+  void ask_for_timeslice() {
+    sched_yield();
+  }
+private:
+  long long start_time;
+  struct timespec ts;
+#ifdef _POSIX_THREAD_CPUTIME
+  static const clockid_t clock = CLOCK_THREAD_CPUTIME_ID;
+#else
+# ifdef CLOCK_MONOTONIC
+  static const clockid_t clock = CLOCK_MONOTONIC;
+# else
+  static const clockid_t clock = CLOCK_REALTIME;
+# endif
+#endif
+};
+
+int estimate_useful_window() 
+{
+  Timer tm;
+  tm.ask_for_timeslice();
+  int window = 1;
+  
+  while(1) {
+    tm.start();
+    for(int i = 0; i < window; i++) {}
+    long long  base_line = tm.lap();
+    if(base_line > 1 and window > 100)
+      return window;
+    window *= 2;
+  }
+}
+
+template <typename T>
+string robust_timer(T &t) {
+  static int  base_rate = estimate_useful_window();
+  //cout << "base line iterations:" << base_rate << endl;
+  double sum = 0;
+  vector<double> results;
+  const int n_trials = 20;
+  results.reserve(n_trials);
+  for(int trials = 0; trials < n_trials; trials++) {
+    Timer tm;
+    tm.ask_for_timeslice();
+    tm.start();
+    int iters = 0;
+    while(tm.lap() < 10000) {
+      for(int i = 0; i < base_rate; i++)
+	t();
+      iters+=base_rate;
+    }
+    base_rate = iters;
+    double lap_time = double(tm.lap());
+    double individual_time = lap_time/base_rate;
+    sum += individual_time;
+    results.push_back(individual_time);
+    //cout << individual_time << endl;
+  }
+  double resS = 0;
+  double resN = 0;
+  sort(results.begin(), results.end());
+  double ave = results[results.size()/2];//sum/n_trials; // median
+  //cout << "median:" << ave << endl;
+  double least = ave;
+  double resSS = 0;
+  for(int i = 0; i < n_trials; i++) {
+    double dt = results[i];
+    if(dt <= ave*1.1) {
+      resS += dt;
+      resN += 1;
+      resSS += dt*dt;
+      if(least < dt)
+	least = dt;
+    }
+  }
+
+  double filtered_ave = resS / resN;
+  double stddev = sqrt((resSS - 2*resS*filtered_ave + resN*filtered_ave*filtered_ave)/(resN-1)); // sum(x-u)^2 = sum(x^2-2xu+u*u)
+  assert (least > filtered_ave*0.7); // If this throws something was really screwy
+  std::basic_stringstream<char> ss;
+  ss << filtered_ave << " +/-" << stddev << "us";
+  return ss.str();
+}
+
+struct nop{
+  void operator()() const {}
+};
+
+#define degenerate_imported 1
+#include "degenerate.cpp"
+using namespace Geom;
+
+template <typename T>
+struct copy{
+  T a, b;
+  void operator()() {
+    T c = a;
+  }
+};
+
+template <typename T>
+struct add{
+  T a, b;
+  void operator()() {
+    T c = a + b;
+  }
+};
+
+template <typename T>
+struct add_mutate{
+  T a, b;
+  void operator()() {
+    a += b;
+  }
+};
+
+template <typename T>
+struct scale{
+  T a;
+  double b;
+  void operator()() {
+    T c = a * b;
+  }
+};
+
+template <typename T>
+struct scale_mutate{
+  T a;
+  double b;
+  void operator()() {
+    a *= b;
+  }
+};
+
+template <typename T>
+struct mult{
+  T a, b;
+  void operator()() {
+    T c = a * b;
+  }
+};
+
+template <typename T>
+struct mult_mutate{
+  T a, b, c;
+  void operator()() {
+    c = a;
+    c *= b;
+  }
+};
+
+template <typename T>
+void basic_arith(T const & a, T const & b) {
+  {
+    ::copy<T> A;
+    A.a = a;
+    A.b = b;
+    cout << "copy:" 
+	 << robust_timer(A) << endl;
+  }
+  {
+    add<T> A;
+    A.a = a;
+    A.b = b;
+    cout << "add:" 
+	 << robust_timer(A) << endl;
+  }
+  {
+    add_mutate<T> A;
+    A.a = a;
+    A.b = b;
+    cout << "add_mutate:" 
+	 << robust_timer(A) << endl;
+  }
+  {
+    ::scale<T> A;
+    A.a = a;
+    A.b = 1;
+    cout << "scale:" 
+	 << robust_timer(A) << endl;
+  }
+  {
+    scale_mutate<T> A;
+    A.a = a;
+    A.b = 1;
+    cout << "scale_mutate:" 
+	 << robust_timer(A) << endl;
+  }
+  {
+    mult<T> A;
+    A.a = a;
+    A.b = b;
+    cout << "mult:" 
+	 << robust_timer(A) << endl;
+  }
+  {
+    mult_mutate<T> A;
+    A.a = a;
+    A.b = b;
+    cout << "mult_mutate:" 
+	 << robust_timer(A) << endl;
+  }
+  
+}
+
+#include <valarray>
+#include <2geom/orphan-code/sbasisN.h>
+#include <2geom/piecewise.h>
+int main(int /*argc*/, char** /*argv*/) {
+  
+  {
+    nop N;
+    cout << "nop:" << robust_timer(N) << endl;
+  }
+
+  vector<SBasis> sbs;
+  valarray<double> va(4), vb(4);
+  generate_random_sbasis(sbs);
+  cout << "double\n";
+  basic_arith(sbs[0][0][0], sbs[1][0][0]);
+  cout << "valarray\n";
+  basic_arith(va, vb);
+  //cout << "Linear\n";
+  //basic_arith(sbs[0][0], sbs[1][0]);
+  cout << "SBasis\n";
+  basic_arith(sbs[0], sbs[1]);
+  cout << "pw<SBasis>\n";
+  basic_arith(Piecewise<SBasis>(sbs[0]), Piecewise<SBasis>(sbs[1]));
+  /*cout << "SBasisN<1>\n";
+  SBasisN<1> sbnA = sbs[0];
+  SBasisN<1> sbnB = sbs[0];
+  basic_arith(sbnA, sbnB);*/
+}
diff --git a/tests/utest.h b/tests/utest.h
new file mode 100644
index 0000000..eda1eb4
--- /dev/null
+++ b/tests/utest.h
@@ -0,0 +1,134 @@
+#ifndef SEEN_UTEST_UTEST_H
+#define SEEN_UTEST_UTEST_H
+
+/* Ultra-minimal unit testing framework */
+/* This file is in the public domain */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <stdlib.h>
+#include <stdio.h>
+#include <setjmp.h>
+//#include <glib/gstrfuncs.h>  /* g_strdup_printf */
+#ifdef __cplusplus
+};
+#endif
+
+jmp_buf utest__jmp_buf;
+int utest__tests;
+int utest__passed;
+int utest__running;
+const char *utest__name;
+
+/** \brief Initializes the framework for running a series of tests.
+  * \param name A descriptive label for this series of tests.
+  */
+void utest_start(const char *name) {
+	printf("Testing %s...\n", name);
+	utest__name = name;
+	utest__tests = utest__passed = 0;
+	utest__running = 0;
+}
+
+void utest__pass(void) {
+	utest__passed++;
+	utest__running = 0;
+	printf("OK\n");
+}
+
+
+/** \brief Write \a a, \a b, \a c, and exit the current block of tests.
+ *
+ *  In the current implementation, any of \a a, \a b, \a c may be NULL, considered equivalent to
+ *  empty string; but don't rely on that unless you also change this documentation string.  (No
+ *  callers use this functionality at the time of writing.)
+ *
+ *  No newline needed in the arguments.
+ */
+int
+utest__fail(const char *a, const char *b, const char *c)
+{
+	utest__running = 0;
+	fflush(stdout);
+	fprintf (stderr, "%s%s%s\n",
+		 (a ? a : ""),
+		 (b ? b : ""),
+		 (c ? c : ""));
+	fflush(stderr);
+	longjmp(utest__jmp_buf, 0);
+	return 0;
+}
+
+
+/** \brief Marks a C block constituting a single test.
+  * \param name A descriptive name for this test.
+  *
+  * The block effectively becomes a try statement; if code within the
+  * block triggers an assertion, control will resume at the end of the
+  * block.
+  */
+#define UTEST_TEST(name) if (!setjmp(utest__jmp_buf)&&utest__test((name)))
+
+/** \brief Terminates the current test if \a cond evaluates to nonzero.
+  * \param cond The condition to test.
+  */
+#define UTEST_ASSERT(cond) UTEST_NAMED_ASSERT( #cond, (cond))
+
+/** \brief Terminates the current tests if \a _cond evaluates to nonzero,
+  *        and prints a descriptive \a _name instead of the condition
+  *        that caused it to fail.
+  * \param _name The descriptive label to use.
+  * \param _cond The condition to test.
+  */
+#define UTEST_NAMED_ASSERT(_name, _cond) static_cast<void>((_cond) || utest__fail("Assertion `", (_name), "' failed"))
+
+#define UTEST_ASSERT_SHOW(_cond, _printf_args) \
+  static_cast<void>((_cond)	\
+		    || (utest__fail("\nAssertion `" #_cond "' failed; ", "",	\
+				    g_strdup_printf _printf_args)))
+
+int utest__test(const char *name) {
+	utest__tests++;
+	if (utest__running) {
+		utest__pass();
+	}
+	printf("\t%s...", name);
+	fflush(stdout);
+	utest__running = 1;
+	return 1;
+}
+
+/** \brief Ends a series of tests, reporting test statistics.
+  *
+  * Test statistics are printed to stdout or stderr, then the function returns
+  * nonzero iff all the tests have passed, zero otherwise.
+  */
+int utest_end(void) {
+	if (utest__running) {
+		utest__pass();
+	}
+	if ( utest__passed == utest__tests ) {
+		printf("%s: OK (all %d passed)\n",
+		       utest__name, utest__tests);
+		return 1;
+	} else {
+		fflush(stdout);
+		fprintf(stderr, "%s: FAILED (%d/%d tests passed)\n",
+		                utest__name, utest__passed, utest__tests);
+		fflush(stderr);
+		return 0;
+	}
+}
+
+
+#endif /* !SEEN_UTEST_UTEST_H */
+
+/*
+  Local Variables:
+  mode:c
+  c-file-style:"linux"
+  fill-column:99
+  End:
+*/
+// vim: filetype=c:noexpandtab:shiftwidth=8:tabstop=8:fileencoding=utf-8:textwidth=99 :