Index: src/Shapes/BaseShapes.cpp
===================================================================
--- src/Shapes/BaseShapes.cpp	(revision 95e6b132cb0973feda4ff43eba6ed2a7366ca78d)
+++ src/Shapes/BaseShapes.cpp	(revision fa18306cccc4f64d475a7deb6a244ce56bae8b61)
@@ -6,6 +6,9 @@
  */
 
+#include "Helpers/Assert.hpp"
 #include "Shapes/BaseShapes.hpp"
 #include "Shapes/BaseShapes_impl.hpp"
+
+#include <cmath>
 
 #include "LinearAlgebra/Vector.hpp"
@@ -15,4 +18,33 @@
 }
 
+
+/**
+ * algorithm taken from http://www.cgafaq.info/wiki/Evenly_distributed_points_on_sphere
+ * \param N number of points on surface
+ */
+std::vector<Vector> Sphere_impl::getHomogeneousPointsOnSurface(const int N) const {
+  std::vector<Vector> PointsOnSurface;
+
+  const double dlength = M_PI*(3.-sqrt(5.));
+  double length = 0;
+  const double dz = 2.0/N;
+  double z = 1. - dz/2.;
+  Vector point;
+  for (int ka = 0; ka<N; ka++){
+    const double r = sqrt(1.-z*z);
+    point.Zero();
+    point[0] = cos(length)*r;
+    point[1] = sin(length)*r;
+    point[2] = z;
+    PointsOnSurface.push_back(point);
+    z = z - dz;
+    length = length + dlength;
+  }
+
+  ASSERT(PointsOnSurface.size() == N, "Sphere_impl::getHomogeneousPointsOnSurface() did not create enough points.");
+  return PointsOnSurface;
+}
+
+
 Shape Sphere(){
   Shape::impl_ptr impl = Shape::impl_ptr(new Sphere_impl());
@@ -21,9 +53,18 @@
 
 bool Cuboid_impl::isInside(const Vector &point){
-  return point[0]<=1 && point[1]<=1 && point[2]<=1;
+  return (point[0]>=0 && point[0]<=1) && (point[1]>=0 && point[1]<=1) && (point[2]>=0 && point[2]<=1);
+}
+
+/**
+ * \param N number of points on surface
+ */
+std::vector<Vector> Cuboid_impl::getHomogeneousPointsOnSurface(const int N) const {
+  std::vector<Vector> PointsOnSurface;
+  ASSERT(false, "Cuboid_impl::getHomogeneousPointsOnSurface() not implemented yet");
+  return PointsOnSurface;
 }
 
 Shape Cuboid(){
-  Shape::impl_ptr impl = Shape::impl_ptr(new Sphere_impl());
+  Shape::impl_ptr impl = Shape::impl_ptr(new Cuboid_impl());
   return Shape(impl);
 }
Index: src/Shapes/BaseShapes_impl.hpp
===================================================================
--- src/Shapes/BaseShapes_impl.hpp	(revision 95e6b132cb0973feda4ff43eba6ed2a7366ca78d)
+++ src/Shapes/BaseShapes_impl.hpp	(revision fa18306cccc4f64d475a7deb6a244ce56bae8b61)
@@ -13,8 +13,10 @@
 class Sphere_impl : public Shape_impl {
   virtual bool isInside(const Vector &point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 };
 
 class Cuboid_impl : public Shape_impl {
   virtual bool isInside(const Vector &point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 };
 
Index: src/Shapes/Shape.cpp
===================================================================
--- src/Shapes/Shape.cpp	(revision 95e6b132cb0973feda4ff43eba6ed2a7366ca78d)
+++ src/Shapes/Shape.cpp	(revision fa18306cccc4f64d475a7deb6a244ce56bae8b61)
@@ -9,4 +9,8 @@
 #include "Shape_impl.hpp"
 
+
+#include "Helpers/Assert.hpp"
+#include "LinearAlgebra/Vector.hpp"
+
 Shape::Shape(const Shape& src) :
   impl(src.getImpl())
@@ -17,4 +21,8 @@
 bool Shape::isInside(const Vector &point) const{
   return impl->isInside(point);
+}
+
+std::vector<Vector> Shape::getHomogeneousPointsOnSurface(const int N) const {
+  return impl->getHomogeneousPointsOnSurface(N);
 }
 
@@ -65,4 +73,11 @@
 }
 
+std::vector<Vector> AndShape_impl::getHomogeneousPointsOnSurface(const int N) const {
+  std::vector<Vector> PointsOnSurface;
+  ASSERT(false, "AndShape_impl::getHomogeneousPointsOnSurface() not implemented yet");
+  return PointsOnSurface;
+}
+
+
 Shape operator&&(const Shape &lhs,const Shape &rhs){
   Shape::impl_ptr newImpl = Shape::impl_ptr(new AndShape_impl(getShapeImpl(lhs),getShapeImpl(rhs)));
@@ -80,4 +95,21 @@
 bool OrShape_impl::isInside(const Vector &point){
   return rhs->isInside(point) || lhs->isInside(point);
+}
+
+std::vector<Vector> OrShape_impl::getHomogeneousPointsOnSurface(const int N) const {
+  std::vector<Vector> PointsOnSurface_lhs = lhs->getHomogeneousPointsOnSurface(N);
+  std::vector<Vector> PointsOnSurface_rhs = rhs->getHomogeneousPointsOnSurface(N);
+  std::vector<Vector> PointsOnSurface;
+
+  for (std::vector<Vector>::const_iterator iter = PointsOnSurface_lhs.begin(); iter != PointsOnSurface_lhs.end(); ++iter) {
+    if (!rhs->isInside(*iter))
+      PointsOnSurface.push_back(*iter);
+  }
+  for (std::vector<Vector>::const_iterator iter = PointsOnSurface_rhs.begin(); iter != PointsOnSurface_rhs.end(); ++iter) {
+    if (!lhs->isInside(*iter))
+      PointsOnSurface.push_back(*iter);
+  }
+
+  return PointsOnSurface;
 }
 
@@ -99,4 +131,9 @@
 }
 
+std::vector<Vector> NotShape_impl::getHomogeneousPointsOnSurface(const int N) const {
+  // surfaces are the same, only normal direction is different
+  return arg->getHomogeneousPointsOnSurface(N);
+}
+
 Shape operator!(const Shape &arg){
   Shape::impl_ptr newImpl = Shape::impl_ptr(new NotShape_impl(getShapeImpl(arg)));
Index: src/Shapes/Shape.hpp
===================================================================
--- src/Shapes/Shape.hpp	(revision 95e6b132cb0973feda4ff43eba6ed2a7366ca78d)
+++ src/Shapes/Shape.hpp	(revision fa18306cccc4f64d475a7deb6a244ce56bae8b61)
@@ -10,4 +10,6 @@
 
 #include <boost/shared_ptr.hpp>
+
+#include <vector>
 
 class Vector;
@@ -25,4 +27,5 @@
 
   bool isInside(const Vector &point) const;
+  std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 
   Shape &operator=(const Shape& rhs);
Index: src/Shapes/ShapeOps.cpp
===================================================================
--- src/Shapes/ShapeOps.cpp	(revision 95e6b132cb0973feda4ff43eba6ed2a7366ca78d)
+++ src/Shapes/ShapeOps.cpp	(revision fa18306cccc4f64d475a7deb6a244ce56bae8b61)
@@ -25,4 +25,13 @@
 }
 
+std::vector<Vector> Resize_impl::getHomogeneousPointsOnSurface(const int N) const {
+  std::vector<Vector> PointsOnSurface = arg->getHomogeneousPointsOnSurface(N);
+  for(std::vector<Vector>::iterator iter = PointsOnSurface.begin(); iter != PointsOnSurface.end(); ++iter) {
+    *iter *= size;
+  }
+  return PointsOnSurface;
+}
+
+
 Shape resize(const Shape &arg,double size){
   Shape::impl_ptr impl = Shape::impl_ptr(new Resize_impl(getShapeImpl(arg),size));
@@ -40,4 +49,12 @@
 bool Translate_impl::isInside(const Vector& point){
   return arg->isInside(point-offset);
+}
+
+std::vector<Vector> Translate_impl::getHomogeneousPointsOnSurface(const int N) const {
+  std::vector<Vector> PointsOnSurface = arg->getHomogeneousPointsOnSurface(N);
+  for(std::vector<Vector>::iterator iter = PointsOnSurface.begin(); iter != PointsOnSurface.end(); ++iter) {
+    *iter += offset;
+  }
+  return PointsOnSurface;
 }
 
@@ -68,4 +85,12 @@
 }
 
+std::vector<Vector> Stretch_impl::getHomogeneousPointsOnSurface(const int N) const {
+  std::vector<Vector> PointsOnSurface = arg->getHomogeneousPointsOnSurface(N);
+  for(std::vector<Vector>::iterator iter = PointsOnSurface.begin(); iter != PointsOnSurface.end(); ++iter) {
+    (*iter).ScaleAll(reciFactors);
+  }
+  return PointsOnSurface;
+}
+
 Shape stretch(const Shape &arg, const Vector &factors){
   Shape::impl_ptr impl = Shape::impl_ptr(new Stretch_impl(getShapeImpl(arg),factors));
@@ -87,4 +112,12 @@
 }
 
+std::vector<Vector> Transform_impl::getHomogeneousPointsOnSurface(const int N) const {
+  std::vector<Vector> PointsOnSurface = arg->getHomogeneousPointsOnSurface(N);
+  for(std::vector<Vector>::iterator iter = PointsOnSurface.begin(); iter != PointsOnSurface.end(); ++iter) {
+    *iter = transformation * (*iter);
+  }
+  return PointsOnSurface;
+}
+
 Shape transform(const Shape &arg, const Matrix &transformation){
   Shape::impl_ptr impl = Shape::impl_ptr(new Transform_impl(getShapeImpl(arg),transformation));
Index: src/Shapes/ShapeOps_impl.hpp
===================================================================
--- src/Shapes/ShapeOps_impl.hpp	(revision 95e6b132cb0973feda4ff43eba6ed2a7366ca78d)
+++ src/Shapes/ShapeOps_impl.hpp	(revision fa18306cccc4f64d475a7deb6a244ce56bae8b61)
@@ -19,4 +19,5 @@
   virtual ~Resize_impl();
   virtual bool isInside(const Vector& point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 private:
   Shape::impl_ptr arg;
@@ -30,4 +31,5 @@
   virtual ~Translate_impl();
   virtual bool isInside(const Vector& point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 private:
   Shape::impl_ptr arg;
@@ -41,4 +43,5 @@
   virtual ~Stretch_impl();
   virtual bool isInside(const Vector& point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 private:
   Shape::impl_ptr arg;
@@ -53,4 +56,5 @@
   virtual ~Transform_impl();
   virtual bool isInside(const Vector& point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 private:
   Shape::impl_ptr arg;
Index: src/Shapes/Shape_impl.hpp
===================================================================
--- src/Shapes/Shape_impl.hpp	(revision 95e6b132cb0973feda4ff43eba6ed2a7366ca78d)
+++ src/Shapes/Shape_impl.hpp	(revision fa18306cccc4f64d475a7deb6a244ce56bae8b61)
@@ -9,5 +9,9 @@
 #define SHAPE_IMPL_HPP_
 
+#include <vector>
+
 #include "Shapes/Shape.hpp"
+
+class Vector;
 
 class Shape_impl {
@@ -16,4 +20,5 @@
   virtual ~Shape_impl(){};
   virtual bool isInside(const Vector &point)=0;
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const=0;
 };
 
@@ -23,4 +28,8 @@
     return true;
   }
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const {
+    std::vector<Vector> PointsOnSurface;
+    return PointsOnSurface;
+  }
 };
 
@@ -28,4 +37,8 @@
   virtual bool isInside(const Vector &point){
     return false;
+  }
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const {
+    std::vector<Vector> PointsOnSurface;
+    return PointsOnSurface;
   }
 };
@@ -36,4 +49,5 @@
   virtual ~AndShape_impl();
   virtual bool isInside(const Vector &point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 private:
   Shape::impl_ptr lhs;
@@ -46,4 +60,5 @@
   virtual ~OrShape_impl();
   virtual bool isInside(const Vector &point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 private:
   Shape::impl_ptr lhs;
@@ -56,4 +71,5 @@
   virtual ~NotShape_impl();
   virtual bool isInside(const Vector &point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 private:
   Shape::impl_ptr arg;
Index: src/unittests/BaseShapesUnittest.cpp
===================================================================
--- src/unittests/BaseShapesUnittest.cpp	(revision fa18306cccc4f64d475a7deb6a244ce56bae8b61)
+++ src/unittests/BaseShapesUnittest.cpp	(revision fa18306cccc4f64d475a7deb6a244ce56bae8b61)
@@ -0,0 +1,135 @@
+/*
+ * BaseShapesUnittest.cpp
+ *
+ *  Created on: Jun 18, 2010
+ *      Author: crueger
+ */
+
+#include "BaseShapesUnittest.hpp"
+
+#include <cppunit/CompilerOutputter.h>
+#include <cppunit/extensions/TestFactoryRegistry.h>
+#include <cppunit/ui/text/TestRunner.h>
+
+#include <cmath>
+
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
+
+#include "LinearAlgebra/Vector.hpp"
+#include "Shapes/Shape.hpp"
+
+#include "Shapes/BaseShapes.hpp"
+
+// Registers the fixture into the 'registry'
+CPPUNIT_TEST_SUITE_REGISTRATION( BaseShapesUnittest );
+
+void BaseShapesUnittest::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;
+}
+
+void BaseShapesUnittest::tearDown()
+{}
+
+
+void BaseShapesUnittest::isInsideTest(){
+  Shape s1 = 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));
+
+  Shape s2 = 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));
+
+}
+
+void BaseShapesUnittest::PointsOnSurfaceTest(){
+  Shape s = Sphere();
+  const size_t N = 200;
+  std::vector<Vector> PointsOnSurface = s.getHomogeneousPointsOnSurface(N);
+  for (std::vector<Vector>::const_iterator iter = PointsOnSurface.begin(); iter != PointsOnSurface.end(); ++iter) {
+    CPPUNIT_ASSERT(fabs(1. - (*iter).NormSquared()) < MYEPSILON);
+  }
+  CPPUNIT_ASSERT_EQUAL(N, PointsOnSurface.size());
+}
+
Index: src/unittests/BaseShapesUnittest.hpp
===================================================================
--- src/unittests/BaseShapesUnittest.hpp	(revision fa18306cccc4f64d475a7deb6a244ce56bae8b61)
+++ src/unittests/BaseShapesUnittest.hpp	(revision fa18306cccc4f64d475a7deb6a244ce56bae8b61)
@@ -0,0 +1,63 @@
+/*
+ * BaseShapesUnittest.hpp
+ *
+ *  Created on: Jun 18, 2010
+ *      Author: crueger
+ */
+
+#ifndef BASESHAPESUNITTEST_HPP_
+#define BASESHAPESUNITTEST_HPP_
+
+#include <cppunit/extensions/HelperMacros.h>
+
+class Vector;
+
+#include "LinearAlgebra/Vector.hpp"
+
+class BaseShapesUnittest : public CppUnit::TestFixture
+{
+  CPPUNIT_TEST_SUITE( BaseShapesUnittest) ;
+  CPPUNIT_TEST ( isInsideTest );
+  CPPUNIT_TEST ( PointsOnSurfaceTest );
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+  void setUp();
+  void tearDown();
+
+  void isInsideTest();
+  void PointsOnSurfaceTest();
+
+  // a lot of vectors.
+  // these define all the edges of a box around -1 +1 on each axis
+  // 0 is 0, 1 is 1 and 2 is -1
+  Vector v000;
+  Vector v100;
+  Vector v200;
+  Vector v010;
+  Vector v110;
+  Vector v210;
+  Vector v020;
+  Vector v120;
+  Vector v220;
+  Vector v001;
+  Vector v101;
+  Vector v201;
+  Vector v011;
+  Vector v111;
+  Vector v211;
+  Vector v021;
+  Vector v121;
+  Vector v221;
+  Vector v002;
+  Vector v102;
+  Vector v202;
+  Vector v012;
+  Vector v112;
+  Vector v212;
+  Vector v022;
+  Vector v122;
+  Vector v222;
+};
+
+#endif /* BASESHAPESUNITTEST_HPP_ */
Index: src/unittests/Makefile.am
===================================================================
--- src/unittests/Makefile.am	(revision 95e6b132cb0973feda4ff43eba6ed2a7366ca78d)
+++ src/unittests/Makefile.am	(revision fa18306cccc4f64d475a7deb6a244ce56bae8b61)
@@ -16,4 +16,5 @@
   atomsCalculationTest \
   AtomDescriptorTest \
+  BaseShapesUnitTest \
   BondGraphUnitTest \
   BoxUnittest \
@@ -73,4 +74,5 @@
   AtomDescriptorTest.cpp \
   atomsCalculationTest.cpp \
+  BaseShapesUnittest.cpp \
   bondgraphunittest.cpp \
   BoxUnittest.cpp \
@@ -111,4 +113,5 @@
   AtomDescriptorTest.hpp \
   atomsCalculationTest.hpp \
+  BaseShapesUnittest.hpp \
   bondgraphunittest.hpp \
   BoxUnittest.hpp \
@@ -164,4 +167,7 @@
 AtomDescriptorTest_LDADD = ${ALLLIBS}
 
+BaseShapesUnitTest_SOURCES = UnitTestMain.cpp BaseShapesUnittest.cpp BaseShapesUnittest.hpp
+BaseShapesUnitTest_LDADD = ${ALLLIBS}
+
 BondGraphUnitTest_SOURCES = UnitTestMain.cpp bondgraphunittest.cpp bondgraphunittest.hpp
 BondGraphUnitTest_LDADD = ${ALLLIBS}
Index: src/unittests/ShapeUnittest.cpp
===================================================================
--- src/unittests/ShapeUnittest.cpp	(revision 95e6b132cb0973feda4ff43eba6ed2a7366ca78d)
+++ src/unittests/ShapeUnittest.cpp	(revision fa18306cccc4f64d475a7deb6a244ce56bae8b61)
@@ -12,4 +12,6 @@
 #include <cppunit/ui/text/TestRunner.h>
 
+#include <cmath>
+
 #ifdef HAVE_TESTRUNNER
 #include "UnitTestMain.hpp"
@@ -18,4 +20,6 @@
 #include "LinearAlgebra/Vector.hpp"
 #include "Shapes/Shape.hpp"
+
+#include "Shapes/BaseShapes.hpp"
 
 // Registers the fixture into the 'registry'
@@ -179,4 +183,5 @@
 
 }
+
 void ShapeUnittest::operatorTest(){
   {
