Index: src/unittests/LineUnittest.cpp
===================================================================
--- src/unittests/LineUnittest.cpp	(revision be97a841b19bbe05e88f3d3ac69c9cb5cd562f10)
+++ src/unittests/LineUnittest.cpp	(revision 3d078db43513ccb8235950baa165cf56607d9167)
@@ -29,12 +29,12 @@
 void LineUnittest::setUp(){
   // three lines along the axes
-  la1 = new Line(zeroVec,e1);
-  la2 = new Line(zeroVec,e2);
-  la3 = new Line(zeroVec,e3);
+  la1 = new Line(zeroVec,unitVec[0]);
+  la2 = new Line(zeroVec,unitVec[1]);
+  la3 = new Line(zeroVec,unitVec[2]);
 
   // the lines along the planes defined by two coordinate axes
-  lp1 = new Line(e1,e1-e2);
-  lp2 = new Line(e2,e2-e3);
-  lp3 = new Line(e3,e3-e1);
+  lp1 = new Line(unitVec[0],unitVec[0]-unitVec[1]);
+  lp2 = new Line(unitVec[1],unitVec[1]-unitVec[2]);
+  lp3 = new Line(unitVec[2],unitVec[2]-unitVec[0]);
 }
 void LineUnittest::tearDown(){
@@ -52,21 +52,21 @@
 
   // direction+origin should never fail
-  CPPUNIT_ASSERT_NO_THROW(Line(zeroVec,e1));
-  CPPUNIT_ASSERT_NO_THROW(Line(zeroVec,e2));
-  CPPUNIT_ASSERT_NO_THROW(Line(zeroVec,e3));
+  CPPUNIT_ASSERT_NO_THROW(Line(zeroVec,unitVec[0]));
+  CPPUNIT_ASSERT_NO_THROW(Line(zeroVec,unitVec[1]));
+  CPPUNIT_ASSERT_NO_THROW(Line(zeroVec,unitVec[2]));
 
   // two points fails if both points are the same
-  CPPUNIT_ASSERT_NO_THROW(makeLineThrough(e1,e2));
-  CPPUNIT_ASSERT_NO_THROW(makeLineThrough(e2,e3));
-  CPPUNIT_ASSERT_NO_THROW(makeLineThrough(e3,e1));
+  CPPUNIT_ASSERT_NO_THROW(makeLineThrough(unitVec[0],unitVec[1]));
+  CPPUNIT_ASSERT_NO_THROW(makeLineThrough(unitVec[1],unitVec[2]));
+  CPPUNIT_ASSERT_NO_THROW(makeLineThrough(unitVec[2],unitVec[0]));
   // for zerovectors
-  CPPUNIT_ASSERT_NO_THROW(makeLineThrough(e1,zeroVec));
-  CPPUNIT_ASSERT_NO_THROW(makeLineThrough(e2,zeroVec));
-  CPPUNIT_ASSERT_NO_THROW(makeLineThrough(e3,zeroVec));
+  CPPUNIT_ASSERT_NO_THROW(makeLineThrough(unitVec[0],zeroVec));
+  CPPUNIT_ASSERT_NO_THROW(makeLineThrough(unitVec[1],zeroVec));
+  CPPUNIT_ASSERT_NO_THROW(makeLineThrough(unitVec[2],zeroVec));
   // now we pass two times the same point
   CPPUNIT_ASSERT_THROW(makeLineThrough(zeroVec,zeroVec),LinearDependenceException);
-  CPPUNIT_ASSERT_THROW(makeLineThrough(e1,e1),LinearDependenceException);
-  CPPUNIT_ASSERT_THROW(makeLineThrough(e2,e2),LinearDependenceException);
-  CPPUNIT_ASSERT_THROW(makeLineThrough(e3,e3),LinearDependenceException);
+  CPPUNIT_ASSERT_THROW(makeLineThrough(unitVec[0],unitVec[0]),LinearDependenceException);
+  CPPUNIT_ASSERT_THROW(makeLineThrough(unitVec[1],unitVec[1]),LinearDependenceException);
+  CPPUNIT_ASSERT_THROW(makeLineThrough(unitVec[2],unitVec[2]),LinearDependenceException);
 
 }
@@ -78,7 +78,7 @@
 void LineUnittest::constructionResultTest(){
   // test all directions
-  CPPUNIT_ASSERT(testDirection(la1->getDirection(),e1));
-  CPPUNIT_ASSERT(testDirection(la2->getDirection(),e2));
-  CPPUNIT_ASSERT(testDirection(la3->getDirection(),e3));
+  CPPUNIT_ASSERT(testDirection(la1->getDirection(),unitVec[0]));
+  CPPUNIT_ASSERT(testDirection(la2->getDirection(),unitVec[1]));
+  CPPUNIT_ASSERT(testDirection(la3->getDirection(),unitVec[2]));
 
   // test origins
@@ -92,15 +92,15 @@
   CPPUNIT_ASSERT(la3->isContained(zeroVec));
 
-  CPPUNIT_ASSERT(la1->isContained(e1));
-  CPPUNIT_ASSERT(la2->isContained(e2));
-  CPPUNIT_ASSERT(la3->isContained(e3));
-
-  CPPUNIT_ASSERT(lp1->isContained(e1));
-  CPPUNIT_ASSERT(lp2->isContained(e2));
-  CPPUNIT_ASSERT(lp3->isContained(e3));
-
-  CPPUNIT_ASSERT(lp1->isContained(e2));
-  CPPUNIT_ASSERT(lp2->isContained(e3));
-  CPPUNIT_ASSERT(lp3->isContained(e1));
+  CPPUNIT_ASSERT(la1->isContained(unitVec[0]));
+  CPPUNIT_ASSERT(la2->isContained(unitVec[1]));
+  CPPUNIT_ASSERT(la3->isContained(unitVec[2]));
+
+  CPPUNIT_ASSERT(lp1->isContained(unitVec[0]));
+  CPPUNIT_ASSERT(lp2->isContained(unitVec[1]));
+  CPPUNIT_ASSERT(lp3->isContained(unitVec[2]));
+
+  CPPUNIT_ASSERT(lp1->isContained(unitVec[1]));
+  CPPUNIT_ASSERT(lp2->isContained(unitVec[2]));
+  CPPUNIT_ASSERT(lp3->isContained(unitVec[0]));
 }
 
@@ -112,54 +112,54 @@
 
   // multiples of the second support vector
-  CPPUNIT_ASSERT(la1->isContained(e1));
-  CPPUNIT_ASSERT(la2->isContained(e2));
-  CPPUNIT_ASSERT(la3->isContained(e3));
-
-  CPPUNIT_ASSERT(la1->isContained(2*e1));
-  CPPUNIT_ASSERT(la2->isContained(2*e2));
-  CPPUNIT_ASSERT(la3->isContained(2*e3));
-
-  CPPUNIT_ASSERT(la1->isContained(3*e1));
-  CPPUNIT_ASSERT(la2->isContained(3*e2));
-  CPPUNIT_ASSERT(la3->isContained(3*e3));
+  CPPUNIT_ASSERT(la1->isContained(unitVec[0]));
+  CPPUNIT_ASSERT(la2->isContained(unitVec[1]));
+  CPPUNIT_ASSERT(la3->isContained(unitVec[2]));
+
+  CPPUNIT_ASSERT(la1->isContained(2*unitVec[0]));
+  CPPUNIT_ASSERT(la2->isContained(2*unitVec[1]));
+  CPPUNIT_ASSERT(la3->isContained(2*unitVec[2]));
+
+  CPPUNIT_ASSERT(la1->isContained(3*unitVec[0]));
+  CPPUNIT_ASSERT(la2->isContained(3*unitVec[1]));
+  CPPUNIT_ASSERT(la3->isContained(3*unitVec[2]));
 
   // negative multiples
-  CPPUNIT_ASSERT(la1->isContained(-1*e1));
-  CPPUNIT_ASSERT(la2->isContained(-1*e2));
-  CPPUNIT_ASSERT(la3->isContained(-1*e3));
-
-  CPPUNIT_ASSERT(la1->isContained(-2*e1));
-  CPPUNIT_ASSERT(la2->isContained(-2*e2));
-  CPPUNIT_ASSERT(la3->isContained(-2*e3));
+  CPPUNIT_ASSERT(la1->isContained(-1*unitVec[0]));
+  CPPUNIT_ASSERT(la2->isContained(-1*unitVec[1]));
+  CPPUNIT_ASSERT(la3->isContained(-1*unitVec[2]));
+
+  CPPUNIT_ASSERT(la1->isContained(-2*unitVec[0]));
+  CPPUNIT_ASSERT(la2->isContained(-2*unitVec[1]));
+  CPPUNIT_ASSERT(la3->isContained(-2*unitVec[2]));
 
   // points that should not be on the lines
