diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8a92ee8c0..508eed3b1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,183 +1,183 @@
 #===============================================================================
 # @file   CMakeLists.txt
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Mon Jun 14 2010
 # @date last modification: Fri Jan 22 2016
 #
 # @brief  main configuration file
 #
 # @section LICENSE
 #
 # Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
 # Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
 # Solides)
 #
 # Akantu is free  software: you can redistribute it and/or  modify it under the
 # terms  of the  GNU Lesser  General Public  License as  published by  the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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  Lesser General  Public License  for more
 # details.
 #
 # You should  have received  a copy  of the GNU  Lesser General  Public License
 # along with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 # @section DESCRIPTION
 #-------------------------------------------------------------------------------
 #                      _               _
 #                     | |             | |
 #                 __ _| | ____ _ _ __ | |_ _   _
 #                / _` | |/ / _` | '_ \| __| | | |
 #               | (_| |   < (_| | | | | |_| |_| |
 #                \__,_|_|\_\__,_|_| |_|\__|\__,_|
 #
 #===============================================================================
 
 #===============================================================================
 # CMake Project
 #===============================================================================
 cmake_minimum_required(VERSION 3.1.3)
 
 # add this options before PROJECT keyword
 set(CMAKE_DISABLE_SOURCE_CHANGES ON)
 set(CMAKE_DISABLE_IN_SOURCE_BUILD ON)
 
 project(Akantu)
 enable_language(CXX)
 
 #===============================================================================
 # Misc. config for cmake
 #===============================================================================
 set(AKANTU_CMAKE_DIR "${PROJECT_SOURCE_DIR}/cmake")
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake")
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake/Modules")
 set(BUILD_SHARED_LIBS ON CACHE BOOL "Build shared libraries.")
 mark_as_advanced(BUILD_SHARED_LIBS)
 
 if(NOT AKANTU_TARGETS_EXPORT)
   set(AKANTU_TARGETS_EXPORT AkantuLibraryDepends)
 endif()
 
 include(CMakeVersionGenerator)
 include(CMakePackagesSystem)
 include(CMakeFlagsHandling)
 
 include(AkantuPackagesSystem)
 include(AkantuMacros)
 include(AkantuCleaning)
 
 #cmake_activate_debug_message()
 
 #===============================================================================
 # Version Number
 #===============================================================================
 # AKANTU version number.  An even minor number corresponds to releases.
 set(AKANTU_MAJOR_VERSION 3)
 set(AKANTU_MINOR_VERSION 0)
 set(AKANTU_PATCH_VERSION 0)
 define_project_version()
 
 #===============================================================================
 # Options
 #===============================================================================
 # Debug
 set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG -DAKANTU_NDEBUG"
   CACHE STRING "Flags used by the compiler during release builds" FORCE)
 
 #add_flags(cxx "-Wall -Wextra -pedantic -Werror")
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
   add_flags(cxx "-Wall -Wextra -pedantic") # -Weffc++
 else()
   add_flags(cxx "-Wall")
 endif()
 
+option(AKANTU_EXAMPLES "Activate examples" OFF)
+option(AKANTU_TESTS "Activate tests" OFF)
+
 include(AkantuExtraCompilationProfiles)
 #===============================================================================
 # Dependencies
 #===============================================================================
 declare_akantu_types()
 
 package_list_packages(${PROJECT_SOURCE_DIR}/packages
   EXTRA_PACKAGES_FOLDER ${PROJECT_SOURCE_DIR}/extra_packages
   NO_AUTO_COMPILE_FLAGS)
 
 ## meta option \todo better way to do it when multiple package give enable the
 ## same feature
 if(AKANTU_SCOTCH)
   set(AKANTU_PARTITIONER ON)
 else()
   set(AKANTU_PARTITIONER OFF)
 endif()
 
 if(AKANTU_MUMPS)
   set(AKANTU_SOLVER ON)
 else()
   set(AKANTU_SOLVER OFF)
 endif()
 
 #===============================================================================
 # Akantu library
 #===============================================================================
 add_subdirectory(src)
 
 #===============================================================================
 # Documentation
 #===============================================================================
 if(AKANTU_DOCUMENTATION_DOXYGEN OR AKANTU_DOCUMENTATION_MANUAL)
   add_subdirectory(doc)
 else()
   set(AKANTU_DOC_EXCLUDE_FILES "${PROJECT_SOURCE_DIR}/doc/manual" CACHE INTERNAL "")
 endif()
 
 #===============================================================================
 # Examples and tests
 #===============================================================================
-option(AKANTU_EXAMPLES "Activate examples" OFF)
-option(AKANTU_TESTS "Activate tests" OFF)
-
 include(AkantuTestsMacros)
 include(AkantuExampleMacros)
 
 if(AKANTU_TESTS)
   option(AKANTU_BUILD_ALL_TESTS "Build all tests" ON)
   find_package(GMSH REQUIRED)
 endif()
 
 if(AKANTU_EXAMPLES)
   find_package(GMSH REQUIRED)
   add_subdirectory(examples)
 endif()
 
 # tests
 add_test_tree(test)
 
 #===============================================================================
 # Python interface
 #===============================================================================
 package_is_activated(python_interface _python_act)
 if(_python_act)
   if(IS_ABSOLUTE "${CMAKE_INSTALL_PREFIX}")
     set(AKANTU_PYTHON_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})
   else()
     set(AKANTU_PYTHON_INSTALL_PREFIX "${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_PREFIX}")
   endif()
   add_subdirectory(python)
 endif()
 
 #===============================================================================
 # Install and Packaging
 #===============================================================================
 include(AkantuInstall)
 
 option(AKANTU_DISABLE_CPACK
   "This option commands the generation of extra info for the \"make package\" target" ON)
 mark_as_advanced(AKANTU_DISABLE_CPACK)
 if(NOT AKANTU_DISABLE_CPACK)
   include(AkantuCPack)
 endif()
diff --git a/cmake/AkantuTestsMacros.cmake b/cmake/AkantuTestsMacros.cmake
index 0b97aff30..27e4e1be0 100644
--- a/cmake/AkantuTestsMacros.cmake
+++ b/cmake/AkantuTestsMacros.cmake
@@ -1,445 +1,473 @@
 #===============================================================================
 # @file   AkantuTestsMacros.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Fri Sep 03 2010
 # @date last modification: Fri Jan 22 2016
 #
 # @brief  macros for tests
 #
 # @section LICENSE
 #
 # Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
 # Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
 # Solides)
 #
 # Akantu is free  software: you can redistribute it and/or  modify it under the
 # terms  of the  GNU Lesser  General Public  License as  published by  the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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  Lesser General  Public License  for more
 # details.
 #
 # You should  have received  a copy  of the GNU  Lesser General  Public License
 # along with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 #[=======================================================================[.rst:
 AkantuTestsMacros
 -----------------
 
 This modules provides the functions to helper to declare tests and folders
 containing tests in akantu
 
 .. command:: add_test_tree
 
     add_test_tree(<test_direcotry>)
 
   ``<test_directory>`` is the entry direcroty of the full structure of
   subfolders containing tests
 
 .. command:: add_akantu_test
 
     add_akantu_test(<dir> <desc>)
 
   This function add a subdirectory ``<dir>`` of tests that will be conditionnaly
   activable and will be visible only if the parent folder as been activated An
   option ``AKANTU_BUILD_TEST_<dir>`` will appear in ccmake with the description
   ``<desc>``. The compilation of all tests can be forced with the option
   ``AKANTU_BUILD_ALL_TESTS``
 
 .. command:: register_test
 
     register_test(<test_name>
       SOURCES <sources>...
       PACKAGE <akantu_packages>...
       SCRIPT <scirpt>
       [FILES_TO_COPY <filenames>...]
       [DEPENDS <targets>...]
       [DIRECTORIES_TO_CREATE <directories>...]
       [COMPILE_OPTIONS <flags>...]
       [EXTRA_FILES <filnames>...]
       [LINK_LIBRARIES <libraries>...]
       [UNSABLE]
       [PARALLEL]
       [PARALLEL_LEVEL <procs>...]
       )
 
   This function defines a test ``<test_name>_run`` this test could be of
   different nature depending on the context. If Just sources are provided the
   test consist of running the executable generated. If a file ``<test_name>.sh``
   is present the test will execute the script. And if a ``<test_name>.verified``
   exists the output of the test will be compared to this reference file
 
   The options are:
 
   ``SOURCES <sources>...``
     The list of source files to compile to generate the executable of the test
 
   ``PACKAGE <akantu_packages>...``
     The list of package to which this test belongs. The test will be activable
     only of all the packages listed are activated
 
   ``SCRIPT <script>``
     The script to execute instead of the executable
 
   ``FILES_TO_COPY <filenames>...``
     List of files to copy from the source directory to the build directory
 
   ``DEPENDS <targets>...``
     List of targets the test depends on, for example if a mesh as to be generated
 
   ``DIRECTORIES_TO_CREATE <directories>...``
     Obsolete. This specifies a list of directories that have to be created in
     the build folder
 
   ``COMPILE_OPTIONS <flags>...``
     List of extra compilations options to pass to the compiler
 
   ``EXTRA_FILES <filnames>...``
     Files to consider when generating a package_source
 
   ``UNSABLE``
     If this option is specified the test can be unacitivated by the glocal option
     ``AKANTU_BUILD_UNSTABLE_TESTS``, this is mainly intendeed to remove test
     under developement from the continious integration
 
   ``PARALLEL``
     This specifies that this test should be run in parallel. It will generate a
     series of test for different number of processors. This automaticaly adds a
     dependency to the package ``AKANTU_PARALLEL``
 
   ``PARALLEL_LEVEL``
     This defines the different processor numbers to use, if not defined the
     macro tries to determine it in a "clever" way
 
 ]=======================================================================]
 
 set(AKANTU_DRIVER_SCRIPT ${AKANTU_CMAKE_DIR}/akantu_test_driver.sh)
 
 # ==============================================================================
 macro(add_test_tree dir)
   if(AKANTU_TESTS)
     enable_testing()
     include(CTest)
     mark_as_advanced(BUILD_TESTING)
 
-
     set(_akantu_current_parent_test ${dir} CACHE INTERNAL "Current test folder" FORCE)
     set(_akantu_${dir}_tests_count 0 CACHE INTERNAL "" FORCE)
 
     string(TOUPPER ${dir} _u_dir)
     set(AKANTU_BUILD_${_u_dir} ON CACHE INTERNAL "${desc}" FORCE)
 
     package_get_all_test_folders(_test_dirs)
 
     foreach(_dir ${_test_dirs})
       add_subdirectory(${_dir})
     endforeach()
   endif()
 endmacro()
 
 # ==============================================================================
 function(add_akantu_test dir desc)
   if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${dir})
     return()
   endif()
 
   set(_my_parent_dir ${_akantu_current_parent_test})
 
   # initialize variables
   set(_akantu_current_parent_test ${dir} CACHE INTERNAL "Current test folder" FORCE)
   set(_akantu_${dir}_tests_count 0 CACHE INTERNAL "" FORCE)
 
   # set the option for this directory
   string(TOUPPER ${dir} _u_dir)
   option(AKANTU_BUILD_${_u_dir} "${desc}")
   mark_as_advanced(AKANTU_BUILD_${_u_dir})
 
+  set(AKANTU_${_u_dir}_GTEST_SOURCE "" CACHE INTERNAL "")
+
   # add the sub-directory
   add_subdirectory(${dir})
 
+  if(AKANTU_${_u_dir}_GTEST_SOURCE)
+    set(_srcs)
+    foreach(_src ${AKANTU_${_u_dir}_GTEST_SOURCE})
+      list(APPEND _srcs ${dir}/${_src})
+    endforeach()
+
+    add_executable(${dir}_gtest_all ${PROJECT_SOURCE_DIR}/test/test_gtest_main.cc ${_srcs})
+    target_link_libraries(${dir}_gtest_all akantu GTest::GTest GTest::Main)
+    set_property(TARGET ${dir}_gtest_all PROPERTY OUTPUT_NAME ${dir}/gtest_all)
+
+    add_test(NAME ${dir}_gtest COMMAND ${AKANTU_DRIVER_SCRIPT}  -n "${dir}" -e "gtest_all" -w "${CMAKE_CURRENT_BINARY_DIR}/${dir}")
+  endif()
+  
   # if no test can be activated make the option disappear
   set(_force_deactivate_count FALSE)
   if(${_akantu_${dir}_tests_count} EQUAL 0)
     set(_force_deactivate_count TRUE)
   endif()
 
   # if parent off make the option disappear
   set(_force_deactivate_parent FALSE)
   string(TOUPPER ${_my_parent_dir} _u_parent_dir)
   if(NOT AKANTU_BUILD_${_u_parent_dir})
     set(_force_deactivate_parent TRUE)
   endif()
 
   if(_force_deactivate_parent OR _force_deactivate_count OR AKANTU_BUILD_ALL_TESTS)
     if(NOT DEFINED _AKANTU_BUILD_${_u_dir}_SAVE)
       set(_AKANTU_BUILD_${_u_dir}_SAVE ${AKANTU_BUILD_${_u_dir}} CACHE INTERNAL "" FORCE)
     endif()
     unset(AKANTU_BUILD_${_u_dir} CACHE)
     if(AKANTU_BUILD_ALL_TESTS AND NOT _force_deactivate_count)
       set(AKANTU_BUILD_${_u_dir} ON CACHE INTERNAL "${desc}" FORCE)
     else()
       set(AKANTU_BUILD_${_u_dir} OFF CACHE INTERNAL "${desc}" FORCE)
     endif()
   else()
     if(DEFINED _AKANTU_BUILD_${_u_dir}_SAVE)
       unset(AKANTU_BUILD_${_u_dir} CACHE)
       set(AKANTU_BUILD_${_u_dir} ${_AKANTU_BUILD_${_u_dir}_SAVE} CACHE BOOL "${desc}")
       unset(_AKANTU_BUILD_${_u_dir}_SAVE CACHE)
     endif()
   endif()
 
   # adding up to the parent count
   math(EXPR _tmp_parent_count "${_akantu_${dir}_tests_count} + ${_akantu_${_my_parent_dir}_tests_count}")
   set(_akantu_${_my_parent_dir}_tests_count ${_tmp_parent_count} CACHE INTERNAL "" FORCE)
 
   # restoring the parent current dir
   set(_akantu_current_parent_test ${_my_parent_dir} CACHE INTERNAL "Current test folder" FORCE)
 endfunction()
 
 
 # ==============================================================================
 function(register_test test_name)
