diff --git a/test/test_async.cpp b/test/test_async.cpp
index bf437f6065f386ccfd49b01c56bc6b6d31848af0..2b5d3587d7eb404f7ccb40035bb5e34d80f17477 100644
--- a/test/test_async.cpp
+++ b/test/test_async.cpp
@@ -1,5 +1,5 @@
 /*
- * This file is a part of the CaosDB Project.
+ * This file is a part of the LinkAhead Project.
  *
  * Copyright (C) 2022 IndiScale GmbH <info@indiscale.com>
  * Copyright (C) 2022 Timm Fitschen <t.fitschen@indiscale.com>
@@ -18,12 +18,12 @@
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  *
  */
-#include "caosdb/entity.h"             // for Entity, Property
-#include "caosdb/connection.h"         // for Connection, Connec...
-#include "caosdb/message_code.h"       // for ENTITY_DOES_NOT_EXIST, Messag...
-#include "caosdb/status_code.h"        // for StatusCode, SUCCESS
-#include "caosdb/transaction.h"        // for Entity, Transaction
-#include "caosdb/transaction_status.h" // for TransactionStatus
+#include "linkahead/entity.h"             // for Entity, Property
+#include "linkahead/connection.h"         // for Connection, Connec...
+#include "linkahead/message_code.h"       // for ENTITY_DOES_NOT_EXIST, Messag...
+#include "linkahead/status_code.h"        // for StatusCode, SUCCESS
+#include "linkahead/transaction.h"        // for Entity, Transaction
+#include "linkahead/transaction_status.h" // for TransactionStatus
 #include <chrono>                      // for operator""ms, chrono_literals
 #include <gtest/gtest-message.h>       // for Message
 #include <gtest/gtest-test-part.h>     // for TestPartResult
@@ -31,8 +31,8 @@
 #include <memory>                      // for allocator, unique_ptr, __shar...
 #include <thread>
 
