Calculate the head and tail of edges to be just where they contact the node (ie: behave more like tikz).

git-svn-id: https://tikzit.svn.sourceforge.net/svnroot/tikzit/trunk@388 7c02a99a-9b00-45e3-bf44-6f3dd7fddb64

7 files changed, 681 insertions, 7 deletions

diff --git a/tikzit/src/common/test/Makefile b/tikzit/src/common/test/Makefile
new file mode 100644
index 0000000..d158d16
--- /dev/null
+++ b/tikzit/src/common/test/Makefile
@@ -0,0 +1,14 @@
+OBJC = gcc -MMD -MP -DSTAND_ALONE -DGNUSTEP -DGNUSTEP_BASE_LIBRARY=1 -DGNU_RUNTIME=1 -DGNUSTEP_BASE_LIBRARY=1 -fno-strict-aliasing -fPIC -Wall -DGSWARN -DGSDIAGNOSE -Wno-import -O0 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector --param=ssp-buffer-size=4 -m64 -mtune=generic -fgnu-runtime -fconstant-string-class=NSConstantString -I. -I.. -I/users/alemer/GNUstep/Library/Headers -std=c99 -D_GNU_SOURCE -rdynamic -fgnu-runtime -L/users/alemer/GNUstep/Library/Libraries -L/usr/local/lib64 -L/usr/lib64 -lgnustep-base -lpthread -lobjc -lm
+
+maths_test_objects = test.m maths.m ../util.m
+color_test_objects = test.m color.m ../ColorRGB.m ../util.m ../BasicMapTable.m ../RColor.m
+
+test: maths-test color-test
+	./maths-test
+	./color-test
+
+maths-test: $(maths_test_objects)
+	$(OBJC) $(maths_test_objects) -o $@
+
+color-test: $(color_test_objects)
+	$(OBJC) $(color_test_objects) -o $@
diff --git a/tikzit/src/common/test/color.m b/tikzit/src/common/test/color.m
index e7a80ba..48a6ff4 100644
--- a/tikzit/src/common/test/color.m
+++ b/tikzit/src/common/test/color.m
@@ -23,7 +23,11 @@
 #import "test/test.h"
 #import "ColorRGB.h"
 
