diff --git a/AABB_tree/dont_submit b/AABB_tree/dont_submit
index 6c3583bae10..df6a7cbf39d 100644
--- a/AABB_tree/dont_submit
+++ b/AABB_tree/dont_submit
@@ -1,3 +1,2 @@
 shark.ppt
 cleanup.bat
-lucy.off
\ No newline at end of file
diff --git a/AABB_tree/test/AABB_tree/aabb_intersection_triangle_test.cpp b/AABB_tree/test/AABB_tree/aabb_intersection_triangle_test.cpp
index 4e8c6cbc669..4dc88aca27e 100644
--- a/AABB_tree/test/AABB_tree/aabb_intersection_triangle_test.cpp
+++ b/AABB_tree/test/AABB_tree/aabb_intersection_triangle_test.cpp
@@ -89,32 +89,98 @@ void test_all_query_types(Tree& tree)
     tree.all_intersections(segment,std::back_inserter(intersections));
 }
 
-template <class Tree, class Polyhedron, class K>
-void test_speed(Tree& tree,
-                Polyhedron& polyhedron)
+double random_in(const double a,
+                 const double b)
+{
+    double r = rand() / (double)RAND_MAX;
+    return a + (b - a) * r;
+}
+
+template <class K>
+typename K::Point_3 random_point_in(CGAL::Bbox_3& bbox)
+{
+    typedef typename K::FT FT;
+    FT x = (FT)random_in(bbox.xmin(),bbox.xmax());
+    FT y = (FT)random_in(bbox.ymin(),bbox.ymax());
+    FT z = (FT)random_in(bbox.zmin(),bbox.zmax());
+    return K::Point_3(x,y,z);
+}
+
+template <class K>
+typename K::Vector_3 random_vector()
+{
+    typedef typename K::FT FT;
+    FT x = (FT)random_in(0.0,1.0);
+    FT y = (FT)random_in(0.0,1.0);
+    FT z = (FT)random_in(0.0,1.0);
+    return K::Vector_3(x,y,z);
+}
+
+enum Query_type {RAY_QUERY,
+                 SEGMENT_QUERY,
+                 LINE_QUERY};
+
+template <class Tree, class K>
+void test_speed_for_query(const Tree& tree,
+                          const Query_type query_type,
+                          const char *query_name)
 {
-    std::cout << "Test for speed" << std::endl;
     typedef typename K::FT FT;
     typedef typename K::Ray_3 Ray;
+    typedef typename K::Line_3 Line;
     typedef typename K::Point_3 Point;
     typedef typename K::Vector_3 Vector;
+    typedef typename K::Segment_3 Segment;
 
     CGAL::Timer timer;
     unsigned int nb = 0;
     timer.start();
-    Point source((FT)0.0, (FT)0.0, (FT)0.0);
-    Vector vec((FT)0.1, (FT)0.2, (FT)0.3);
-    Ray ray(source, vec);
     while(timer.time() < 1.0)
     {
-        tree.do_intersect(ray);
+        switch(query_type)
+        {
+            case RAY_QUERY:
+                {
+                    Point source = random_point_in<K>(tree.root_bbox());
+                    Vector vec = random_vector<K>();
+                    Ray ray(source, vec);
+                    tree.do_intersect(ray);
+                    break;
+                }
+            case SEGMENT_QUERY:
+                {
+                    Point a = random_point_in<K>(tree.root_bbox());
+                    Point b = random_point_in<K>(tree.root_bbox());
+                    tree.do_intersect(Segment(a,b));
+                    break;
+                }
+                break;
+            case LINE_QUERY:
+                {
+                    Point a = random_point_in<K>(tree.root_bbox());
+                    Point b = random_point_in<K>(tree.root_bbox());
+                    tree.do_intersect(Line(a,b));
+                    break;
+                }
+        }
         nb++;
     }
-    double speed = (double)nb / timer.time();
-    std::cout << speed << " intersections/s" << std::endl;
+    unsigned int speed = (unsigned int)(nb / timer.time());
+    std::cout.precision(10);
+    std::cout.width(15);
+    std::cout << speed << " intersections/s with " << query_name << std::endl;
     timer.stop();
 }
 