-   set(multi_variables
-     SOURCES FILES_TO_COPY DEPENDS DIRECTORIES_TO_CREATE COMPILE_OPTIONS
-     EXTRA_FILES LINK_LIBRARIES PACKAGE PARALLEL_LEVEL
-     )
-
-   cmake_parse_arguments(_register_test
-     "UNSTABLE;PARALLEL"
-     "POSTPROCESS;SCRIPT"
-     "${multi_variables}"
-     ${ARGN}
-     )
+  set(flags
+    GTEST
+    UNSTABLE
+    PARALLEL
+    )
+  set(one_variables
+    POSTPROCESS
+    SCRIPT
+    )
+  set(multi_variables
+    SOURCES
+    FILES_TO_COPY
+    DEPENDS
+    DIRECTORIES_TO_CREATE
+    COMPILE_OPTIONS
+    EXTRA_FILES
+    LINK_LIBRARIES
+    PACKAGE
+    PARALLEL_LEVEL
+    )
+
+  cmake_parse_arguments(_register_test
+    "${flags}"
+    "${one_variables}"
+    "${multi_variables}"
+    ${ARGN}
+    )
 
   if(NOT _register_test_PACKAGE)
     message(FATAL_ERROR "No reference package was defined for the test"
       " ${test_name} in folder ${CMAKE_CURRENT_SOURCE_DIR}")
   endif()
 
   set(_test_act TRUE)
   # Activate the test anly if all packages associated to the test are activated
   foreach(_package ${_register_test_PACKAGE})
     package_is_activated(${_package} _act)
     if(NOT _act)
       set(_test_act FALSE)
     endif()
   endforeach()
 
   # check if the test is marked unstable and if the unstable test should be run
   if(_register_test_UNSTABLE AND NOT AKANTU_BUILD_UNSTABLE_TESTS)
     set(_test_act FALSE)
   endif()
 
   # check that the sources are files that need to be compiled
   if(_register_test_SOURCES} OR _register_test_UNPARSED_ARGUMENTS)
     set(_need_to_compile TRUE)
   else()
     set(_need_to_compile FALSE)
   endif()
 
   set(_compile_source)
   foreach(_file ${_register_test_SOURCES} ${_register_test_UNPARSED_ARGUMENTS})
     if(_file MATCHES "\\.cc$" OR _file MATCHES "\\.hh$")
       list(APPEND _compile_source ${_file})
     endif()
   endforeach()
 
   # todo this should be checked for the build package_sources since the file will not be listed.
   if(_test_act)
     math(EXPR _tmp_parent_count "${_akantu_${_akantu_current_parent_test}_tests_count} + 1")
     set(_akantu_${_akantu_current_parent_test}_tests_count ${_tmp_parent_count} CACHE INTERNAL "" FORCE)
 
     string(TOUPPER ${_akantu_current_parent_test} _u_parent)
 
     if(AKANTU_BUILD_${_u_parent} OR AKANTU_BUILD_ALL_TESTS)
       if(_compile_source)
-         # get the include directories for sources in activated directories
+        # get the include directories for sources in activated directories
         package_get_all_include_directories(
           AKANTU_LIBRARY_INCLUDE_DIRS
           )
 
         # get the external packages compilation and linking informations
         package_get_all_external_informations(
           AKANTU_EXTERNAL_INCLUDE_DIR
           AKANTU_EXTERNAL_LIBRARIES
           )
 
-        # set the proper includes to build most of the tests
-        include_directories(
-          ${PROJECT_BINARY_DIR}/src
-          ${AKANTU_LIBRARY_INCLUDE_DIRS}
-          ${AKANTU_EXTERNAL_INCLUDE_DIR}
-          )
-
-        # Register the executable to compile
-        add_executable(${test_name} ${_compile_source})
-        #set_target_properties(${test_name} PROPERTIES CXX_STANDARD 14)
 
-        target_include_directories(${test_name}
-          PRIVATE ${AKANTU_LIBRARY_INCLUDE_DIRS} ${AKANTU_EXTERNAL_INCLUDE_DIR})
-        target_link_libraries(${test_name} akantu ${_register_test_LINK_LIBRARIES})
+        if(NOT _register_test_GTEST)
+          # Register the executable to compile
+          add_executable(${test_name} ${_compile_source})
+          
+          # set the proper includes to build most of the tests
+          target_include_directories(${test_name}
+            PRIVATE ${AKANTU_LIBRARY_INCLUDE_DIRS} ${AKANTU_EXTERNAL_INCLUDE_DIR} ${PROJECT_BINARY_DIR}/src)
+          target_link_libraries(${test_name} akantu ${_register_test_LINK_LIBRARIES})
 
-        if(_register_test_DEPENDS)
-          add_dependencies(${test_name} ${_register_test_DEPENDS})
-        endif()
+          if(_register_test_DEPENDS)
+            add_dependencies(${test_name} ${_register_test_DEPENDS})
+          endif()
 
-        # add the extra compilation options
-        if(_register_test_COMPILE_OPTIONS)
-          set_target_properties(${test_name}
-            PROPERTIES COMPILE_DEFINITIONS "${_register_test_COMPILE_OPTIONS}")
-        endif()
+          # add the extra compilation options
+          if(_register_test_COMPILE_OPTIONS)
+            set_target_properties(${test_name}
+              PROPERTIES COMPILE_DEFINITIONS "${_register_test_COMPILE_OPTIONS}")
+          endif()
 
-        if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND  CMAKE_BUILD_TYPE STREQUAL "Debug")
-          set(AKANTU_EXTRA_CXX_FLAGS "${AKANTU_EXTRA_CXX_FLAGS} -no-pie")
-        endif()
-        if(AKANTU_EXTRA_CXX_FLAGS)
-          set_target_properties(${test_name}
-            PROPERTIES COMPILE_FLAGS "${AKANTU_EXTRA_CXX_FLAGS}")
+          if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND  CMAKE_BUILD_TYPE STREQUAL "Debug")
+            set(AKANTU_EXTRA_CXX_FLAGS "${AKANTU_EXTRA_CXX_FLAGS} -no-pie")
+          endif()
+          if(AKANTU_EXTRA_CXX_FLAGS)
+            set_target_properties(${test_name}
+              PROPERTIES COMPILE_FLAGS "${AKANTU_EXTRA_CXX_FLAGS}")
+          endif()
+        else()
+          set(_list ${AKANTU_${_u_parent}_GTEST_SOURCE})
+          list(APPEND _list ${_compile_source})
+          set(AKANTU_${_u_parent}_GTEST_SOURCE ${_list} CACHE INTERNAL "")
         endif()
       else()
         if(_register_test_UNPARSED_ARGUMENTS AND NOT _register_test_SCRIPT)
           set(_register_test_SCRIPT ${_register_test_UNPARSED_ARGUMENTS})
         endif()
       endif()
 
       # copy the needed files to the build folder
       if(_register_test_FILES_TO_COPY)
         foreach(_file ${_register_test_FILES_TO_COPY})
           file(COPY "${_file}" DESTINATION .)
         endforeach()
       endif()
 
       # create the needed folders in the build folder
       if(_register_test_DIRECTORIES_TO_CREATE)
         foreach(_dir ${_register_test_DIRECTORIES_TO_CREATE})
           if(IS_ABSOLUTE ${dir})
             file(MAKE_DIRECTORY "${_dir}")
           else()
             file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/${_dir}")
           endif()
         endforeach()
       endif()
 
       # register the test for ctest
       set(_arguments -n "${test_name}")
       if(_register_test_SCRIPT)
         file(COPY ${_register_test_SCRIPT}
           FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
           DESTINATION .)
         list(APPEND _arguments -e "${_register_test_SCRIPT}")
       elseif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${test_name}.sh")
         file(COPY ${test_name}.sh DESTINATION .)
         list(APPEND _arguments -e "${test_name}.sh")
       else()
         list(APPEND _arguments -e "${test_name}")
       endif()
 
       list(APPEND _arguments -E "${PROJECT_BINARY_DIR}/akantu_environement.sh")
 
       package_is_activated(parallel _is_parallel)
 
       if(_is_parallel AND AKANTU_TESTS_ALWAYS_USE_MPI AND NOT _register_test_PARALLEL)
         set(_register_test_PARALLEL TRUE)
         set(_register_test_PARALLEL_LEVEL 1)
       endif()
 
       if(_register_test_PARALLEL)
         list(APPEND _arguments -p "${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG}")
         if(_register_test_PARALLEL_LEVEL)
           set(_procs "${_register_test_PARALLEL_LEVEL}")
         elseif(CMAKE_VERSION VERSION_GREATER "3.0")
           set(_procs)
           include(ProcessorCount)
           ProcessorCount(N)
           while(N GREATER 1)
             list(APPEND _procs ${N})
             math(EXPR N "${N} / 2")
           endwhile()
         endif()
 
         if(NOT _procs)
           set(_procs 2)
         endif()
       endif()
 
       if(_register_test_POSTPROCESS)
         list(APPEND _arguments -s "${_register_test_POSTPROCESS}")
         file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/${_register_test_POSTPROCESS} 
           FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
           DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
       endif()
 
       list(APPEND _arguments -w "${CMAKE_CURRENT_BINARY_DIR}")
 
       if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${test_name}.verified")
         list(APPEND _arguments -r "${CMAKE_CURRENT_SOURCE_DIR}/${test_name}.verified")
       endif()
 
       string(REPLACE ";" " " _command "${_arguments}")
 
-      # register them test
-      if(_procs)
-        foreach(p ${_procs})
-          add_test(NAME ${test_name}_${p}_run COMMAND ${AKANTU_DRIVER_SCRIPT} ${_arguments} -N ${p})
-          # add the executable as a dependency of the run
-          set_tests_properties(${test_name}_${p}_run PROPERTIES DEPENDS ${test_name})
-        endforeach()
-      else()
-        add_test(NAME ${test_name}_run COMMAND ${AKANTU_DRIVER_SCRIPT} ${_arguments})
-        # add the executable as a dependency of the run
-        set_tests_properties(${test_name}_run PROPERTIES DEPENDS ${test_name})
+      if(NOT _register_test_GTEST)
+        
+        # register them test
+        if(_procs)
+          foreach(p ${_procs})
+            add_test(NAME ${test_name}_${p} COMMAND ${AKANTU_DRIVER_SCRIPT} ${_arguments} -N ${p})
+          endforeach()
+        else()
+          add_test(NAME ${test_name} COMMAND ${AKANTU_DRIVER_SCRIPT} ${_arguments})
+        endif()
       endif()
-
     endif()
   endif()
 
   set(_test_all_files)
   # add the source files in the list of all files
   foreach(_file ${_register_test_SOURCES} ${_register_test_UNPARSED_ARGUMENTS}
       ${_register_test_EXTRA_FILES} ${_register_test_SOURCES} ${_register_test_SCRIPT}
       ${_register_test_POSTPROCESS} ${_register_test_FILES_TO_COPY})
     if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${_file})
       list(APPEND _test_all_files "${_file}")
     else()
       message("The file \"${_file}\" registred by the test \"${test_name}\" does not exists")
     endif()
   endforeach()
 
   # add the different dependencies files (meshes, local libraries, ...)
   foreach(_dep ${_register_test_DEPENDS})
     get_target_list_of_associated_files(${_dep} _dep_ressources)
     if(_dep_ressources)
       list(APPEND _test_all_files "${_dep_ressources}")
     endif()
   endforeach()
 
   # add estra files to the list of files referenced by a given test
   if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${test_name}.sh")
     list(APPEND _test_all_files "${test_name}.sh")
   endif()
   if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${test_name}.verified")
     list(APPEND _test_all_files "${test_name}.verified")
   endif()
   if(_register_test_SCRIPT)
     list(APPEND _test_all_files "${_register_test_SCRIPT}")
   endif()
 
   # clean the list of all files for this test and add them in the total list
   foreach(_file ${_test_all_files})
     get_filename_component(_full ${_file} ABSOLUTE)
     file(RELATIVE_PATH __file ${PROJECT_SOURCE_DIR} ${_full})
     list(APPEND _tmp "${__file}")
   endforeach()
 
   foreach(_pkg ${_register_test_PACKAGE})
     package_get_name(${_pkg} _pkg_name)
     _package_add_to_variable(TESTS_FILES ${_pkg_name} ${_tmp})
   endforeach()
 endfunction()
diff --git a/cmake/Modules/CMakePackagesSystem.cmake b/cmake/Modules/CMakePackagesSystem.cmake
index 56cdbba58..c9fa1e6da 100644
--- a/cmake/Modules/CMakePackagesSystem.cmake
+++ b/cmake/Modules/CMakePackagesSystem.cmake
@@ -1,1062 +1,1076 @@
 #===============================================================================
 # @file   CMakePackagesSystem.cmake
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Wed Nov 05 2014
 # @date last modification: Wed Jan 20 2016
 #
 # @brief  Set of macros used by akantu to handle the package system
 #
 # @section LICENSE
 #
 # Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
 # (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free  software: you can redistribute it and/or  modify it under the
 # terms  of the  GNU Lesser  General Public  License as  published by  the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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  Lesser General  Public License  for more
 # details.
 #
 # You should  have received  a copy  of the GNU  Lesser General  Public License
 # along with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 #[=======================================================================[.rst:
 #CMakePackagesSystem
 #-------------------
 #
 #This package defines multiple function to handle packages. This packages can
 #be of two kinds regular ones and extra_packages (ex: in akantu the LGPL part
 #is regular packages and extra packages are on Propetary license)
 #
 #Package are loaded with the help of the command:
 #
 #.. command:: package_list_packages
 #
 #     package_list_packages(<regular_package_folder>
 #       [ EXTRA_PACKAGE_FOLDER <extra_package_folder> ]
 #       [ SOURCE_FOLDER <source_folder>]
 #       [ TEST_FOLDER <test_folder> ]
 #       [ MANUAL_FOLDER <manual_folder> ]
 #       )
 #
 #     This command will look for packages name like ``<regular_package_folder>/<package>.cmake``
 #     OR ``<extra_package_folder>/<package>/package.cmake``
 #
 #A package is a cmake script that should contain at list the declaration of a
 #package
 #
 #.. command:: package_declare
 #
 #     package_declare(<package real name>
 #       [EXTERNAL] [META] [ADVANCED] [NOT_OPTIONAL]
 #       [DESCRIPTION <description>] [DEFAULT <default_value>]
 #       [DEPENDS <pkg> ...]
 #       [BOOST_COMPONENTS <pkg> ...]
 #       [EXTRA_PACKAGE_OPTIONS <opt> ...]
 #       [COMPILE_FLAGS <lang> <flags>]
 #       [SYSTEM <bool> [ <script_to_compile> ]]