+#ifdef STAND_ALONE
+void runTests() {
+#else
 void testColor() {
+#endif
 	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 	startTestBlock(@"color");
 	
@@ -73,4 +77,4 @@ void testColor() {
 	
 	endTestBlock(@"color");
 	[pool drain];
-}
\ No newline at end of file
+}
diff --git a/tikzit/src/common/test/common.m b/tikzit/src/common/test/common.m
index ee6cb5f..c9ac980 100644
--- a/tikzit/src/common/test/common.m
+++ b/tikzit/src/common/test/common.m
@@ -23,10 +23,12 @@
 #import "test/test.h"
 void testParser();
 void testColor();
+void testMaths();
 
 void testCommon() {
 	startTestBlock(@"common");
 	testParser();
 	testColor();
+	testMaths();
 	endTestBlock(@"common");
-}
\ No newline at end of file
+}
diff --git a/tikzit/src/common/test/maths.m b/tikzit/src/common/test/maths.m
new file mode 100644
index 0000000..a11e58e
--- /dev/null
+++ b/tikzit/src/common/test/maths.m
@@ -0,0 +1,562 @@
+//
+//  TikZiT
+//
+//  Copyright 2011 Alex Merry
+//
+//  This file is part of TikZiT.
+//
+//  TikZiT is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  TikZiT is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with TikZiT.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#import "../util.h"
+
+#import "test.h"
+
+void testRectAroundPoints() {
+	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+	startTestBlock(@"NSRectAroundPoints");
+
+	NSRect rect = NSRectAroundPoints (NSZeroPoint, NSZeroPoint);
+	assertRectsEqual (@"(0,0) and (0,0)", rect, NSZeroRect);
+
+	rect = NSRectAroundPoints (NSZeroPoint, NSMakePoint (1.0f, 1.0f));
+	assertRectsEqual (@"(0,0) and (1,1)", rect, NSMakeRect (0.0f, 0.0f, 1.0f, 1.0f));
+
+	rect = NSRectAroundPoints (NSMakePoint (-1.0f, 1.0f), NSMakePoint (1.0f, -1.0f));
+	assertRectsEqual (@"(-1,1) and (1,-1)", rect, NSMakeRect (-1.0f, -1.0f, 2.0f, 2.0f));
+
+	endTestBlock(@"NSRectAroundPoints");
+	[pool drain];
+}
+
+void testRectAroundPointsWithPadding() {
+	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+	startTestBlock(@"NSRectAroundPointsWithPadding");
+
+	NSRect rect = NSRectAroundPointsWithPadding (NSZeroPoint, NSZeroPoint, 0.0f);
+	assertRectsEqual (@"(0,0) and (0,0); 0 padding", rect, NSZeroRect);
+
+	rect = NSRectAroundPointsWithPadding (NSZeroPoint, NSZeroPoint, 0.2f);
+	assertRectsEqual (@"(0,0) and (0,0); 0.2 padding", rect, NSMakeRect (-0.2f, -0.2f, 0.4f, 0.4f));
+
+	rect = NSRectAroundPointsWithPadding (NSZeroPoint, NSMakePoint (1.0f, 1.0f), -0.2f);
+	assertRectsEqual (@"(0,0) and (1,1); -0.2 padding", rect, NSMakeRect (0.2f, 0.2f, 0.6f, 0.6f));
+
+	endTestBlock(@"NSRectAroundPointsWithPadding");
+	[pool drain];
+}
+
+void testGoodAtan() {
+	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+	startTestBlock(@"good_atan");
+
+	assertFloatsEqual (@"0.0, 0.0", good_atan (0.0f, 0.0f), 0.0f);
+	assertFloatsEqual (@"0.0, 1.0", good_atan (0.0f, 1.0f), 0.5f * M_PI);
+	assertFloatsEqual (@"0.0, -1.0", good_atan (0.0f, -1.0f), 1.5f * M_PI);
+	assertFloatsEqual (@"1.0, 0.0", good_atan (1.0f, 0.0f), 0.0f);
+	assertFloatsEqual (@"1.0, 0.1", good_atan (1.0f, 0.1f), 0.0996687f);
+
+	endTestBlock(@"good_atan");
+	[pool drain];
+}
+
+void testBezierInterpolate() {
+	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+	startTestBlock(@"bezierInterpolate");
+
+	assertFloatsEqual (@"0.0, (0.0, 0.1, 0.2, 0.3)", bezierInterpolate (0.0f, 0.0f, 0.1f, 0.2f, 0.3f), 0.0f);
+	assertFloatsEqual (@"1.0, (0.0, 0.1, 0.2, 0.3)", bezierInterpolate (1.0f, 0.0f, 0.1f, 0.2f, 0.3f), 0.3f);
+	assertFloatsEqual (@"0.5, (0.0, 0.1, 0.2, 0.3)", bezierInterpolate (0.5f, 0.0f, 0.1f, 0.2f, 0.3f), 0.15f);
+	// FIXME: other tests
+
+	endTestBlock(@"bezierInterpolate");
+	[pool drain];
+}
+
+void testLineSegmentsIntersect() {
+	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+	startTestBlock(@"lineSegmentsIntersect");
+
+	BOOL result = NO;
+	NSPoint intersection = NSMakePoint (-1.0f, -1.0f);
+
+	result = lineSegmentsIntersect (NSMakePoint (-1.0f, -1.0f), NSMakePoint (1.0f, 1.0f),
+	                                NSMakePoint (-1.0f, 1.0f), NSMakePoint (1.0f, -1.0f),
+	                                &intersection);
+	TEST (@"Cross at zero: has intersection", result);
+	assertPointsEqual (@"Cross at zero: intersection value", intersection, NSZeroPoint);
+
+	result = lineSegmentsIntersect (NSMakePoint (-1.0f, -1.0f), NSMakePoint (-0.5f, -0.5f),
+	                                NSMakePoint (-1.0f, 1.0f), NSMakePoint (1.0f, -1.0f),
+	                                &intersection);
+	TEST (@"Fail to cross at zero", !result);
+
+	result = lineSegmentsIntersect (NSMakePoint (1.0f, 1.0f), NSMakePoint (1.0f, -1.0f),
+	                                NSMakePoint (0.0f, 0.0f), NSMakePoint (1.0f, 0.0f),
+	                                &intersection);
+	TEST (@"Touch at one: has intersection", result);
+	assertPointsEqual (@"Touch at one: intersection value", intersection, NSMakePoint (1.0f, 0.0f));
+
+	endTestBlock(@"lineSegmentsIntersect");
+	[pool drain];
+}
+
+void testLineSegmentIntersectsRect() {
+	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+	startTestBlock(@"lineSegmentIntersectsRect");
+
+	BOOL result = NO;
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (-1.0f, -1.0f),
+			NSMakePoint (0.0f, 0.0f),
+	        NSZeroRect);
+	TEST (@"Zero rect; line touches zero", result);
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (-1.0f, -1.0f),
+			NSMakePoint (-0.1f, -0.1f),
+	        NSZeroRect);
+	TEST (@"Zero rect; line short of zero", !result);
+
+	NSRect rect = NSMakeRect (1.0f, 1.0f, 1.0f, 1.0f);
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (0.0f, 0.0f),
+			NSMakePoint (3.0f, 1.0f),
+	        rect);
+	TEST (@"Line underneath", !result);
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (0.0f, 0.0f),
+			NSMakePoint (1.0f, 3.0f),
+	        rect);
+	TEST (@"Line to left", !result);
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (0.0f, 2.0f),
+			NSMakePoint (3.0f, 3.0f),
+	        rect);
+	TEST (@"Line above", !result);
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (2.0f, 0.0f),
+			NSMakePoint (3.0f, 3.0f),
+	        rect);
+	TEST (@"Line to right", !result);
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (0.0f, 0.0f),
+			NSMakePoint (0.9f, 0.9f),
+	        rect);
+	TEST (@"Line short", !result);
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (1.1f, 1.1f),
+			NSMakePoint (1.9f, 1.9f),
+	        rect);
+	TEST (@"Line inside", result);
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (0.0f, 1.5f),
+			NSMakePoint (3.0f, 1.5f),
+	        rect);
+	TEST (@"Horizontal line through", result);
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (1.5f, 0.0f),
+			NSMakePoint (1.5f, 3.0f),
+	        rect);
+	TEST (@"Vertical line through", result);
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (0.5f, 1.0f),
+			NSMakePoint (2.0f, 2.5f),
+	        rect);
+	TEST (@"Cut top and left", result);
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (2.0f, 0.5f),
+			NSMakePoint (0.5f, 2.0f),
+	        rect);
+	TEST (@"Cut bottom and left", result);
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (1.0f, 0.5f),
+			NSMakePoint (2.5f, 2.0f),
+	        rect);
+	TEST (@"Cut bottom and right", result);
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (0.0f, 1.0f),
+			NSMakePoint (2.0f, 3.0f),
+	        rect);
+	TEST (@"Touch top left", result);
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (1.0f, 0.0f),
+			NSMakePoint (3.0f, 2.0f),
+	        rect);
+	TEST (@"Touch bottom right", result);
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (1.0f, 0.0f),
+			NSMakePoint (1.0f, 3.0f),
+	        rect);
+	TEST (@"Along left side", result);
+
+	result = lineSegmentIntersectsRect (
+			NSMakePoint (0.0f, 1.0f),
+			NSMakePoint (3.0f, 1.0f),
+	        rect);
+	TEST (@"Along bottom side", result);
+
+	endTestBlock(@"lineSegmentIntersectsRect");
+	[pool drain];
+}
+
+struct line_bezier_test {
+	NSString *msg;
+	NSPoint lstart;
+	NSPoint lend;
+	NSPoint c0;
+	NSPoint c1;
+	NSPoint c2;
+	NSPoint c3;
+	BOOL expectedResult;
+	float expectedT;
+	NSPoint expectedIntersect;
+};
+
+static struct line_bezier_test line_bezier_tests[] = {
+	{
+		@"Outside box",
+		{0.0f, 0.0f},
+		{1.0f, 0.0f},
+		{0.0f, 1.0f},
+		{0.0f, 2.0f},
+		{1.0f, 2.0f},
+		{1.0f, 1.0f},
+		NO,
+		-1.0f,
+		{0.0f, 0.0f}
+	},
+	{
+		@"Single intersect",
+		{100.0f, 20.0f},
+		{195.0f, 255.0f},
+		{93.0f, 163.0f},
+		{40.0f, 30.0f},
+		{270.0f, 115.0f},
+		{219.0f, 178.0f},
+		YES,
+		-0.4f,
+		{129.391693f, 92.705772f}
+	},
+	{
+		@"Double intersect",
+		{100.0f, 20.0f},
+		{195.0f, 255.0f},
+		{93.0f, 163.0f},
+		{40.0f, 30.0f},
+		{270.0f, 115.0f},
+		{154.0f, 212.0f},
+		YES,
+		-0.909f,
+		{170.740646f,194.990021f}
+	},
+	{
+		@"Near miss",
+		{100.0f, 20.0f},
+		{195.0f, 255.0f},
+		{93.0f, 163.0f},
+		{40.0f, 30.0f},
+		{176.0f, 100.0f},
+		{154.0f, 212.0f},
+		NO,
+		-1.0f,
+		{0.0f,0.0f}
+	}
+};
+static unsigned int n_line_bezier_tests = sizeof (line_bezier_tests) / sizeof (line_bezier_tests[0]);
+
+void testLineSegmentIntersectsBezier() {
+	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+	startTestBlock(@"lineSegmentIntersectsBezier");
+
+	for (unsigned int i = 0; i < n_line_bezier_tests; ++i) {
+		NSPoint intersect;
+		BOOL result = lineSegmentIntersectsBezier (
+				line_bezier_tests[i].lstart,
+				line_bezier_tests[i].lend,
+				line_bezier_tests[i].c0,
+				line_bezier_tests[i].c1,
+				line_bezier_tests[i].c2,
+				line_bezier_tests[i].c3,
+				&intersect);
+		if (result) {
+			if (line_bezier_tests[i].expectedT < 0.0f) {
+				assertPointsEqual (line_bezier_tests[i].msg, intersect, line_bezier_tests[i].expectedIntersect);
+			} else {
+				assertPointsEqual (line_bezier_tests[i].msg, intersect,
+						bezierInterpolateFull (line_bezier_tests[i].expectedT, line_bezier_tests[i].c0, line_bezier_tests[i].c1, line_bezier_tests[i].c2, line_bezier_tests[i].c3));
+			}
+		} else {
+			if (line_bezier_tests[i].expectedResult)
+				fail (line_bezier_tests[i].msg);
+			else
+				pass (line_bezier_tests[i].msg);
+		}
+	}
+
+BOOL lineSegmentIntersectsBezier (NSPoint lstart, NSPoint lend, NSPoint c0, NSPoint c1, NSPoint c2, NSPoint c3, NSPoint *result);
+	endTestBlock(@"lineSegmentIntersectsBezier");
+	[pool drain];
+}
+
+struct exit_point_test {
+	NSString *msg;
+	NSPoint rayStart;
+	float angle;
+	NSRect rect;
+	NSPoint expected;
+};
+
+static struct exit_point_test exit_point_tests[] = {
+	{
+		@"0.0 rads",
+		{0.0f, 0.0f},
+		0.0f,
+		{{-1.0f, -1.0f}, {2.0f, 2.0f}},
+		{1.0f, 0.0f}
+	},
+	{
+		@"pi/2 rads",
+		{0.0f, 0.0f},
+		M_PI / 2.0f,
+		{{-1.0f, -1.0f}, {2.0f, 2.0f}},
+		{0.0f, 1.0f}
+	},
+	{
+		@"-pi/2 rads",
+		{0.0f, 0.0f},
+		-M_PI / 2.0f,
+		{{-1.0f, -1.0f}, {2.0f, 2.0f}},
+		{0.0f, -1.0f}
+	},
+	{
+		@"pi rads",
+		{0.0f, 0.0f},
+		M_PI,
+		{{-1.0f, -1.0f}, {2.0f, 2.0f}},
+		{-1.0f, 0.0f}
+	},
+	{
+		@"-pi rads",
+		{0.0f, 0.0f},
+		-M_PI,
+		{{-1.0f, -1.0f}, {2.0f, 2.0f}},
+		{-1.0f, 0.0f}
+	},
+	{
+		@"pi/4 rads",
+		{0.0f, 0.0f},
+		M_PI / 4.0f,
+		{{-1.0f, -1.0f}, {2.0f, 2.0f}},
+		{1.0f, 1.0f}
+	},
+	{
+		@"3pi/4 rads",
+		{0.0f, 0.0f},
+		(3.0f * M_PI) / 4.0f,
+		{{-1.0f, -1.0f}, {2.0f, 2.0f}},
+		{-1.0f, 1.0f}
+	},
+	{
+		@"-pi/4 rads",
+		{0.0f, 0.0f},
+		-M_PI / 4.0f,
+		{{-1.0f, -1.0f}, {2.0f, 2.0f}},
+		{1.0f, -1.0f}
+	},
+	{
+		@"-3pi/4 rads",
+		{0.0f, 0.0f},
+		(-3.0f * M_PI) / 4.0f,
+		{{-1.0f, -1.0f}, {2.0f, 2.0f}},
+		{-1.0f, -1.0f}
+	},
+	{
+		@"pi/8 rads",
+		{0.0f, 0.0f},
+		M_PI / 8.0f,
+		{{-1.0f, -1.0f}, {2.0f, 2.0f}},
+		{1.0f, 0.414213562373095f}
+	},
+	{
+		@"3pi/8 rads",
+		{0.0f, 0.0f},
+		3.0f * M_PI / 8.0f,
+		{{-1.0f, -1.0f}, {2.0f, 2.0f}},
+		{0.414213562373095f, 1.0f}
+	},
+	{
+		@"-5pi/8 rads",
+		{0.0f, 0.0f},
+		-5.0f * M_PI / 8.0f,
+		{{-1.0f, -1.0f}, {2.0f, 2.0f}},
+		{-0.414213562373095f, -1.0f}
+	},
+	{
+		@"-7pi/8 rads",
+		{0.0f, 0.0f},
+		-7.0f * M_PI / 8.0f,
+		{{-1.0f, -1.0f}, {2.0f, 2.0f}},
+		{-1.0f, -0.414213562373095f}
+	},
+	{
+		@"pi/8 rads; origin (1,1)",
+		{1.0f, 1.0f},
+		M_PI / 8.0f,
+		{{0.0f, 0.0f}, {2.0f, 2.0f}},
+		{2.0f, 1.414213562373095f}
+	},
+	{
+		@"7pi/8 rads; origin (-2,2)",
+		{-2.0f, 2.0f},
+		7.0f * M_PI / 8.0f,
+		{{-3.0f, 1.0f}, {2.0f, 2.0f}},
+		{-3.0f, 2.414213562373095f}
+	},
+	{
+		@"pi/8 rads; origin (1,1); SW of box",
+		{1.0f, 1.0f},
+		M_PI / 8.0f,
+		{{1.0f, 1.0f}, {1.0f, 1.0f}},
+		{2.0f, 1.414213562373095f}
+	},
+	{
+		@"pi/8 rads; origin (1,1); SE of box",
+		{1.0f, 1.0f},
+		M_PI / 8.0f,
+		{{0.0f, 1.0f}, {1.0f, 1.0f}},
+		{1.0f, 1.0f}
+	},
+	{
+		@"pi/8 rads; origin (1,1); NE of box",
+		{1.0f, 1.0f},
+		M_PI / 8.0f,
+		{{0.0f, 1.0f}, {1.0f, 1.0f}},
+		{1.0f, 1.0f}
+	},
+	{
+		@"pi/8 rads; origin (1,1); NW of box",
+		{1.0f, 1.0f},
+		M_PI / 8.0f,
+		{{1.0f, 0.0f}, {1.0f, 1.0f}},
+		{1.0f, 1.0f}
+	},
+	{
+		@"pi/8 rads; origin (1,1); N of box",
+		{1.0f, 1.0f},
+		M_PI / 8.0f,
+		{{0.5f, 0.0f}, {1.0f, 1.0f}},
+		{1.0f, 1.0f}
+	},
+	{
+		@"7pi/8 rads; origin (1,1); N of box",
+		{1.0f, 1.0f},
+		7.0f * M_PI / 8.0f,
+		{{0.5f, 0.0f}, {1.0f, 1.0f}},
+		{1.0f, 1.0f}
+	},
+	{
+		@"-pi/8 rads; origin (1,1); S of box",
+		{1.0f, 1.0f},
+		-M_PI / 8.0f,
+		{{0.5f, 1.0f}, {1.0f, 1.0f}},
+		{1.0f, 1.0f}
+	},
+	{
+		@"-pi/8 rads; origin (1,1); E of box",
+		{1.0f, 1.0f},
+		-M_PI / 8.0f,
+		{{0.0f, 0.5f}, {1.0f, 1.0f}},
+		{1.0f, 1.0f}
+	},
+	{
+		@"-7pi/8 rads; origin (1,1); W of box",
+		{1.0f, 1.0f},
+		-7.0f * M_PI / 8.0f,
+		{{1.0f, 0.5f}, {1.0f, 1.0f}},
+		{1.0f, 1.0f}
+	},
+	{
+		@"7pi/8 rads; origin (1,1); W of box",
+		{1.0f, 1.0f},
+		7.0f * M_PI / 8.0f,
+		{{1.0f, 0.5f}, {1.0f, 1.0f}},
+		{1.0f, 1.0f}
+	},
+	{
+		@"pi/8 rads; origin (1,1); leave through top",
+		{1.0f, 1.0f},
+		M_PI / 8.0f,
+		{{0.9f, 0.1f}, {1.0f, 1.0f}},
+		{1.2414213562373f, 1.1f}
+	},
+	{
+		@"0 rads; origin (1,1); N of box",
+		{1.0f, 1.0f},
+		0.0f,
+		{{0.5f, 0.0f}, {1.0f, 1.0f}},
+		{1.5f, 1.0f}
+	}
+};
+static unsigned int n_exit_point_tests = sizeof (exit_point_tests) / sizeof (exit_point_tests[0]);
+
+void testFindExitPointOfRay() {
+	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+	startTestBlock(@"findExitPointOfRay");
+
+	for (unsigned int i = 0; i < n_exit_point_tests; ++i) {
+		NSPoint exitPoint = findExitPointOfRay (
+				exit_point_tests[i].rayStart,
+				exit_point_tests[i].angle,
+				exit_point_tests[i].rect);
+		assertPointsEqual (exit_point_tests[i].msg, exitPoint, exit_point_tests[i].expected);
+	}
+
+	endTestBlock(@"findExitPointOfRay");
+	[pool drain];
+}
+
+#ifdef STAND_ALONE
+void runTests() {
+#else
+void testMaths() {
+#endif
+	startTestBlock(@"maths");
+	testRectAroundPoints();
+	testRectAroundPointsWithPadding();
+	testGoodAtan();
+	testBezierInterpolate();
+	testLineSegmentsIntersect();
+	testLineSegmentIntersectsRect();
+	testFindExitPointOfRay();
+	testLineSegmentIntersectsBezier();
+	endTestBlock(@"maths");
+}
+
+// vim:ft=objc:ts=4:sts=4:sw=4:noet
diff --git a/tikzit/src/common/test/parser.m b/tikzit/src/common/test/parser.m
index fc9e76e..29dabe7 100644
--- a/tikzit/src/common/test/parser.m
+++ b/tikzit/src/common/test/parser.m
@@ -23,7 +23,12 @@
 #import "test/test.h"
 #import "TikzGraphAssembler.h"
 
+
+#ifdef STAND_ALONE
+void runTests() {
+#else
 void testParser() {
+#endif
 	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
 	startTestBlock(@"parser");
 	
@@ -75,4 +80,4 @@ void testParser() {
 	endTestBlock(@"parser");
 	
 	[pool drain];
-}
\ No newline at end of file
+}
diff --git a/tikzit/src/common/test/test.h b/tikzit/src/common/test/test.h
index 4fddc92..59dcdd4 100644
--- a/tikzit/src/common/test/test.h
+++ b/tikzit/src/common/test/test.h
@@ -26,8 +26,17 @@
 {}
 @end
 
+BOOL fuzzyCompare (float f1, float f2);
+BOOL fuzzyComparePoints (NSPoint p1, NSPoint p2);
+
 void setColorEnabled(BOOL b);
+
+void pass(NSString *msg);
+void fail(NSString *msg);
 void TEST(NSString *msg, BOOL test);
+void assertRectsEqual (NSString *msg, NSRect val, NSRect exp);
+void assertPointsEqual (NSString *msg, NSPoint val, NSPoint exp);
+void assertFloatsEqual (NSString *msg, float val, float exp);
 
 void startTests();
 void endTests();
@@ -39,3 +48,10 @@ void endTestBlock(NSString *name);
 	NSString *_str = [[NSString alloc] initWithFormat:fmt, ##__VA_ARGS__]; \
 	printf("%s\n", [_str UTF8String]); \
 	[_str release]; }
+
+#define failFmt(fmt, ...) { \
+	NSString *_fstr = [[NSString alloc] initWithFormat:fmt, ##__VA_ARGS__]; \
+	fail(_fstr); \
+	[_fstr release]; }
+
+// vim:ft=objc:ts=4:sts=4:sw=4:noet
diff --git a/tikzit/src/common/test/test.m b/tikzit/src/common/test/test.m
index 5e05c6e..8437646 100644
--- a/tikzit/src/common/test/test.m
+++ b/tikzit/src/common/test/test.m
@@ -57,13 +57,64 @@ static NSString *indents[6] =
 
 @end
 
+BOOL fuzzyCompare(float f1, float f2) {
+	return (ABS(f1 - f2) <= 0.00001f * MAX(1.0f,MIN(ABS(f1), ABS(f2))));
+}
+
+BOOL fuzzyComparePoints (NSPoint p1, NSPoint p2) {
+	return fuzzyCompare (p1.x, p2.x) && fuzzyCompare (p1.y, p2.y);
+}
+
+void pass(NSString *msg) {
+	PUTS(@"%@[%@PASS%@] %@", INDENT, GREEN, OFF, msg);
+	++PASSES;
+}
+
+void fail(NSString *msg) {
+	PUTS(@"%@[%@FAIL%@] %@", INDENT, RED, OFF, msg);
+	++FAILS;
+}
+
 void TEST(NSString *msg, BOOL test) {
 	if (test) {
-		PUTS(@"%@[%@PASS%@] %@", INDENT, GREEN, OFF, msg);
-		++PASSES;
+		pass (msg);
+	} else {
+		fail (msg);
+	}
+}
+
+void assertRectsEqual (NSString *msg, NSRect r1, NSRect r2) {
+	BOOL equal = fuzzyCompare (r1.origin.x, r2.origin.x) &&
+	             fuzzyCompare (r1.origin.y, r2.origin.y) &&
+	             fuzzyCompare (r1.size.width, r2.size.width) &&
+	             fuzzyCompare (r1.size.height, r2.size.height);
+	if (equal) {
+		pass (msg);
+	} else {
+		failFmt(@"%@ (expected (%f,%f:%fx%f) but got (%f,%f:%fx%f))",
+				msg,
+				r2.origin.x, r2.origin.y, r2.size.width, r2.size.height,
+				r1.origin.x, r1.origin.y, r1.size.width, r1.size.height);
+	}
+}
+
+void assertPointsEqual (NSString *msg, NSPoint p1, NSPoint p2) {
+	BOOL equal = fuzzyCompare (p1.x, p2.x) && fuzzyCompare (p1.y, p2.y);
+	if (equal) {
+		pass (msg);
 	} else {
-		PUTS(@"%@[%@FAIL%@] %@", INDENT, RED, OFF, msg);
-		++FAILS;
+		failFmt(@"%@ (expected (%f,%f) but got (%f,%f)",
+				msg,
+				p2.x, p2.y,
+				p1.x, p1.y);
+	}
+}
+
+void assertFloatsEqual (NSString *msg, float f1, float f2) {
+	if (fuzzyCompare (f1, f2)) {
+		pass (msg);
+	} else {
+		failFmt(@"%@ (expected %f but got %f", msg, f2, f1);
 	}
 }
 
@@ -102,3 +153,23 @@ void setColorEnabled(BOOL b) {
 		OFF = @"";
 	}
 }
+
+#ifdef STAND_ALONE
+void runTests();
+
+int main() {
+	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+
+	setColorEnabled (YES);
+	startTests();
+
+	runTests();
+
+	endTests();
+
+	[pool drain];
+	return 0;
+}
+#endif
+
+// vim:ft=objc:ts=4:sts=4:sw=4:noet