-  CPPUNIT_ASSERT(!la1->isContained(e2));
-  CPPUNIT_ASSERT(!la2->isContained(e3));
-  CPPUNIT_ASSERT(!la3->isContained(e1));
-
-  CPPUNIT_ASSERT(!la1->isContained(2*e2));
-  CPPUNIT_ASSERT(!la2->isContained(2*e3));
-  CPPUNIT_ASSERT(!la3->isContained(2*e1));
-
-  CPPUNIT_ASSERT(!la1->isContained(-1*e2));
-  CPPUNIT_ASSERT(!la2->isContained(-1*e3));
-  CPPUNIT_ASSERT(!la3->isContained(-1*e1));
+  CPPUNIT_ASSERT(!la1->isContained(unitVec[1]));
+  CPPUNIT_ASSERT(!la2->isContained(unitVec[2]));
+  CPPUNIT_ASSERT(!la3->isContained(unitVec[0]));
+
+  CPPUNIT_ASSERT(!la1->isContained(2*unitVec[1]));
+  CPPUNIT_ASSERT(!la2->isContained(2*unitVec[2]));
+  CPPUNIT_ASSERT(!la3->isContained(2*unitVec[0]));
+
+  CPPUNIT_ASSERT(!la1->isContained(-1*unitVec[1]));
+  CPPUNIT_ASSERT(!la2->isContained(-1*unitVec[2]));
+  CPPUNIT_ASSERT(!la3->isContained(-1*unitVec[0]));
 
   // For the plane lines
-  CPPUNIT_ASSERT(lp1->isContained(e1));
-  CPPUNIT_ASSERT(lp2->isContained(e2));
-  CPPUNIT_ASSERT(lp3->isContained(e3));
-
-  CPPUNIT_ASSERT(lp1->isContained(e2));
-  CPPUNIT_ASSERT(lp2->isContained(e3));
-  CPPUNIT_ASSERT(lp3->isContained(e1));
-
-  CPPUNIT_ASSERT(lp1->isContained(e1+2*(e1-e2)));
-  CPPUNIT_ASSERT(lp2->isContained(e2+2*(e2-e3)));
-  CPPUNIT_ASSERT(lp3->isContained(e3+2*(e3-e1)));
-
-  CPPUNIT_ASSERT(lp1->isContained(e1-2*(e1-e2)));
-  CPPUNIT_ASSERT(lp2->isContained(e2-2*(e2-e3)));
-  CPPUNIT_ASSERT(lp3->isContained(e3-2*(e3-e1)));
+  CPPUNIT_ASSERT(lp1->isContained(unitVec[0]));
+  CPPUNIT_ASSERT(lp2->isContained(unitVec[1]));
+  CPPUNIT_ASSERT(lp3->isContained(unitVec[2]));
+
+  CPPUNIT_ASSERT(lp1->isContained(unitVec[1]));
+  CPPUNIT_ASSERT(lp2->isContained(unitVec[2]));
+  CPPUNIT_ASSERT(lp3->isContained(unitVec[0]));
+
+  CPPUNIT_ASSERT(lp1->isContained(unitVec[0]+2*(unitVec[0]-unitVec[1])));
+  CPPUNIT_ASSERT(lp2->isContained(unitVec[1]+2*(unitVec[1]-unitVec[2])));
+  CPPUNIT_ASSERT(lp3->isContained(unitVec[2]+2*(unitVec[2]-unitVec[0])));
+
+  CPPUNIT_ASSERT(lp1->isContained(unitVec[0]-2*(unitVec[0]-unitVec[1])));
+  CPPUNIT_ASSERT(lp2->isContained(unitVec[1]-2*(unitVec[1]-unitVec[2])));
+  CPPUNIT_ASSERT(lp3->isContained(unitVec[2]-2*(unitVec[2]-unitVec[0])));
 }
 
@@ -177,24 +177,24 @@
   // axes and plane lines
   fixture = la1->getIntersection(*lp1);
-  CPPUNIT_ASSERT_EQUAL(fixture,e1);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[0]);
   fixture = la2->getIntersection(*lp2);
-  CPPUNIT_ASSERT_EQUAL(fixture,e2);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[1]);
   fixture = la3->getIntersection(*lp3);
-  CPPUNIT_ASSERT_EQUAL(fixture,e3);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[2]);
 
   fixture = la1->getIntersection(*lp3);
-  CPPUNIT_ASSERT_EQUAL(fixture,e1);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[0]);
   fixture = la2->getIntersection(*lp1);
-  CPPUNIT_ASSERT_EQUAL(fixture,e2);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[1]);
   fixture = la3->getIntersection(*lp2);
-  CPPUNIT_ASSERT_EQUAL(fixture,e3);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[2]);
 
   // two plane lines
   fixture = lp1->getIntersection(*lp2);
-  CPPUNIT_ASSERT_EQUAL(fixture,e2);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[1]);
   fixture = lp2->getIntersection(*lp3);
-  CPPUNIT_ASSERT_EQUAL(fixture,e3);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[2]);
   fixture = lp3->getIntersection(*lp1);
-  CPPUNIT_ASSERT_EQUAL(fixture,e1);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[0]);
 
   // When we have two times the same line, we check if the point is on the line
@@ -242,80 +242,80 @@
 
   // rotate vectors on the axis around their lines
-  fixture = la1->rotateVector(e1,1.);
-  CPPUNIT_ASSERT_EQUAL(fixture,e1);
-  fixture = la2->rotateVector(e2,1.);
-  CPPUNIT_ASSERT_EQUAL(fixture,e2);
-  fixture = la3->rotateVector(e3,1.);
-  CPPUNIT_ASSERT_EQUAL(fixture,e3);
-
-  fixture = la1->rotateVector(e1,2.);
-  CPPUNIT_ASSERT_EQUAL(fixture,e1);
-  fixture = la2->rotateVector(e2,2.);
-  CPPUNIT_ASSERT_EQUAL(fixture,e2);
-  fixture = la3->rotateVector(e3,2.);
-  CPPUNIT_ASSERT_EQUAL(fixture,e3);
+  fixture = la1->rotateVector(unitVec[0],1.);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[0]);
+  fixture = la2->rotateVector(unitVec[1],1.);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[1]);
+  fixture = la3->rotateVector(unitVec[2],1.);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[2]);
+
+  fixture = la1->rotateVector(unitVec[0],2.);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[0]);
+  fixture = la2->rotateVector(unitVec[1],2.);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[1]);
+  fixture = la3->rotateVector(unitVec[2],2.);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[2]);
 
   // more vectors on the axis
-  fixture = la1->rotateVector(2*e1,1.);
-  CPPUNIT_ASSERT_EQUAL(fixture,2*e1);
-  fixture = la2->rotateVector(2*e2,1.);
-  CPPUNIT_ASSERT_EQUAL(fixture,2*e2);
-  fixture = la3->rotateVector(2*e3,1.);
-  CPPUNIT_ASSERT_EQUAL(fixture,2*e3);
-
-  fixture = la1->rotateVector(2*e1,2.);
-  CPPUNIT_ASSERT_EQUAL(fixture,2*e1);
-  fixture = la2->rotateVector(2*e2,2.);
-  CPPUNIT_ASSERT_EQUAL(fixture,2*e2);
-  fixture = la3->rotateVector(2*e3,2.);
-  CPPUNIT_ASSERT_EQUAL(fixture,2*e3);
+  fixture = la1->rotateVector(2*unitVec[0],1.);
+  CPPUNIT_ASSERT_EQUAL(fixture,2*unitVec[0]);
+  fixture = la2->rotateVector(2*unitVec[1],1.);
+  CPPUNIT_ASSERT_EQUAL(fixture,2*unitVec[1]);
+  fixture = la3->rotateVector(2*unitVec[2],1.);
+  CPPUNIT_ASSERT_EQUAL(fixture,2*unitVec[2]);
+
+  fixture = la1->rotateVector(2*unitVec[0],2.);
+  CPPUNIT_ASSERT_EQUAL(fixture,2*unitVec[0]);
+  fixture = la2->rotateVector(2*unitVec[1],2.);
+  CPPUNIT_ASSERT_EQUAL(fixture,2*unitVec[1]);
+  fixture = la3->rotateVector(2*unitVec[2],2.);
+  CPPUNIT_ASSERT_EQUAL(fixture,2*unitVec[2]);
 
   // negative factors