+template <class Tree, class K>
+void test_speed(Tree& tree)
+{
+    std::cout << "Test for speed" << std::endl;
+    test_speed_for_query<Tree,K>(tree,RAY_QUERY,"ray");
+    test_speed_for_query<Tree,K>(tree,LINE_QUERY,"line");
+    test_speed_for_query<Tree,K>(tree,SEGMENT_QUERY,"segment");
+}
+
 template <class K>
 void test(const char *filename)
 {
@@ -133,17 +199,23 @@ void test(const char *filename)
     ifs >> polyhedron;
 
     // construct tree (without internal KD-tree as we do not query any projection).
+    std::cout << "construct tree...";
+    CGAL::Timer timer;
+    timer.start();
     Tree tree(polyhedron.facets_begin(),polyhedron.facets_end());
+    timer.stop();
+    std::cout << "done (" << timer.time() << " s)" << std::endl;
 
     // call tests
     test_all_query_types<Tree,K>(tree);
-    test_speed<Tree,Polyhedron,K>(tree,polyhedron);
+    test_speed<Tree,K>(tree);
 }
 
 void test_several_kernels(const char *filename)
 {
     std::cout << std::endl;
     std::cout << "Polyhedron " << filename << std::endl;
+    std::cout << "============================" << std::endl;
 
     std::cout << std::endl;
     std::cout << "Simple cartesian float kernel" << std::endl;
diff --git a/AABB_tree/test/AABB_tree/aabb_projection_triangle_test.cpp b/AABB_tree/test/AABB_tree/aabb_projection_triangle_test.cpp
index e99c538d494..e1b3a59b047 100644
--- a/AABB_tree/test/AABB_tree/aabb_projection_triangle_test.cpp
+++ b/AABB_tree/test/AABB_tree/aabb_projection_triangle_test.cpp
@@ -28,6 +28,8 @@
 
 #include <CGAL/AABB_intersections.h>
 #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
+#include <CGAL/Cartesian.h>
+#include <CGAL/Simple_cartesian.h>
 
 #include <CGAL/AABB_tree.h>
 #include <CGAL/AABB_traits.h>
@@ -82,17 +84,28 @@ void test(const char *filename)
 
 void test_kernels(const char *filename)
 {
-        std::cout << std::endl;
-        std::cout << "Polyhedron " << filename << std::endl;
+    std::cout << std::endl;
+    std::cout << "Polyhedron " << filename << std::endl;
 
-        std::cout << "Simple cartesian float kernel" << std::endl;
-        test<CGAL::Simple_cartesian<float> >(filename);
+    std::cout << std::endl;
+    std::cout << "Simple cartesian float kernel" << std::endl;
+    test<CGAL::Simple_cartesian<float> >(filename);
 
-        std::cout << "Simple cartesian double kernel" << std::endl;
-        test<CGAL::Simple_cartesian<double> >(filename);
+    std::cout << std::endl;
+    std::cout << "Cartesian float kernel" << std::endl;
+    test<CGAL::Cartesian<float> >(filename);
 
-        std::cout << "Epic kernel" << std::endl;
-        test<CGAL::Exact_predicates_inexact_constructions_kernel>(filename);
+    std::cout << std::endl;
+    std::cout << "Simple cartesian double kernel" << std::endl;
+    test<CGAL::Simple_cartesian<double> >(filename);
+
+    std::cout << std::endl;
+    std::cout << "Cartesian double kernel" << std::endl;
+    test<CGAL::Cartesian<double> >(filename);
+
+    std::cout << std::endl;
+    std::cout << "Epic kernel" << std::endl;
+    test<CGAL::Exact_predicates_inexact_constructions_kernel>(filename);
 }
 
 int main(void)
@@ -101,5 +114,6 @@ int main(void)
         test_kernels("./data/cube.off");
         test_kernels("./data/coverrear.off");
         test_kernels("./data/nested_spheres.off");
+        test_kernels("./data/lucy.off");
         return 0;
 }