+#       [FALLBACK_ON_SYSTEM_MISSING <bool>
 #       [FEATURES_PUBLIC <feature> ...]
 #       [FEATURES_PRIVATE <feature> ...]
 #       )
 #
 #.. command:: package_declare_sources
 #
 #     It can also declare multiple informations:
 #     source files:
 #
 #     package_declare_sources(<package real name>
 #       <src1> <src2> ... <srcn>)
 #
 #.. command:: package_declare_documentation
 #
 #     a LaTeX documentation
 #     package_declare_documentation(<package real name>
 #       <line1> <line2> ...<linen>)
 #
 #.. command:: package_declare_documentation_files
 #
 #     LaTeX documentation files
 #     package_declare_documentation_files(<package real name>
 #       <file1> <file2> ... <filen>)
 #
 #Different function can also be retrieved from the package system by using the
 #different accessors
 #
 #.. command:: package_get_name
 #     package_get_name(<pkg> <retval>)
 #
 #.. command:: package_get_real_name
 #    package_get_real_name(<pkg> <retval>)
 #
 #.. command:: package_get_option_name
 #     package_get_option_name(<pkg> <retval>)
 #
 #.. command:: package_use_system
 #     package_use_system(<pkg> <retval>)
 #
 #.. command:: package_get_nature
 #     package_get_nature(<pkg> <retval>)
 #
 #.. command:: package_get_description
 #     package_get_description(<pkg> <retval>)
 #
 #.. command:: package_get_filename
 #     package_get_filename(<pkg> <retval>)
 #
 #.. command:: package_get_sources_folder
 #     package_get_sources_folder(<pkg> <retval>)
 #.. command:: package_get_tests_folder
 #     package_get_tests_folder(<pkg> <retval>)
 #.. command:: package_get_manual_folder
 #     package_get_manual_folder(<pkg> <retval>)
 #
 #.. command:: package_get_find_package_extra_options
 #     package_get_find_package_extra_options(<pkg> <retval>)
 #
 #.. command:: package_get_compile_flags
 #     package_get_compile_flags(<pkg> <lang> <retval>)
 #.. command:: package_set_compile_flags
 #     package_set_compile_flags(<pkg> <lang> <flag1> <flag2> ... <flagn>)
 #
 #.. command:: package_get_include_dir
 #     package_get_include_dir(<pkg> <retval>)
 #.. command:: package_set_include_dir
 #     package_set_include_dir(<pkg> <inc1> <inc2> ... <incn>)
 #.. command:: package_add_include_dir
 #     package_add_include_dir(<pkg> <inc1> <inc2> ... <incn>)
 #
 #.. command:: package_get_libraries
 #     package_get_libraries(<pkg> <retval>)
 #.. command:: package_set_libraries
 #     package_set_libraries(<pkg> <lib1> <lib2> ... <libn>)
 #
 #.. command:: package_add_extra_dependency
 #     package_add_extra_dependency(pkg <dep1> <dep2> ... <depn>)
 #.. command:: package_rm_extra_dependency
 #     package_rm_extra_dependency(<pkg> <dep>)
 #.. command:: package_get_extra_dependencies
 #     package_get_extra_dependencies(<pkg> <retval>)
 #
 #.. command:: package_is_activated
 #     package_is_activated(<pkg> <retval>)
 #.. command:: package_is_deactivated
 #     package_is_deactivated(<pkg> <retval>)
 #
 #.. command:: package_get_dependencies
 #     package_get_dependencies(<pkg> <retval>)
 #.. command:: package_add_dependencies
 #     package_add_dependencies(<pkg> <dep1> <dep2> ... <depn>)
 #     package_remove_dependencies(<pkg> <dep1> <dep2> ... <depn>)
 #     package_remove_dependency(<pkg> <dep>)
 #
 #.. command:: package_on_enabled_script
 #     package_on_enabled_script(<pkg> <script>)
 #
 #.. command:: package_get_all_source_files
 #     package_get_all_source_files(<srcs> <public_headers> <private_headers>)
 #.. command:: package_get_all_include_directories
 #     package_get_all_include_directories(<inc_dirs>)
 #.. command:: package_get_all_external_informations
 #     package_get_all_external_informations(<include_dir> <libraries>)
 #.. command:: package_get_all_definitions
 #     package_get_all_definitions(<definitions>)
 #.. command:: package_get_all_extra_dependencies
 #     package_get_all_extra_dependencies(<dependencies>)
 #.. command:: package_get_all_test_folders
 #     package_get_all_test_folders(<test_dirs>)
 #.. command:: package_get_all_documentation_files
 #     package_get_all_documentation_files(<doc_files>)
 #.. command:: package_get_all_activated_packages
 #     package_get_all_activated_packages(<activated_list>)
 #.. command:: package_get_all_deactivated_packages
 #     package_get_all_deactivated_packages(<deactivated_list>)
 #.. command:: package_get_all_packages
 #     package_get_all_packages(<packages_list>)
 #.. command:: package_get_all_features_public
 #     package_get_all_features_public(<features>)
 #.. command:: package_get_all_features_private
 #     package_get_all_features_private(<features>)
 #
 #
 #     .. command:: package_set_package_system_dependency
 #
 #     package_set_package_system_dependency(<pkg> <system> <dep1>
 #                                           <dep2> ... <depn>)
 #
 #                                       .. command:: package_get_package_system_dependency
 #
 #     package_get_package_system_dependency(<pkg> <var>)
 #
 #
 #]=======================================================================]
 
 
 include(CMakeParseArguments)
 
 #===============================================================================
 # Package Management
 #===============================================================================
 if(__CMAKE_PACKAGES_SYSTEM)
   return()
 endif()
 set(__CMAKE_PACKAGES_SYSTEM TRUE)
 
 if(CMAKE_VERSION VERSION_GREATER 3.1.2)
   cmake_policy(SET CMP0054 NEW)
 endif()
 
 #===============================================================================
 option(AUTO_MOVE_UNKNOWN_FILES
   "Give to cmake the permission to move the unregistered files to the ${PROJECT_SOURCE_DIR}/tmp directory" FALSE)
 mark_as_advanced(AUTO_MOVE_UNKNOWN_FILES)
 
 
 include(CMakePackagesSystemGlobalFunctions)
 include(CMakePackagesSystemPrivateFunctions)
 
 # ==============================================================================
 # "Public" Accessors
 # ==============================================================================
 # ------------------------------------------------------------------------------
 # Package name
 # ------------------------------------------------------------------------------
 function(package_get_name pkg pkg_name)
   string(TOUPPER ${PROJECT_NAME} _project)
   string(REPLACE "-" "_" _str_pkg "${pkg}")
   string(TOUPPER ${_str_pkg} _u_package)
   set(${pkg_name} ${_project}_PKG_${_u_package} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Real name
 # ------------------------------------------------------------------------------
 function(package_get_real_name pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_real_name(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Option name
 # ------------------------------------------------------------------------------
 function(package_get_option_name pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_option_name(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Set if system package or compile external lib
 # ------------------------------------------------------------------------------
 function(package_use_system pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_use_system(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_add_third_party_script_variable pkg var)
   package_get_name(${pkg} _pkg_name)
   _package_add_third_party_script_variable(${_pkg_name} ${var} ${ARGN})
   set(${var} ${ARGN} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Set if system package or compile external lib
 # ------------------------------------------------------------------------------
 function(package_add_to_export_list pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_to_export_list(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Nature
 # ------------------------------------------------------------------------------
 function(package_get_nature pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_nature(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Description
 # ------------------------------------------------------------------------------
 function(package_get_description pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_description(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Package file name
 # ------------------------------------------------------------------------------
 function(package_get_filename pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_filename(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Source files
 # ------------------------------------------------------------------------------
 function(package_get_source_files pkg ret_srcs ret_pub ret_priv)
   package_get_name(${pkg} _pkg_name)
   _package_get_source_files(${_pkg_name} _tmp_srcs _tmp_pub _tmp_priv)
   set(${ret_srcs} ${_tmp_srcs} PARENT_SCOPE)
   set(${ret_pub}  ${_tmp_pub}  PARENT_SCOPE)
   set(${ret_priv} ${_tmp_pric} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Source folder
 # ------------------------------------------------------------------------------
 function(package_get_sources_folder pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_sources_folder(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Test folder
 # ------------------------------------------------------------------------------
 function(package_get_tests_folder pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_tests_folder(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Manual folder
 # ------------------------------------------------------------------------------
 function(package_get_manual_folder pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_manual_folder(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Extra option for the find_package
 # ------------------------------------------------------------------------------
 function(package_get_find_package_extra_options pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_find_package_extra_options(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_set_find_package_extra_options pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_find_package_extra_options(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Compilation flags
 # ------------------------------------------------------------------------------
 function(package_get_compile_flags pkg lang ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_compile_flags(${_pkg_name} ${lang} _tmp)
   set(${ret} "${_tmp}" PARENT_SCOPE)
 endfunction()
 
 function(package_set_compile_flags pkg lang)
   package_get_name(${pkg} _pkg_name)
   _package_set_compile_flags(${_pkg_name} ${lang} ${ARGN})
 endfunction()
 
 function(package_unset_compile_flags pkg lang)
   package_get_name(${pkg} _pkg_name)
   _package_unset_compile_flags(${_pkg_name} ${lang})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Include dir
 # ------------------------------------------------------------------------------
 function(package_get_include_dir pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_include_dir(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_set_include_dir pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_include_dir(${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_add_include_dir pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_include_dir(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Libraries
 # ------------------------------------------------------------------------------
 function(package_get_libraries pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_libraries(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_set_libraries pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_libraries(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Extra dependencies like custom commands of ExternalProject
 # ------------------------------------------------------------------------------
 function(package_add_extra_dependency pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_extra_dependency(${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_rm_extra_dependency pkg dep)
   package_get_name(${pkg} _pkg_name)
   _package_rm_extra_dependency(${_pkg_name} ${dep})
 endfunction()
 
 function(package_get_extra_dependencies pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_extra_dependencies(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Activate/deactivate
 # ------------------------------------------------------------------------------
 function(package_is_activated pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_is_activated(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_is_deactivated pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_is_deactivated(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Direct dependencies
 # ------------------------------------------------------------------------------
 function(package_get_dependencies pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_dependencies(${_pkg_name} _tmp_name)
   _package_get_real_name(${_tmp_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_add_dependencies pkg)
   package_get_name(${pkg} _pkg_name)
   foreach(_dep ${ARGN})
     package_get_name(${_dep} _dep_pkg_name)
     list(APPEND _tmp_deps ${_dep_pkg_name})
   endforeach()
 
   _package_add_dependencies(${_pkg_name} ${_tmp_deps})
 endfunction()
 
 function(package_remove_dependencies pkg)
   foreach(_dep ${ARGN})
     package_remove_dependency(${pkg} _dep)
   endforeach()
 endfunction()
 
 function(package_remove_dependency pkg dep)
   package_get_name(${pkg} _pkg_name)
   package_get_name(${dep} _dep_pkg_name)
   _package_remove_dependency(${_pkg_name} ${_dep_pkg_name})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Documentation related functions
 # ------------------------------------------------------------------------------
 function(package_declare_documentation pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_documentation(${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_declare_documentation_files pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_documentation_files(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Set any user variables needed
 # ------------------------------------------------------------------------------
 function(package_set_variable variable pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_variable(${variable} ${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_add_to_variable variable pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_to_variable(${variable} ${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_get_variable variable pkg value)
   package_get_name(${pkg} _pkg_name)
   _package_get_variable(${variable} ${_pkg_name} _value_tmp)
   if(_value_tmp)
     set(${value} ${_value_tmp} PARENT_SCOPE)
   else()
     unset(${value} PARENT_SCOPE)
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Exteral package system as apt rpm dependencies
 # ------------------------------------------------------------------------------
 function(package_set_package_system_dependency pkg system)
   package_get_name(${pkg} _pkg_name)
   _package_set_package_system_dependency(${_pkg_name} ${system} ${ARGN})
 endfunction()
 
 function(package_get_package_system_dependency pkg system var)
   package_get_name(${pkg} _pkg_name)
   _package_set_package_system_dependency(${_pkg_name} ${sytem} _tmp)
   set(${var} ${_tmp} PARENT_SCOPE)
 endfunction()
 # ------------------------------------------------------------------------------
 
 # ==============================================================================
 # Global accessors
 # ==============================================================================
 # ------------------------------------------------------------------------------
 # get the list of source files
 # ------------------------------------------------------------------------------
 function(package_get_all_source_files SRCS PUBLIC_HEADERS PRIVATE_HEADERS)
   string(TOUPPER ${PROJECT_NAME} _project)
 
   unset(_tmp_srcs)
   unset(_tmp_public_headers)
   unset(_tmp_private_headers)
 
   package_get_all_activated_packages(_activated_list)
   foreach(_pkg_name ${_activated_list})
     _package_get_source_files(${_pkg_name}
       _pkg_srcs
       _pkg_public_headers
       _pkg_private_headers
       )
     list(APPEND _tmp_srcs ${_pkg_srcs})
     list(APPEND _tmp_public_headers ${_pkg_public_headers})
     list(APPEND _tmp_private_headers ${_pkg_private_headers})
   endforeach()
 
   set(${SRCS}            ${_tmp_srcs}            PARENT_SCOPE)
   set(${PUBLIC_HEADERS}  ${_tmp_public_headers}  PARENT_SCOPE)
   set(${PRIVATE_HEADERS} ${_tmp_private_headers} PARENT_SCOPE)
 endfunction()
 
 
 # ------------------------------------------------------------------------------
 # Get include directories
 # ------------------------------------------------------------------------------
 function(package_get_all_include_directories inc_dirs)
   set(_tmp)
   package_get_all_activated_packages(_activated_list)
 
   foreach(_pkg_name ${_activated_list})
     foreach(_type SRCS PUBLIC_HEADERS PRIVATE_HEADERS)
       foreach(_file ${${_pkg_name}_${_type}})
         get_filename_component(_path "${_file}" PATH)
         list(APPEND _tmp "${_path}")
       endforeach()
     endforeach()
   endforeach()
 
   if(_tmp)
     list(REMOVE_DUPLICATES _tmp)
   endif()
 
   set(${inc_dirs} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get external libraries informations
 # ------------------------------------------------------------------------------
 function(package_get_all_external_informations INCLUDE_DIR LIBRARIES)
   _package_get_variable_for_activated(INCLUDE_DIR tmp_INCLUDE_DIR)
   _package_get_variable_for_activated(LIBRARIES tmp_LIBRARIES)
 
   set(${INCLUDE_DIR} ${tmp_INCLUDE_DIR} PARENT_SCOPE)
   set(${LIBRARIES}   ${tmp_LIBRARIES}   PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get export list for all activated packages
 # ------------------------------------------------------------------------------
 function(package_get_all_export_list export_list)
   _package_get_variable_for_activated(EXPORT_LIST _tmp)
   set(${export_list} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get definitions like external projects
 # ------------------------------------------------------------------------------
 function(package_get_all_definitions definitions)
   _package_get_variable_for_activated(OPTION_NAME _tmp)
   set(${definitions} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get extra dependencies like external projects
 # ------------------------------------------------------------------------------
 function(package_get_all_extra_dependencies deps)
   _package_get_variable_for_activated(EXTRA_DEPENDENCY _tmp)
   set(${deps} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get extra infos
 # ------------------------------------------------------------------------------
 function(package_get_all_test_folders TEST_DIRS)
   _package_get_variable_for_activated(TEST_FOLDER _tmp)
   set(${TEST_DIRS} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get compilation flags
 # ------------------------------------------------------------------------------
 function(package_get_all_compilation_flags LANG FLAGS)
   _package_get_variable_for_activated(COMPILE_${LANG}_FLAGS _tmp_flags)
   string(REPLACE ";" " " _flags "${_tmp_flags}")
   set(${FLAGS} ${_flags} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Documentation informations
 # ------------------------------------------------------------------------------
 function(package_get_all_documentation_files doc_files)
   set(_tmp_DOC_FILES)
 
   package_get_all_activated_packages(_activated_list)
   foreach(_pkg_name ${_activated_list})
     _package_get_manual_folder(${_pkg_name} _doc_dir)
     _package_get_documentation_files(${_pkg_name} _doc_files)
 
     foreach(_doc_file ${_doc_files})
       list(APPEND _tmp_DOC_FILES ${_doc_dir}/${_doc_file})
     endforeach()
   endforeach()
 
   if(_tmp_DOC_FILES)
     list(REMOVE_DUPLICATES _tmp_DOC_FILES)
   endif()
 
   set(${doc_files} ${_tmp_DOC_FILES} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get package systems dependencies
 # ------------------------------------------------------------------------------
 function(package_get_all_package_system_dependency system deps)
   string(TOUPPER ${system} _u_system)
   _package_get_variable_for_activated(PACKAGE_SYSTEM_${_u_system} _tmp)
   set(${deps} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # List packages
 # ------------------------------------------------------------------------------
 function(package_get_all_activated_packages activated_list)
   package_get_project_variable(ACTIVATED_PACKAGE_LIST _activated_list)
   set(${activated_list} ${_activated_list} PARENT_SCOPE)
 endfunction()
 
 function(package_get_all_deactivated_packages deactivated_list)
   package_get_project_variable(DEACTIVATED_PACKAGE_LIST _deactivated_list)
   set(${deactivated_list} ${_deactivated_list} PARENT_SCOPE)
 endfunction()
 
 function(package_get_all_packages packages_list)
   package_get_project_variable(ALL_PACKAGES_LIST _packages_list)
   set(${packages_list} ${_packages_list} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # List all the needed features
 # ------------------------------------------------------------------------------
 function(package_get_all_features_public features)
   _package_get_variable_for_activated(FEATURES_PUBLIC _tmp)
   set(${features} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_get_all_features_private features)
   _package_get_variable_for_activated(FEATURES_PRIVATE _tmp)
   set(${features} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Callbacks
 # ------------------------------------------------------------------------------
 function(package_on_enabled_script pkg script)
   package_get_name(${pkg} _pkg_name)
   _package_on_enable_script(${_pkg_name} "${script}")
 endfunction()
 
 # ------------------------------------------------------------------------------
 # list all the packages in the PACKAGE_FOLDER
 # extra packages can be given with an EXTRA_PACKAGE_FOLDER
 # <package_folder>/<package>.cmake
 #
 # Extra packages folder structure
 # <extra_package_folder>/<package>/package.cmake
 #                                 /src
 #                                 /test
 #                                 /manual
 #
 # ------------------------------------------------------------------------------
 function(package_list_packages PACKAGE_FOLDER)
   cmake_parse_arguments(_opt_pkg
     "NO_AUTO_COMPILE_FLAGS"
     "SOURCE_FOLDER;EXTRA_PACKAGES_FOLDER;TEST_FOLDER;MANUAL_FOLDER"
     ""
     ${ARGN})
 
   string(TOUPPER ${PROJECT_NAME} _project)
 
   # Cleaning some states to start correctly
   package_get_all_packages(_already_loaded_pkg)
   foreach(_pkg_name ${_already_loaded_pkg})
     _package_unset_extra_dependencies(${_pkg_name})
     _package_unset_dependencies(${_pkg_name})
     _package_unset_activated(${_pkg_name})
   endforeach()
 
 
   if(_opt_pkg_SOURCE_FOLDER)
     set(_src_folder "${_opt_pkg_SOURCE_FOLDER}")
   else()
     set(_src_folder "src/")
   endif()
 
   get_filename_component(_abs_src_folder ${_src_folder} ABSOLUTE)
 
   if(_opt_pkg_TEST_FOLDER)
     set(_test_folder "${_opt_pkg_TEST_FOLDER}")
   else()
     set(_test_folder "test/")
   endif()
 
   if(_opt_pkg_MANUAL_FOLDER)
     set(_manual_folder "${_opt_pkg_MANUAL_FOLDER}")
   else()
     set(_manual_folder "doc/manual")
   endif()
 
   if(_opt_pkg_NO_AUTO_COMPILE_FLAGS)
     package_set_project_variable(NO_AUTO_COMPILE_FLAGS TRUE)
   else()
     package_set_project_variable(NO_AUTO_COMPILE_FLAGS FALSE)
   endif()
 
 
   get_filename_component(_abs_test_folder ${_test_folder} ABSOLUTE)
   get_filename_component(_abs_manual_folder ${_manual_folder} ABSOLUTE)
 
   # check all the packages in the <package_folder>
   file(GLOB _package_list "${PACKAGE_FOLDER}/*.cmake")
 
   set(_package_files)
   foreach(_pkg ${_package_list})
     get_filename_component(_basename ${_pkg} NAME)
     if(NOT _basename MATCHES "^\\.#.*")
       list(APPEND _package_files ${_basename})
     endif()
   endforeach()
 
   if(_package_files)
     list(SORT _package_files)
   endif()
 
   # check all packages
   set(_packages_list_all)
   foreach(_pkg_file ${_package_files})
     string(REGEX REPLACE "[0-9]+_" "" _pkg_file_stripped ${_pkg_file})
     string(REGEX REPLACE "\\.cmake" "" _pkg ${_pkg_file_stripped})
 
     set(_current_src_folder "${_abs_src_folder}" CACHE INTERNAL "" FORCE)
     set(_current_test_folder "${_abs_test_folder}" CACHE INTERNAL "" FORCE)
     set(_current_manual_folder "${_abs_manual_folder}" CACHE INTERNAL "" FORCE)
 
     include("${PACKAGE_FOLDER}/${_pkg_file}")
 
     unset(_current_src_folder CACHE)
     unset(_current_test_folder CACHE)
     unset(_current_manual_folder CACHE)
   endforeach()
 
   # check the extra_packages if they exists
   if(_opt_pkg_EXTRA_PACKAGES_FOLDER)
     file(GLOB _extra_package_list RELATIVE
       "${_opt_pkg_EXTRA_PACKAGES_FOLDER}" "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/*")
     foreach(_pkg ${_extra_package_list})
       if(EXISTS "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/package.cmake")
 
         package_get_name(${_pkg} _pkg_name)
 
         _package_set_filename(${_pkg_name}
           "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/package.cmake")
 
         set(_current_src_folder "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/src" CACHE INTERNAL "" FORCE)
 
         if(EXISTS "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/test")
           set(_current_test_folder "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/test" CACHE INTERNAL "" FORCE)
         endif()
 
         if(EXISTS "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/manual")
           set(_current_manual_folder "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/manual" CACHE INTERNAL "" FORCE)
         endif()
 
         list(APPEND _extra_pkg_src_folders "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/src")
 
         include("${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/package.cmake")
 
         unset(_current_src_folder CACHE)
         unset(_current_test_folder CACHE)
         unset(_current_manual_folder CACHE)
       endif()
     endforeach()
   endif()
 
   _package_build_rdependencies()
   _package_load_packages()
   _package_check_files_exists()
   _package_check_files_registered(${_abs_src_folder} ${_extra_pkg_src_folders})
 
   # Load boost components if boost was loaded
   package_is_activated(Boost _ret)
   if(_ret)
     _package_load_boost_components()
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # macro to include internal/external packages packages
 # package_declare(<package real name>
 #                 [EXTERNAL] [META] [ADVANCED] [NOT_OPTIONAL]
 #                 [DESCRIPTION <description>] [DEFAULT <default_value>]
 #                 [DEPENDS <pkg> ...]
 #                 [BOOST_COMPONENTS <pkg> ...]
 #                 [EXTRA_PACKAGE_OPTIONS <opt> ...]
 #                 [COMPILE_FLAGS <lang> <flags>]
 #                 [SYSTEM <bool> [ <script_to_compile> ]]
+#                 [FALLBACK_ON_SYSTEM_MISSING <bool>]
 #                 [FEATURES_PUBLIC <feature> ...]
 #                 [FEATURES_PRIVATE <feature> ...])
 # ------------------------------------------------------------------------------
 function(package_declare pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_real_name(${_pkg_name} ${pkg})
   _package_set_filename(${_pkg_name} "${CMAKE_CURRENT_LIST_FILE}")
 
   _package_set_sources_folder(${_pkg_name} "${_current_src_folder}")
 
   _package_variable_unset(SRCS ${_pkg_name})
   _package_variable_unset(PUBLIC_HEADERS ${_pkg_name})
   _package_variable_unset(PRIVATE_HEADERS ${_pkg_name})
 
   if(_current_test_folder)
     _package_set_tests_folder(${_pkg_name} "${_current_test_folder}")
   endif()
 
   if(_current_manual_folder)
     _package_set_manual_folder(${_pkg_name} "${_current_manual_folder}")
   endif()
 
   package_get_project_variable(ALL_PACKAGES_LIST _tmp_pkg_list)
   list(APPEND _tmp_pkg_list ${_pkg_name})
   list(REMOVE_DUPLICATES _tmp_pkg_list)
   package_set_project_variable(ALL_PACKAGES_LIST ${_tmp_pkg_list})
 
   set(_options
     EXTERNAL
     NOT_OPTIONAL
     META
     ADVANCED)
   set(_one_valued_options
     DEFAULT
-    DESCRIPTION)
+    DESCRIPTION
+    FALLBACK_ON_SYSTEM_MISSING
+    EXCLUDE_FROM_ALL)
   set(_multi_valued_options
     DEPENDS
     EXTRA_PACKAGE_OPTIONS
-    COMPILE_FLAGS BOOST_COMPONENTS
+    COMPILE_FLAGS
+    BOOST_COMPONENTS
     SYSTEM
     FEATURES_PUBLIC
     FEATURES_PRIVATE)
 
   cmake_parse_arguments(_opt_pkg
     "${_options}"
     "${_one_valued_options}"
     "${_multi_valued_options}"
     ${ARGN})
 
   if(_opt_pkg_UNPARSED_ARGUMENTS)
     message("You gave to many arguments while registering the package ${pkg} \"${_opt_pkg_UNPARSED_ARGUMENTS}\"")
   endif()
 
   # set the nature
   if(_opt_pkg_EXTERNAL)
     _package_set_nature(${_pkg_name} "external")
   elseif(_opt_pkg_META)
     _package_set_nature(${_pkg_name} "meta")
   else()
     _package_set_nature(${_pkg_name} "internal")
   endif()
 
   _package_declare_option(${_pkg_name})
 
   # set description
   if(_opt_pkg_DESCRIPTION)
     _package_set_description(${_pkg_name} ${_opt_pkg_DESCRIPTION})
   else()
     _package_set_description(${_pkg_name} "")
   endif()
 
   _package_get_option_name(${_pkg_name} _option_name)
   _package_get_description(${_pkg_name} _description)
 
   # get the default value
   if(DEFINED _opt_pkg_DEFAULT)
     set(_default ${_opt_pkg_DEFAULT})
   else()
     if(_opt_pkg_NOT_OPTIONAL)
       set(_default ON)
     else()
       set(_default OFF)
     endif()
   endif()
 
   # set the option if needed
   if(_opt_pkg_NOT_OPTIONAL)
     _package_get_nature(${_pkg_name} _nature)
     _package_set_nature(${_pkg_name} "${_nature}_not_optional")
     set(${_option_name} ${_default} CACHE INTERNAL "${_description}" FORCE)
   else()
     option(${_option_name} "${_description}" ${_default})
     if(_opt_pkg_ADVANCED OR _opt_pkg_EXTERNAL)
       mark_as_advanced(${_option_name})
     endif()
   endif()
 
   # Set the option for third-partie that can be compiled as an ExternalProject
   if(DEFINED _opt_pkg_SYSTEM)
     list(LENGTH _opt_pkg_SYSTEM _length)
     list(GET _opt_pkg_SYSTEM 0 _bool)
     _package_set_system_option(${_pkg_name} ${_bool})
     if(_length GREATER 1)
       list(GET _opt_pkg_SYSTEM 1 _script)
       _package_set_system_script(${_pkg_name} ${_script})
+      if(_opt_pkg_FALLBACK_ON_SYSTEM_MISSING)
+        _package_set_variable(SYSTEM_FALLBACK ${_pkg_name} ${_opt_pkg_FALLBACK_ON_SYSTEM_MISSING})
+      else()
+        _package_set_variable(SYSTEM_FALLBACK ${_pkg_name} OFF)
+      endif()
     endif()
   endif()
 
+  if(_opt_pkg_EXCLUDE_FROM_ALL)
+    _package_set_variable(EXCLUDE_FROM_ALL ${_pkg_name} ${_opt_pkg_EXCLUDE_FROM_ALL})
+  endif()
+
   # set the dependecies
   if(_opt_pkg_DEPENDS)
     set(_depends)
     foreach(_dep ${_opt_pkg_DEPENDS})
       package_get_name(${_dep} _dep_pkg_name)
       list(APPEND _depends ${_dep_pkg_name})
     endforeach()
     _package_add_dependencies(${_pkg_name} ${_depends})
   endif()
 
   # keep the extra option for the future find package
   if(_opt_pkg_EXTRA_PACKAGE_OPTIONS)
     _package_set_find_package_extra_options(${_pkg_name} "${_opt_pkg_EXTRA_PACKAGE_OPTIONS}")
   endif()
 
   # register the compilation flags
   if(_opt_pkg_COMPILE_FLAGS)
     set(_languages C CXX Fortran)
     cmake_parse_arguments(_compile_flags
       "" "" "${_languages}"
       ${_opt_pkg_COMPILE_FLAGS}
       )
 
 
     # this is done to maintain backward compatibility
     if(_compile_flags_UNPARSED_ARGUMENTS)
       set(_compile_flags_CXX ${_compile_flags_UNPARSED_ARGUMENTS})
     endif()
 
     foreach(_lang ${_languages})
       if(_compile_flags_${_lang})
         _package_set_compile_flags(${_pkg_name} ${_lang} ${_compile_flags_${_lang}})
       else()
         _package_unset_compile_flags(${_pkg_name} ${_lang})
       endif()
     endforeach()
   endif()
 
   # set the boost dependencies
   if(_opt_pkg_BOOST_COMPONENTS)
     _package_set_boost_component_needed(${_pkg_name} "${_opt_pkg_BOOST_COMPONENTS}")
   endif()
 
   if(_opt_pkg_FEATURES_PUBLIC)
     _package_set_variable(FEATURES_PUBLIC ${_pkg_name} "${_opt_pkg_FEATURES_PUBLIC}")
   endif()
 
   if(_opt_pkg_FEATURES_PRIVATE)
     _package_set_variable(FEATURES_PRIVATE ${_pkg_name} "${_opt_pkg_FEATURES_PRIVATE}")
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # declare the source files of a given package
 #
 # package_declare_sources(<package> <list of sources>
 #                         SOURCES <source file> ...
 #                         PUBLIC_HEADER <header file> ...
 #                         PRIVATE_HEADER <header file> ...)
 # ------------------------------------------------------------------------------
 function(package_declare_sources pkg)
   package_get_name(${pkg} _pkg_name)
 
   # get 3 lists, if none of the options given try to distinguish the different lists
   cmake_parse_arguments(_opt_pkg
     ""
     ""
     "SOURCES;PUBLIC_HEADERS;PRIVATE_HEADERS"
     ${ARGN})
 
   set(_tmp_srcs     ${_opt_pkg_SOURCES})
   set(_tmp_pub_hdrs ${_opt_pkg_PUBLIC_HEADER})
   set(_tmp_pri_hdrs ${_opt_pkg_PRIVATE_HEADERS})
 
   foreach(_file ${_opt_pkg_UNPARSED_ARGUMENTS})
     if(${_file} MATCHES ".*inline.*\\.cc")
       list(APPEND _tmp_pub_hdrs ${_file})
     elseif(${_file} MATCHES ".*\\.h+")
       list(APPEND _tmp_pub_hdrs ${_file})
     else()
       list(APPEND _tmp_srcs ${_file})
     endif()
   endforeach()
 
   _package_get_sources_folder(${_pkg_name} _src_folder)
 
   foreach(_type _srcs _pub_hdrs _pri_hdrs)
     set(${_type})
     foreach(_file ${_tmp${_type}})
       # get the full name
       list(APPEND ${_type} "${_src_folder}/${_file}")
     endforeach()
   endforeach()
 
   set(${_pkg_name}_SRCS "${_srcs}"
     CACHE INTERNAL "List of sources files" FORCE)
   set(${_pkg_name}_PUBLIC_HEADERS  "${_pub_hdrs}"
     CACHE INTERNAL "List of public header files" FORCE)
   set(${_pkg_name}_PRIVATE_HEADERS "${_pri_hdrs}"
     CACHE INTERNAL "List of private header files" FORCE)
 endfunction()
 
 # ------------------------------------------------------------------------------
diff --git a/cmake/Modules/CMakePackagesSystemPrivateFunctions.cmake b/cmake/Modules/CMakePackagesSystemPrivateFunctions.cmake
index 7b579961b..d2d80a32d 100644
--- a/cmake/Modules/CMakePackagesSystemPrivateFunctions.cmake
+++ b/cmake/Modules/CMakePackagesSystemPrivateFunctions.cmake
@@ -1,924 +1,936 @@
 #===============================================================================
 # @file   CMakePackagesSystemPrivateFunctions.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Sat Jul 18 2015
 # @date last modification: Wed Jan 20 2016
 #
 # @brief  Set of macros used by the package system, internal functions
 #
 # @section LICENSE
 #
 # Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
 # (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free  software: you can redistribute it and/or  modify it under the
 # terms  of the  GNU Lesser  General Public  License as  published by  the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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  Lesser General  Public License  for more
 # details.
 #
 # You should  have received  a copy  of the GNU  Lesser General  Public License
 # along with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 # ==============================================================================
 # "Private" Accessors
 # ==============================================================================
 # ------------------------------------------------------------------------------
 # Real name
 # ------------------------------------------------------------------------------
 function(_package_get_real_name pkg_name real_name)
   set(${real_name} ${${pkg_name}} PARENT_SCOPE)
 endfunction()
 
 function(_package_set_real_name pkg_name real_name)
   set(${pkg_name} ${real_name} CACHE INTERNAL "" FORCE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Option name
 # ------------------------------------------------------------------------------
 function(_package_declare_option pkg_name)
   string(TOUPPER "${PROJECT_NAME}" _project)
   _package_get_real_name(${pkg_name} _real_name)
   string(TOUPPER "${_real_name}" _u_package)
 
   _package_get_nature(${pkg_name} _nature)
 
   if(${_nature} MATCHES "internal" OR ${_nature} MATCHES "meta")
     set(_opt_name ${_project}_${_u_package})
   elseif(${_nature} MATCHES "external")
     set(_opt_name ${_project}_USE_${_u_package})
   else()
     set(_opt_name UNKNOWN_NATURE_${_project}_${_u_package})
   endif()
 
   _package_set_variable(OPTION_NAME ${pkg_name} ${_opt_name})
 endfunction()
 
 function(_package_get_option_name pkg_name opt_name)
   _package_get_variable(OPTION_NAME ${pkg_name} _opt_name)
   set(${opt_name} ${_opt_name} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Set if system package or compile external lib
 # ------------------------------------------------------------------------------
 function(_package_set_system_option pkg_name default)
   string(TOUPPER "${PROJECT_NAME}" _project)
   _package_get_real_name(${pkg_name} _real_name)
   string(TOUPPER "${_real_name}" _u_package)
 
   option(${_project}_USE_SYSTEM_${_u_package}
     "Should akantu compile the third-party: \"${_real_name}\"" ${default})
   mark_as_advanced(${_project}_USE_SYSTEM_${_u_package})
 endfunction()
 
 function(_package_use_system pkg_name use)
   string(TOUPPER "${PROJECT_NAME}" _project)
   _package_get_real_name(${pkg_name} _real_name)
   string(TOUPPER "${_real_name}" _u_package)
   if(DEFINED ${_project}_USE_SYSTEM_${_u_package})
     set(${use} ${${_project}_USE_SYSTEM_${_u_package}} PARENT_SCOPE)
   else()
     set(${use} TRUE PARENT_SCOPE)
   endif()
 endfunction()
 
 function(_package_set_system_script pkg_name script)
   _package_set_variable(COMPILE_SCRIPT ${pkg_name} "${script}")
 endfunction()
 
 function(_package_add_third_party_script_variable pkg_name var)
   _package_set_variable(VARIABLE_${var} ${pkg_name} "${ARGN}")
   set(${var} ${ARGN} PARENT_SCOPE)
 endfunction()
 
 function(_package_load_third_party_script pkg_name)
   if(${pkg_name}_COMPILE_SCRIPT)
     # set the stored variable
     get_cmake_property(_all_vars VARIABLES)
     foreach(_var ${_all_vars})
       if(_var MATCHES "^${pkg_name}_VARIABLE_.*")
         string(REPLACE "${pkg_name}_VARIABLE_" "" _orig_var "${_var}")
         set(${_orig_var} ${${_var}})
       endif()
     endforeach()
 
     _package_get_real_name(${pkg_name} _name)
     string(TOUPPER "${_name}" _u_name)
 
     _package_get_option_name(${pkg_name} _opt_name)
     if(${_opt_name}_VERSION)
       set(_version "${${_opt_name}_VERSION}")
       set(${_u_name}_VERSION "${_version}" CACHE INTERNAL "" FORCE)
     elseif(${_u_name}_VERSION)
       set(_version "${${_u_name}_VERSION}")
     endif()
 
     # load the script
     include(ExternalProject)
     include(${${pkg_name}_COMPILE_SCRIPT})
 
     if(${_u_name}_LIBRARIES)
       _package_set_libraries(${pkg_name} ${${_u_name}_LIBRARIES})
       list(APPEND _required_vars ${_u_name}_LIBRARIES)
     endif()
     if(${_u_name}_INCLUDE_DIR)
       _package_set_include_dir(${pkg_name} ${${_u_name}_INCLUDE_DIR})
       list(APPEND _required_vars ${_u_name}_INCLUDE_DIR)
     endif()
 
     include(FindPackageHandleStandardArgs)
     if(CMAKE_VERSION VERSION_GREATER 2.8.12)
       find_package_handle_standard_args(${_name}
         REQUIRED_VARS ${_required_vars}
         VERSION_VAR _version
         FAIL_MESSAGE "Something was not configured by a the third-party script for ${_name}"
         )
     else()
       find_package_handle_standard_args(${_name}
         "Something was not configured by a the third-party script for ${_name}"
         ${_required_vars}
         )
     endif()
   endif()
   set(${pkg_name}_USE_SYSTEM_PREVIOUS FALSE CACHE INTERNAL "" FORCE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Nature
 # ------------------------------------------------------------------------------
 function(_package_set_nature pkg_name nature)
   _package_set_variable(NATURE ${pkg_name} ${nature})
 endfunction()
 
 function(_package_get_nature pkg_name nature)
   _package_get_variable(NATURE ${pkg_name} _nature "unknown")
   set(${nature} ${_nature} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Description
 # ------------------------------------------------------------------------------
 function(_package_set_description pkg_name desc)
   _package_set_variable(DESC ${pkg_name} ${desc})
 endfunction()
 
 function(_package_get_description pkg_name desc)
   _package_get_variable(DESC ${pkg_name} _desc "No description set for the package ${${pkg_name}} (${pkg_name})")
   set(${desc} ${_desc} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Package file name
 # ------------------------------------------------------------------------------
 function(_package_set_filename pkg_name file)
   _package_set_variable(FILE ${pkg_name} ${file})
 endfunction()
 
 function(_package_get_filename pkg_name file)
   _package_get_variable(FILE ${pkg_name} _file "No filename set for the package ${${pkg_name}}")
   set(${file} ${_file} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Source folder
 # ------------------------------------------------------------------------------
 function(_package_set_sources_folder pkg_name src_folder)
   _package_set_variable(SRC_FOLDER ${pkg_name} ${src_folder})
 endfunction()
 
 function(_package_get_sources_folder pkg_name src_folder)
   _package_get_variable(SRC_FOLDER ${pkg_name} _src_folder)
   set(${src_folder} ${_src_folder} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Test folder
 # ------------------------------------------------------------------------------
 function(_package_set_tests_folder pkg_name test_folder)
   _package_set_variable(TEST_FOLDER ${pkg_name} ${test_folder})
 endfunction()
 
 function(_package_get_tests_folder pkg_name test_folder)
   _package_get_variable(TEST_FOLDER ${pkg_name} _test_folder)
   set(${test_folder} ${_test_folder} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Manual folder
 # ------------------------------------------------------------------------------
 function(_package_set_manual_folder pkg_name manual_folder)
   _package_set_variable(MANUAL_FOLDER ${pkg_name} ${manual_folder})
 endfunction()
 
 function(_package_get_manual_folder pkg_name manual_folder)
   _package_get_variable(MANUAL_FOLDER ${pkg_name} _manual_folder)
   set(${manual_folder} ${_manual_folder} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Extra option for the find_package
 # ------------------------------------------------------------------------------
 function(_package_set_find_package_extra_options pkg_name)
   _package_set_variable(FIND_PKG_OPTIONS ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_find_package_extra_options pkg_name options)
   _package_get_variable(FIND_PKG_OPTIONS ${pkg_name} _options)
   set(${options} ${_options} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Compilation flags
 # ------------------------------------------------------------------------------
 function(_package_set_compile_flags pkg_name lang)
   _package_set_variable(COMPILE_${lang}_FLAGS ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_unset_compile_flags pkg_name lang)
   _package_variable_unset(COMPILE_${lang}_FLAGS ${pkg_name})
 endfunction()
 
 function(_package_get_compile_flags pkg_name lang flags)
   _package_get_variable(COMPILE_${lang}_FLAGS ${pkg_name} _tmp_flags)
   string(REPLACE ";" " " _flags "${_tmp_flags}")
   set(${flags} "${_flags}" PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Include dir
 # ------------------------------------------------------------------------------
 function(_package_set_include_dir pkg_name)
   _package_set_variable(INCLUDE_DIR ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_include_dir pkg_name include_dir)
   _package_get_variable(INCLUDE_DIR ${pkg_name} _include_dir "")
   set(${include_dir} ${_include_dir} PARENT_SCOPE)
 endfunction()
 
 function(_package_add_include_dir pkg_name)
   _package_add_to_variable(INCLUDE_DIR ${pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Libraries
 # ------------------------------------------------------------------------------
 function(_package_set_libraries pkg_name)
   _package_set_variable(LIBRARIES ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_libraries pkg_name libraries)
   _package_get_variable(LIBRARIES ${pkg_name} _libraries "")
   set(${libraries} ${_libraries} PARENT_SCOPE)
 endfunction()
 
 function(_package_add_libraries pkg_name)
   _package_add_to_variable(LIBRARIES ${pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Extra dependencies like custom commands of ExternalProject
 # ------------------------------------------------------------------------------
 function(_package_add_extra_dependency pkg_name)
   _package_add_to_variable(EXTRA_DEPENDENCY ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_rm_extra_dependency pkg_name dep)
   _package_remove_from_variable(EXTRA_DEPENDENCY ${pkg_name} ${dep})
 endfunction()
 
 function(_package_set_extra_dependencies pkg)
   _package_set_variable(EXTRA_DEPENDENCY ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_extra_dependencies pkg deps)
   _package_get_variable(EXTRA_DEPENDENCY ${pkg_name} _deps "")
   set(${deps} ${_deps} PARENT_SCOPE)
 endfunction()
 
 function(_package_unset_extra_dependencies pkg_name)
   _package_variable_unset(EXTRA_DEPENDENCY ${pkg_name})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Activate/deactivate
 # ------------------------------------------------------------------------------
 function(_package_activate pkg_name)
   _package_set_variable(STATE ${pkg_name} ON)
 endfunction()
 
 function(_package_deactivate pkg_name)
   _package_set_variable(STATE ${pkg_name} OFF)
 endfunction()
 
 function(_package_is_activated pkg_name act)
   _package_get_variable(STATE ${pkg_name} _state OFF)
   if(_state)
     set(${act} TRUE PARENT_SCOPE)
   else()
     set(${act} FALSE PARENT_SCOPE)
   endif()
 endfunction()
 
 function(_package_is_deactivated pkg_name act)
   _package_get_variable(STATE ${pkg_name} _state OFF)
   if(NOT _state)
     set(${act} TRUE PARENT_SCOPE)
   else()
     set(${act} FALSE PARENT_SCOPE)
   endif()
 endfunction()
 
 function(_package_unset_activated pkg_name)
   _package_variable_unset(STATE ${pkg_name})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Callbacks
 # ------------------------------------------------------------------------------
 function(_package_on_enable_script pkg_name script)
   string(TOLOWER "${pkg_name}" _l_pkg_name)
   set(_output_file "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${_l_pkg_name}.cmake")
   file(WRITE "${_output_file}"
     "${script}")
   _package_set_variable(CALLBACK_SCRIPT ${pkg_name} "${_output_file}")
 endfunction()
 
 function(_package_get_callback_script pkg_name filename)
   _package_get_variable(CALLBACK_SCRIPT ${pkg_name} _filename NOTFOUND)
   set(${filename} ${_filename} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Export list
 # ------------------------------------------------------------------------------
 function(_package_add_to_export_list pkg_name)
   _package_add_to_variable(EXPORT_LIST ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_export_list pkg_name export_list)
   _package_get_variable(EXPORT_LIST ${pkg_name} _export_list)
   set(${export_list} ${_export_list} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Direct dependencies
 # ------------------------------------------------------------------------------
 function(_package_add_dependencies pkg_name)
   _package_add_to_variable(DEPENDENCIES ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_dependencies pkg_name dependencies)
   _package_get_variable(DEPENDENCIES ${pkg_name} _dependencies)
   set(${dependencies} ${_dependencies} PARENT_SCOPE)
 endfunction()
 
 function(_package_unset_dependencies pkg_name)
   _package_variable_unset(DEPENDENCIES ${pkg_name})
 endfunction()
 
 function(_package_remove_dependency pkg_name dep)
   set(_deps ${${pkg_name}_DEPENDENCIES})
 
   _package_get_fdependencies(${dep} _fdeps)
 
   # check if this is the last reverse dependency
   list(LENGTH _fdeps len)
   list(FIND _fdeps ${pkg_name} pos)
   if((len EQUAL 1) AND (NOT pos EQUAL -1))
     _package_get_description(${dep} _dep_desc)
     _package_get_option_name(${dep} _dep_option_name)
     set(${_dep_option_name} ${${dep}_OLD} CACHE BOOL "${_dep_desc}" FORCE)
     unset(${dep}_OLD CACHE)
   endif()
 
   # remove the pkg_name form the reverse dependency
   _package_remove_fdependency(${dep} ${pkg_name})
 
   list(FIND _deps ${dep} pos)
   if(NOT pos EQUAL -1)
     list(REMOVE_AT _deps ${pos})
     _package_set_variable(DEPENDENCIES ${pkg_name} ${_deps})
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Functions to handle reverse dependencies
 # ------------------------------------------------------------------------------
 function(_package_set_rdependencies pkg_name)
   _package_set_variable(RDEPENDENCIES ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_rdependencies pkg_name rdependencies)
   _package_get_variable(RDEPENDENCIES ${pkg_name} _rdependencies)
   set(${rdependencies} ${_rdependencies} PARENT_SCOPE)
 endfunction()
 
 function(_package_add_rdependency pkg_name rdep)
   # store the reverse dependency
   _package_add_to_variable(RDEPENDENCIES ${pkg_name} ${rdep})
 endfunction()
 
 function(_package_remove_rdependency pkg_name rdep)
   _package_remove_from_variable(RDEPENDENCIES ${pkg_name} ${rdep})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Function to handle forcing dependencies (Package turn ON that enforce their
 # dependencies ON)
 # ------------------------------------------------------------------------------
 function(_package_set_fdependencies pkg_name)
   _package_set_variable(FDEPENDENCIES ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_fdependencies pkg_name fdependencies)
   _package_get_variable(FDEPENDENCIES ${pkg_name} _fdependencies)
   set(${fdependencies} ${_fdependencies} PARENT_SCOPE)
 endfunction()
 
 function(_package_add_fdependency pkg_name fdep)
   # store the reverse dependency
   _package_add_to_variable(FDEPENDENCIES ${pkg_name} ${fdep})
 endfunction()
 
 function(_package_remove_fdependency pkg_name fdep)
   _package_remove_from_variable(FDEPENDENCIES ${pkg_name} ${fdep})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Exteral package system as apt rpm dependencies
 # ------------------------------------------------------------------------------
 function(_package_set_package_system_dependency pkg system)
   string(TOUPPER "${_system}" _u_system)
   _package_set_variable(PACKAGE_SYSTEM_${_u_system} ${_pkg_name} ${ARGN})
 endfunction()
 
 
 function(_package_get_package_system_dependency pkg system var)
   string(TOUPPER "${_system}" _u_system)
   _package_get_variable(PACKAGE_SYSTEM_${_u_system} ${_pkg_name} ${_deps})
   set(${var} ${_deps} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Documentation related functions
 # ------------------------------------------------------------------------------
 function(_package_set_documentation_files pkg_name)
   _package_set_variable(DOCUMENTATION_FILES ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_documentation_files pkg_name doc_files)
   _package_get_variable(DOCUMENTATION_FILES ${pkg_name} _doc_files "")
   set(${doc_files} ${_doc_files} PARENT_SCOPE)
 endfunction()
 
 function(_package_set_documentation pkg_name)
   # \n replaced by && and \\ by ££ to avoid cache problems
   set(_doc_str "")
   foreach(_str ${ARGN})
     set(_doc_str "${_doc_str}&&${_str}")
   endforeach()
 
   string(REPLACE "\\" "££" _doc_escaped "${_doc_str}")
 
   _package_set_variable(DOCUMENTATION ${pkg_name} "${_doc_str}")
 endfunction()
 
 function(_package_get_documentation pkg_name _doc)
   # \n replaced by && and \\ by ££ to avoid cache problems
   _package_get_variable(DOCUMENTATION ${pkg_name} _doc_tmp "")
 
   string(REPLACE "££" "\\" _doc_escaped "${_doc_tmp}")
   string(REPLACE "&&" "\n" _doc_newlines "${_doc_escaped}")
   set(${_doc} "${_doc_newlines}" PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Special boost thingy
 # ------------------------------------------------------------------------------
 function(_package_set_boost_component_needed pkg_name)
   _package_add_to_variable(BOOST_COMPONENTS_NEEDED ${pkg_name} ${ARGN})
   package_get_name(Boost _boost_pkg_name)
   _package_add_dependencies(${pkg_name} ${_boost_pkg_name})
 endfunction()
 
 function(_package_get_boost_component_needed pkg_name needed)
   _package_get_variable(BOOST_COMPONENTS_NEEDED ${pkg_name} _needed)
   set(${needed} ${_needed} PARENT_SCOPE)
 endfunction()
 
 function(_package_load_boost_components)
   string(TOUPPER ${PROJECT_NAME} _project)
 
   _package_get_variable_for_activated(BOOST_COMPONENTS_NEEDED _boost_needed_components)
   package_get_name(Boost _pkg_name)
 
   if(_boost_needed_components)
     message(STATUS "Looking for Boost liraries: ${_boost_needed_components}")
     foreach(_comp ${_boost_needed_components})
       find_package(Boost COMPONENTS ${_comp} QUIET)
       string(TOUPPER ${_comp} _u_comp)
       if(Boost_${_u_comp}_FOUND)
         message(STATUS "   ${_comp}: FOUND")
         package_set_project_variable(BOOST_${_u_comp} TRUE)
 
         # Generate the libraries for the package
         _package_add_libraries(${_pkg_name} ${Boost_${_u_comp}_LIBRARY})
       else()
         message(STATUS "   ${_comp}: NOT FOUND")
       endif()
     endforeach()
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # get the list of source files for a given package
 # ------------------------------------------------------------------------------
 function(_package_get_source_files pkg_name SRCS PUBLIC_HEADERS PRIVATE_HEADERS)
   string(TOUPPER ${PROJECT_NAME} _project)
 
   set(tmp_SRCS)
   set(tmp_PUBLIC_HEADERS)
   set(tmp_PRIVATE_HEADERS)
 
   foreach(_type SRCS PUBLIC_HEADERS PRIVATE_HEADERS)
     foreach(_file ${${pkg_name}_${_type}})
       string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" _rel_file "${_file}")
       list(APPEND tmp_${_type} "${_rel_file}")
     endforeach()
   endforeach()
 
   set(${SRCS}            ${tmp_SRCS}            PARENT_SCOPE)
   set(${PUBLIC_HEADERS}  ${tmp_PUBLIC_HEADERS}  PARENT_SCOPE)
   set(${PRIVATE_HEADERS} ${tmp_PRIVATE_HEADERS} PARENT_SCOPE)
 endfunction()
 
 # ==============================================================================
 # Internal functions
 # ==============================================================================
 # ------------------------------------------------------------------------------
 # Build the reverse dependencies from the dependencies
 # ------------------------------------------------------------------------------
 function(_package_build_rdependencies)
   package_get_all_packages(_pkg_list)
 
   # set empty lists
   foreach(_pkg_name ${_pkg_list})
     set(${_pkg_name}_rdeps)
   endforeach()
 
   # fill the dependencies list
   foreach(_pkg_name ${_pkg_list})
     _package_get_dependencies(${_pkg_name} _deps)
     foreach(_dep_name ${_deps})
       list(APPEND ${_dep_name}_rdeps ${_pkg_name})
     endforeach()
   endforeach()
 
   # clean and set the reverse dependencies
   foreach(_pkg_name ${_pkg_list})
     if(${_pkg_name}_rdeps)
       list(REMOVE_DUPLICATES ${_pkg_name}_rdeps)
       _package_set_rdependencies(${_pkg_name} ${${_pkg_name}_rdeps})
     endif()
   endforeach()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # This function resolve the dependance order run the needed find_packages
 # ------------------------------------------------------------------------------
 function(_package_load_packages)
   package_get_all_packages(_pkg_list)
 
   # Activate the dependencies of activated package and generate an ordered list
   # of dependencies
   set(ordered_loading_list)
   foreach(_pkg_name ${_pkg_list})
     _package_load_dependencies_package(${_pkg_name} ordered_loading_list)
   endforeach()
 
   # Load the packages in the propoer order
   foreach(_pkg_name ${ordered_loading_list})
     _package_get_option_name(${_pkg_name} _option_name)
 
     if(${_option_name})
       _package_load_package(${_pkg_name})
     else()
       # deactivate the packages than can already be deactivated
       _package_deactivate(${_pkg_name})
     endif()
   endforeach()
 
   # generates the activated and unactivated lists of packages
   set(_packages_activated)
   set(_packages_deactivated)
   foreach(_pkg_name ${_pkg_list})
     _package_is_activated(${_pkg_name} _active)
-    if(_active)
+    set(_exclude FALSE)
+    _package_get_variable(EXCLUDE_FROM_ALL ${_pkg_name} _exclude)
+    if(_active AND NOT _exclude)
       list(APPEND _packages_activated ${_pkg_name})
     else()
       list(APPEND _packages_deactivated ${_pkg_name})
     endif()
   endforeach()
 
   # generate the list usable by the calling code
   package_set_project_variable(ACTIVATED_PACKAGE_LIST "${_packages_activated}")
   package_set_project_variable(DEACTIVATED_PACKAGE_LIST "${_packages_deactivated}")
 endfunction()
 
 
 
 # ------------------------------------------------------------------------------
 # This load an external package and recursively all its dependencies
 # ------------------------------------------------------------------------------
 function(_package_load_dependencies_package pkg_name loading_list)
   # Get packages informations
   _package_get_option_name(${pkg_name} _pkg_option_name)
   _package_get_dependencies(${pkg_name} _dependencies)
 
   # handle the dependencies
   foreach(_dep_name ${_dependencies})
     _package_get_description(${_dep_name} _dep_desc)
     _package_get_option_name(${_dep_name} _dep_option_name)
 
     _package_get_fdependencies(${_dep_name} _fdeps)
     if(${_pkg_option_name})
       if("${_fdeps}" STREQUAL "")
         set(${_dep_name}_OLD ${${_dep_option_name}} CACHE INTERNAL "" FORCE)
       endif()
 
       # set the option to on
       set(${_dep_option_name} ON CACHE BOOL "${_dep_desc}" FORCE)
 
       # store the reverse dependency
       _package_add_fdependency(${_dep_name} ${pkg_name})
     else()
       # check if this is the last reverse dependency
       list(LENGTH _fdeps len)
       list(FIND _fdeps ${pkg_name} pos)
       if((len EQUAL 1) AND (NOT pos EQUAL -1))
         set(${_dep_option_name} ${${_dep_name}_OLD} CACHE BOOL "${_dep_desc}" FORCE)
         unset(${_dep_name}_OLD CACHE)
       endif()
 
       # remove the pkg_name form the reverse dependency
       _package_remove_fdependency(${_dep_name} ${pkg_name})
     endif()
 
     # recusively load the dependencies
     _package_load_dependencies_package(${_dep_name} ${loading_list})
   endforeach()
 
   # get the compile flags
   _package_get_compile_flags(${pkg_name} CXX _pkg_compile_flags)
   package_get_project_variable(NO_AUTO_COMPILE_FLAGS _no_auto_compile_flags)
 
   # if package option is on add it in the list
   if(${_pkg_option_name})
     list(FIND ${loading_list} ${pkg_name} _pos)
     if(_pos EQUAL -1)
       set(_tmp_loading_list ${${loading_list}})
       list(APPEND _tmp_loading_list ${pkg_name})
       set(${loading_list} "${_tmp_loading_list}" PARENT_SCOPE)
     endif()
 
     #add the comilation flags if needed
     if(_pkg_compile_flags AND NOT _no_auto_compile_flags)
       add_flags(cxx ${_pkg_compile_flags})
     endif()
   else()
     #remove the comilation flags if needed
     if(_pkg_comile_flags AND NOT _no_auto_compile_flags)
       remove_flags(cxx ${_pkg_compile_flags})
     endif()
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Load the package if it is an external one
 # ------------------------------------------------------------------------------
 function(_package_load_package pkg_name)
   # load the package if it is an external
   _package_get_nature(${pkg_name} _nature)
   if(${_nature} MATCHES "external")
     _package_use_system(${pkg_name} _use_system)
 
     set(_activated TRUE)
     if(_use_system)
       _package_load_external_package(${pkg_name} _activated)
-    else()
+    endif()
+
+
+    _package_get_variable(SYSTEM_FALLBACK ${pkg_name} _fallback)
+    if((NOT _use_system) OR (_fallback AND (NOT _activated)))
       _package_load_third_party_script(${pkg_name})
     endif()
 
     if(_activated)
       _package_activate(${pkg_name})
     elseif()
       _package_deactivate(${pkg_name})
     endif()
   else(${_nature})
     _package_activate(${pkg_name})
   endif()
 endfunction()
 
 
 # ------------------------------------------------------------------------------
 # Load external packages
 # ------------------------------------------------------------------------------
 function(_package_load_external_package pkg_name activate)
   _package_get_real_name(${pkg_name} _real_name)
   string(TOUPPER ${_real_name} _u_package)
 
   if(NOT ${pkg_name}_USE_SYSTEM_PREVIOUS)
     #if system was off before clear the cache of preset variables
     get_cmake_property(_all_vars VARIABLES)
     foreach(_var ${_all_vars})
       if(_var MATCHES "^${_u_package}_.*")
         unset(${_var} CACHE)
       endif()
     endforeach()
     set(${pkg_name}_USE_SYSTEM_PREVIOUS TRUE CACHE INTERNAL "" FORCE)
   endif()
 
   _package_get_find_package_extra_options(${pkg_name} _options)
   if(_options)
     cmake_parse_arguments(_opt_pkg "" "LANGUAGE" "PREFIX;FOUND;ARGS" ${_options})
     if(_opt_pkg_UNPARSED_ARGUMENTS)
       message("You passed too many options for the find_package related to ${${pkg_name}} \"${_opt_pkg_UNPARSED_ARGUMENTS}\"")
     endif()
   endif()
 
   if(_opt_pkg_LANGUAGE)
     foreach(_language ${_opt_pkg_LANGUAGE})
       enable_language(${_language})
     endforeach()
   endif()
 
 
   # find the package
-  find_package(${_real_name} REQUIRED ${_opt_pkg_ARGS})
+  set(_required REQUIRED)
+  _package_get_variable(SYSTEM_FALLBACK ${pkg_name} _fallback)
+  if(_fallback)
+    set(_required QUIET)
+  endif()
+
+  find_package(${_real_name} ${_required} ${_opt_pkg_ARGS})
 
   # check if the package is found
   if(_opt_pkg_PREFIX)
     set(_package_prefix ${_opt_pkg_PREFIX})
   else()
     set(_package_prefix ${_u_package})
   endif()
 
   set(_act FALSE)
   set(_prefix_to_consider)
   if(DEFINED _opt_pkg_FOUND)
     if(${_opt_pkg_FOUND})
       set(_act TRUE)
       set(_prefix_to_consider ${_package_prefix})
     endif()
   else()
     foreach(_prefix ${_package_prefix})
       if(${_prefix}_FOUND)
         set(_act TRUE)
         list(APPEND _prefix_to_consider ${_prefix})
       endif()
     endforeach()
   endif()
 
   if(_act)
     foreach(_prefix ${_prefix_to_consider})
       # Generate the include dir for the package
       if(DEFINED ${_prefix}_INCLUDE_DIRS)
         _package_set_include_dir(${pkg_name} ${${_prefix}_INCLUDE_DIRS})
       elseif(DEFINED ${_prefix}_INCLUDE_DIR)
         _package_set_include_dir(${pkg_name} ${${_prefix}_INCLUDE_DIR})
       elseif(DEFINED ${_prefix}_INCLUDE_PATH)
         _package_set_include_dir(${pkg_name} ${${_prefix}_INCLUDE_PATH})
       endif()
 
       # Generate the libraries for the package
       if(DEFINED ${_prefix}_LIBRARIES)
         _package_set_libraries(${pkg_name} ${${_prefix}_LIBRARIES})
       elseif(DEFINED ${_prefix}_LIBRARY)
         _package_set_libraries(${pkg_name} ${${_prefix}_LIBRARY})
       endif()
     endforeach()
 
     _package_get_callback_script(${pkg_name} _script_file)
     if(_script_file)
       include("${_script_file}")
     endif()
   endif()
   set(${activate} ${_act} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Sanity check functions
 # ------------------------------------------------------------------------------
 function(_package_check_files_exists)
   set(_message FALSE)
 
   package_get_all_packages(_pkg_list)
   foreach(_pkg_name ${_pkg_list})
     set(_pkg_files
       ${${_pkg_name}_SRCS}
       ${${_pkg_name}_PUBLIC_HEADERS}
       ${${_pkg_name}_PRIVATE_HEADERS}
       )
 
     _package_get_real_name(${_pkg_name} _real_name)
 
     foreach(_file ${_pkg_files})
       if(NOT EXISTS "${_file}")
         if(NOT _message)
           set(_message TRUE)
           message("This file(s) is(are) present in a package but are not present on disk.")
         endif()
 
         message(" PACKAGE ${_real_name} FILE ${_file}")
       endif()
     endforeach()
   endforeach()
 
   if(_message)
     message(SEND_ERROR "Please check the content of your packages to correct this warnings")
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 function(_package_check_files_registered)
   set(_pkg_files)
   package_get_all_packages(_pkg_list)
   # generates a file list of registered files
   foreach(_pkg_name ${_pkg_list})
     list(APPEND _pkg_files
       ${${_pkg_name}_SRCS}
       ${${_pkg_name}_PUBLIC_HEADERS}
       ${${_pkg_name}_PRIVATE_HEADERS}
       )
   endforeach()
 
   # generates the list of files in the source folders
   set(_all_src_files)
   foreach(_src_folder ${ARGN})
     foreach(_ext "cc" "hh" "c" "h" "hpp")
       file(GLOB_RECURSE _src_files "${_src_folder}/*.${_ext}")
       list(APPEND _all_src_files ${_src_files})
     endforeach()
   endforeach()
 
   if(_all_src_files)
     list(REMOVE_DUPLICATES _all_src_files)
   endif()
 
   set(_not_registerd_files)
   # check only sources files in the source folders
   foreach(_src_folder ${ARGN})
     foreach(_file ${_all_src_files})
       if("${_file}" MATCHES  "${_src_folder}")
         list(FIND _pkg_files "${_file}" _index)
         if (_index EQUAL -1)
           list(APPEND _not_registerd_files ${_file})
         endif()
       endif()
     endforeach()
   endforeach()
 
   if(AUTO_MOVE_UNKNOWN_FILES)
     file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/unknown_files)
   endif()
 
   # warn the user and move the files if needed
   if(_not_registerd_files)
     if(EXISTS ${PROJECT_BINARY_DIR}/missing_files_in_packages)
       file(REMOVE ${PROJECT_BINARY_DIR}/missing_files_in_packages)
     endif()
 
     message("This files are present in the source folders but are not registered in any package")
     foreach(_file ${_not_registerd_files})
       message(" ${_file}")
       if(AUTO_MOVE_UNKNOWN_FILES)
         get_filename_component(_file_name ${_file} NAME)
         file(RENAME ${_file} ${PROJECT_BINARY_DIR}/unknown_files/${_file_name})
       endif()
 
       file(APPEND ${PROJECT_BINARY_DIR}/missing_files_in_packages "${_file}
 ")
     endforeach()
 
     if(AUTO_MOVE_UNKNOWN_FILES)
       message(SEND_ERROR "The files where moved in the followinf folder ${PROJECT_BINARY_DIR}/unknown_files\n
 Please register them in the good package or clean the sources")
     else()
       message(SEND_ERROR "Please register them in the good package or clean the sources")
     endif()
 
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
diff --git a/packages/google-test.cmake b/packages/google-test.cmake
new file mode 100644
index 000000000..ad50f6be8
--- /dev/null
+++ b/packages/google-test.cmake
@@ -0,0 +1,15 @@
+package_declare(gtest EXTERNAL
+  DESCRIPTION "Add GTest support for tests"
+  SYSTEM ON third-party/cmake/gtest.cmake
+  FALLBACK_ON_SYSTEM_MISSING ON
+  )
+
+package_get_option_name(gtest _opt_name)
+if(AKANTU_TESTS)
+  set(${_opt_name} ON CACHE BOOL "Add GTest support for tests (forced)" FORCE)
+endif()
+
+package_add_third_party_script_variable(google-test
+  GTEST_VERSION "master")
+package_add_third_party_script_variable(google-test
+  GTEST_GIT "https://github.com/google/googletest.git")
diff --git a/packages/iohelper.cmake b/packages/iohelper.cmake
index 6f6a6393a..68aa4feaa 100644
--- a/packages/iohelper.cmake
+++ b/packages/iohelper.cmake
@@ -1,76 +1,76 @@
 #===============================================================================
 # @file   iohelper.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Tue Nov 29 2011
 # @date last modification: Mon Jan 18 2016
 #
 # @brief  package description for iohelper
 #
 # @section LICENSE
 #
 # Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
 # Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
 # Solides)
 #
 # Akantu is free  software: you can redistribute it and/or  modify it under the
 # terms  of the  GNU Lesser  General Public  License as  published by  the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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  Lesser General  Public License  for more
 # details.
 #
 # You should  have received  a copy  of the GNU  Lesser General  Public License
 # along with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 package_declare(IOHelper EXTERNAL
   DESCRIPTION "Add IOHelper support in akantu"
   SYSTEM OFF third-party/cmake/iohelper.cmake
   DEFAULT ON)
 
 set(_version "1.1.1")
 package_add_third_party_script_variable(IOHelper
   IOHELPER_VERSION ${_version})
 package_add_third_party_script_variable(IOHelper
   IOHELPER_GIT "https://c4science.ch/source/iohelper.git")
-package_add_third_party_script_variable(Scotch
+package_add_third_party_script_variable(IOHelper
   IOHELPER_ARCHIVE "iohelper_${_version}.tar.gz")
 
 package_declare_sources(IOHelper
   io/dumper/dumpable_iohelper.hh
   io/dumper/dumper_iohelper.hh
   io/dumper/dumper_iohelper.cc
   io/dumper/dumper_paraview.hh
   io/dumper/dumper_text.cc
   io/dumper/dumper_text.hh
   io/dumper/dumper_paraview.cc
   io/dumper/dumper_homogenizing_field.hh
   io/dumper/dumper_type_traits.hh
   io/dumper/dumper_compute.hh
   io/dumper/dumper_nodal_field.hh
   io/dumper/dumper_quadrature_point_iterator.hh
   io/dumper/dumper_variable.hh
   io/dumper/dumper_padding_helper.hh
   io/dumper/dumper_elemental_field.hh
   io/dumper/dumper_element_iterator.hh
   io/dumper/dumper_internal_material_field.hh
   io/dumper/dumper_generic_elemental_field.hh
   io/dumper/dumper_generic_elemental_field_tmpl.hh
   )
 
 package_declare_documentation(IOHelper
   "This package activates the IOHelper facilities withing Akantu. This is mandatory if you want to be able to output Paraview files"
   "as well as any Dumper within Akantu."
   )
 
 package_declare_extra_files_to_package(IOHelper
   PROJECT
     third-party/cmake/iohelper.cmake
     cmake/Modules/FindIOHelper.cmake
   )
diff --git a/test/test_common/CMakeLists.txt b/test/test_common/CMakeLists.txt
index 6470ad26a..f542daa8c 100644
--- a/test/test_common/CMakeLists.txt
+++ b/test/test_common/CMakeLists.txt
@@ -1,45 +1,47 @@
 #===============================================================================
 # @file   CMakeLists.txt
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Fri Sep 03 2010
 # @date last modification: Mon Dec 07 2015
 #
 # @brief  configurations for common tests
 #
 # @section LICENSE
 #
 # Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
 # Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
 # Solides)
 #
 # Akantu is free  software: you can redistribute it and/or  modify it under the
 # terms  of the  GNU Lesser  General Public  License as  published by  the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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  Lesser General  Public License  for more
 # details.
 #
 # You should  have received  a copy  of the GNU  Lesser General  Public License
 # along with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 add_akantu_test(test_vector "Test akantu vector")
 
 add_mesh(test_grid_mesh circle.geo 2 1)
 
 register_test(test_csr test_csr.cc PACKAGE core)
 register_test(test_grid test_grid.cc
   DEPENDS test_grid_mesh
   PACKAGE core)
 
 register_test(test_math test_math.cc PACKAGE core)
 register_test(test_types test_types.cc PACKAGE core)
 
 register_test(test_zip_iterator test_zip_iterator.cc PACKAGE core)
 register_test(test_arange_iterator test_arange_iterator.cc PACKAGE core)
+
+register_test(test_array test_array.cc PACKAGE core GTEST)
diff --git a/test/test_common/test_array.cc b/test/test_common/test_array.cc
new file mode 100644
index 000000000..d1c2e170d
--- /dev/null
+++ b/test/test_common/test_array.cc
@@ -0,0 +1,234 @@
+/* -------------------------------------------------------------------------- */
+#include "aka_array.hh"
+#include "aka_types.hh"
+/* -------------------------------------------------------------------------- */
+#include <gtest/gtest.h>
+#include <memory>
+#include <typeindex>
+#include <typeinfo>
+/* -------------------------------------------------------------------------- */
+
+using namespace akantu;
+
+namespace {
+
+class NonTrivial {
+public:
+  NonTrivial() = default;
+  NonTrivial(int a) : a(a){};
+
+  bool operator==(const NonTrivial & rhs) { return a == rhs.a; }
+  int a{0};
+};
+
+bool operator==(const int & a, const NonTrivial & rhs) { return a == rhs.a; }
+
+std::ostream & operator<<(std::ostream & stream, const NonTrivial & _this) {
+  stream << _this.a;
+  return stream;
+}
+
+/* -------------------------------------------------------------------------- */
+using TestTypes = ::testing::Types<Real, UInt, NonTrivial>;
+/* -------------------------------------------------------------------------- */
+
+::testing::AssertionResult AssertType(const char * /*a_expr*/, const char * /*b_expr*/,
+                                      const std::type_info & a,
+                                      const std::type_info & b) {
+  if (std::type_index(a) == std::type_index(b))
+    return ::testing::AssertionSuccess();
+
+  return ::testing::AssertionFailure()
+      << debug::demangle(a.name()) << " != " << debug::demangle(b.name()) << ") are different";
+}
+
+/* -------------------------------------------------------------------------- */
+
+template <typename T> class ArrayConstructor : public ::testing::Test {
+protected:
+  using type = T;
+
+  void SetUp() override { type_str = debug::demangle(typeid(T).name()); }
+
+  template <typename... P> decltype(auto) construct(P &&... params) {
+    return std::make_unique<Array<T>>(std::forward<P>(params)...);
+  }
+
+protected:
+  std::string type_str;
+};
+
+TYPED_TEST_CASE(ArrayConstructor, TestTypes);
+
+TYPED_TEST(ArrayConstructor, ConstructDefault1) {
+  auto array = this->construct();
+  EXPECT_EQ(0, array->size());
+  EXPECT_EQ(1, array->getNbComponent());
+  EXPECT_STREQ("", array->getID().c_str());
+}
+
+TYPED_TEST(ArrayConstructor, ConstructDefault2) {
+  auto array = this->construct(1000);
+  EXPECT_EQ(1000, array->size());
+  EXPECT_EQ(1, array->getNbComponent());
+  EXPECT_STREQ("", array->getID().c_str());
+}
+
+TYPED_TEST(ArrayConstructor, ConstructDefault3) {
+  auto array = this->construct(1000, 10);
+  EXPECT_EQ(1000, array->size());
+  EXPECT_EQ(10, array->getNbComponent());
+  EXPECT_STREQ("", array->getID().c_str());
+}
+
+TYPED_TEST(ArrayConstructor, ConstructDefault4) {
+  auto array = this->construct(1000, 10, "test");
+  EXPECT_EQ(1000, array->size());
+  EXPECT_EQ(10, array->getNbComponent());
+  EXPECT_STREQ("test", array->getID().c_str());
+}
+
+TYPED_TEST(ArrayConstructor, ConstructDefault5) {
+  auto array = this->construct(1000, 10, 1);
+  EXPECT_EQ(1000, array->size());
+  EXPECT_EQ(10, array->getNbComponent());
+  EXPECT_EQ(1, array->operator()(10, 6));
+  EXPECT_STREQ("", array->getID().c_str());
+}
+
+TYPED_TEST(ArrayConstructor, ConstructDefault6) {
+  typename TestFixture::type defaultv[2] = {0, 1};
+
+  auto array = this->construct(1000, 10, defaultv);
+  EXPECT_EQ(1000, array->size());
+  EXPECT_EQ(10, array->getNbComponent());
+  EXPECT_EQ(1, array->operator()(10, 1));
+  EXPECT_EQ(0, array->operator()(603, 0));
+  EXPECT_STREQ("", array->getID().c_str());
+}
+
+/* -------------------------------------------------------------------------- */
+template <typename T> class ArrayFixture : public ArrayConstructor<T> {
+public:
+  void SetUp() override {
+    ArrayConstructor<T>::SetUp();
+    array = this->construct(1000, 10);
+  }
+
+  void TearDown() override { array.release(); }
+
+protected:
+  std::unique_ptr<Array<T>> array;
+};
+
+TYPED_TEST_CASE(ArrayFixture, TestTypes);
+
+TYPED_TEST(ArrayFixture, Copy) {
+  Array<typename TestFixture::type> copy(*this->array);
+
+  EXPECT_EQ(1000, copy.size());
+  EXPECT_EQ(10, copy.getNbComponent());
+  EXPECT_NE(this->array->storage(), copy.storage());
+}
+
+TYPED_TEST(ArrayFixture, Set) {
+  auto & arr = *(this->array);
+  arr.set(12);
+  EXPECT_EQ(12, arr(156, 5));
+  EXPECT_EQ(12, arr(520, 7));
+  EXPECT_EQ(12, arr(999, 9));
+}
+
+TYPED_TEST(ArrayFixture, Resize) {
+  auto & arr = *(this->array);
+
+  auto ptr = arr.storage();
+
+  arr.resize(0);
+  EXPECT_EQ(0, arr.size());
+  EXPECT_EQ(ptr, arr.storage());
+  EXPECT_EQ(1000, arr.getAllocatedSize());
+
+  arr.resize(3000);
+  EXPECT_EQ(3000, arr.size());
+  EXPECT_EQ(3000, arr.getAllocatedSize());
+
+  arr.resize(0);
+  EXPECT_EQ(0, arr.size());
+  EXPECT_EQ(nullptr, arr.storage());
+  EXPECT_EQ(0, arr.getAllocatedSize());
+}
+
+TYPED_TEST(ArrayFixture, PushBack) {
+  auto & arr = *(this->array);
+
+  auto ptr = arr.storage();
+
+  arr.resize(0);
+  EXPECT_EQ(0, arr.size());
+  EXPECT_EQ(ptr, arr.storage());
+  EXPECT_EQ(1000, arr.getAllocatedSize());
+
+  arr.resize(3000);
+  EXPECT_EQ(3000, arr.size());
+  EXPECT_EQ(3000, arr.getAllocatedSize());
+
+  arr.resize(0);
+  EXPECT_EQ(0, arr.size());
+  EXPECT_EQ(nullptr, arr.storage());
+  EXPECT_EQ(0, arr.getAllocatedSize());
+}
+
+TYPED_TEST(ArrayFixture, ViewVector) {
+  auto && view = make_view(*this->array, 10);
+  EXPECT_NO_THROW(view.begin());
+  {
+    auto it = view.begin();
+    EXPECT_EQ(10, it->size());
+    EXPECT_PRED_FORMAT2(AssertType, typeid(*it), typeid(Vector<typename TestFixture::type>));
+    EXPECT_PRED_FORMAT2(AssertType, typeid(it[0]), typeid(VectorProxy<typename TestFixture::type>));
+  }
+}
+
+TYPED_TEST(ArrayFixture, ViewMatrix) {
+  {
+    auto && view = make_view(*this->array, 2, 5);
+
+    EXPECT_NO_THROW(view.begin());
+    {
+      auto it = view.begin();
+      EXPECT_EQ(10, it->size());
+      EXPECT_EQ(2, it->size(0));
+      EXPECT_EQ(5, it->size(1));
+
+      EXPECT_PRED_FORMAT2(AssertType, typeid(*it), typeid(Matrix<typename TestFixture::type>));
+      EXPECT_PRED_FORMAT2(AssertType, typeid(it[0]), typeid(MatrixProxy<typename TestFixture::type>));
+    }
+  }
+}
+
+TYPED_TEST(ArrayFixture, ViewVectorWrong) {
+  auto && view = make_view(*this->array, 11);
+  EXPECT_THROW(view.begin(), debug::ArrayException);
+}
+
+TYPED_TEST(ArrayFixture, ViewMatrixWrong) {
+  auto && view = make_view(*this->array, 3, 7);
+  EXPECT_THROW(view.begin(), debug::ArrayException);
+}
+
+TYPED_TEST(ArrayFixture, ViewMatrixIter) {
+  std::size_t count = 0;
+  for(auto && mat : make_view(*this->array, 10, 10)) {
+    EXPECT_EQ(100, mat.size());
+    EXPECT_EQ(10, mat.size(0));
+    EXPECT_EQ(10, mat.size(1));
+    EXPECT_PRED_FORMAT2(AssertType, typeid(mat), typeid(Matrix<typename TestFixture::type>));
+
+    ++count;
+  }
+
+  EXPECT_EQ(100, count);
+}
+
+} // namespace
diff --git a/test/test_gtest_main.cc b/test/test_gtest_main.cc
new file mode 100644
index 000000000..8be8739bc
--- /dev/null
+++ b/test/test_gtest_main.cc
@@ -0,0 +1,24 @@
+#include "aka_common.hh"
+#include <gtest/gtest.h>
+
+namespace {
+class AkaEnvironment : public ::testing::Environment {
+public:
+  AkaEnvironment(int & argc, char **& argv) : argc(argc), argv(argv) {}
+  // Override this to define how to set up the environment.
+  void SetUp() override { ::akantu::initialize(argc, argv); }
+  // Override this to define how to tear down the environment.
+  void TearDown() override {  }
+
+protected:
+  int & argc;
+  char **& argv;
+};
+}
+
+int main(int argc, char ** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  ::testing::AddGlobalTestEnvironment(new AkaEnvironment(argc, argv));
+
+  return RUN_ALL_TESTS();
+}
diff --git a/third-party/cmake/gtest.cmake b/third-party/cmake/gtest.cmake
new file mode 100644
index 000000000..c21f8638f
--- /dev/null
+++ b/third-party/cmake/gtest.cmake
@@ -0,0 +1,34 @@
+set(_working_dir ${PROJECT_BINARY_DIR}/third-party/src/gtest-download)
+
+configure_file(${PROJECT_SOURCE_DIR}/third-party/gtest.cmake.in ${_working_dir}/CMakeLists.txt)
+
+set(GTEST_ROOT ${PROJECT_BINARY_DIR}/third-party)
+find_package(GTest QUIET)
+
+
+if(NOT GTEST_FOUND)
+  message(STATUS "Downloading googletest")
+  execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
+    RESULT_VARIABLE result WORKING_DIRECTORY ${_working_dir}
+    OUTPUT_FILE ${_working_dir}/configure-out.log
+    ERROR_FILE ${_working_dir}/configure-error.log)
+
+  if(result)
+    message(SEND_ERROR "CMake step for googletest failed: ${result}")
+    return()
+  endif()
+
+  message(STATUS "Building googletest")
+  execute_process(COMMAND ${CMAKE_COMMAND} --build .
+    RESULT_VARIABLE result WORKING_DIRECTORY ${_working_dir}
+    OUTPUT_FILE ${_working_dir}/build-out.log
+    ERROR_FILE ${_working_dir}/build-error.log)
+
+  if(result)
+    message(SEND_ERROR "Build step for googletest failed: ${result}")
+    return()
+  endif()
+endif()
+
+set(GTEST_ROOT ${PROJECT_BINARY_DIR}/third-party)
+find_package(GTest REQUIRED)
diff --git a/third-party/cmake/iohelper.cmake b/third-party/cmake/iohelper.cmake
index 24f8a94c1..17f3ee111 100644
--- a/third-party/cmake/iohelper.cmake
+++ b/third-party/cmake/iohelper.cmake
@@ -1,100 +1,97 @@
 #===============================================================================
 # @file   iohelper.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Mon Mar 30 2015
 # @date last modification: Tue Jan 19 2016
 #
 # @brief  build script for iohelper
 #
 # @section LICENSE
 #
 # Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
 # (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free  software: you can redistribute it and/or  modify it under the
 # terms  of the  GNU Lesser  General Public  License as  published by  the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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  Lesser General  Public License  for more
 # details.
 #
 # You should  have received  a copy  of the GNU  Lesser General  Public License
 # along with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 if(EXISTS ${PROJECT_SOURCE_DIR}/third-party/iohelper)
   set(IOHELPER_TARGETS_EXPORT ${AKANTU_TARGETS_EXPORT})
   add_subdirectory(${PROJECT_SOURCE_DIR}/third-party/iohelper)
 
   set(IOHELPER_SOURCE_TYPE "internal"
     CACHE INTERNAL "internal variable for clean export")
 
   set(IOHELPER_INCLUDE_DIR "${PROJECT_SOURCE_DIR}/third-party/iohelper/src"
     CACHE INTERNAL "IOHelper include directory")
 
   set(IOHELPER_LIBRARIES iohelper CACHE INTERNAL "IOHelper library")
   package_add_to_export_list(iohelper iohelper)
   return()
 endif()
 
 if(NOT EXISTS ${PROJECT_SOURCE_DIR}/third-party/${IOHELPER_ARCHIVE})
   set(_iohelper_download_command
     GIT_REPOSITORY ${IOHELPER_GIT}
     GIT_TAG ${IOHELPER_VERSION}
     )
 else()
   set(_iohelper_download_command
     URL ${PROJECT_SOURCE_DIR}/third-party/${IOHELPER_ARCHIVE}
     )
 endif()
 
 if(CMAKE_VERSION VERSION_GREATER 3.1)
   set(_extra_options 
     UPDATE_DISCONNECTED 1
     DOWNLOAD_NO_PROGRESS 1
     EXCLUDE_FROM_ALL 1
     )
 endif()
 
 ExternalProject_Add(iohelper
   PREFIX ${PROJECT_BINARY_DIR}/third-party
   ${_iohelper_download_command}
   ${_extra_options}
   CMAKE_ARGS <SOURCE_DIR>/
   CMAKE_CACHE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR> -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE} -DCMAKE_CXX_COMPILER:PATH=${CMAKE_CXX_COMPILER}
-  LOG_DOWNLOAD 1
-  LOG_CONFIGURE 1
-  LOG_BUILD 1
-  LOG_INSTALL 1
   )
 
-set_third_party_shared_libirary_name(IOHELPER_LIBRARIES iohelper)
+find_library(IOHELPER_LIBRARIES iohelper HINTS ${PROJECT_BINARY_DIR}/third-party)
 if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
   set(_tmp ${IOHELPER_LIBRARIES})
   set(IOHELPER_LIBRARIES "${_tmp}.a" CACHE FILEPATH "" FORCE)
 endif()
 
-set(IOHELPER_INCLUDE_DIR "${PROJECT_BINARY_DIR}/third-party/include/iohelper" CACHE PATH "IOHelper include directory")
+find_path(IOHELPER_INCLUDE_DIR iohelper/io_helper.hh HINTS ${PROJECT_BINARY_DIR}/third-party)
+
 set(IOHELPER_SOURCE_TYPE "external" CACHE INTERNAL "internal variable for clean export")
 
 mark_as_advanced(
   IOHELPER_LIBRARIES
   IOHELPER_INCLUDE_DIR
   )
 
 package_add_extra_dependency(IOHelper iohelper)
 
 install(FILES ${IOHELPER_LIBRARIES}
   DESTINATION lib
   COMPONENT lib
   )
 
 install(DIRECTORY ${IOHELPER_INCLUDE_DIR}
   DESTINATION include
   COMPONENT dev)
diff --git a/third-party/gtest.cmake.in b/third-party/gtest.cmake.in
new file mode 100644
index 000000000..7da91d110
--- /dev/null
+++ b/third-party/gtest.cmake.in
@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.1)
+
+project(gtest-download NONE)
+
+include(ExternalProject)
+
+ExternalProject_Add(gtest
+  PREFIX ${PROJECT_BINARY_DIR}/third-party
+  GIT_REPOSITORY    ${GTEST_GIT}
+  GIT_TAG           ${GTEST_VERSION}
+  CMAKE_CACHE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR> -DGTEST_CREATE_SHARED_LIBRARY:BOOL=ON
+  DOWNLOAD_NO_PROGRESS 1
+  UPDATE_DISCONNECTED 1
+  USES_TERMINAL_INSTALL 0
+  USES_TERMINAL_UPDATE 0
+  )