-  fixture = la1->rotateVector(-1*e1,1.);
-  CPPUNIT_ASSERT_EQUAL(fixture,-1*e1);
-  fixture = la2->rotateVector(-1*e2,1.);
-  CPPUNIT_ASSERT_EQUAL(fixture,-1*e2);
-  fixture = la3->rotateVector(-1*e3,1.);
-  CPPUNIT_ASSERT_EQUAL(fixture,-1*e3);
-
-  fixture = la1->rotateVector(-1*e1,2.);
-  CPPUNIT_ASSERT_EQUAL(fixture,-1*e1);
-  fixture = la2->rotateVector(-1*e2,2.);
-  CPPUNIT_ASSERT_EQUAL(fixture,-1*e2);
-  fixture = la3->rotateVector(-1*e3,2.);
-  CPPUNIT_ASSERT_EQUAL(fixture,-1*e3);
+  fixture = la1->rotateVector(-1*unitVec[0],1.);
+  CPPUNIT_ASSERT_EQUAL(fixture,-1*unitVec[0]);
+  fixture = la2->rotateVector(-1*unitVec[1],1.);
+  CPPUNIT_ASSERT_EQUAL(fixture,-1*unitVec[1]);
+  fixture = la3->rotateVector(-1*unitVec[2],1.);
+  CPPUNIT_ASSERT_EQUAL(fixture,-1*unitVec[2]);
+
+  fixture = la1->rotateVector(-1*unitVec[0],2.);
+  CPPUNIT_ASSERT_EQUAL(fixture,-1*unitVec[0]);
+  fixture = la2->rotateVector(-1*unitVec[1],2.);
+  CPPUNIT_ASSERT_EQUAL(fixture,-1*unitVec[1]);
+  fixture = la3->rotateVector(-1*unitVec[2],2.);
+  CPPUNIT_ASSERT_EQUAL(fixture,-1*unitVec[2]);
 
 
 
   // now the real rotations
-  // e2 around e1
-  fixture = la1->rotateVector(e2,0);
-  CPPUNIT_ASSERT_EQUAL(fixture,e2);
-  fixture = la1->rotateVector(e2,1./2.*M_PI);
-  CPPUNIT_ASSERT_EQUAL(fixture,-1*e3);
-  fixture = la1->rotateVector(e2,M_PI);
-  CPPUNIT_ASSERT_EQUAL(fixture,-1*e2);
-  fixture = la1->rotateVector(e2,2*M_PI);
-  CPPUNIT_ASSERT_EQUAL(fixture,e2);
-
-  // e3 around e2
-  fixture = la2->rotateVector(e3,0);
-  CPPUNIT_ASSERT_EQUAL(fixture,e3);
-  fixture = la2->rotateVector(e3,1./2.*M_PI);
-  CPPUNIT_ASSERT_EQUAL(fixture,-1*e1);
-  fixture = la2->rotateVector(e3,M_PI);
-  CPPUNIT_ASSERT_EQUAL(fixture,-1*e3);
-  fixture = la2->rotateVector(e3,2*M_PI);
-  CPPUNIT_ASSERT_EQUAL(fixture,e3);
-
-  // e1 around e3
-  fixture = la3->rotateVector(e1,0);
-  CPPUNIT_ASSERT_EQUAL(fixture,e1);
-  fixture = la3->rotateVector(e1,1./2.*M_PI);
-  CPPUNIT_ASSERT_EQUAL(fixture,-1*e2);
-  fixture = la3->rotateVector(e1,M_PI);
-  CPPUNIT_ASSERT_EQUAL(fixture,-1*e1);
-  fixture = la3->rotateVector(e1,2*M_PI);
-  CPPUNIT_ASSERT_EQUAL(fixture,e1);
+  // unitVec[1] around unitVec[0]
+  fixture = la1->rotateVector(unitVec[1],0);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[1]);
+  fixture = la1->rotateVector(unitVec[1],1./2.*M_PI);
+  CPPUNIT_ASSERT_EQUAL(fixture,-1*unitVec[2]);
+  fixture = la1->rotateVector(unitVec[1],M_PI);
+  CPPUNIT_ASSERT_EQUAL(fixture,-1*unitVec[1]);
+  fixture = la1->rotateVector(unitVec[1],2*M_PI);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[1]);
+
+  // unitVec[2] around unitVec[1]
+  fixture = la2->rotateVector(unitVec[2],0);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[2]);
+  fixture = la2->rotateVector(unitVec[2],1./2.*M_PI);
+  CPPUNIT_ASSERT_EQUAL(fixture,-1*unitVec[0]);
+  fixture = la2->rotateVector(unitVec[2],M_PI);
+  CPPUNIT_ASSERT_EQUAL(fixture,-1*unitVec[2]);
+  fixture = la2->rotateVector(unitVec[2],2*M_PI);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[2]);
+
+  // unitVec[0] around unitVec[2]
+  fixture = la3->rotateVector(unitVec[0],0);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[0]);
+  fixture = la3->rotateVector(unitVec[0],1./2.*M_PI);
+  CPPUNIT_ASSERT_EQUAL(fixture,-1*unitVec[1]);
+  fixture = la3->rotateVector(unitVec[0],M_PI);
+  CPPUNIT_ASSERT_EQUAL(fixture,-1*unitVec[0]);
+  fixture = la3->rotateVector(unitVec[0],2*M_PI);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[0]);
 
 
@@ -323,18 +323,18 @@
 
   // Vectors on the line
-  fixture = lp1->rotateVector(e1,1.);
-  CPPUNIT_ASSERT_EQUAL(fixture,e1);
-  fixture = lp1->rotateVector(e2,1.);
-  CPPUNIT_ASSERT_EQUAL(fixture,e2);
-
-  fixture = lp2->rotateVector(e2,1.);
-  CPPUNIT_ASSERT_EQUAL(fixture,e2);
-  fixture = lp2->rotateVector(e3,1.);
-  CPPUNIT_ASSERT_EQUAL(fixture,e3);
-
-  fixture = lp3->rotateVector(e3,1.);
-  CPPUNIT_ASSERT_EQUAL(fixture,e3);
-  fixture = lp3->rotateVector(e1,1.);
-  CPPUNIT_ASSERT_EQUAL(fixture,e1);
+  fixture = lp1->rotateVector(unitVec[0],1.);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[0]);
+  fixture = lp1->rotateVector(unitVec[1],1.);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[1]);
+
+  fixture = lp2->rotateVector(unitVec[1],1.);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[1]);
+  fixture = lp2->rotateVector(unitVec[2],1.);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[2]);
+
+  fixture = lp3->rotateVector(unitVec[2],1.);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[2]);
+  fixture = lp3->rotateVector(unitVec[0],1.);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[0]);
 
   // the real stuff
@@ -358,6 +358,6 @@
     std::vector<Vector> res = la1->getSphereIntersections();
     CPPUNIT_ASSERT_EQUAL(res.size(),(size_t)2);
-    CPPUNIT_ASSERT(testDirection(res[0],e1));
-    CPPUNIT_ASSERT(testDirection(res[1],e1));
+    CPPUNIT_ASSERT(testDirection(res[0],unitVec[0]));
+    CPPUNIT_ASSERT(testDirection(res[1],unitVec[0]));
     CPPUNIT_ASSERT(res[0]!=res[1]);
   }
@@ -366,6 +366,6 @@
     std::vector<Vector> res = la2->getSphereIntersections();
     CPPUNIT_ASSERT_EQUAL(res.size(),(size_t)2);
-    CPPUNIT_ASSERT(testDirection(res[0],e2));
-    CPPUNIT_ASSERT(testDirection(res[1],e2));
+    CPPUNIT_ASSERT(testDirection(res[0],unitVec[1]));
+    CPPUNIT_ASSERT(testDirection(res[1],unitVec[1]));
     CPPUNIT_ASSERT(res[0]!=res[1]);
   }
@@ -374,6 +374,6 @@
     std::vector<Vector> res = la3->getSphereIntersections();
     CPPUNIT_ASSERT_EQUAL(res.size(),(size_t)2);
-    CPPUNIT_ASSERT(testDirection(res[0],e3));
-    CPPUNIT_ASSERT(testDirection(res[1],e3));
+    CPPUNIT_ASSERT(testDirection(res[0],unitVec[2]));
+    CPPUNIT_ASSERT(testDirection(res[1],unitVec[2]));
     CPPUNIT_ASSERT(res[0]!=res[1]);
   }
@@ -382,6 +382,6 @@
     std::vector<Vector> res = lp1->getSphereIntersections();
     CPPUNIT_ASSERT_EQUAL(res.size(),(size_t)2);
-    CPPUNIT_ASSERT((res[0]==e1) || (res[0]==e2));
-    CPPUNIT_ASSERT((res[1]==e1) || (res[1]==e2));
+    CPPUNIT_ASSERT((res[0]==unitVec[0]) || (res[0]==unitVec[1]));
+    CPPUNIT_ASSERT((res[1]==unitVec[0]) || (res[1]==unitVec[1]));
     CPPUNIT_ASSERT(res[0]!=res[1]);
   }