-namespace caosdb::transaction {
-using caosdb::entity::MessageCode;
+namespace linkahead::transaction {
+using linkahead::entity::MessageCode;
 
 /*
  * Test the retrieval of a non-existing entity
@@ -42,7 +42,7 @@ using caosdb::entity::MessageCode;
  */
 TEST(test_async, retrieve_non_existing) {
   using namespace std::chrono_literals;
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto transaction(connection->CreateTransaction());
 
@@ -76,4 +76,4 @@ TEST(test_async, retrieve_non_existing) {
   EXPECT_EQ(entity.GetErrors().at(0).GetCode(), MessageCode::ENTITY_DOES_NOT_EXIST);
 }
 
-} // namespace caosdb::transaction
+} // namespace linkahead::transaction
diff --git a/test/test_ccaosdb.cpp b/test/test_ccaosdb.cpp
index 347b8696e015cdf865fe94623599f4cf8cb07143..84cddd6ca76afda0352ecf09f4b651ba3497767e 100644
--- a/test/test_ccaosdb.cpp
+++ b/test/test_ccaosdb.cpp
@@ -1,5 +1,5 @@
 /*
- * This file is a part of the CaosDB Project.
+ * This file is a part of the LinkAhead Project.
  *
  * Copyright (C) 2021 Timm Fitschen <t.fitschen@indiscale.com>
  * Copyright (C) 2021 Florian Spreckelsen <f.spreckelsen@indiscale.com>
@@ -18,10 +18,10 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  */
-#include "caosdb/file_transmission/file_writer.h" // for FileWriter
-#include "caosdb/message_code.h"                  // for ENTITY_DOES_NOT_EXIST
-#include "caosdb/status_code.h"                   // for GO_ON, StatusCode
-#include "ccaosdb.h"                              // for caosdb_connection_...
+#include "linkahead/file_transmission/file_writer.h" // for FileWriter
+#include "linkahead/message_code.h"                  // for ENTITY_DOES_NOT_EXIST
+#include "linkahead/status_code.h"                   // for GO_ON, StatusCode
+#include "clinkahead.h"                              // for linkahead_connection_...
 #include <chrono>                                 // for filesystem
 #include <cstring>                                // for strcmp
 #include <filesystem>                             // for remove
@@ -32,7 +32,7 @@
 #include <string>                                 // for allocator, string
 
 namespace fs = std::filesystem;
-class test_ccaosdb : public ::testing::Test {
+class test_clinkahead : public ::testing::Test {
 protected:
   fs::path test_upload_file_1;
   fs::path test_download_file_1;
@@ -43,7 +43,7 @@ protected:
     test_download_file_1 = fs::path("test_download_file_1_delete_me.dat");
 
     // fill the file that shall be uploaded
-    caosdb::transaction::FileWriter writer(test_upload_file_1);
+    linkahead::transaction::FileWriter writer(test_upload_file_1);
     std::string buffer(1024, 'c');
     for (int i = 0; i < 20; i++) {
       writer.write(buffer);
@@ -62,49 +62,49 @@ protected:
    * Delete everything with id>99, C style
    */
   static void DeleteEntities() {
-    caosdb_connection_connection connection;
-    caosdb_connection_connection_manager_get_default_connection(&connection);
+    linkahead_connection_connection connection;
+    linkahead_connection_connection_manager_get_default_connection(&connection);
 
-    caosdb_transaction_transaction query_transaction;
-    caosdb_connection_connection_create_transaction(&connection, &query_transaction);
-    caosdb_transaction_transaction_query(&query_transaction, "FIND ENTITY WITH id > 99");
-    caosdb_transaction_transaction_execute(&query_transaction);
+    linkahead_transaction_transaction query_transaction;
+    linkahead_connection_connection_create_transaction(&connection, &query_transaction);
+    linkahead_transaction_transaction_query(&query_transaction, "FIND ENTITY WITH id > 99");
+    linkahead_transaction_transaction_execute(&query_transaction);
 
-    caosdb_transaction_result_set result_set;
-    caosdb_transaction_transaction_get_result_set(&query_transaction, &result_set);
+    linkahead_transaction_result_set result_set;
+    linkahead_transaction_transaction_get_result_set(&query_transaction, &result_set);
     int count[] = {-1}; // NOLINT
-    caosdb_transaction_result_set_size(&result_set, count);
+    linkahead_transaction_result_set_size(&result_set, count);
     if (*count > 0) {
-      caosdb_transaction_transaction delete_transaction;
-      caosdb_connection_connection_create_transaction(&connection, &delete_transaction);
-      caosdb_entity_entity entity;
+      linkahead_transaction_transaction delete_transaction;
+      linkahead_connection_connection_create_transaction(&connection, &delete_transaction);
+      linkahead_entity_entity entity;
       char *id = nullptr; // NOLINT
       for (int i = 0; i < *count; i++) {
-        caosdb_transaction_result_set_at(&result_set, &entity, i);
-        caosdb_entity_entity_get_id(&entity, &id);
-        caosdb_transaction_transaction_delete_by_id(&delete_transaction, id);
+        linkahead_transaction_result_set_at(&result_set, &entity, i);
+        linkahead_entity_entity_get_id(&entity, &id);
+        linkahead_transaction_transaction_delete_by_id(&delete_transaction, id);
       }
 
-      caosdb_transaction_transaction_execute(&delete_transaction);
-      caosdb_transaction_delete_transaction(&delete_transaction);
+      linkahead_transaction_transaction_execute(&delete_transaction);
+      linkahead_transaction_delete_transaction(&delete_transaction);
     }
 
-    caosdb_transaction_delete_transaction(&query_transaction);
+    linkahead_transaction_delete_transaction(&query_transaction);
   }
 };
 
-TEST_F(test_ccaosdb, connection_ssl_authentication_success) {
+TEST_F(test_clinkahead, connection_ssl_authentication_success) {
 
-  caosdb_connection_connection connection;
-  caosdb_connection_connection_manager_get_default_connection(&connection);
+  linkahead_connection_connection connection;
+  linkahead_connection_connection_manager_get_default_connection(&connection);
 
-  caosdb_info_version_info version_info;
-  caosdb_connection_get_version_info(&version_info, &connection);
+  linkahead_info_version_info version_info;
+  linkahead_connection_get_version_info(&version_info, &connection);
 
-  auto major = caosdb_constants_COMPATIBLE_SERVER_VERSION_MAJOR();
-  auto minor = caosdb_constants_COMPATIBLE_SERVER_VERSION_MINOR();
-  auto patch = caosdb_constants_COMPATIBLE_SERVER_VERSION_PATCH();
-  const auto *const pre_release = caosdb_constants_COMPATIBLE_SERVER_VERSION_PRE_RELEASE();
+  auto major = linkahead_constants_COMPATIBLE_SERVER_VERSION_MAJOR();
+  auto minor = linkahead_constants_COMPATIBLE_SERVER_VERSION_MINOR();
+  auto patch = linkahead_constants_COMPATIBLE_SERVER_VERSION_PATCH();
+  const auto *const pre_release = linkahead_constants_COMPATIBLE_SERVER_VERSION_PRE_RELEASE();
 
   EXPECT_EQ(major, version_info.major);
   EXPECT_LE(minor, version_info.minor);
@@ -116,515 +116,515 @@ TEST_F(test_ccaosdb, connection_ssl_authentication_success) {
   }
 }
 
-TEST_F(test_ccaosdb, test_count_query) {
+TEST_F(test_clinkahead, test_count_query) {
 
-  caosdb_connection_connection connection;
-  int return_code(caosdb_connection_connection_manager_get_default_connection(&connection));
+  linkahead_connection_connection connection;
+  int return_code(linkahead_connection_connection_manager_get_default_connection(&connection));
   EXPECT_EQ(return_code, 0);
 
-  caosdb_transaction_transaction transaction;
-  return_code = caosdb_connection_connection_create_transaction(&connection, &transaction);
+  linkahead_transaction_transaction transaction;
+  return_code = linkahead_connection_connection_create_transaction(&connection, &transaction);
   EXPECT_EQ(return_code, 0);
 
   // COUNT query with an empty result
-  return_code = caosdb_transaction_transaction_query(&transaction, "COUNT ENTITY WITH id=-1");
-  EXPECT_EQ(return_code, caosdb::StatusCode::GO_ON);
+  return_code = linkahead_transaction_transaction_query(&transaction, "COUNT ENTITY WITH id=-1");
+  EXPECT_EQ(return_code, linkahead::StatusCode::GO_ON);
 
-  return_code = caosdb_transaction_transaction_execute(&transaction);
+  return_code = linkahead_transaction_transaction_execute(&transaction);
   EXPECT_EQ(return_code, 0);
 
   long dummy(-1);       // NOLINT
   long *count = &dummy; // NOLINT
-  return_code = caosdb_transaction_transaction_get_count_result(&transaction, count);
+  return_code = linkahead_transaction_transaction_get_count_result(&transaction, count);
   EXPECT_EQ(return_code, 0);
   EXPECT_EQ(*count, 0);
 
-  return_code = caosdb_transaction_delete_transaction(&transaction);
+  return_code = linkahead_transaction_delete_transaction(&transaction);
   EXPECT_EQ(return_code, 0);
 }
 
-TEST_F(test_ccaosdb, test_query) {
-  caosdb_connection_connection connection;
-  int return_code(caosdb_connection_connection_manager_get_default_connection(&connection));
+TEST_F(test_clinkahead, test_query) {
+  linkahead_connection_connection connection;
+  int return_code(linkahead_connection_connection_manager_get_default_connection(&connection));
   EXPECT_EQ(return_code, 0);
 
-  caosdb_transaction_transaction transaction;
-  return_code = caosdb_connection_connection_create_transaction(&connection, &transaction);
+  linkahead_transaction_transaction transaction;
+  return_code = linkahead_connection_connection_create_transaction(&connection, &transaction);
   EXPECT_EQ(return_code, 0);
 
-  return_code = caosdb_transaction_transaction_query(&transaction, "FIND ENTITY WITH id=-1");
-  EXPECT_EQ(return_code, caosdb::StatusCode::GO_ON);
+  return_code = linkahead_transaction_transaction_query(&transaction, "FIND ENTITY WITH id=-1");
+  EXPECT_EQ(return_code, linkahead::StatusCode::GO_ON);
 
-  return_code = caosdb_transaction_transaction_execute(&transaction);
+  return_code = linkahead_transaction_transaction_execute(&transaction);
   EXPECT_EQ(return_code, 0);
 
-  caosdb_transaction_result_set result_set;
-  return_code = caosdb_transaction_transaction_get_result_set(&transaction, &result_set);
+  linkahead_transaction_result_set result_set;
+  return_code = linkahead_transaction_transaction_get_result_set(&transaction, &result_set);
   EXPECT_EQ(return_code, 0);
 
   int dummy(-1);
   int *count = &dummy; // NOLINT
-  return_code = caosdb_transaction_result_set_size(&result_set, count);
+  return_code = linkahead_transaction_result_set_size(&result_set, count);
   EXPECT_EQ(return_code, 0);
   EXPECT_EQ(*count, 0);
 
-  return_code = caosdb_transaction_delete_transaction(&transaction);
+  return_code = linkahead_transaction_delete_transaction(&transaction);
   EXPECT_EQ(return_code, 0);
 }
 
-TEST_F(test_ccaosdb, test_single_id_retrieve) {
-  caosdb_connection_connection connection;
-  int return_code(caosdb_connection_connection_manager_get_default_connection(&connection));
+TEST_F(test_clinkahead, test_single_id_retrieve) {
+  linkahead_connection_connection connection;
+  int return_code(linkahead_connection_connection_manager_get_default_connection(&connection));
   EXPECT_EQ(return_code, 0);
 
-  caosdb_transaction_transaction transaction;
-  return_code = caosdb_connection_connection_create_transaction(&connection, &transaction);
+  linkahead_transaction_transaction transaction;
+  return_code = linkahead_connection_connection_create_transaction(&connection, &transaction);
   EXPECT_EQ(return_code, 0);
 
-  return_code = caosdb_transaction_transaction_retrieve_by_id(&transaction, "21");
-  EXPECT_EQ(return_code, caosdb::StatusCode::GO_ON);
+  return_code = linkahead_transaction_transaction_retrieve_by_id(&transaction, "21");
+  EXPECT_EQ(return_code, linkahead::StatusCode::GO_ON);
 
-  return_code = caosdb_transaction_transaction_execute(&transaction);
+  return_code = linkahead_transaction_transaction_execute(&transaction);
   EXPECT_EQ(return_code, 0);
 
-  caosdb_transaction_result_set result_set;
-  return_code = caosdb_transaction_transaction_get_result_set(&transaction, &result_set);
+  linkahead_transaction_result_set result_set;
+  return_code = linkahead_transaction_transaction_get_result_set(&transaction, &result_set);
   EXPECT_EQ(return_code, 0);
 
   int dummy(-1);
   int *count = &dummy; // NOLINT
-  return_code = caosdb_transaction_result_set_size(&result_set, count);
+  return_code = linkahead_transaction_result_set_size(&result_set, count);
   EXPECT_EQ(return_code, 0);
   EXPECT_EQ(*count, 1);
 
-  caosdb_entity_entity entity;
-  return_code = caosdb_transaction_result_set_at(&result_set, &entity, 0);
+  linkahead_entity_entity entity;
+  return_code = linkahead_transaction_result_set_at(&result_set, &entity, 0);
   EXPECT_EQ(return_code, 0);
 
-  return_code = caosdb_entity_entity_get_errors_size(&entity, count);
+  return_code = linkahead_entity_entity_get_errors_size(&entity, count);
   EXPECT_EQ(return_code, 0);
   EXPECT_EQ(*count, 0);
 
   char *out = nullptr; // NOLINT
-  return_code = caosdb_entity_entity_get_name(&entity, &out);
+  return_code = linkahead_entity_entity_get_name(&entity, &out);
   EXPECT_EQ(return_code, 0);
   EXPECT_STREQ(out, "unit");
 
-  return_code = caosdb_transaction_delete_transaction(&transaction);
+  return_code = linkahead_transaction_delete_transaction(&transaction);
   EXPECT_EQ(return_code, 0);
 }
 
-TEST_F(test_ccaosdb, test_multi_id_retrieve) {
-  caosdb_connection_connection connection;
-  int return_code(caosdb_connection_connection_manager_get_default_connection(&connection));
+TEST_F(test_clinkahead, test_multi_id_retrieve) {
+  linkahead_connection_connection connection;
+  int return_code(linkahead_connection_connection_manager_get_default_connection(&connection));
   EXPECT_EQ(return_code, 0);
 
-  caosdb_transaction_transaction transaction;
-  return_code = caosdb_connection_connection_create_transaction(&connection, &transaction);
+  linkahead_transaction_transaction transaction;
+  return_code = linkahead_connection_connection_create_transaction(&connection, &transaction);
   EXPECT_EQ(return_code, 0);
 
   const char *ids[] = {"20", "21", "22"}; // NOLINT
-  return_code = caosdb_transaction_transaction_retrieve_by_ids(&transaction, ids, 3);
-  EXPECT_EQ(return_code, caosdb::StatusCode::GO_ON);
+  return_code = linkahead_transaction_transaction_retrieve_by_ids(&transaction, ids, 3);
+  EXPECT_EQ(return_code, linkahead::StatusCode::GO_ON);
 
-  return_code = caosdb_transaction_transaction_execute(&transaction);
+  return_code = linkahead_transaction_transaction_execute(&transaction);
   // Should have an error since entity 22 doesn't exist
   EXPECT_TRUE((return_code > 0));
 
-  caosdb_transaction_result_set result_set;
-  return_code = caosdb_transaction_transaction_get_result_set(&transaction, &result_set);
+  linkahead_transaction_result_set result_set;
+  return_code = linkahead_transaction_transaction_get_result_set(&transaction, &result_set);
   EXPECT_EQ(return_code, 0);
 
   int dummy(-1);
   int *count = &dummy; // NOLINT
-  return_code = caosdb_transaction_result_set_size(&result_set, count);
+  return_code = linkahead_transaction_result_set_size(&result_set, count);
   EXPECT_EQ(return_code, 0);
   EXPECT_EQ(*count, 3);
 
-  caosdb_entity_entity entity;
-  return_code = caosdb_transaction_result_set_at(&result_set, &entity, 1);
+  linkahead_entity_entity entity;
+  return_code = linkahead_transaction_result_set_at(&result_set, &entity, 1);
   EXPECT_EQ(return_code, 0);
 
-  return_code = caosdb_entity_entity_get_errors_size(&entity, count);
+  return_code = linkahead_entity_entity_get_errors_size(&entity, count);
   EXPECT_EQ(return_code, 0);
   EXPECT_EQ(*count, 0);
 
   char *out = nullptr; // NOLINT
-  return_code = caosdb_entity_entity_get_name(&entity, &out);
+  return_code = linkahead_entity_entity_get_name(&entity, &out);
   EXPECT_EQ(return_code, 0);
   EXPECT_STREQ(out, "unit");
 
-  caosdb_entity_entity other_entity;
-  return_code = caosdb_transaction_result_set_at(&result_set, &other_entity, 2);
+  linkahead_entity_entity other_entity;
+  return_code = linkahead_transaction_result_set_at(&result_set, &other_entity, 2);
   EXPECT_EQ(return_code, 0);
-  return_code = caosdb_entity_entity_get_errors_size(&other_entity, count);
+  return_code = linkahead_entity_entity_get_errors_size(&other_entity, count);
   EXPECT_EQ(return_code, 0);
   EXPECT_EQ(*count, 1);
 
-  caosdb_entity_message err_msg;
-  return_code = caosdb_entity_entity_get_error(&other_entity, &err_msg, 0);
+  linkahead_entity_message err_msg;
+  return_code = linkahead_entity_entity_get_error(&other_entity, &err_msg, 0);
   EXPECT_EQ(return_code, 0);
 
-  return_code = caosdb_entity_message_get_code(&err_msg, count);
+  return_code = linkahead_entity_message_get_code(&err_msg, count);
   EXPECT_EQ(return_code, 0);
-  EXPECT_EQ(*count, caosdb::entity::MessageCode::ENTITY_DOES_NOT_EXIST);
+  EXPECT_EQ(*count, linkahead::entity::MessageCode::ENTITY_DOES_NOT_EXIST);
 
-  return_code = caosdb_transaction_delete_transaction(&transaction);
+  return_code = linkahead_transaction_delete_transaction(&transaction);
   EXPECT_EQ(return_code, 0);
 }
 
-TEST_F(test_ccaosdb, test_insert_update_delete) {
+TEST_F(test_clinkahead, test_insert_update_delete) {
 
-  caosdb_connection_connection connection;
-  caosdb_connection_connection_manager_get_default_connection(&connection);
+  linkahead_connection_connection connection;
+  linkahead_connection_connection_manager_get_default_connection(&connection);
 
-  caosdb_entity_entity original_entity;
-  caosdb_entity_create_entity(&original_entity);
-  caosdb_entity_entity_set_name(&original_entity, "TestName");
-  caosdb_entity_entity_set_role(&original_entity, "PROPERTY");
-  caosdb_entity_datatype in_type;
-  caosdb_entity_create_atomic_datatype(&in_type, "TEXT");
-  caosdb_entity_entity_set_datatype(&original_entity, &in_type);
+  linkahead_entity_entity original_entity;
+  linkahead_entity_create_entity(&original_entity);
+  linkahead_entity_entity_set_name(&original_entity, "TestName");
+  linkahead_entity_entity_set_role(&original_entity, "PROPERTY");
+  linkahead_entity_datatype in_type;
+  linkahead_entity_create_atomic_datatype(&in_type, "TEXT");
+  linkahead_entity_entity_set_datatype(&original_entity, &in_type);
 
-  caosdb_transaction_transaction insert_transaction;
-  caosdb_connection_connection_create_transaction(&connection, &insert_transaction);
-  caosdb_transaction_transaction_insert_entity(&insert_transaction, &original_entity);
-  int return_code(caosdb_transaction_transaction_execute(&insert_transaction));
+  linkahead_transaction_transaction insert_transaction;
+  linkahead_connection_connection_create_transaction(&connection, &insert_transaction);
+  linkahead_transaction_transaction_insert_entity(&insert_transaction, &original_entity);
+  int return_code(linkahead_transaction_transaction_execute(&insert_transaction));
   EXPECT_EQ(return_code, 0);
 
   // Insert the entity and check results
-  caosdb_transaction_result_set insert_result_set;
-  caosdb_transaction_transaction_get_result_set(&insert_transaction, &insert_result_set);
+  linkahead_transaction_result_set insert_result_set;
+  linkahead_transaction_transaction_get_result_set(&insert_transaction, &insert_result_set);
   int count[] = {-1}; // NOLINT
-  caosdb_transaction_result_set_size(&insert_result_set, count);
+  linkahead_transaction_result_set_size(&insert_result_set, count);
   EXPECT_EQ(*count, 1);
-  caosdb_entity_entity inserted_entity;
-  caosdb_transaction_result_set_at(&insert_result_set, &inserted_entity, 0);
+  linkahead_entity_entity inserted_entity;
+  linkahead_transaction_result_set_at(&insert_result_set, &inserted_entity, 0);
   char *in = nullptr; // NOLINT
-  caosdb_entity_entity_get_id(&inserted_entity, &in);
+  linkahead_entity_entity_get_id(&inserted_entity, &in);
 
   // Retrieve it again for checks and update
-  caosdb_transaction_transaction retrieve_transaction_1;
-  caosdb_connection_connection_create_transaction(&connection, &retrieve_transaction_1);
-  caosdb_transaction_transaction_retrieve_by_id(&retrieve_transaction_1, in);
-  return_code = caosdb_transaction_transaction_execute(&retrieve_transaction_1);
+  linkahead_transaction_transaction retrieve_transaction_1;
+  linkahead_connection_connection_create_transaction(&connection, &retrieve_transaction_1);
+  linkahead_transaction_transaction_retrieve_by_id(&retrieve_transaction_1, in);
+  return_code = linkahead_transaction_transaction_execute(&retrieve_transaction_1);
   EXPECT_EQ(return_code, 0);
 
-  caosdb_transaction_result_set retrieve_results_1;
-  caosdb_transaction_transaction_get_result_set(&retrieve_transaction_1, &retrieve_results_1);
-  caosdb_transaction_result_set_size(&retrieve_results_1, count);
+  linkahead_transaction_result_set retrieve_results_1;
+  linkahead_transaction_transaction_get_result_set(&retrieve_transaction_1, &retrieve_results_1);
+  linkahead_transaction_result_set_size(&retrieve_results_1, count);
   EXPECT_EQ(*count, 1);
-  caosdb_entity_entity retrieved_entity_1;
-  caosdb_transaction_result_set_at(&retrieve_results_1, &retrieved_entity_1, 0);
+  linkahead_entity_entity retrieved_entity_1;
+  linkahead_transaction_result_set_at(&retrieve_results_1, &retrieved_entity_1, 0);
   char *out = nullptr; // NOLINT
-  caosdb_entity_entity_get_id(&retrieved_entity_1, &out);
+  linkahead_entity_entity_get_id(&retrieved_entity_1, &out);
   EXPECT_EQ(strcmp(in, out), 0);
 
-  caosdb_entity_entity_get_name(&original_entity, &in);
-  caosdb_entity_entity_get_name(&retrieved_entity_1, &out);
+  linkahead_entity_entity_get_name(&original_entity, &in);
+  linkahead_entity_entity_get_name(&retrieved_entity_1, &out);
   EXPECT_EQ(strcmp(in, out), 0);
 
-  caosdb_entity_entity_get_role(&original_entity, &in);
-  caosdb_entity_entity_get_role(&retrieved_entity_1, &out);
+  linkahead_entity_entity_get_role(&original_entity, &in);
+  linkahead_entity_entity_get_role(&retrieved_entity_1, &out);
   EXPECT_EQ(strcmp(in, out), 0);
 
-  caosdb_entity_datatype out_type;
-  caosdb_entity_entity_get_datatype(&original_entity, &out_type);
+  linkahead_entity_datatype out_type;
+  linkahead_entity_entity_get_datatype(&original_entity, &out_type);
   bool out_is(false);
-  caosdb_entity_datatype_is_atomic(&out_type, &out_is);
+  linkahead_entity_datatype_is_atomic(&out_type, &out_is);
   EXPECT_TRUE(out_is);
-  caosdb_entity_datatype_get_datatype_name(&in_type, &in);
-  caosdb_entity_datatype_get_datatype_name(&out_type, &out);
+  linkahead_entity_datatype_get_datatype_name(&in_type, &in);
+  linkahead_entity_datatype_get_datatype_name(&out_type, &out);
   EXPECT_EQ(strcmp(in, out), 0);
 
   // Change name and update
-  return_code = caosdb_entity_entity_set_name(&retrieved_entity_1, "TestNameNew");
+  return_code = linkahead_entity_entity_set_name(&retrieved_entity_1, "TestNameNew");
   EXPECT_EQ(return_code, 0);
-  caosdb_transaction_transaction update_transaction;
-  caosdb_connection_connection_create_transaction(&connection, &update_transaction);
-  caosdb_transaction_transaction_update_entity(&update_transaction, &retrieved_entity_1);
-  return_code = caosdb_transaction_transaction_execute(&update_transaction);
+  linkahead_transaction_transaction update_transaction;
+  linkahead_connection_connection_create_transaction(&connection, &update_transaction);
+  linkahead_transaction_transaction_update_entity(&update_transaction, &retrieved_entity_1);
+  return_code = linkahead_transaction_transaction_execute(&update_transaction);
   EXPECT_EQ(return_code, 0);
 
-  caosdb_transaction_result_set update_results;
-  caosdb_transaction_transaction_get_result_set(&update_transaction, &update_results);
-  caosdb_transaction_result_set_size(&update_results, count);
+  linkahead_transaction_result_set update_results;
+  linkahead_transaction_transaction_get_result_set(&update_transaction, &update_results);
+  linkahead_transaction_result_set_size(&update_results, count);
   EXPECT_EQ(*count, 1);
-  caosdb_entity_entity updated_entity;
-  caosdb_transaction_result_set_at(&update_results, &updated_entity, 0);
-  caosdb_entity_entity_get_id(&inserted_entity, &in);
-  caosdb_entity_entity_get_id(&updated_entity, &out);
+  linkahead_entity_entity updated_entity;
+  linkahead_transaction_result_set_at(&update_results, &updated_entity, 0);
+  linkahead_entity_entity_get_id(&inserted_entity, &in);
+  linkahead_entity_entity_get_id(&updated_entity, &out);
   EXPECT_EQ(strcmp(in, out), 0);
 
   // Retrieve again
-  caosdb_transaction_transaction retrieve_transaction_2;
-  caosdb_connection_connection_create_transaction(&connection, &retrieve_transaction_2);
-  caosdb_transaction_transaction_retrieve_by_id(&retrieve_transaction_2, out);
-  return_code = caosdb_transaction_transaction_execute(&retrieve_transaction_2);
+  linkahead_transaction_transaction retrieve_transaction_2;
+  linkahead_connection_connection_create_transaction(&connection, &retrieve_transaction_2);
+  linkahead_transaction_transaction_retrieve_by_id(&retrieve_transaction_2, out);
+  return_code = linkahead_transaction_transaction_execute(&retrieve_transaction_2);
   EXPECT_EQ(return_code, 0);
 
-  caosdb_transaction_result_set retrieve_results_2;
-  caosdb_transaction_transaction_get_result_set(&retrieve_transaction_2, &retrieve_results_2);
-  caosdb_transaction_result_set_size(&retrieve_results_2, count);
+  linkahead_transaction_result_set retrieve_results_2;
+  linkahead_transaction_transaction_get_result_set(&retrieve_transaction_2, &retrieve_results_2);
+  linkahead_transaction_result_set_size(&retrieve_results_2, count);
   EXPECT_EQ(*count, 1);
-  caosdb_entity_entity retrieved_entity_2;
-  caosdb_transaction_result_set_at(&retrieve_results_2, &retrieved_entity_2, 0);
+  linkahead_entity_entity retrieved_entity_2;
+  linkahead_transaction_result_set_at(&retrieve_results_2, &retrieved_entity_2, 0);
 
-  caosdb_entity_entity_get_id(&retrieved_entity_2, &out);
+  linkahead_entity_entity_get_id(&retrieved_entity_2, &out);
   EXPECT_EQ(strcmp(in, out), 0);
 
-  caosdb_entity_entity_get_name(&retrieved_entity_1, &in);
-  caosdb_entity_entity_get_name(&retrieved_entity_2, &out);
+  linkahead_entity_entity_get_name(&retrieved_entity_1, &in);
+  linkahead_entity_entity_get_name(&retrieved_entity_2, &out);
   EXPECT_EQ(strcmp(in, out), 0);
 
   // Doesn't have the old name anymore
-  caosdb_entity_entity_get_name(&original_entity, &in);
+  linkahead_entity_entity_get_name(&original_entity, &in);
   EXPECT_FALSE((strcmp(in, out) == 0));
 
   // Everything else hasn't changed
-  caosdb_entity_entity_get_role(&original_entity, &in);
-  caosdb_entity_entity_get_role(&retrieved_entity_2, &out);
+  linkahead_entity_entity_get_role(&original_entity, &in);
+  linkahead_entity_entity_get_role(&retrieved_entity_2, &out);
   EXPECT_EQ(strcmp(in, out), 0);
 
-  caosdb_entity_entity_get_datatype(&retrieved_entity_2, &out_type);
-  caosdb_entity_datatype_is_atomic(&out_type, &out_is);
+  linkahead_entity_entity_get_datatype(&retrieved_entity_2, &out_type);
+  linkahead_entity_datatype_is_atomic(&out_type, &out_is);
   EXPECT_TRUE(out_is);
-  caosdb_entity_datatype_get_datatype_name(&in_type, &in);
-  caosdb_entity_datatype_get_datatype_name(&out_type, &out);
+  linkahead_entity_datatype_get_datatype_name(&in_type, &in);
+  linkahead_entity_datatype_get_datatype_name(&out_type, &out);
   EXPECT_EQ(strcmp(in, out), 0);
 
   // Now delete
-  caosdb_transaction_transaction delete_transaction;
-  caosdb_connection_connection_create_transaction(&connection, &delete_transaction);
-  caosdb_entity_entity_get_id(&retrieved_entity_2, &in);
-  caosdb_transaction_transaction_delete_by_id(&delete_transaction, in);
-  return_code = caosdb_transaction_transaction_execute(&delete_transaction);
+  linkahead_transaction_transaction delete_transaction;
+  linkahead_connection_connection_create_transaction(&connection, &delete_transaction);
+  linkahead_entity_entity_get_id(&retrieved_entity_2, &in);
+  linkahead_transaction_transaction_delete_by_id(&delete_transaction, in);
+  return_code = linkahead_transaction_transaction_execute(&delete_transaction);
   EXPECT_EQ(return_code, 0);
 
-  caosdb_transaction_result_set delete_results;
-  caosdb_transaction_transaction_get_result_set(&delete_transaction, &delete_results);
-  caosdb_transaction_result_set_size(&delete_results, count);
+  linkahead_transaction_result_set delete_results;
+  linkahead_transaction_transaction_get_result_set(&delete_transaction, &delete_results);
+  linkahead_transaction_result_set_size(&delete_results, count);
   EXPECT_EQ(*count, 1);
 
-  caosdb_entity_entity deleted_entity;
-  caosdb_transaction_result_set_at(&delete_results, &deleted_entity, 0);
-  caosdb_entity_entity_get_id(&deleted_entity, &out);
+  linkahead_entity_entity deleted_entity;
+  linkahead_transaction_result_set_at(&delete_results, &deleted_entity, 0);
+  linkahead_entity_entity_get_id(&deleted_entity, &out);
   EXPECT_EQ(strcmp(in, out), 0);
 
   // Try to retrieve again
-  caosdb_transaction_transaction retrieve_transaction_3;
-  caosdb_connection_connection_create_transaction(&connection, &retrieve_transaction_3);
-  caosdb_transaction_transaction_retrieve_by_id(&retrieve_transaction_3, out);
-  return_code = caosdb_transaction_transaction_execute(&retrieve_transaction_3);
+  linkahead_transaction_transaction retrieve_transaction_3;
+  linkahead_connection_connection_create_transaction(&connection, &retrieve_transaction_3);
+  linkahead_transaction_transaction_retrieve_by_id(&retrieve_transaction_3, out);
+  return_code = linkahead_transaction_transaction_execute(&retrieve_transaction_3);
   EXPECT_TRUE((return_code > 0));
 
-  caosdb_transaction_result_set retrieve_results_3;
-  caosdb_transaction_transaction_get_result_set(&retrieve_transaction_3, &retrieve_results_3);
-  caosdb_transaction_result_set_size(&retrieve_results_3, count);
+  linkahead_transaction_result_set retrieve_results_3;
+  linkahead_transaction_transaction_get_result_set(&retrieve_transaction_3, &retrieve_results_3);
+  linkahead_transaction_result_set_size(&retrieve_results_3, count);
   EXPECT_EQ(*count, 1);
-  caosdb_entity_entity retrieved_entity_3;
-  caosdb_transaction_result_set_at(&retrieve_results_3, &retrieved_entity_3, 0);
-  caosdb_entity_entity_get_errors_size(&retrieved_entity_3, count);
+  linkahead_entity_entity retrieved_entity_3;
+  linkahead_transaction_result_set_at(&retrieve_results_3, &retrieved_entity_3, 0);
+  linkahead_entity_entity_get_errors_size(&retrieved_entity_3, count);
   EXPECT_EQ(*count, 1);
-  caosdb_entity_message err_msg;
-  caosdb_entity_entity_get_error(&retrieved_entity_3, &err_msg, 0);
-  caosdb_entity_message_get_code(&err_msg, count);
-  EXPECT_EQ(*count, caosdb::entity::MessageCode::ENTITY_DOES_NOT_EXIST);
+  linkahead_entity_message err_msg;
+  linkahead_entity_entity_get_error(&retrieved_entity_3, &err_msg, 0);
+  linkahead_entity_message_get_code(&err_msg, count);
+  EXPECT_EQ(*count, linkahead::entity::MessageCode::ENTITY_DOES_NOT_EXIST);
 
   // Delete everything
-  caosdb_transaction_delete_transaction(&retrieve_transaction_3);
-  caosdb_transaction_delete_transaction(&delete_transaction);
-  caosdb_transaction_delete_transaction(&retrieve_transaction_2);
-  caosdb_transaction_delete_transaction(&update_transaction);
-  caosdb_transaction_delete_transaction(&retrieve_transaction_1);
-  caosdb_transaction_delete_transaction(&insert_transaction);
-  caosdb_entity_delete_entity(&original_entity);
-  caosdb_entity_delete_datatype(&in_type);
+  linkahead_transaction_delete_transaction(&retrieve_transaction_3);
+  linkahead_transaction_delete_transaction(&delete_transaction);
+  linkahead_transaction_delete_transaction(&retrieve_transaction_2);
+  linkahead_transaction_delete_transaction(&update_transaction);
+  linkahead_transaction_delete_transaction(&retrieve_transaction_1);
+  linkahead_transaction_delete_transaction(&insert_transaction);
+  linkahead_entity_delete_entity(&original_entity);
+  linkahead_entity_delete_datatype(&in_type);
 }
 
-TEST_F(test_ccaosdb, test_insert_with_prop_and_parent) {
+TEST_F(test_clinkahead, test_insert_with_prop_and_parent) {
 
-  caosdb_connection_connection connection;
-  caosdb_connection_connection_manager_get_default_connection(&connection);
+  linkahead_connection_connection connection;
+  linkahead_connection_connection_manager_get_default_connection(&connection);
 
   // Create and insert a property, ...
   std::cout << "Creating a property..." << std::endl;
-  caosdb_entity_entity original_prop;
-  caosdb_entity_create_entity(&original_prop);
+  linkahead_entity_entity original_prop;
+  linkahead_entity_create_entity(&original_prop);
 
-  caosdb_entity_entity_set_name(&original_prop, "TestProp");
-  caosdb_entity_entity_set_role(&original_prop, "PROPERTY");
-  caosdb_entity_datatype original_type;
-  caosdb_entity_create_atomic_datatype(&original_type, "TEXT");
-  caosdb_entity_entity_set_datatype(&original_prop, &original_type);
+  linkahead_entity_entity_set_name(&original_prop, "TestProp");
+  linkahead_entity_entity_set_role(&original_prop, "PROPERTY");
+  linkahead_entity_datatype original_type;
+  linkahead_entity_create_atomic_datatype(&original_type, "TEXT");
+  linkahead_entity_entity_set_datatype(&original_prop, &original_type);
 
   std::cout << "Inserting a property..." << std::endl;
-  caosdb_transaction_transaction prop_insertion;
-  caosdb_connection_connection_create_transaction(&connection, &prop_insertion);
-  caosdb_transaction_transaction_insert_entity(&prop_insertion, &original_prop);
-  int return_code(caosdb_transaction_transaction_execute(&prop_insertion));
+  linkahead_transaction_transaction prop_insertion;
+  linkahead_connection_connection_create_transaction(&connection, &prop_insertion);
+  linkahead_transaction_transaction_insert_entity(&prop_insertion, &original_prop);
+  int return_code(linkahead_transaction_transaction_execute(&prop_insertion));
   EXPECT_EQ(return_code, 0);
 
   std::cout << "Checking result..." << std::endl;
-  caosdb_transaction_result_set prop_results;
-  caosdb_transaction_transaction_get_result_set(&prop_insertion, &prop_results);
-  caosdb_entity_entity inserted_prop;
-  caosdb_transaction_result_set_at(&prop_results, &inserted_prop, 0);
+  linkahead_transaction_result_set prop_results;
+  linkahead_transaction_transaction_get_result_set(&prop_insertion, &prop_results);
+  linkahead_entity_entity inserted_prop;
+  linkahead_transaction_result_set_at(&prop_results, &inserted_prop, 0);
   char *prop_id = nullptr; // NOLINT
-  caosdb_entity_entity_get_id(&inserted_prop, &prop_id);
+  linkahead_entity_entity_get_id(&inserted_prop, &prop_id);
 
   // ... a record type with this property, ...
-  caosdb_entity_entity original_rt;
-  caosdb_entity_create_entity(&original_rt);
+  linkahead_entity_entity original_rt;
+  linkahead_entity_create_entity(&original_rt);
 
-  caosdb_entity_entity_set_name(&original_rt, "TestType");
-  caosdb_entity_entity_set_role(&original_rt, "RECORD_TYPE");
+  linkahead_entity_entity_set_name(&original_rt, "TestType");
+  linkahead_entity_entity_set_role(&original_rt, "RECORD_TYPE");
 
-  caosdb_entity_property rt_prop;
-  caosdb_entity_create_property(&rt_prop);
-  caosdb_entity_property_set_id(&rt_prop, prop_id);
-  caosdb_entity_entity_append_property(&original_rt, &rt_prop);
+  linkahead_entity_property rt_prop;
+  linkahead_entity_create_property(&rt_prop);
+  linkahead_entity_property_set_id(&rt_prop, prop_id);
+  linkahead_entity_entity_append_property(&original_rt, &rt_prop);
 
-  caosdb_transaction_transaction rt_insertion;
-  caosdb_connection_connection_create_transaction(&connection, &rt_insertion);
-  caosdb_transaction_transaction_insert_entity(&rt_insertion, &original_rt);
-  return_code = caosdb_transaction_transaction_execute(&rt_insertion);
+  linkahead_transaction_transaction rt_insertion;
+  linkahead_connection_connection_create_transaction(&connection, &rt_insertion);
+  linkahead_transaction_transaction_insert_entity(&rt_insertion, &original_rt);
+  return_code = linkahead_transaction_transaction_execute(&rt_insertion);
   EXPECT_EQ(return_code, 0);
 
-  caosdb_transaction_result_set rt_results;
-  caosdb_transaction_transaction_get_result_set(&rt_insertion, &rt_results);
-  caosdb_entity_entity inserted_rt;
-  caosdb_transaction_result_set_at(&rt_results, &inserted_rt, 0);
+  linkahead_transaction_result_set rt_results;
+  linkahead_transaction_transaction_get_result_set(&rt_insertion, &rt_results);
+  linkahead_entity_entity inserted_rt;
+  linkahead_transaction_result_set_at(&rt_results, &inserted_rt, 0);
   char *rt_id = nullptr; // NOLINT
-  caosdb_entity_entity_get_id(&inserted_rt, &rt_id);
+  linkahead_entity_entity_get_id(&inserted_rt, &rt_id);
 
   // ... and a record with this record type as a parent.
-  caosdb_entity_entity original_rec;
-  caosdb_entity_create_entity(&original_rec);
-  caosdb_entity_entity_set_name(&original_rec, "TestRec");
-  caosdb_entity_entity_set_role(&original_rec, "RECORD");
-  caosdb_entity_parent rec_parent;
-  caosdb_entity_create_parent(&rec_parent);
-  caosdb_entity_parent_set_id(&rec_parent, rt_id);
-  caosdb_entity_entity_append_parent(&original_rec, &rec_parent);
-  caosdb_entity_property rec_prop;
-  caosdb_entity_create_property(&rec_prop);
-  caosdb_entity_property_set_id(&rec_prop, prop_id);
-  caosdb_entity_value in_value;
-  caosdb_entity_create_string_value(&in_value, "Bla");
-  caosdb_entity_property_set_value(&rec_prop, &in_value);
-  caosdb_entity_entity_append_property(&original_rec, &rec_prop);
-
-  caosdb_transaction_transaction rec_insertion;
-  caosdb_connection_connection_create_transaction(&connection, &rec_insertion);
-  caosdb_transaction_transaction_insert_entity(&rec_insertion, &original_rec);
-  return_code = caosdb_transaction_transaction_execute(&rec_insertion);
-  EXPECT_EQ(return_code, 0);
-
-  caosdb_transaction_result_set rec_results;
-  caosdb_transaction_transaction_get_result_set(&rec_insertion, &rec_results);
-  caosdb_entity_entity inserted_rec;
-  caosdb_transaction_result_set_at(&rec_results, &inserted_rec, 0);
+  linkahead_entity_entity original_rec;
+  linkahead_entity_create_entity(&original_rec);
+  linkahead_entity_entity_set_name(&original_rec, "TestRec");
+  linkahead_entity_entity_set_role(&original_rec, "RECORD");
+  linkahead_entity_parent rec_parent;
+  linkahead_entity_create_parent(&rec_parent);
+  linkahead_entity_parent_set_id(&rec_parent, rt_id);
+  linkahead_entity_entity_append_parent(&original_rec, &rec_parent);
+  linkahead_entity_property rec_prop;
+  linkahead_entity_create_property(&rec_prop);
+  linkahead_entity_property_set_id(&rec_prop, prop_id);
+  linkahead_entity_value in_value;
+  linkahead_entity_create_string_value(&in_value, "Bla");
+  linkahead_entity_property_set_value(&rec_prop, &in_value);
+  linkahead_entity_entity_append_property(&original_rec, &rec_prop);
+
+  linkahead_transaction_transaction rec_insertion;
+  linkahead_connection_connection_create_transaction(&connection, &rec_insertion);
+  linkahead_transaction_transaction_insert_entity(&rec_insertion, &original_rec);
+  return_code = linkahead_transaction_transaction_execute(&rec_insertion);
+  EXPECT_EQ(return_code, 0);
+
+  linkahead_transaction_result_set rec_results;
+  linkahead_transaction_transaction_get_result_set(&rec_insertion, &rec_results);
+  linkahead_entity_entity inserted_rec;
+  linkahead_transaction_result_set_at(&rec_results, &inserted_rec, 0);
   char *rec_id = nullptr; // NOLINT
-  caosdb_entity_entity_get_id(&inserted_rec, &rec_id);
+  linkahead_entity_entity_get_id(&inserted_rec, &rec_id);
 
   // Retrieve the record again for comparison
-  caosdb_transaction_transaction retrieve_transaction;
-  caosdb_connection_connection_create_transaction(&connection, &retrieve_transaction);
-  caosdb_transaction_transaction_retrieve_by_id(&retrieve_transaction, rec_id);
-  return_code = caosdb_transaction_transaction_execute(&retrieve_transaction);
+  linkahead_transaction_transaction retrieve_transaction;
+  linkahead_connection_connection_create_transaction(&connection, &retrieve_transaction);
+  linkahead_transaction_transaction_retrieve_by_id(&retrieve_transaction, rec_id);
+  return_code = linkahead_transaction_transaction_execute(&retrieve_transaction);
   EXPECT_EQ(return_code, 0);
 
-  caosdb_transaction_result_set retrieve_result;
-  caosdb_transaction_transaction_get_result_set(&retrieve_transaction, &retrieve_result);
-  caosdb_entity_entity retrieved_rec;
-  caosdb_transaction_result_set_at(&retrieve_result, &retrieved_rec, 0);
+  linkahead_transaction_result_set retrieve_result;
+  linkahead_transaction_transaction_get_result_set(&retrieve_transaction, &retrieve_result);
+  linkahead_entity_entity retrieved_rec;
+  linkahead_transaction_result_set_at(&retrieve_result, &retrieved_rec, 0);
   char *in = nullptr;  // NOLINT
   char *out = nullptr; // NOLINT
-  caosdb_entity_entity_get_name(&original_rec, &in);
-  caosdb_entity_entity_get_name(&retrieved_rec, &out);
+  linkahead_entity_entity_get_name(&original_rec, &in);
+  linkahead_entity_entity_get_name(&retrieved_rec, &out);
   EXPECT_EQ(strcmp(in, out), 0);
   int count[] = {0}; // NOLINT
-  caosdb_entity_entity_get_properties_size(&retrieved_rec, count);
+  linkahead_entity_entity_get_properties_size(&retrieved_rec, count);
   EXPECT_EQ(*count, 1);
-  caosdb_entity_entity_get_parents_size(&retrieved_rec, count);
+  linkahead_entity_entity_get_parents_size(&retrieved_rec, count);
   EXPECT_EQ(*count, 1);
 
-  caosdb_entity_parent retrieved_parent;
-  caosdb_entity_entity_get_parent(&retrieved_rec, &retrieved_parent, 0);
-  caosdb_entity_entity_get_name(&original_rt, &in);
-  caosdb_entity_parent_get_name(&retrieved_parent, &out);
+  linkahead_entity_parent retrieved_parent;
+  linkahead_entity_entity_get_parent(&retrieved_rec, &retrieved_parent, 0);
+  linkahead_entity_entity_get_name(&original_rt, &in);
+  linkahead_entity_parent_get_name(&retrieved_parent, &out);
   EXPECT_EQ(strcmp(in, out), 0);
-  caosdb_entity_parent_get_id(&retrieved_parent, &out);
+  linkahead_entity_parent_get_id(&retrieved_parent, &out);
   EXPECT_EQ(strcmp(rt_id, out), 0);
 
-  caosdb_entity_property retrieved_property;
-  caosdb_entity_entity_get_property(&retrieved_rec, &retrieved_property, 0);
-  caosdb_entity_entity_get_name(&original_prop, &in);
-  caosdb_entity_property_get_name(&retrieved_property, &out);
+  linkahead_entity_property retrieved_property;
+  linkahead_entity_entity_get_property(&retrieved_rec, &retrieved_property, 0);
+  linkahead_entity_entity_get_name(&original_prop, &in);
+  linkahead_entity_property_get_name(&retrieved_property, &out);
   EXPECT_EQ(strcmp(in, out), 0);
-  caosdb_entity_value out_value;
-  caosdb_entity_property_get_value(&retrieved_property, &out_value);
-  caosdb_entity_value_get_as_string(&in_value, &in);
-  caosdb_entity_value_get_as_string(&out_value, &out);
+  linkahead_entity_value out_value;
+  linkahead_entity_property_get_value(&retrieved_property, &out_value);
+  linkahead_entity_value_get_as_string(&in_value, &in);
+  linkahead_entity_value_get_as_string(&out_value, &out);
   EXPECT_EQ(strcmp(in, out), 0);
 
-  caosdb_transaction_delete_transaction(&retrieve_transaction);
-  caosdb_transaction_delete_transaction(&rec_insertion);
-  caosdb_entity_delete_property(&rec_prop);
-  caosdb_entity_delete_parent(&rec_parent);
-  caosdb_entity_delete_entity(&original_rec);
-  caosdb_transaction_delete_transaction(&rt_insertion);
-  caosdb_entity_delete_property(&rt_prop);
-  caosdb_entity_delete_entity(&original_rt);
-  caosdb_transaction_delete_transaction(&prop_insertion);
-  caosdb_entity_delete_entity(&original_prop);
-  caosdb_entity_delete_datatype(&original_type);
-  caosdb_entity_delete_value(&in_value);
+  linkahead_transaction_delete_transaction(&retrieve_transaction);
+  linkahead_transaction_delete_transaction(&rec_insertion);
+  linkahead_entity_delete_property(&rec_prop);
+  linkahead_entity_delete_parent(&rec_parent);
+  linkahead_entity_delete_entity(&original_rec);
+  linkahead_transaction_delete_transaction(&rt_insertion);
+  linkahead_entity_delete_property(&rt_prop);
+  linkahead_entity_delete_entity(&original_rt);
+  linkahead_transaction_delete_transaction(&prop_insertion);
+  linkahead_entity_delete_entity(&original_prop);
+  linkahead_entity_delete_datatype(&original_type);
+  linkahead_entity_delete_value(&in_value);
 }
 
-TEST_F(test_ccaosdb, test_up_n_download_file) {
+TEST_F(test_clinkahead, test_up_n_download_file) {
 
-  caosdb_connection_connection connection;
-  caosdb_connection_connection_manager_get_default_connection(&connection);
+  linkahead_connection_connection connection;
+  linkahead_connection_connection_manager_get_default_connection(&connection);
 
-  caosdb_entity_entity original_entity;
-  caosdb_entity_create_entity(&original_entity);
-  caosdb_entity_entity_set_role(&original_entity, "FILE");
-  caosdb_entity_entity_set_local_path(&original_entity, test_upload_file_1.c_str());
-  caosdb_entity_entity_set_file_path(&original_entity, "/some/file");
+  linkahead_entity_entity original_entity;
+  linkahead_entity_create_entity(&original_entity);
+  linkahead_entity_entity_set_role(&original_entity, "FILE");
+  linkahead_entity_entity_set_local_path(&original_entity, test_upload_file_1.c_str());
+  linkahead_entity_entity_set_file_path(&original_entity, "/some/file");
 
-  caosdb_transaction_transaction insert_transaction;
-  caosdb_connection_connection_create_transaction(&connection, &insert_transaction);
-  caosdb_transaction_transaction_insert_entity(&insert_transaction, &original_entity);
-  int return_code(caosdb_transaction_transaction_execute(&insert_transaction));
+  linkahead_transaction_transaction insert_transaction;
+  linkahead_connection_connection_create_transaction(&connection, &insert_transaction);
+  linkahead_transaction_transaction_insert_entity(&insert_transaction, &original_entity);
+  int return_code(linkahead_transaction_transaction_execute(&insert_transaction));
   EXPECT_EQ(return_code, 0);
 
-  caosdb_transaction_result_set rec_results;
-  caosdb_transaction_transaction_get_result_set(&insert_transaction, &rec_results);
-  caosdb_entity_entity inserted_rec;
-  caosdb_transaction_result_set_at(&rec_results, &inserted_rec, 0);
+  linkahead_transaction_result_set rec_results;
+  linkahead_transaction_transaction_get_result_set(&insert_transaction, &rec_results);
+  linkahead_entity_entity inserted_rec;
+  linkahead_transaction_result_set_at(&rec_results, &inserted_rec, 0);
   char *rec_id = nullptr; // NOLINT
-  caosdb_entity_entity_get_id(&inserted_rec, &rec_id);
+  linkahead_entity_entity_get_id(&inserted_rec, &rec_id);
 
-  caosdb_entity_entity download_entity;
-  caosdb_entity_create_entity(&download_entity);
-  caosdb_entity_entity_set_role(&download_entity, "FILE");
-  caosdb_entity_entity_set_local_path(&download_entity, "lol");
-  caosdb_entity_entity_set_file_path(&download_entity, "/some/file");
+  linkahead_entity_entity download_entity;
+  linkahead_entity_create_entity(&download_entity);
+  linkahead_entity_entity_set_role(&download_entity, "FILE");
+  linkahead_entity_entity_set_local_path(&download_entity, "lol");
+  linkahead_entity_entity_set_file_path(&download_entity, "/some/file");
 
-  caosdb_transaction_transaction retrieve_transaction_1;
-  caosdb_connection_connection_create_transaction(&connection, &retrieve_transaction_1);
+  linkahead_transaction_transaction retrieve_transaction_1;
+  linkahead_connection_connection_create_transaction(&connection, &retrieve_transaction_1);
   EXPECT_EQ(return_code, 0);
-  // return_code = caosdb_transaction_transaction_retrieve_by_id(
+  // return_code = linkahead_transaction_transaction_retrieve_by_id(
   //   &retrieve_transaction_1, rec_id);
-  return_code = caosdb_transaction_transaction_retrieve_and_download_file_by_id(
+  return_code = linkahead_transaction_transaction_retrieve_and_download_file_by_id(
     &retrieve_transaction_1, rec_id, test_download_file_1.c_str());
-  EXPECT_EQ(return_code, caosdb::StatusCode::GO_ON);
-  return_code = caosdb_transaction_transaction_execute(&retrieve_transaction_1);
+  EXPECT_EQ(return_code, linkahead::StatusCode::GO_ON);
+  return_code = linkahead_transaction_transaction_execute(&retrieve_transaction_1);
   EXPECT_EQ(return_code, 0);
 
-  caosdb_transaction_result_set result_set;
-  return_code = caosdb_transaction_transaction_get_result_set(&retrieve_transaction_1, &result_set);
+  linkahead_transaction_result_set result_set;
+  return_code = linkahead_transaction_transaction_get_result_set(&retrieve_transaction_1, &result_set);
   EXPECT_EQ(return_code, 0);
 }
diff --git a/test/test_connection.cpp b/test/test_connection.cpp
index f0042f25b2992d98a73d9a3702b060915d491801..a0f2636b3e5751da99f9dedf16e847dcc146968c 100644
--- a/test/test_connection.cpp
+++ b/test/test_connection.cpp
@@ -1,5 +1,5 @@
 /*
- * This file is a part of the CaosDB Project.
+ * This file is a part of the LinkAhead Project.
  *
  * Copyright (C) 2021 Timm Fitschen <t.fitschen@indiscale.com>
  * Copyright (C) 2021 IndiScale GmbH <info@indiscale.com>
@@ -18,15 +18,15 @@
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  *
  */
-#include "caosdb/authentication.h"       // for PlainPasswordAuthenticator
-#include "caosdb/certificate_provider.h" // for PemFileCertificateProvider
-#include "caosdb/configuration.h"        // for InsecureConnectionConfigura...
-#include "caosdb/connection.h"           // for Connection, VersionInfo, path
-#include "caosdb/constants.h"            // for COMPATIBLE_SERVER_VERSION_M...
-#include "caosdb/exceptions.h"           // for AuthenticationError, Connec...
-#include "caosdb/info.h"                 // for VersionInfo
-#include "caosdb/utility.h"              // for get_env_fallback
-#include "caosdb_test_utility.h"         // for EXPECT_THROW_MESSAGE
+#include "linkahead/authentication.h"       // for PlainPasswordAuthenticator
+#include "linkahead/certificate_provider.h" // for PemFileCertificateProvider
+#include "linkahead/configuration.h"        // for InsecureConnectionConfigura...
+#include "linkahead/connection.h"           // for Connection, VersionInfo, path
+#include "linkahead/constants.h"            // for COMPATIBLE_SERVER_VERSION_M...
+#include "linkahead/exceptions.h"           // for AuthenticationError, Connec...
+#include "linkahead/info.h"                 // for VersionInfo
+#include "linkahead/utility.h"              // for get_env_fallback
+#include "linkahead_test_utility.h"         // for EXPECT_THROW_MESSAGE
 #include <filesystem>                    // for path
 #include <gtest/gtest_pred_impl.h> // NOLINT TODO how to fix this? for Test, TestInfo, TEST, EXPEC...
 #include <gtest/gtest-message.h>   // for Message
@@ -34,13 +34,13 @@
 #include <memory>                  // for allocator, unique_ptr, __sh...
 #include <string>                  // for stoi, string
 
-namespace caosdb::connection {
-using caosdb::authentication::PlainPasswordAuthenticator;
-using caosdb::configuration::InsecureConnectionConfiguration;
-using caosdb::configuration::PemFileCertificateProvider;
-using caosdb::configuration::TlsConnectionConfiguration;
-using caosdb::exceptions::AuthenticationError;
-using caosdb::exceptions::ConnectionError;
+namespace linkahead::connection {
+using linkahead::authentication::PlainPasswordAuthenticator;
+using linkahead::configuration::InsecureConnectionConfiguration;
+using linkahead::configuration::PemFileCertificateProvider;
+using linkahead::configuration::TlsConnectionConfiguration;
+using linkahead::exceptions::AuthenticationError;
+using linkahead::exceptions::ConnectionError;
 
 TEST(test_connection, config_somehost_25323) {
   auto port = 25323;
@@ -61,9 +61,9 @@ TEST(test_connection, connect_somehost_42347_fails) {
 }
 
 TEST(test_connection, connection_insecure_authentication_error_anonymous) {
-  const auto *port_str = caosdb::utility::get_env_fallback("CAOSDB_SERVER_GRPC_PORT_HTTP", "8080");
+  const auto *port_str = linkahead::utility::get_env_fallback("CAOSDB_SERVER_GRPC_PORT_HTTP", "8080");
   auto port = std::stoi(port_str);
-  const auto *const host = caosdb::utility::get_env_fallback("CAOSDB_SERVER_HOST", "localhost");
+  const auto *const host = linkahead::utility::get_env_fallback("CAOSDB_SERVER_HOST", "localhost");
 
   auto config = InsecureConnectionConfiguration(host, port);
   auto connection = Connection(config);
@@ -72,10 +72,10 @@ TEST(test_connection, connection_insecure_authentication_error_anonymous) {
 }
 
 TEST(test_connection, connection_ssl_authentication_error_anonymous) {
-  const auto *port_str = caosdb::utility::get_env_fallback("CAOSDB_SERVER_GRPC_PORT_HTTPS", "8443");
+  const auto *port_str = linkahead::utility::get_env_fallback("CAOSDB_SERVER_GRPC_PORT_HTTPS", "8443");
   auto port = std::stoi(port_str);
-  const auto *const host = caosdb::utility::get_env_fallback("CAOSDB_SERVER_HOST", "localhost");
-  const auto path = caosdb::utility::get_env_fallback("CAOSDB_SERVER_CERT", std::string());
+  const auto *const host = linkahead::utility::get_env_fallback("CAOSDB_SERVER_HOST", "localhost");
+  const auto path = linkahead::utility::get_env_fallback("CAOSDB_SERVER_CERT", std::string());
 
   auto cert = PemFileCertificateProvider(path);
   auto config = TlsConnectionConfiguration(host, port, cert);
@@ -88,10 +88,10 @@ TEST(test_connection, connection_ssl_authentication_error_anonymous) {
 }
 
 TEST(test_connection, connection_ssl_authentication_error_wrong_credentials) {
-  const auto *port_str = caosdb::utility::get_env_fallback("CAOSDB_SERVER_GRPC_PORT_HTTPS", "8443");
+  const auto *port_str = linkahead::utility::get_env_fallback("CAOSDB_SERVER_GRPC_PORT_HTTPS", "8443");
   auto port = std::stoi(port_str);
-  const auto *const host = caosdb::utility::get_env_fallback("CAOSDB_SERVER_HOST", "localhost");
-  const auto path = caosdb::utility::get_env_fallback("CAOSDB_SERVER_CERT", std::string());
+  const auto *const host = linkahead::utility::get_env_fallback("CAOSDB_SERVER_HOST", "localhost");
+  const auto path = linkahead::utility::get_env_fallback("CAOSDB_SERVER_CERT", std::string());
   const auto *const user = "not-a-user-23461237";
   const auto *const password = "very-c-cred";
 
@@ -109,10 +109,10 @@ TEST(test_connection, connection_ssl_authentication_error_wrong_credentials) {
 TEST(test_connection, connection_ssl_authentication_success) {
   const auto &connection = ConnectionManager::GetDefaultConnection();
 
-  auto major = caosdb::COMPATIBLE_SERVER_VERSION_MAJOR;
-  auto minor = caosdb::COMPATIBLE_SERVER_VERSION_MINOR;
-  auto patch = caosdb::COMPATIBLE_SERVER_VERSION_PATCH;
-  const auto pre_release = std::string(caosdb::COMPATIBLE_SERVER_VERSION_PRE_RELEASE);
+  auto major = linkahead::COMPATIBLE_SERVER_VERSION_MAJOR;
+  auto minor = linkahead::COMPATIBLE_SERVER_VERSION_MINOR;
+  auto patch = linkahead::COMPATIBLE_SERVER_VERSION_PATCH;
+  const auto pre_release = std::string(linkahead::COMPATIBLE_SERVER_VERSION_PRE_RELEASE);
 
   const auto &v_info = connection->RetrieveVersionInfo();
 
@@ -126,4 +126,4 @@ TEST(test_connection, connection_ssl_authentication_success) {
   }
 }
 
-} // namespace caosdb::connection
+} // namespace linkahead::connection
diff --git a/test/test_issues.cpp b/test/test_issues.cpp
index 9935eb179b3768f736a8ba37bdca5dc58d92a14f..fd2eeb9efd695a5fa951d36999f039c4ce34541c 100644
--- a/test/test_issues.cpp
+++ b/test/test_issues.cpp
@@ -1,5 +1,5 @@
 /*
- * This file is a part of the CaosDB Project.
+ * This file is a part of the LinkAhead Project.
  *
  * Copyright (C) 2021 IndiScale GmbH <info@indiscale.com>
  * Copyright (C) 2021 Daniel Hornung <d.hornung@indiscale.com>
@@ -17,11 +17,11 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  */
-#include "caosdb/connection.h"         // for Connection, Connec...
-#include "caosdb/data_type.h"          // for AtomicDataType
-#include "caosdb/entity.h"             // for Entity, Parent, Role
-#include "caosdb/transaction.h"        // for Transaction, Entity
-#include "caosdb/transaction_status.h" // for TransactionStatus
+#include "linkahead/connection.h"         // for Connection, Connec...
+#include "linkahead/data_type.h"          // for AtomicDataType
+#include "linkahead/entity.h"             // for Entity, Parent, Role
+#include "linkahead/transaction.h"        // for Transaction, Entity
+#include "linkahead/transaction_status.h" // for TransactionStatus
 #include <cstdint>                     // for int32_t
 #include <gtest/gtest-message.h>       // for Message
 #include <gtest/gtest-spi.h>           // for EXPECT_NONFATAL_FA...
@@ -32,11 +32,11 @@
 #include <string>                      // for operator+, operator<<
 #include <vector>                      // for vector
 
-namespace caosdb::transaction {
-using caosdb::entity::AtomicDataType;
-using caosdb::entity::Entity;
-using caosdb::entity::Parent;
-using caosdb::entity::Role;
+namespace linkahead::transaction {
+using linkahead::entity::AtomicDataType;
+using linkahead::entity::Entity;
+using linkahead::entity::Parent;
+using linkahead::entity::Role;
 
 class test_issues : public ::testing::Test {
 public:
@@ -45,7 +45,7 @@ public:
 
   static void DeleteEntities() {
     // delete all entities
-    const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+    const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
     auto query_transaction(connection->CreateTransaction());
     query_transaction->Query("FIND ENTITY WITH id > 99");
     query_transaction->Execute();
@@ -72,7 +72,7 @@ protected:
  * test error-prone updates
  */
 TEST_F(test_issues, server_issue_170) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   // Insert original
   auto insert_transaction(connection->CreateTransaction());
@@ -116,7 +116,7 @@ TEST_F(test_issues, server_issue_170) {
  * This must result in a server error.
  */
 TEST_F(test_issues, server_issue_171) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto insert_transaction(connection->CreateTransaction());
 
@@ -166,7 +166,7 @@ TEST_F(test_issues, server_issue_171) {
  * The file attributes should be ignored by the server.
  */
 TEST_F(test_issues, server_issue_174) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto insert_transaction(connection->CreateTransaction());
 
@@ -183,4 +183,4 @@ TEST_F(test_issues, server_issue_174) {
   EXPECT_FALSE(insert_status.IsError());
 }
 
-} // namespace caosdb::transaction
+} // namespace linkahead::transaction
diff --git a/test/test_list_properties.cpp b/test/test_list_properties.cpp
index b60c58fadff358b878108ca72edbb67b1af3f26e..9708e3523a054caa4267a98fcf8f5e9076f8cfc1 100644
--- a/test/test_list_properties.cpp
+++ b/test/test_list_properties.cpp
@@ -1,5 +1,5 @@
 /*
- * This file is a part of the CaosDB Project.
+ * This file is a part of the LinkAhead Project.
  *
  * Copyright (C) 2021 Timm Fitschen <t.fitschen@indiscale.com>
  * Copyright (C) 2021 IndiScale GmbH <info@indiscale.com>
@@ -18,12 +18,12 @@
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  *
  */
-#include "caosdb/connection.h"         // for Connection, ConnectionManager
-#include "caosdb/data_type.h"          // for AtomicDataType
-#include "caosdb/entity.h"             // for Entity, Messages, Message
-#include "caosdb/transaction.h"        // for Entity, Transaction,...
-#include "caosdb/transaction_status.h" // for TransactionStatus, StatusCode
-#include "caosdb/value.h"              // for value
+#include "linkahead/connection.h"         // for Connection, ConnectionManager
+#include "linkahead/data_type.h"          // for AtomicDataType
+#include "linkahead/entity.h"             // for Entity, Messages, Message
+#include "linkahead/transaction.h"        // for Entity, Transaction,...
+#include "linkahead/transaction_status.h" // for TransactionStatus, StatusCode
+#include "linkahead/value.h"              // for value
 #include <cstdint>                     // for int64_t
 #include <gtest/gtest-message.h>       // for Message
 #include <gtest/gtest-test-part.h>     // for TestPartResult, SuiteApiResolver
@@ -33,7 +33,7 @@
 #include <string>                      // for string
 #include <vector>                      // for vector
 
-namespace caosdb::entity {
+namespace linkahead::entity {
 
 class test_list_properties : public ::testing::Test {
 protected:
@@ -42,7 +42,7 @@ protected:
   void TearDown() override { DeleteEntities(); }
 
   static void DeleteEntities() {
-    const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+    const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
     auto query_transaction(connection->CreateTransaction());
     query_transaction->Query("FIND ENTITY WITH id > 99");
     query_transaction->Execute();
@@ -57,7 +57,7 @@ protected:
 };
 
 TEST_F(test_list_properties, insert_list_of_text) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto insertion_prop(connection->CreateTransaction());
 
@@ -112,7 +112,7 @@ TEST_F(test_list_properties, insert_list_of_text) {
 }
 
 TEST_F(test_list_properties, insert_list_of_int) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto insertion_prop(connection->CreateTransaction());
 
@@ -167,7 +167,7 @@ TEST_F(test_list_properties, insert_list_of_int) {
 }
 
 TEST_F(test_list_properties, insert_list_of_bool) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto insertion_prop(connection->CreateTransaction());
 
@@ -222,7 +222,7 @@ TEST_F(test_list_properties, insert_list_of_bool) {
 }
 
 TEST_F(test_list_properties, insert_list_non_list_datatype) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto insertion_prop(connection->CreateTransaction());
 
@@ -245,4 +245,4 @@ TEST_F(test_list_properties, insert_list_non_list_datatype) {
   EXPECT_EQ(query_transaction->GetResultSet().size(), 0);
 }
 
-} // namespace caosdb::entity
+} // namespace linkahead::entity
diff --git a/test/test_properties.cpp b/test/test_properties.cpp
index 95dffb7f0aedea4b8016b332315175ed8a3b1d56..cc3f63d48fd14c0e757d01ffb200d951e4164fd4 100644
--- a/test/test_properties.cpp
+++ b/test/test_properties.cpp
@@ -1,5 +1,5 @@
 /*
- * This file is a part of the CaosDB Project.
+ * This file is a part of the LinkAhead Project.
  *
  * Copyright (C) 2021 Timm Fitschen <t.fitschen@indiscale.com>
  * Copyright (C) 2021 IndiScale GmbH <info@indiscale.com>
@@ -18,17 +18,17 @@
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  *
  */
-#include "caosdb/connection.h"         // for Connection, ConnectionManager
-#include "caosdb/data_type.h"          // for AtomicDataType, AtomicDataTyp...
-#include "caosdb/entity.h"             // for Entity, Properties, Property
-#include "caosdb/transaction.h"        // for Transaction, ResultSet, Resul...
-#include "caosdb/transaction_status.h" // for TransactionStatus
+#include "linkahead/connection.h"         // for Connection, ConnectionManager
+#include "linkahead/data_type.h"          // for AtomicDataType, AtomicDataTyp...
+#include "linkahead/entity.h"             // for Entity, Properties, Property
+#include "linkahead/transaction.h"        // for Transaction, ResultSet, Resul...
+#include "linkahead/transaction_status.h" // for TransactionStatus
 #include <gtest/gtest-message.h>       // for Message
 #include <gtest/gtest-test-part.h>     // for TestPartResult, SuiteApiResolver
 #include <gtest/gtest_pred_impl.h>     // for AssertionResult, EXPECT_EQ
 #include <memory>                      // for unique_ptr, allocator, __shar...
 
-namespace caosdb::entity {
+namespace linkahead::entity {
 
 class test_properties : public ::testing::Test {
 protected:
@@ -37,7 +37,7 @@ protected:
   void TearDown() override { DeleteEntities(); }
 
   static void DeleteEntities() {
-    const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+    const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
     auto query_transaction(connection->CreateTransaction());
     query_transaction->Query("FIND ENTITY WITH id > 99");
     query_transaction->Execute();
@@ -52,7 +52,7 @@ protected:
 };
 
 TEST_F(test_properties, retrieve_unit) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto insertion_prop(connection->CreateTransaction());
 
@@ -101,4 +101,4 @@ TEST_F(test_properties, retrieve_unit) {
   EXPECT_EQ(same_record_type.GetProperties().at(0).GetUnit(), "V");
 }
 
-} // namespace caosdb::entity
+} // namespace linkahead::entity
diff --git a/test/test_select.cpp b/test/test_select.cpp
index fa63eefc69e52a6ebc292495e02f35b45b1e29a1..d8f630279f401905cea921e5156ef674be1c161b 100644
--- a/test/test_select.cpp
+++ b/test/test_select.cpp
@@ -1,5 +1,5 @@
 /*
- * This file is a part of the CaosDB Project.
+ * This file is a part of the LinkAhead Project.
  *
  * Copyright (C) 2022 IndiScale GmbH <info@indiscale.com>
  * Copyright (C) 2022 Timm Fitschen <t.fitschen@indiscale.com>
@@ -17,13 +17,13 @@
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  *
  */
-#include "caosdb/connection.h"     // for Connection, ConnectionManager
-#include "caosdb/data_type.h"      // for AtomicDataType
-#include "caosdb/entity.h"         // for Entity, Property, Role, Parent
-#include "caosdb/result_set.h"     // for Entity, ResultSet, ResultSet::ite...
-#include "caosdb/result_table.h"   // for ResultTable::HeaderIterator, Resu...
-#include "caosdb/transaction.h"    // for Transaction, ResultTable
-#include "caosdb/value.h"          // for Value
+#include "linkahead/connection.h"     // for Connection, ConnectionManager
+#include "linkahead/data_type.h"      // for AtomicDataType
+#include "linkahead/entity.h"         // for Entity, Property, Role, Parent
+#include "linkahead/result_set.h"     // for Entity, ResultSet, ResultSet::ite...
+#include "linkahead/result_table.h"   // for ResultTable::HeaderIterator, Resu...
+#include "linkahead/transaction.h"    // for Transaction, ResultTable
+#include "linkahead/value.h"          // for Value
 #include <gtest/gtest-message.h>   // for Message
 #include <gtest/gtest-spi.h>       // for EXPECT_NONFATAL_FA...
 #include <gtest/gtest-test-part.h> // for SuiteApiResolver, TestFactoryImpl
@@ -32,19 +32,19 @@
 #include <memory>                  // for allocator, unique_ptr, __shared_p...
 #include <string>                  // for string
 
-namespace caosdb::transaction {
-using caosdb::entity::AtomicDataType;
-using caosdb::entity::DataType;
-using caosdb::entity::Entity;
-using caosdb::entity::Parent;
-using caosdb::entity::Property;
-using caosdb::entity::Role;
-using caosdb::entity::Value;
+namespace linkahead::transaction {
+using linkahead::entity::AtomicDataType;
+using linkahead::entity::DataType;
+using linkahead::entity::Entity;
+using linkahead::entity::Parent;
+using linkahead::entity::Property;
+using linkahead::entity::Role;
+using linkahead::entity::Value;
 
 class test_select : public ::testing::Test {
 public:
   static void InsertEntity(Entity *entity) {
-    const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+    const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
     auto insert_transaction(connection->CreateTransaction());
     insert_transaction->InsertEntity(entity);
     insert_transaction->Execute();
@@ -52,7 +52,7 @@ public:
 
   static void DeleteEntities() {
     // delete all entities
-    const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+    const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
     auto query_transaction(connection->CreateTransaction());
     query_transaction->Query("FIND Entity");
     query_transaction->Execute();
@@ -119,7 +119,7 @@ protected:
     DeleteEntities();
 
     // Test Entities
-    const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+    const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
     auto insert_transaction(connection->CreateTransaction());
     // 1. Two RecordTypes
     auto rt = CreateTestRT();
@@ -175,7 +175,7 @@ protected:
  */
 TEST_F(test_select, test_select_empty) {
   test_select::DeleteEntities();
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto query_transaction(connection->CreateTransaction());
   query_transaction->Query("SELECT name FROM RecordType TestRT");
@@ -195,7 +195,7 @@ TEST_F(test_select, test_select_empty) {
  * Test select name query on record type.
  */
 TEST_F(test_select, test_select_name) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto query_transaction(connection->CreateTransaction());
   query_transaction->Query("SELECT name FROM RecordType TestRT");
@@ -215,7 +215,7 @@ TEST_F(test_select, test_select_name) {
  * Test select description query on record type.
  */
 TEST_F(test_select, test_select_property_description) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto query_transaction(connection->CreateTransaction());
   query_transaction->Query("SELECT TestPropDouble.description FROM Record TestRT2");
@@ -236,7 +236,7 @@ TEST_F(test_select, test_select_property_description) {
  * Test select description query on record type.
  */
 TEST_F(test_select, test_select_description) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto query_transaction(connection->CreateTransaction());
   query_transaction->Query("SELECT description FROM RecordType TestRT");
@@ -256,7 +256,7 @@ TEST_F(test_select, test_select_description) {
  * Test select TestProp query on record.
  */
 TEST_F(test_select, test_select_testprop) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
   auto entity = test_select::CreateRecord("TestProp", Value("val1"));
   test_select::InsertEntity(&entity);
 
@@ -278,7 +278,7 @@ TEST_F(test_select, test_select_testprop) {
  * Test select double value query on record.
  */
 TEST_F(test_select, test_select_double) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
   auto entity = test_select::CreateRecord("TestPropDouble", Value(2.123));
   test_select::InsertEntity(&entity);
 
@@ -301,7 +301,7 @@ TEST_F(test_select, test_select_double) {
  * Test select double value query on record.
  */
 TEST_F(test_select, test_select_value) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
   auto entity = test_select::CreateRecord("TestPropDouble", Value(2.123));
   test_select::InsertEntity(&entity);
 
@@ -324,7 +324,7 @@ TEST_F(test_select, test_select_value) {
  * Test select unit value query on record.
  */
 TEST_F(test_select, test_select_unit) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto query_transaction(connection->CreateTransaction());
   query_transaction->Query("SELECT unit FROM PROPERTY TestPropDouble");
@@ -344,7 +344,7 @@ TEST_F(test_select, test_select_unit) {
  * Test select unit value query on record.
  */
 TEST_F(test_select, test_select_property_unit) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
   auto entity = test_select::CreateRecord("TestPropDouble", Value(2.123));
   test_select::InsertEntity(&entity);
 
@@ -371,7 +371,7 @@ TEST_F(test_select, test_select_property_unit) {
  * Test select int value query on record.
  */
 TEST_F(test_select, test_select_int) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
   auto entity = test_select::CreateRecord("TestPropInt", Value(1234));
   test_select::InsertEntity(&entity);
 
@@ -392,7 +392,7 @@ TEST_F(test_select, test_select_int) {
 
 /* Test select boolean value query on record.  */
 TEST_F(test_select, test_select_boolean) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
   auto entity = test_select::CreateRecord("TestPropBool", Value(true));
   test_select::InsertEntity(&entity);
 
@@ -415,7 +415,7 @@ TEST_F(test_select, test_select_boolean) {
  * Test select the referenced id.
  */
 TEST_F(test_select, test_select_reference) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
   auto get_id_of_ref_rec(connection->CreateTransaction());
   get_id_of_ref_rec->Query("SELECT id FROM RECORD TestRT2");
   get_id_of_ref_rec->Execute();
@@ -442,7 +442,7 @@ TEST_F(test_select, test_select_reference) {
  * Test select the referenced id.
  */
 TEST_F(test_select, test_select_reference_value) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
   auto get_id_of_ref_rec(connection->CreateTransaction());
   get_id_of_ref_rec->Query("SELECT id, version FROM RECORD TestRT2");
   get_id_of_ref_rec->Execute();
@@ -471,7 +471,7 @@ TEST_F(test_select, test_select_reference_value) {
  * Test select the referenced entity's property.
  */
 TEST_F(test_select, test_select_reference_entitys_property) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
   auto get_id_of_ref_rec(connection->CreateTransaction());
   get_id_of_ref_rec->Query("SELECT id FROM RECORD TestRT2");
   get_id_of_ref_rec->Execute();
@@ -498,7 +498,7 @@ TEST_F(test_select, test_select_reference_entitys_property) {
  * Test select the referenced entity's property's unit.
  */
 TEST_F(test_select, test_select_reference_entitys_propertys_unit) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
   auto get_id_of_ref_rec(connection->CreateTransaction());
   get_id_of_ref_rec->Query("SELECT id FROM RECORD TestRT2");
   get_id_of_ref_rec->Execute();
@@ -525,7 +525,7 @@ TEST_F(test_select, test_select_reference_entitys_propertys_unit) {
  * Test select the referenced entity's property's description.
  */
 TEST_F(test_select, test_select_reference_entitys_propertys_description) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
   auto get_id_of_ref_rec(connection->CreateTransaction());
   get_id_of_ref_rec->Query("SELECT id FROM RECORD TestRT2");
   get_id_of_ref_rec->Execute();
@@ -553,7 +553,7 @@ TEST_F(test_select, test_select_reference_entitys_propertys_description) {
  * Test select the referenced entity's property's name.
  */
 TEST_F(test_select, test_select_reference_entitys_propertys_name) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
   auto get_id_of_ref_rec(connection->CreateTransaction());
   get_id_of_ref_rec->Query("SELECT id FROM RECORD TestRT2");
   get_id_of_ref_rec->Execute();
@@ -580,7 +580,7 @@ TEST_F(test_select, test_select_reference_entitys_propertys_name) {
  * Test select the referenced entity's property's id.
  */
 TEST_F(test_select, test_select_reference_entitys_propertys_id) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
   auto get_id_of_ref_rec(connection->CreateTransaction());
   get_id_of_ref_rec->Query("SELECT id FROM RECORD TestRT2");
   get_id_of_ref_rec->Execute();
@@ -612,7 +612,7 @@ TEST_F(test_select, test_select_reference_entitys_propertys_id) {
  * Test select a list (TEXT).
  */
 TEST_F(test_select, test_select_list_of_text) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto entity = test_select::CreateRecord("TestRT2", Value());
   Property listp;
@@ -641,7 +641,7 @@ TEST_F(test_select, test_select_list_of_text) {
  * Test select a list (REFERENCE).
  */
 TEST_F(test_select, test_select_list_of_reference) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto get_id_of_ref_rec(connection->CreateTransaction());
   get_id_of_ref_rec->Query("SELECT id FROM RECORD TestRT2");
@@ -671,4 +671,4 @@ TEST_F(test_select, test_select_list_of_reference) {
   }
 }
 
-} // namespace caosdb::transaction
+} // namespace linkahead::transaction
diff --git a/test/test_transaction.cpp b/test/test_transaction.cpp
index 2b1be4c04250c989a3f2283ad24dab438625df62..34a43486068c1248b7fd2b69d19731ea6fa7c2fd 100644
--- a/test/test_transaction.cpp
+++ b/test/test_transaction.cpp
@@ -1,5 +1,5 @@
 /*
- * This file is a part of the CaosDB Project.
+ * This file is a part of the LinkAhead Project.
  *
  * Copyright (C) 2021 IndiScale GmbH <info@indiscale.com>
  * Copyright (C) 2021 Timm Fitschen <t.fitschen@indiscale.com>
@@ -19,17 +19,17 @@
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  *
  */
-#include "caosdb/connection.h"                    // for Connection, Connec...
-#include "caosdb/data_type.h"                     // for AtomicDataType
-#include "caosdb/entity.h"                        // for Entity, Property
-#include "caosdb/file_descriptor.h"               // for FileDescriptor
-#include "caosdb/file_transmission/file_reader.h" // for path, FileReader
-#include "caosdb/file_transmission/file_writer.h" // for FileWriter
-#include "caosdb/message_code.h"                  // for MessageCode, ENTIT...
-#include "caosdb/status_code.h"                   // for StatusCode, SUCCESS
-#include "caosdb/transaction.h"                   // for Entity, Transaction
-#include "caosdb/transaction_status.h"            // for TransactionStatus
-#include "caosdb/value.h"                         // for Value
+#include "linkahead/connection.h"                    // for Connection, Connec...
+#include "linkahead/data_type.h"                     // for AtomicDataType
+#include "linkahead/entity.h"                        // for Entity, Property
+#include "linkahead/file_descriptor.h"               // for FileDescriptor
+#include "linkahead/file_transmission/file_reader.h" // for path, FileReader
+#include "linkahead/file_transmission/file_writer.h" // for FileWriter
+#include "linkahead/message_code.h"                  // for MessageCode, ENTIT...
+#include "linkahead/status_code.h"                   // for StatusCode, SUCCESS
+#include "linkahead/transaction.h"                   // for Entity, Transaction
+#include "linkahead/transaction_status.h"            // for TransactionStatus
+#include "linkahead/value.h"                         // for Value
 #include <chrono>                                 // for filesystem
 #include <cstddef>                                // for size_t
 #include <cstdint>                                // for int64_t, int32_t
@@ -46,15 +46,15 @@
 #include <vector>                                 // for vector, operator!=
 
 namespace fs = std::filesystem;
-namespace caosdb::transaction {
-using caosdb::entity::AtomicDataType;
-using caosdb::entity::Entity;
-using caosdb::entity::Importance;
-using caosdb::entity::MessageCode;
-using caosdb::entity::Parent;
-using caosdb::entity::Property;
-using caosdb::entity::Role;
-using caosdb::entity::Value;
+namespace linkahead::transaction {
+using linkahead::entity::AtomicDataType;
+using linkahead::entity::Entity;
+using linkahead::entity::Importance;
+using linkahead::entity::MessageCode;
+using linkahead::entity::Parent;
+using linkahead::entity::Property;
+using linkahead::entity::Role;
+using linkahead::entity::Value;
 
 class test_transaction : public ::testing::Test {
 public:
@@ -101,7 +101,7 @@ public:
   }
   static void DeleteEntities() {
     // delete all entities
-    const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+    const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
     auto query_transaction(connection->CreateTransaction());
     query_transaction->Query("FIND ENTITY WITH id > 99");
     query_transaction->Execute();
@@ -168,7 +168,7 @@ template <> auto test_transaction::getValueAs<bool>(const Value &value) -> bool
  * error message
  */
 TEST_F(test_transaction, retrieve_non_existing) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto transaction(connection->CreateTransaction());
 
@@ -196,7 +196,7 @@ TEST_F(test_transaction, retrieve_non_existing) {
  * is set.
  */
 TEST_F(test_transaction, insert_without_delete) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto insert_transaction(connection->CreateTransaction());
 
@@ -229,7 +229,7 @@ TEST_F(test_transaction, insert_without_delete) {
 TEST_F(test_transaction, insert_delete) {
   // same as in insert_without_delete
   // until marked  END SAME
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto insert_transaction(connection->CreateTransaction());
 
@@ -273,7 +273,7 @@ TEST_F(test_transaction, insert_delete) {
 TEST_F(test_transaction, insert_delete_with_parent) {
   // same as in insert_without_delete
   // until marked  END SAME
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto insert_transaction(connection->CreateTransaction());
 
@@ -367,7 +367,7 @@ TEST_F(test_transaction, insert_delete_with_parent) {
  * insert a property, record type with that property and a record with it
  */
 TEST_F(test_transaction, insert_delete_with_property) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   // Create and insert Text property
   Entity prop_ent;
@@ -559,7 +559,7 @@ TEST_F(test_transaction, insert_delete_with_property) {
  * test retrieving multiple entities at once
  */
 TEST_F(test_transaction, test_multi_retrieve) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto transaction(connection->CreateTransaction());
 
@@ -591,7 +591,7 @@ TEST_F(test_transaction, test_multi_retrieve) {
  * test insert, then update and then delete a RecordType
  */
 TEST_F(test_transaction, insert_update_delete) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   // INSERT
   auto insert_transaction(connection->CreateTransaction());
@@ -658,7 +658,7 @@ TEST_F(test_transaction, insert_update_delete) {
  * test insert a RecordType and then submit a find and a count query
  */
 TEST_F(test_transaction, test_query) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto insert_transaction(connection->CreateTransaction());
 
@@ -701,7 +701,7 @@ TEST_F(test_transaction, test_query) {
  * Test numeric values (template).
  */
 template <typename T, typename S> auto test_numeric_values_impl(AtomicDataType a_type) -> void {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   // Insert entities
   auto values_orig = test_transaction::generateValues<T>();
@@ -765,7 +765,7 @@ TEST_F(test_transaction, test_numeric_values) {
  * Test date time values.
  */
 TEST_F(test_transaction, test_datetime_values) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   // Insert entities
   auto values_orig = test_transaction::generateDatetimeValues();
@@ -817,7 +817,7 @@ TEST_F(test_transaction, test_datetime_values) {
 }
 
 TEST_F(test_transaction, test_integer_out_of_range) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   // Insert entities
   std::vector<int64_t> values = {std::numeric_limits<int64_t>::max(),
@@ -852,7 +852,7 @@ TEST_F(test_transaction, test_integer_out_of_range) {
  * Insert three record types in a single transaction.
  */
 TEST_F(test_transaction, test_multi_insert_transactions) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto insert_transaction(connection->CreateTransaction());
 
@@ -885,7 +885,7 @@ TEST_F(test_transaction, test_multi_insert_transactions) {
  * Update three record types in a single transaction.
  */
 TEST_F(test_transaction, test_multi_update_transactions) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   auto insert_transaction(connection->CreateTransaction());
 
@@ -940,7 +940,7 @@ TEST_F(test_transaction, test_multi_update_transactions) {
  * to C), delete B.
  */
 TEST_F(test_transaction, test_multi_write_transactions) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   Entity entity_a;
   Entity entity_b;
@@ -1005,7 +1005,7 @@ TEST_F(test_transaction, test_multi_write_transactions) {
  * combinations
  */
 TEST_F(test_transaction, test_query_with_retrieve) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   // rt1
   Entity rt1;
@@ -1118,7 +1118,7 @@ TEST_F(test_transaction, test_query_with_retrieve) {
  * create a file object and upload it
  */
 TEST_F(test_transaction, test_file_upload) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   Entity file;
   file.SetRole(Role::FILE);
@@ -1154,7 +1154,7 @@ TEST_F(test_transaction, test_file_upload) {
  * create a file object, upload and then download it
  */
 TEST_F(test_transaction, test_file_up_n_download) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   Entity file;
   file.SetRole(Role::FILE);
@@ -1206,7 +1206,7 @@ TEST_F(test_transaction, test_file_up_n_download) {
  * Test a small worklfow
  */
 TEST_F(test_transaction, test_full_workflow) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
 
   // ######  Create Data Model  ######
   Entity dataRT;
@@ -1329,7 +1329,7 @@ TEST_F(test_transaction, test_full_workflow) {
 }
 
 TEST_F(test_transaction, test_delete_string_id) {
-  const auto &connection = caosdb::connection::ConnectionManager::GetDefaultConnection();
+  const auto &connection = linkahead::connection::ConnectionManager::GetDefaultConnection();
   auto transaction(connection->CreateTransaction());
 
   transaction->DeleteById("20");
@@ -1347,4 +1347,4 @@ TEST_F(test_transaction, test_delete_string_id) {
   EXPECT_EQ(results.at(1).GetErrors().at(0).GetDescription(), "Entity does not exist.");
 }
 
-} // namespace caosdb::transaction
+} // namespace linkahead::transaction
diff --git a/test/test_user.cpp b/test/test_user.cpp
index 9f4abe5cd26cd47475c6b8fba1283eaff8ce66ca..7817aff09b180ef38d83bc52a18cd9a516e23b45 100644
--- a/test/test_user.cpp
+++ b/test/test_user.cpp
@@ -1,5 +1,5 @@
 /*
- * This file is a part of the CaosDB Project.
+ * This file is a part of the LinkAhead Project.
  *
  * Copyright (C) 2022 Timm Fitschen <t.fitschen@indiscale.com>
  * Copyright (C) 2022 IndiScale GmbH <info@indiscale.com>
@@ -18,24 +18,24 @@
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  *
  */
-#include "caosdb/acm/user.h"       // for User
-#include "caosdb/connection.h"     // for Connection, VersionInfo, path
-#include "caosdb/exceptions.h"     // for TransactionError
-#include "caosdb_test_utility.h"   // for EXPECT_THROW_MESSAGE
+#include "linkahead/acm/user.h"       // for User
+#include "linkahead/connection.h"     // for Connection, VersionInfo, path
+#include "linkahead/exceptions.h"     // for TransactionError
+#include "linkahead_test_utility.h"   // for EXPECT_THROW_MESSAGE
 #include <gtest/gtest-message.h>   // for Message
 #include <gtest/gtest-test-part.h> // for SuiteApiResolver, TestPartR...
 #include <gtest/gtest_pred_impl.h> // for Test, TestInfo, TEST, EXPEC...
 #include <memory>                  // for allocator, unique_ptr, __sh...
 #include <string>                  // for stoi, string
 
-namespace caosdb::connection {
-using caosdb::acm::User;
+namespace linkahead::connection {
+using linkahead::acm::User;
 
 TEST(test_user, test_create_single_user_failure_invalid_name) {
   auto connection = ConnectionManager::GetDefaultConnection();
   User user("CaosDB", "-user1");
   EXPECT_THROW_STARTS_WITH(
-    connection->CreateSingleUser(user), caosdb::exceptions::Exception,
+    connection->CreateSingleUser(user), linkahead::exceptions::Exception,
     "The attempt to execute this transaction was not successful because an error occured in the "
     "transport or RPC protocol layer. Original error: 2 - The user name does not comply with the "
     "current policies for user names:");
@@ -46,7 +46,7 @@ TEST(test_user, test_create_single_user_failure_invalid_password) {
   User user("CaosDB", "user1");
   user.SetPassword("1234");
   EXPECT_THROW_STARTS_WITH(
-    connection->CreateSingleUser(user), caosdb::exceptions::Exception,
+    connection->CreateSingleUser(user), linkahead::exceptions::Exception,
     "The attempt to execute this transaction was not successful because an error occured in the "
     "transport or RPC protocol layer. Original error: 2 - The password does not comply with the "
     "current policies for passwords: ");
@@ -61,7 +61,7 @@ TEST(test_user, test_create_single_user_success) {
   EXPECT_EQ(re.GetName(), user.GetName());
   connection->DeleteSingleUser("CaosDB", "user1");
   EXPECT_THROW_MESSAGE(
-    connection->RetrieveSingleUser("CaosDB", "user1"), caosdb::exceptions::Exception,
+    connection->RetrieveSingleUser("CaosDB", "user1"), linkahead::exceptions::Exception,
     "The attempt to execute this transaction was not successful because an error occured in the "
     "transport or RPC protocol layer. Original error: 5 - This account does not exist.");
 }
@@ -84,4 +84,4 @@ TEST(test_user, test_list_users) {
   EXPECT_EQ(users.size(), 1);
 }
 
-} // namespace caosdb::connection
+} // namespace linkahead::connection