@@ -390,6 +390,6 @@
     std::vector<Vector> res = lp2->getSphereIntersections();
     CPPUNIT_ASSERT_EQUAL(res.size(),(size_t)2);
-    CPPUNIT_ASSERT((res[0]==e2) || (res[0]==e3));
-    CPPUNIT_ASSERT((res[1]==e2) || (res[1]==e3));
+    CPPUNIT_ASSERT((res[0]==unitVec[1]) || (res[0]==unitVec[2]));
+    CPPUNIT_ASSERT((res[1]==unitVec[1]) || (res[1]==unitVec[2]));
     CPPUNIT_ASSERT(res[0]!=res[1]);
   }
@@ -398,7 +398,7 @@
     std::vector<Vector> res = lp3->getSphereIntersections();
     CPPUNIT_ASSERT_EQUAL(res.size(),(size_t)2);
-    CPPUNIT_ASSERT((res[0]==e3) || (res[0]==e1));
-    CPPUNIT_ASSERT((res[1]==e3) || (res[1]==e1));
-    CPPUNIT_ASSERT(res[0]!=res[1]);
-  }
-}
+    CPPUNIT_ASSERT((res[0]==unitVec[2]) || (res[0]==unitVec[0]));
+    CPPUNIT_ASSERT((res[1]==unitVec[2]) || (res[1]==unitVec[0]));
+    CPPUNIT_ASSERT(res[0]!=res[1]);
+  }
+}
Index: src/unittests/MatrixUnittest.cpp
===================================================================
--- src/unittests/MatrixUnittest.cpp	(revision be97a841b19bbe05e88f3d3ac69c9cb5cd562f10)
+++ src/unittests/MatrixUnittest.cpp	(revision 3d078db43513ccb8235950baa165cf56607d9167)
@@ -39,28 +39,28 @@
   }
   perm1 = new Matrix();
-  perm1->column(0) = e1;
-  perm1->column(1) = e3;
-  perm1->column(2) = e2;
+  perm1->column(0) = unitVec[0];
+  perm1->column(1) = unitVec[2];
+  perm1->column(2) = unitVec[1];
 
 
   perm2 = new Matrix();
-  perm2->column(0) = e2;
-  perm2->column(1) = e1;
-  perm2->column(2) = e3;
+  perm2->column(0) = unitVec[1];
+  perm2->column(1) = unitVec[0];
+  perm2->column(2) = unitVec[2];
 
   perm3 = new Matrix();
-  perm3->column(0) = e2;
-  perm3->column(1) = e3;
-  perm3->column(2) = e1;
+  perm3->column(0) = unitVec[1];
+  perm3->column(1) = unitVec[2];
+  perm3->column(2) = unitVec[0];
 
   perm4 = new Matrix();
-  perm4->column(0) = e3;
-  perm4->column(1) = e2;
-  perm4->column(2) = e1;
+  perm4->column(0) = unitVec[2];
+  perm4->column(1) = unitVec[1];
+  perm4->column(2) = unitVec[0];
 
   perm5 = new Matrix();
-  perm5->column(0) = e3;
-  perm5->column(1) = e1;
-  perm5->column(2) = e2;
+  perm5->column(0) = unitVec[2];
+  perm5->column(1) = unitVec[0];
+  perm5->column(2) = unitVec[1];
 
 }
@@ -108,10 +108,10 @@
 
   mat.one();
-  CPPUNIT_ASSERT_EQUAL(mat.row(0),e1);
-  CPPUNIT_ASSERT_EQUAL(mat.row(1),e2);
-  CPPUNIT_ASSERT_EQUAL(mat.row(2),e3);
-  CPPUNIT_ASSERT_EQUAL(mat.column(0),e1);
-  CPPUNIT_ASSERT_EQUAL(mat.column(1),e2);
-  CPPUNIT_ASSERT_EQUAL(mat.column(2),e3);
+  CPPUNIT_ASSERT_EQUAL(mat.row(0),unitVec[0]);
+  CPPUNIT_ASSERT_EQUAL(mat.row(1),unitVec[1]);
+  CPPUNIT_ASSERT_EQUAL(mat.row(2),unitVec[2]);
+  CPPUNIT_ASSERT_EQUAL(mat.column(0),unitVec[0]);
+  CPPUNIT_ASSERT_EQUAL(mat.column(1),unitVec[1]);
+  CPPUNIT_ASSERT_EQUAL(mat.column(2),unitVec[2]);
 
   Vector t1=Vector(1.,1.,1.);
@@ -204,23 +204,23 @@
 
   res = (*diagonal)*(*perm1);
-  CPPUNIT_ASSERT_EQUAL(res.column(0),e1);
-  CPPUNIT_ASSERT_EQUAL(res.column(1),3*e3);
-  CPPUNIT_ASSERT_EQUAL(res.column(2),2*e2);
+  CPPUNIT_ASSERT_EQUAL(res.column(0),unitVec[0]);
+  CPPUNIT_ASSERT_EQUAL(res.column(1),3*unitVec[2]);
+  CPPUNIT_ASSERT_EQUAL(res.column(2),2*unitVec[1]);
   res = (*diagonal)*(*perm2);
-  CPPUNIT_ASSERT_EQUAL(res.column(0),2*e2);
-  CPPUNIT_ASSERT_EQUAL(res.column(1),e1);
-  CPPUNIT_ASSERT_EQUAL(res.column(2),3*e3);
+  CPPUNIT_ASSERT_EQUAL(res.column(0),2*unitVec[1]);
+  CPPUNIT_ASSERT_EQUAL(res.column(1),unitVec[0]);
+  CPPUNIT_ASSERT_EQUAL(res.column(2),3*unitVec[2]);
   res = (*diagonal)*(*perm3);
-  CPPUNIT_ASSERT_EQUAL(res.column(0),2*e2);
-  CPPUNIT_ASSERT_EQUAL(res.column(1),3*e3);
-  CPPUNIT_ASSERT_EQUAL(res.column(2),e1);
+  CPPUNIT_ASSERT_EQUAL(res.column(0),2*unitVec[1]);
+  CPPUNIT_ASSERT_EQUAL(res.column(1),3*unitVec[2]);
+  CPPUNIT_ASSERT_EQUAL(res.column(2),unitVec[0]);
   res = (*diagonal)*(*perm4);
-  CPPUNIT_ASSERT_EQUAL(res.column(0),3*e3);
-  CPPUNIT_ASSERT_EQUAL(res.column(1),2*e2);
-  CPPUNIT_ASSERT_EQUAL(res.column(2),e1);
+  CPPUNIT_ASSERT_EQUAL(res.column(0),3*unitVec[2]);
+  CPPUNIT_ASSERT_EQUAL(res.column(1),2*unitVec[1]);
+  CPPUNIT_ASSERT_EQUAL(res.column(2),unitVec[0]);
   res = (*diagonal)*(*perm5);
-  CPPUNIT_ASSERT_EQUAL(res.column(0),3*e3);
-  CPPUNIT_ASSERT_EQUAL(res.column(1),e1);
-  CPPUNIT_ASSERT_EQUAL(res.column(2),2*e2);
+  CPPUNIT_ASSERT_EQUAL(res.column(0),3*unitVec[2]);
+  CPPUNIT_ASSERT_EQUAL(res.column(1),unitVec[0]);
+  CPPUNIT_ASSERT_EQUAL(res.column(2),2*unitVec[1]);
 }
 
@@ -261,42 +261,42 @@
 
 void MatrixUnittest::VecMultTest(){
-  CPPUNIT_ASSERT_EQUAL((*zero)*e1,zeroVec);
-  CPPUNIT_ASSERT_EQUAL((*zero)*e2,zeroVec);
-  CPPUNIT_ASSERT_EQUAL((*zero)*e3,zeroVec);
+  CPPUNIT_ASSERT_EQUAL((*zero)*unitVec[0],zeroVec);
+  CPPUNIT_ASSERT_EQUAL((*zero)*unitVec[1],zeroVec);
+  CPPUNIT_ASSERT_EQUAL((*zero)*unitVec[2],zeroVec);
   CPPUNIT_ASSERT_EQUAL((*zero)*zeroVec,zeroVec);
 
-  CPPUNIT_ASSERT_EQUAL((*one)*e1,e1);
-  CPPUNIT_ASSERT_EQUAL((*one)*e2,e2);
-  CPPUNIT_ASSERT_EQUAL((*one)*e3,e3);
+  CPPUNIT_ASSERT_EQUAL((*one)*unitVec[0],unitVec[0]);
+  CPPUNIT_ASSERT_EQUAL((*one)*unitVec[1],unitVec[1]);
+  CPPUNIT_ASSERT_EQUAL((*one)*unitVec[2],unitVec[2]);
   CPPUNIT_ASSERT_EQUAL((*one)*zeroVec,zeroVec);
 
-  CPPUNIT_ASSERT_EQUAL((*diagonal)*e1,e1);
-  CPPUNIT_ASSERT_EQUAL((*diagonal)*e2,2*e2);
-  CPPUNIT_ASSERT_EQUAL((*diagonal)*e3,3*e3);
+  CPPUNIT_ASSERT_EQUAL((*diagonal)*unitVec[0],unitVec[0]);
+  CPPUNIT_ASSERT_EQUAL((*diagonal)*unitVec[1],2*unitVec[1]);
+  CPPUNIT_ASSERT_EQUAL((*diagonal)*unitVec[2],3*unitVec[2]);
   CPPUNIT_ASSERT_EQUAL((*diagonal)*zeroVec,zeroVec);
 
-  CPPUNIT_ASSERT_EQUAL((*perm1)*e1,e1);
-  CPPUNIT_ASSERT_EQUAL((*perm1)*e2,e3);
-  CPPUNIT_ASSERT_EQUAL((*perm1)*e3,e2);
+  CPPUNIT_ASSERT_EQUAL((*perm1)*unitVec[0],unitVec[0]);
+  CPPUNIT_ASSERT_EQUAL((*perm1)*unitVec[1],unitVec[2]);
+  CPPUNIT_ASSERT_EQUAL((*perm1)*unitVec[2],unitVec[1]);
   CPPUNIT_ASSERT_EQUAL((*perm1)*zeroVec,zeroVec);
 
-  CPPUNIT_ASSERT_EQUAL((*perm2)*e1,e2);
-  CPPUNIT_ASSERT_EQUAL((*perm2)*e2,e1);
-  CPPUNIT_ASSERT_EQUAL((*perm2)*e3,e3);
+  CPPUNIT_ASSERT_EQUAL((*perm2)*unitVec[0],unitVec[1]);
+  CPPUNIT_ASSERT_EQUAL((*perm2)*unitVec[1],unitVec[0]);
+  CPPUNIT_ASSERT_EQUAL((*perm2)*unitVec[2],unitVec[2]);
   CPPUNIT_ASSERT_EQUAL((*perm2)*zeroVec,zeroVec);
 
-  CPPUNIT_ASSERT_EQUAL((*perm3)*e1,e2);
-  CPPUNIT_ASSERT_EQUAL((*perm3)*e2,e3);
-  CPPUNIT_ASSERT_EQUAL((*perm3)*e3,e1);
+  CPPUNIT_ASSERT_EQUAL((*perm3)*unitVec[0],unitVec[1]);
+  CPPUNIT_ASSERT_EQUAL((*perm3)*unitVec[1],unitVec[2]);
+  CPPUNIT_ASSERT_EQUAL((*perm3)*unitVec[2],unitVec[0]);
   CPPUNIT_ASSERT_EQUAL((*perm3)*zeroVec,zeroVec);
 
-  CPPUNIT_ASSERT_EQUAL((*perm4)*e1,e3);
-  CPPUNIT_ASSERT_EQUAL((*perm4)*e2,e2);
-  CPPUNIT_ASSERT_EQUAL((*perm4)*e3,e1);
+  CPPUNIT_ASSERT_EQUAL((*perm4)*unitVec[0],unitVec[2]);
+  CPPUNIT_ASSERT_EQUAL((*perm4)*unitVec[1],unitVec[1]);
+  CPPUNIT_ASSERT_EQUAL((*perm4)*unitVec[2],unitVec[0]);
   CPPUNIT_ASSERT_EQUAL((*perm4)*zeroVec,zeroVec);
 
-  CPPUNIT_ASSERT_EQUAL((*perm5)*e1,e3);
-  CPPUNIT_ASSERT_EQUAL((*perm5)*e2,e1);
-  CPPUNIT_ASSERT_EQUAL((*perm5)*e3,e2);
+  CPPUNIT_ASSERT_EQUAL((*perm5)*unitVec[0],unitVec[2]);
+  CPPUNIT_ASSERT_EQUAL((*perm5)*unitVec[1],unitVec[0]);
+  CPPUNIT_ASSERT_EQUAL((*perm5)*unitVec[2],unitVec[1]);
   CPPUNIT_ASSERT_EQUAL((*perm5)*zeroVec,zeroVec);
 
Index: src/unittests/PlaneUnittest.cpp
===================================================================
--- src/unittests/PlaneUnittest.cpp	(revision be97a841b19bbe05e88f3d3ac69c9cb5cd562f10)
+++ src/unittests/PlaneUnittest.cpp	(revision 3d078db43513ccb8235950baa165cf56607d9167)
@@ -24,8 +24,8 @@
 
 void PlaneUnittest::setUp(){
-  p1 = new Plane(e1,e2,e3);
-  p2 = new Plane(e1,e2,zeroVec);
-  p3 = new Plane(e1,zeroVec,e3);
-  p4 = new Plane(zeroVec,e2,e3);
+  p1 = new Plane(unitVec[0],unitVec[1],unitVec[2]);
+  p2 = new Plane(unitVec[0],unitVec[1],zeroVec);
+  p3 = new Plane(unitVec[0],zeroVec,unitVec[2]);
+  p4 = new Plane(zeroVec,unitVec[1],unitVec[2]);
 }
 
@@ -42,24 +42,24 @@
 
   // three points
-  CPPUNIT_ASSERT_NO_THROW(Plane(e1,e2,e3));
+  CPPUNIT_ASSERT_NO_THROW(Plane(unitVec[0],unitVec[1],unitVec[2]));
   // when only two points are differnt this gives an error
-  CPPUNIT_ASSERT_THROW(Plane(e1,e2,e2),LinearDependenceException);
+  CPPUNIT_ASSERT_THROW(Plane(unitVec[0],unitVec[1],unitVec[1]),LinearDependenceException);
   // same with only one point
-  CPPUNIT_ASSERT_THROW(Plane(e1,e1,e1),LinearDependenceException);
+  CPPUNIT_ASSERT_THROW(Plane(unitVec[0],unitVec[0],unitVec[0]),LinearDependenceException);
 
   // use two vector giving two directions
-  CPPUNIT_ASSERT_NO_THROW(Plane(e1,e2,0));
+  CPPUNIT_ASSERT_NO_THROW(Plane(unitVec[0],unitVec[1],0));
   // and again this is actually only one vector
-  CPPUNIT_ASSERT_THROW(Plane(e1,e1,0),LinearDependenceException);
+  CPPUNIT_ASSERT_THROW(Plane(unitVec[0],unitVec[0],0),LinearDependenceException);
   // Zero vector does not give a good direction
-  CPPUNIT_ASSERT_THROW(Plane(e1,zeroVec,0),ZeroVectorException);
+  CPPUNIT_ASSERT_THROW(Plane(unitVec[0],zeroVec,0),ZeroVectorException);
 
   // use a normalvector and an scalar offset
-  CPPUNIT_ASSERT_NO_THROW(Plane(e1,0));
+  CPPUNIT_ASSERT_NO_THROW(Plane(unitVec[0],0));
   // The zero vector is no good as a normalvector
   CPPUNIT_ASSERT_THROW(Plane(zeroVec,0),ZeroVectorException);
 
   // use a normalvector and an offset vector
-  CPPUNIT_ASSERT_NO_THROW(Plane(e1,zeroVec));
+  CPPUNIT_ASSERT_NO_THROW(Plane(unitVec[0],zeroVec));
   // and the bad zeroVector again
   CPPUNIT_ASSERT_THROW(Plane(zeroVec,zeroVec),ZeroVectorException);
@@ -75,28 +75,28 @@
   {
     // construct with three points on plane
-    Plane p1(e1,e2,zeroVec);
-    CPPUNIT_ASSERT(testNormal(e3,p1.getNormal()));
+    Plane p1(unitVec[0],unitVec[1],zeroVec);
+    CPPUNIT_ASSERT(testNormal(unitVec[2],p1.getNormal()));
     CPPUNIT_ASSERT_EQUAL(0.,p1.getOffset());
 
-    Plane p2(e1,e3,zeroVec);
-    CPPUNIT_ASSERT(testNormal(e2,p2.getNormal()));
+    Plane p2(unitVec[0],unitVec[2],zeroVec);
+    CPPUNIT_ASSERT(testNormal(unitVec[1],p2.getNormal()));
     CPPUNIT_ASSERT_EQUAL(0.,p2.getOffset());
 
-    Plane p3(e2,e3,zeroVec);
-    CPPUNIT_ASSERT(testNormal(e1,p3.getNormal()));
+    Plane p3(unitVec[1],unitVec[2],zeroVec);
+    CPPUNIT_ASSERT(testNormal(unitVec[0],p3.getNormal()));
     CPPUNIT_ASSERT_EQUAL(0.,p3.getOffset());
   }
   {
     // construct with two directions + offset
-    Plane p1(e1,e2,0);
-    CPPUNIT_ASSERT(testNormal(e3,p1.getNormal()));
+    Plane p1(unitVec[0],unitVec[1],0);
+    CPPUNIT_ASSERT(testNormal(unitVec[2],p1.getNormal()));
     CPPUNIT_ASSERT_EQUAL(0.,p1.getOffset());
 
-    Plane p2(e1,e3,0);
-    CPPUNIT_ASSERT(testNormal(e2,p2.getNormal()));
+    Plane p2(unitVec[0],unitVec[2],0);
+    CPPUNIT_ASSERT(testNormal(unitVec[1],p2.getNormal()));
     CPPUNIT_ASSERT_EQUAL(0.,p2.getOffset());
 
-    Plane p3(e2,e3,0);
-    CPPUNIT_ASSERT(testNormal(e1,p3.getNormal()));
+    Plane p3(unitVec[1],unitVec[2],0);
+    CPPUNIT_ASSERT(testNormal(unitVec[0],p3.getNormal()));
     CPPUNIT_ASSERT_EQUAL(0.,p3.getOffset());
   }
@@ -145,15 +145,15 @@
 void PlaneUnittest::operationsTest(){
   {
-    Vector t = (1./3.)*(e1+e2+e3);
+    Vector t = (1./3.)*(unitVec[0]+unitVec[1]+unitVec[2]);
     CPPUNIT_ASSERT(fabs(p1->distance(zeroVec)-t.Norm()) < MYEPSILON);
     CPPUNIT_ASSERT_EQUAL(t,p1->getClosestPoint(zeroVec));
   }
 
-  CPPUNIT_ASSERT(fabs(p2->distance(e3)-1) < MYEPSILON);
-  CPPUNIT_ASSERT_EQUAL(zeroVec,p2->getClosestPoint(e3));
-  CPPUNIT_ASSERT(fabs(p3->distance(e2)-1) < MYEPSILON);
-  CPPUNIT_ASSERT_EQUAL(zeroVec,p3->getClosestPoint(e2));
-  CPPUNIT_ASSERT(fabs(p4->distance(e1)-1) < MYEPSILON);
-  CPPUNIT_ASSERT_EQUAL(zeroVec,p4->getClosestPoint(e1));
+  CPPUNIT_ASSERT(fabs(p2->distance(unitVec[2])-1) < MYEPSILON);
+  CPPUNIT_ASSERT_EQUAL(zeroVec,p2->getClosestPoint(unitVec[2]));
+  CPPUNIT_ASSERT(fabs(p3->distance(unitVec[1])-1) < MYEPSILON);
+  CPPUNIT_ASSERT_EQUAL(zeroVec,p3->getClosestPoint(unitVec[1]));
+  CPPUNIT_ASSERT(fabs(p4->distance(unitVec[0])-1) < MYEPSILON);
+  CPPUNIT_ASSERT_EQUAL(zeroVec,p4->getClosestPoint(unitVec[0]));
 }
 
@@ -162,45 +162,45 @@
 
   // some Vectors that lie on the planes
-  fixture = p1->mirrorVector(e1);
-  CPPUNIT_ASSERT_EQUAL(fixture,e1);
-  fixture = p1->mirrorVector(e2);
-  CPPUNIT_ASSERT_EQUAL(fixture,e2);
-  fixture = p1->mirrorVector(e3);
-  CPPUNIT_ASSERT_EQUAL(fixture,e3);
+  fixture = p1->mirrorVector(unitVec[0]);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[0]);
+  fixture = p1->mirrorVector(unitVec[1]);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[1]);
+  fixture = p1->mirrorVector(unitVec[2]);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[2]);
 
   fixture = p2->mirrorVector(zeroVec);
   CPPUNIT_ASSERT_EQUAL(fixture,zeroVec);
-  fixture = p2->mirrorVector(e1);
-  CPPUNIT_ASSERT_EQUAL(fixture,e1);
-  fixture = p2->mirrorVector(e2);
-  CPPUNIT_ASSERT_EQUAL(fixture,e2);
+  fixture = p2->mirrorVector(unitVec[0]);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[0]);
+  fixture = p2->mirrorVector(unitVec[1]);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[1]);
 
   fixture = p3->mirrorVector(zeroVec);
   CPPUNIT_ASSERT_EQUAL(fixture,zeroVec);
-  fixture = p3->mirrorVector(e1);
-  CPPUNIT_ASSERT_EQUAL(fixture,e1);
-  fixture = p3->mirrorVector(e3);
-  CPPUNIT_ASSERT_EQUAL(fixture,e3);
+  fixture = p3->mirrorVector(unitVec[0]);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[0]);
+  fixture = p3->mirrorVector(unitVec[2]);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[2]);
 
   fixture = p4->mirrorVector(zeroVec);
   CPPUNIT_ASSERT_EQUAL(fixture,zeroVec);
-  fixture = p4->mirrorVector(e2);
-  CPPUNIT_ASSERT_EQUAL(fixture,e2);
-  fixture = p4->mirrorVector(e3);
-  CPPUNIT_ASSERT_EQUAL(fixture,e3);
+  fixture = p4->mirrorVector(unitVec[1]);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[1]);
+  fixture = p4->mirrorVector(unitVec[2]);
+  CPPUNIT_ASSERT_EQUAL(fixture,unitVec[2]);
 
   // some Vectors outside of the planes
   {
-    Vector t = (2./3.)*(e1+e2+e3);
+    Vector t = (2./3.)*(unitVec[0]+unitVec[1]+unitVec[2]);
     fixture = p1->mirrorVector(zeroVec);
     CPPUNIT_ASSERT_EQUAL(fixture,t);
   }
 
-  fixture = p2->mirrorVector(e3);
-  CPPUNIT_ASSERT_EQUAL(fixture,-1*e3);
-  fixture = p3->mirrorVector(e2);
-  CPPUNIT_ASSERT_EQUAL(fixture,-1*e2);
-  fixture = p4->mirrorVector(e1);
-  CPPUNIT_ASSERT_EQUAL(fixture,-1*e1);
+  fixture = p2->mirrorVector(unitVec[2]);
+  CPPUNIT_ASSERT_EQUAL(fixture,-1*unitVec[2]);
+  fixture = p3->mirrorVector(unitVec[1]);
+  CPPUNIT_ASSERT_EQUAL(fixture,-1*unitVec[1]);
+  fixture = p4->mirrorVector(unitVec[0]);
+  CPPUNIT_ASSERT_EQUAL(fixture,-1*unitVec[0]);
 }
 
@@ -209,10 +209,10 @@
   // plane at (0,0,0) normal to (1,0,0) cuts line from (0,0,0) to (2,1,0) at ???
   Line l1 = makeLineThrough(zeroVec,Vector(2,1,0));
-  CPPUNIT_ASSERT_NO_THROW(fixture = Plane(e1, zeroVec).GetIntersection(l1) );
+  CPPUNIT_ASSERT_NO_THROW(fixture = Plane(unitVec[0], zeroVec).GetIntersection(l1) );
   CPPUNIT_ASSERT_EQUAL( zeroVec, fixture );
 
   // plane at (2,1,0) normal to (0,1,0) cuts line from (1,0,0) to (0,1,1) at ???
-  Line l2 = makeLineThrough(e1,Vector(0,1,1));
-  CPPUNIT_ASSERT_NO_THROW(fixture = Plane(e2, Vector(2,1,0)).GetIntersection(l2) );
+  Line l2 = makeLineThrough(unitVec[0],Vector(0,1,1));
+  CPPUNIT_ASSERT_NO_THROW(fixture = Plane(unitVec[1], Vector(2,1,0)).GetIntersection(l2) );
   CPPUNIT_ASSERT_EQUAL( Vector(0., 1., 1.), fixture );
 }
Index: src/unittests/ShapeUnittest.cpp
===================================================================
--- src/unittests/ShapeUnittest.cpp	(revision be97a841b19bbe05e88f3d3ac69c9cb5cd562f10)
+++ src/unittests/ShapeUnittest.cpp	(revision 3d078db43513ccb8235950baa165cf56607d9167)
@@ -17,4 +17,5 @@
 
 #include "Shapes/Shape.hpp"
+#include "Shapes/BaseShapes.hpp"
 #include "vector.cpp"
 
@@ -24,31 +25,31 @@
 void ShapeUnittest::setUp()
 {
-  v000 =  0*e1+0*e2+0*e3;
-  v100 =  1*e1+0*e2+0*e3;
-  v200 = -1*e1+0*e2+0*e3;
-  v010 =  0*e1+1*e2+0*e3;
-  v110 =  1*e1+1*e2+0*e3;
-  v210 = -1*e1+1*e2+0*e3;
-  v020 =  0*e1-1*e2+0*e3;
-  v120 =  1*e1-1*e2+0*e3;
-  v220 = -1*e1-1*e2+0*e3;
-  v001 =  0*e1+0*e2+1*e3;
-  v101 =  1*e1+0*e2+1*e3;
-  v201 = -1*e1+0*e2+1*e3;
-  v011 =  0*e1+1*e2+1*e3;
-  v111 =  1*e1+1*e2+1*e3;
-  v211 = -1*e1+1*e2+1*e3;
-  v021 =  0*e1-1*e2+1*e3;
-  v121 =  1*e1-1*e2+1*e3;
-  v221 = -1*e1-1*e2+1*e3;
-  v002 =  0*e1+0*e2-1*e3;
-  v102 =  1*e1+0*e2-1*e3;
-  v202 = -1*e1+0*e2-1*e3;
-  v012 =  0*e1+1*e2-1*e3;
-  v112 =  1*e1+1*e2-1*e3;
-  v212 = -1*e1+1*e2-1*e3;
-  v022 =  0*e1-1*e2-1*e3;
-  v122 =  1*e1-1*e2-1*e3;
-  v222 = -1*e1-1*e2-1*e3;
+  v000 =  0*unitVec[0]+0*unitVec[1]+0*unitVec[2];
+  v100 =  1*unitVec[0]+0*unitVec[1]+0*unitVec[2];
+  v200 = -1*unitVec[0]+0*unitVec[1]+0*unitVec[2];
+  v010 =  0*unitVec[0]+1*unitVec[1]+0*unitVec[2];
+  v110 =  1*unitVec[0]+1*unitVec[1]+0*unitVec[2];
+  v210 = -1*unitVec[0]+1*unitVec[1]+0*unitVec[2];
+  v020 =  0*unitVec[0]-1*unitVec[1]+0*unitVec[2];
+  v120 =  1*unitVec[0]-1*unitVec[1]+0*unitVec[2];
+  v220 = -1*unitVec[0]-1*unitVec[1]+0*unitVec[2];
+  v001 =  0*unitVec[0]+0*unitVec[1]+1*unitVec[2];
+  v101 =  1*unitVec[0]+0*unitVec[1]+1*unitVec[2];
+  v201 = -1*unitVec[0]+0*unitVec[1]+1*unitVec[2];
+  v011 =  0*unitVec[0]+1*unitVec[1]+1*unitVec[2];
+  v111 =  1*unitVec[0]+1*unitVec[1]+1*unitVec[2];
+  v211 = -1*unitVec[0]+1*unitVec[1]+1*unitVec[2];
+  v021 =  0*unitVec[0]-1*unitVec[1]+1*unitVec[2];
+  v121 =  1*unitVec[0]-1*unitVec[1]+1*unitVec[2];
+  v221 = -1*unitVec[0]-1*unitVec[1]+1*unitVec[2];
+  v002 =  0*unitVec[0]+0*unitVec[1]-1*unitVec[2];
+  v102 =  1*unitVec[0]+0*unitVec[1]-1*unitVec[2];
+  v202 = -1*unitVec[0]+0*unitVec[1]-1*unitVec[2];
+  v012 =  0*unitVec[0]+1*unitVec[1]-1*unitVec[2];
+  v112 =  1*unitVec[0]+1*unitVec[1]-1*unitVec[2];
+  v212 = -1*unitVec[0]+1*unitVec[1]-1*unitVec[2];
+  v022 =  0*unitVec[0]-1*unitVec[1]-1*unitVec[2];
+  v122 =  1*unitVec[0]-1*unitVec[1]-1*unitVec[2];
+  v222 = -1*unitVec[0]-1*unitVec[1]-1*unitVec[2];
 }
 
@@ -113,4 +114,146 @@
   CPPUNIT_ASSERT(Everywhere().isInside(v122));
   CPPUNIT_ASSERT(Everywhere().isInside(v222));
+
+  CPPUNIT_ASSERT(Cuboid().isInside(v000));
+  CPPUNIT_ASSERT(Cuboid().isInside(v100));
+  CPPUNIT_ASSERT(Cuboid().isInside(v200));
+  CPPUNIT_ASSERT(Cuboid().isInside(v010));
+  CPPUNIT_ASSERT(Cuboid().isInside(v110));
+  CPPUNIT_ASSERT(Cuboid().isInside(v210));
+  CPPUNIT_ASSERT(Cuboid().isInside(v020));
+  CPPUNIT_ASSERT(Cuboid().isInside(v120));
+  CPPUNIT_ASSERT(Cuboid().isInside(v220));
+  CPPUNIT_ASSERT(Cuboid().isInside(v001));
+  CPPUNIT_ASSERT(Cuboid().isInside(v101));
+  CPPUNIT_ASSERT(Cuboid().isInside(v201));
+  CPPUNIT_ASSERT(Cuboid().isInside(v011));
+  CPPUNIT_ASSERT(Cuboid().isInside(v111));
+  CPPUNIT_ASSERT(Cuboid().isInside(v211));
+  CPPUNIT_ASSERT(Cuboid().isInside(v021));
+  CPPUNIT_ASSERT(Cuboid().isInside(v121));
+  CPPUNIT_ASSERT(Cuboid().isInside(v221));
+  CPPUNIT_ASSERT(Cuboid().isInside(v002));
+  CPPUNIT_ASSERT(Cuboid().isInside(v102));
+  CPPUNIT_ASSERT(Cuboid().isInside(v202));
+  CPPUNIT_ASSERT(Cuboid().isInside(v012));
+  CPPUNIT_ASSERT(Cuboid().isInside(v112));
+  CPPUNIT_ASSERT(Cuboid().isInside(v212));
+  CPPUNIT_ASSERT(Cuboid().isInside(v022));
+  CPPUNIT_ASSERT(Cuboid().isInside(v122));
+  CPPUNIT_ASSERT(Cuboid().isInside(v222));
+
+  CPPUNIT_ASSERT(Sphere().isInside(v000));
+  CPPUNIT_ASSERT(Sphere().isInside(v100));
+  CPPUNIT_ASSERT(Sphere().isInside(v200));
+  CPPUNIT_ASSERT(Sphere().isInside(v010));
+  CPPUNIT_ASSERT(!Sphere().isInside(v110));
+  CPPUNIT_ASSERT(!Sphere().isInside(v210));
+  CPPUNIT_ASSERT(Sphere().isInside(v020));
+  CPPUNIT_ASSERT(!Sphere().isInside(v120));
+  CPPUNIT_ASSERT(!Sphere().isInside(v220));
+  CPPUNIT_ASSERT(Sphere().isInside(v001));
+  CPPUNIT_ASSERT(!Sphere().isInside(v101));
+  CPPUNIT_ASSERT(!Sphere().isInside(v201));
+  CPPUNIT_ASSERT(!Sphere().isInside(v011));
+  CPPUNIT_ASSERT(!Sphere().isInside(v111));
+  CPPUNIT_ASSERT(!Sphere().isInside(v211));
+  CPPUNIT_ASSERT(!Sphere().isInside(v021));
+  CPPUNIT_ASSERT(!Sphere().isInside(v121));
+  CPPUNIT_ASSERT(!Sphere().isInside(v221));
+  CPPUNIT_ASSERT(Sphere().isInside(v002));
+  CPPUNIT_ASSERT(!Sphere().isInside(v102));
+  CPPUNIT_ASSERT(!Sphere().isInside(v202));
+  CPPUNIT_ASSERT(!Sphere().isInside(v012));
+  CPPUNIT_ASSERT(!Sphere().isInside(v112));
+  CPPUNIT_ASSERT(!Sphere().isInside(v212));
+  CPPUNIT_ASSERT(!Sphere().isInside(v022));
+  CPPUNIT_ASSERT(!Sphere().isInside(v122));
+  CPPUNIT_ASSERT(!Sphere().isInside(v222));
+}
+
+void ShapeUnittest::surfaceTest(){
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v000));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v100));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v200));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v010));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v110));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v210));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v020));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v120));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v220));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v001));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v101));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v201));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v011));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v111));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v211));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v021));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v121));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v221));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v002));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v102));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v202));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v012));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v112));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v212));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v022));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v122));
+  CPPUNIT_ASSERT(!Nowhere().isOnSurface(v222));
+
+  CPPUNIT_ASSERT(!Cuboid().isOnSurface(v000));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v100));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v200));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v010));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v110));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v210));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v020));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v120));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v220));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v001));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v101));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v201));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v011));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v111));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v211));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v021));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v121));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v221));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v002));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v102));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v202));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v012));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v112));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v212));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v022));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v122));
+  CPPUNIT_ASSERT(Cuboid().isOnSurface(v222));
+
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v000));
+  CPPUNIT_ASSERT(Sphere().isOnSurface(v100));
+  CPPUNIT_ASSERT(Sphere().isOnSurface(v200));
+  CPPUNIT_ASSERT(Sphere().isOnSurface(v010));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v110));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v210));
+  CPPUNIT_ASSERT(Sphere().isOnSurface(v020));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v120));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v220));
+  CPPUNIT_ASSERT(Sphere().isOnSurface(v001));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v101));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v201));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v011));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v111));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v211));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v021));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v121));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v221));
+  CPPUNIT_ASSERT(Sphere().isOnSurface(v002));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v102));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v202));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v012));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v112));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v212));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v022));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v122));
+  CPPUNIT_ASSERT(!Sphere().isOnSurface(v222));
 }
 
@@ -360,3 +503,122 @@
   }
 
+  {
+    Shape s1 = Sphere() && Cuboid(); // should be the same as Sphere
+
+    CPPUNIT_ASSERT(s1.isInside(v000));
+    CPPUNIT_ASSERT(s1.isInside(v100));
+    CPPUNIT_ASSERT(s1.isInside(v200));
+    CPPUNIT_ASSERT(s1.isInside(v010));
+    CPPUNIT_ASSERT(!s1.isInside(v110));
+    CPPUNIT_ASSERT(!s1.isInside(v210));
+    CPPUNIT_ASSERT(s1.isInside(v020));
+    CPPUNIT_ASSERT(!s1.isInside(v120));
+    CPPUNIT_ASSERT(!s1.isInside(v220));
+    CPPUNIT_ASSERT(s1.isInside(v001));
+    CPPUNIT_ASSERT(!s1.isInside(v101));
+    CPPUNIT_ASSERT(!s1.isInside(v201));
+    CPPUNIT_ASSERT(!s1.isInside(v011));
+    CPPUNIT_ASSERT(!s1.isInside(v111));
+    CPPUNIT_ASSERT(!s1.isInside(v211));
+    CPPUNIT_ASSERT(!s1.isInside(v021));
+    CPPUNIT_ASSERT(!s1.isInside(v121));
+    CPPUNIT_ASSERT(!s1.isInside(v221));
+    CPPUNIT_ASSERT(s1.isInside(v002));
+    CPPUNIT_ASSERT(!s1.isInside(v102));
+    CPPUNIT_ASSERT(!s1.isInside(v202));
+    CPPUNIT_ASSERT(!s1.isInside(v012));
+    CPPUNIT_ASSERT(!s1.isInside(v112));
+    CPPUNIT_ASSERT(!s1.isInside(v212));
+    CPPUNIT_ASSERT(!s1.isInside(v022));
+    CPPUNIT_ASSERT(!s1.isInside(v122));
+    CPPUNIT_ASSERT(!s1.isInside(v222));
+
+    CPPUNIT_ASSERT(!s1.isOnSurface(v000));
+    CPPUNIT_ASSERT(s1.isOnSurface(v100));
+    CPPUNIT_ASSERT(s1.isOnSurface(v200));
+    CPPUNIT_ASSERT(s1.isOnSurface(v010));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v110));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v210));
+    CPPUNIT_ASSERT(s1.isOnSurface(v020));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v120));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v220));
+    CPPUNIT_ASSERT(s1.isOnSurface(v001));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v101));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v201));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v011));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v111));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v211));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v021));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v121));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v221));
+    CPPUNIT_ASSERT(s1.isOnSurface(v002));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v102));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v202));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v012));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v112));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v212));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v022));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v122));
+    CPPUNIT_ASSERT(!s1.isOnSurface(v222));
+
+
+    Shape s2 = Sphere() || Cuboid(); // Should be same as Cuboid
+
+    CPPUNIT_ASSERT(s2.isInside(v000));
+    CPPUNIT_ASSERT(s2.isInside(v100));
+    CPPUNIT_ASSERT(s2.isInside(v200));
+    CPPUNIT_ASSERT(s2.isInside(v010));
+    CPPUNIT_ASSERT(s2.isInside(v110));
+    CPPUNIT_ASSERT(s2.isInside(v210));
+    CPPUNIT_ASSERT(s2.isInside(v020));
+    CPPUNIT_ASSERT(s2.isInside(v120));
+    CPPUNIT_ASSERT(s2.isInside(v220));
+    CPPUNIT_ASSERT(s2.isInside(v001));
+    CPPUNIT_ASSERT(s2.isInside(v101));
+    CPPUNIT_ASSERT(s2.isInside(v201));
+    CPPUNIT_ASSERT(s2.isInside(v011));
+    CPPUNIT_ASSERT(s2.isInside(v111));
+    CPPUNIT_ASSERT(s2.isInside(v211));
+    CPPUNIT_ASSERT(s2.isInside(v021));
+    CPPUNIT_ASSERT(s2.isInside(v121));
+    CPPUNIT_ASSERT(s2.isInside(v221));
+    CPPUNIT_ASSERT(s2.isInside(v002));
+    CPPUNIT_ASSERT(s2.isInside(v102));
+    CPPUNIT_ASSERT(s2.isInside(v202));
+    CPPUNIT_ASSERT(s2.isInside(v012));
+    CPPUNIT_ASSERT(s2.isInside(v112));
+    CPPUNIT_ASSERT(s2.isInside(v212));
+    CPPUNIT_ASSERT(s2.isInside(v022));
+    CPPUNIT_ASSERT(s2.isInside(v122));
+    CPPUNIT_ASSERT(s2.isInside(v222));
+
+    CPPUNIT_ASSERT(!s2.isOnSurface(v000));
+    CPPUNIT_ASSERT(s2.isOnSurface(v100));
+    CPPUNIT_ASSERT(s2.isOnSurface(v200));
+    CPPUNIT_ASSERT(s2.isOnSurface(v010));
+    CPPUNIT_ASSERT(s2.isOnSurface(v110));
+    CPPUNIT_ASSERT(s2.isOnSurface(v210));
+    CPPUNIT_ASSERT(s2.isOnSurface(v020));
+    CPPUNIT_ASSERT(s2.isOnSurface(v120));
+    CPPUNIT_ASSERT(s2.isOnSurface(v220));
+    CPPUNIT_ASSERT(s2.isOnSurface(v001));
+    CPPUNIT_ASSERT(s2.isOnSurface(v101));
+    CPPUNIT_ASSERT(s2.isOnSurface(v201));
+    CPPUNIT_ASSERT(s2.isOnSurface(v011));
+    CPPUNIT_ASSERT(s2.isOnSurface(v111));
+    CPPUNIT_ASSERT(s2.isOnSurface(v211));
+    CPPUNIT_ASSERT(s2.isOnSurface(v021));
+    CPPUNIT_ASSERT(s2.isOnSurface(v121));
+    CPPUNIT_ASSERT(s2.isOnSurface(v221));
+    CPPUNIT_ASSERT(s2.isOnSurface(v002));
+    CPPUNIT_ASSERT(s2.isOnSurface(v102));
+    CPPUNIT_ASSERT(s2.isOnSurface(v202));
+    CPPUNIT_ASSERT(s2.isOnSurface(v012));
+    CPPUNIT_ASSERT(s2.isOnSurface(v112));
+    CPPUNIT_ASSERT(s2.isOnSurface(v212));
+    CPPUNIT_ASSERT(s2.isOnSurface(v022));
+    CPPUNIT_ASSERT(s2.isOnSurface(v122));
+    CPPUNIT_ASSERT(s2.isOnSurface(v222));
+  }
+
 }
Index: src/unittests/ShapeUnittest.hpp
===================================================================
--- src/unittests/ShapeUnittest.hpp	(revision be97a841b19bbe05e88f3d3ac69c9cb5cd562f10)
+++ src/unittests/ShapeUnittest.hpp	(revision 3d078db43513ccb8235950baa165cf56607d9167)
@@ -20,4 +20,5 @@
   CPPUNIT_TEST_SUITE( ShapeUnittest) ;
   CPPUNIT_TEST ( baseShapesTest );
+  CPPUNIT_TEST ( surfaceTest );
   CPPUNIT_TEST ( assignmentTest );
   CPPUNIT_TEST ( operatorTest );
@@ -29,4 +30,5 @@
 
   void baseShapesTest();
+  void surfaceTest();
   void assignmentTest();
   void operatorTest();
