diff --git a/.github/workflows/build_and_test.yml b/.github/workflows/build_and_test.yml
index 0d32b00d..9308e1d7 100644
--- a/.github/workflows/build_and_test.yml
+++ b/.github/workflows/build_and_test.yml
@@ -91,31 +91,31 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      - run: brew install ninja boost cryptopp curl llvm@19
+      - run: brew install ninja boost cryptopp curl llvm@19 lld@19
 
-      - name: Get Brew Prefix
+      - name: Get LLVM Paths
         run: |
           echo "BREW_PREFIX=$(brew --prefix)" >> $GITHUB_ENV
-
-      - name: Set Env Vars
-        run: |
-          echo "export LDFLAGS=-L$BREW_PREFIX/lib" >> $GITHUB_ENV
-          echo "export CPPFLAGS=-I$BREW_PREFIX/include" >> $GITHUB_ENV
+          echo "LLVM_PREFIX=$(brew --prefix llvm@19)" >> $GITHUB_ENV
+          echo "SDKROOT=$(xcrun --sdk macosx --show-sdk-path)" >> $GITHUB_ENV
 
       - name: Configure CMake
         run: >
           cmake
-          -DCMAKE_C_COMPILER=$BREW_PREFIX/opt/llvm@19/bin/clang
-          -DCMAKE_CXX_COMPILER=$BREW_PREFIX/opt/llvm@19/bin/clang++
-          -DCMAKE_LINKER=$BREW_PREFIX/opt/llvm@19/bin/lld
+          -DCMAKE_C_COMPILER=${{env.LLVM_PREFIX}}/bin/clang
+          -DCMAKE_CXX_COMPILER=${{env.LLVM_PREFIX}}/bin/clang++
+          -DCMAKE_LINKER=${{env.BREW_PREFIX}}/opt/lld@19/bin/lld
+          -DCMAKE_OSX_SYSROOT=${{env.SDKROOT}}
+          -DCMAKE_CXX_FLAGS="-stdlib=libc++"
+          -DCMAKE_EXE_LINKER_FLAGS="-L${{env.LLVM_PREFIX}}/lib/c++ -L${{env.LLVM_PREFIX}}/lib/unwind -lunwind -Wl,-rpath,${{env.LLVM_PREFIX}}/lib/c++"
           -DROAR_BUILD_TESTS=on
           -S ${{github.workspace}}
           -B ${{github.workspace}}/build/clang_${{env.BUILD_TYPE}}
           -G"Ninja"
           -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
-          -DBREW_PREFIX="$BREW_PREFIX"
+          -DBREW_PREFIX="${{env.BREW_PREFIX}}"
           -DCMAKE_CXX_EXTENSIONS=on
           -DCMAKE_CXX_STANDARD=20
 
       - name: Build
-        run: cmake --build ${{github.workspace}}/build/clang_${{env.BUILD_TYPE}} --config ${{env.BUILD_TYPE}}
+        run: cmake --build ${{github.workspace}}/build/clang_${{env.BUILD_TYPE}} --config ${{env.BUILD_TYPE}}
\ No newline at end of file
diff --git a/test/curl/test_request.hpp b/test/curl/test_request.hpp
index adcc1865..307c750b 100644
--- a/test/curl/test_request.hpp
+++ b/test/curl/test_request.hpp
@@ -75,7 +75,7 @@ namespace Roar::Tests
     TEST_F(CurlRequestTests, CanMakeSimpleGetRequest)
     {
         auto response = Request{}.get(url("/index.txt"));
-        EXPECT_EQ(response.code(), http::status::ok) << response.result();
+        EXPECT_EQ(response.code(), 200) << response.result();
     }
 
     TEST_F(CurlRequestTests, CanRetrieveBodyWithStringSink)
@@ -117,7 +117,7 @@ namespace Roar::Tests
     TEST_F(CurlRequestTests, CanGetResponseCode)
     {
         const auto response = Request{}.get(url("/index.txt"));
-        EXPECT_EQ(response.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(response.code(), 200) << response.result();
     }
 
     TEST_F(CurlRequestTests, CanGetSizeOfDownload)
@@ -174,19 +174,19 @@ namespace Roar::Tests
     TEST_F(CurlRequestTests, CanMakeDeleteRequest)
     {
         const auto result = Request{}.delete_(url("/deleteHere"));
-        EXPECT_EQ(result.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(result.code(), 200) << result.result();
     }
 
     TEST_F(CurlRequestTests, CanMakeOptionsRequest)
     {
         const auto result = Request{}.options(url("/optionsHere"));
-        EXPECT_EQ(result.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(result.code(), 200) << result.result();
     }
 
     TEST_F(CurlRequestTests, CanMakeHeadRequest)
     {
         const auto result = Request{}.head(url("/headHere"));
-        EXPECT_EQ(result.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(result.code(), 200) << result.result();
     }
 
     TEST_F(CurlRequestTests, CanUseFileAsSource)
@@ -243,6 +243,6 @@ namespace Roar::Tests
     TEST_F(CurlRequestTests, CanPerformBodylessPutViaCustomRequest)
     {
         const auto result = Request{}.custom("PUT", url("/putHereNothing"));
-        EXPECT_EQ(result.code(), boost::beast::http::status::no_content);
+        EXPECT_EQ(result.code(), 204) << result.result();
     }
 }
\ No newline at end of file
diff --git a/test/test_cors.hpp b/test/test_cors.hpp
index ebf42779..7356b90a 100644
--- a/test/test_cors.hpp
+++ b/test/test_cors.hpp
@@ -205,7 +205,7 @@ namespace Roar::Tests
     {
         std::unordered_map<std::string, std::string> headers;
         auto res = Curl::Request{}.headerSink(headers).options(url("/permissiveCors"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200) << res.result();
         ASSERT_NE(std::end(headers), headers.find("Access-Control-Allow-Origin"));
         EXPECT_EQ(headers["Access-Control-Allow-Origin"], "*");
     }
@@ -233,13 +233,13 @@ namespace Roar::Tests
     {
         std::unordered_map<std::string, std::string> headers;
         auto res = Curl::Request{}.headerSink(headers).options(urlEncryptedServer("/permissiveCors"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::forbidden);
+        EXPECT_EQ(res.code(), 403);
     }
 
     TEST_F(CorsTests, PreflightRequestOnEncryptedServerIsAccessibleUnencryptedWhenAllowed)
     {
         std::unordered_map<std::string, std::string> headers;
         auto res = Curl::Request{}.headerSink(headers).options(urlEncryptedServer("/unsecurePermissiveCors"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200);
     }
 }
\ No newline at end of file
diff --git a/test/test_http_server.hpp b/test/test_http_server.hpp
index 0f95392d..32c44401 100644
--- a/test/test_http_server.hpp
+++ b/test/test_http_server.hpp
@@ -87,7 +87,7 @@ namespace Roar::Tests
     TEST_F(HttpServerTests, StringPathIsCorrectlyRouted)
     {
         auto res = Curl::Request{}.get(url("/index.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200);
     }
 
     TEST_F(HttpServerTests, RegexPathIsCorrectlyRouted)
@@ -96,7 +96,7 @@ namespace Roar::Tests
 
         nlohmann::json body;
         auto res = Curl::Request{}.sink(body).get(url("/something/here"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200);
         EXPECT_EQ(body["path"], "/something/here");
         ASSERT_THAT(body["matches"], ElementsAre("something", "here"));
     }
@@ -107,7 +107,7 @@ namespace Roar::Tests
 
         std::string body;
         auto res = Curl::Request{}.sink(body).get(url("/a/b"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200);
         EXPECT_EQ(body, "AB");
     }
 
@@ -115,7 +115,7 @@ namespace Roar::Tests
     {
         auto res =
             Curl::Request{}.verifyPeer(false).verifyHost(false).get(urlEncryptedServer("/index.txt", {.secure = true}));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200);
     }
 
     TEST_F(HttpServerTests, EncryptedServerDoesNotAcceptUnencryptedConnection)
@@ -124,27 +124,27 @@ namespace Roar::Tests
         auto res = Curl::Request{}.headerSink(headers).verifyPeer(false).verifyHost(false).get(
             urlEncryptedServer("/index.txt", {.secure = false}));
         EXPECT_NE(headers.find("Strict-Transport-Security"), std::end(headers));
-        EXPECT_EQ(res.code(), boost::beast::http::status::forbidden);
+        EXPECT_EQ(res.code(), 403);
     }
 
     TEST_F(HttpServerTests, UnencryptedServerDoesNotAcceptEncryptedConnection)
     {
         auto res = Curl::Request{}.get(url("/a/b", {.secure = true}));
         EXPECT_NE(res.result(), CURLE_OK);
-        EXPECT_NE(res.code(), boost::beast::http::status::ok);
+        EXPECT_NE(res.code(), 200);
     }
 
     TEST_F(HttpServerTests, EncryptedServerDoesAcceptUnencryptedConnectionWhenExplicitlyAllowed)
     {
         auto res = Curl::Request{}.get(urlEncryptedServer("/unsecure", {.secure = false}));
-        EXPECT_EQ(res.code(), boost::beast::http::status::no_content);
+        EXPECT_EQ(res.code(), 204) << res.result();
     }
 
     TEST_F(HttpServerTests, CanSendUsingSendIntermediate)
     {
         std::string body;
         auto res = Curl::Request{}.sink(body).get(url("/sendIntermediate", {.secure = false}));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200) << res.result();
         EXPECT_EQ(body, "Hi");
     }
 
@@ -152,7 +152,7 @@ namespace Roar::Tests
     {
         std::string body;
         auto res = Curl::Request{}.sink(body).setHeader("Range", "bytes=0-100").get(url("/slice"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::partial_content);
+        EXPECT_EQ(res.code(), 206) << res.result();
         ASSERT_EQ(body.size(), 100);
         LetterGenerator gen;
         bool allEqual = true;
@@ -177,7 +177,7 @@ namespace Roar::Tests
             base.push_back(gen());
         auto pos = headers["Content-Type"].find("boundary=");
         EXPECT_EQ(pos, std::string::npos);
-        EXPECT_EQ(res.code(), boost::beast::http::status::partial_content);
+        EXPECT_EQ(res.code(), 206) << res.result();
         EXPECT_EQ(body, base.substr(200, 150));
     }
 
@@ -194,7 +194,7 @@ namespace Roar::Tests
         LetterGenerator gen;
         for (int i = 0; i != 1024; ++i)
             base.push_back(gen());
-        EXPECT_EQ(res.code(), boost::beast::http::status::partial_content);
+        EXPECT_EQ(res.code(), 206);
         auto pos = headers["Content-Type"].find("boundary=");
         ASSERT_NE(pos, std::string::npos);
         const auto boundary = headers["Content-Type"].substr(pos + 9);
@@ -225,7 +225,7 @@ namespace Roar::Tests
         LetterGenerator gen;
         for (int i = 0; i != 25000; ++i)
             base.push_back(gen());
-        EXPECT_EQ(res.code(), boost::beast::http::status::partial_content);
+        EXPECT_EQ(res.code(), 206);
         auto pos = headers["Content-Type"].find("boundary=");
         ASSERT_NE(pos, std::string::npos);
         const auto boundary = headers["Content-Type"].substr(pos + 9);
@@ -246,28 +246,28 @@ namespace Roar::Tests
     TEST_F(HttpServerTests, InvalidRangeRequestIsRejected)
     {
         auto res = Curl::Request{}.setHeader("Range", "bytes?0-100").get(url("/slice"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::bad_request);
+        EXPECT_EQ(res.code(), 400) << res.result();
 
         res = Curl::Request{}.setHeader("Range", "=0-100").get(url("/slice"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::bad_request);
+        EXPECT_EQ(res.code(), 400) << res.result();
 
         res = Curl::Request{}.setHeader("Range", "asdf").get(url("/slice"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::bad_request);
+        EXPECT_EQ(res.code(), 400) << res.result();
 
         res = Curl::Request{}.setHeader("Range", "bytes=0").get(url("/slice"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::bad_request);
+        EXPECT_EQ(res.code(), 400) << res.result();
 
         res = Curl::Request{}.setHeader("Range", "bytes=x").get(url("/slice"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::bad_request);
+        EXPECT_EQ(res.code(), 400) << res.result();
 
         res = Curl::Request{}.setHeader("Range", "bytes=0-").get(url("/slice"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::bad_request);
+        EXPECT_EQ(res.code(), 400) << res.result();
 
         res = Curl::Request{}.setHeader("Range", "bytes=0-x").get(url("/slice"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::bad_request);
+        EXPECT_EQ(res.code(), 400) << res.result();
 
         res = Curl::Request{}.setHeader("Range", "bytes=100-0").get(url("/slice"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::bad_request);
+        EXPECT_EQ(res.code(), 400) << res.result();
     }
 
     TEST_F(HttpServerTests, CanExtractAuthorizationScheme)
diff --git a/test/test_reading.hpp b/test/test_reading.hpp
index df31791c..6775ff69 100644
--- a/test/test_reading.hpp
+++ b/test/test_reading.hpp
@@ -101,7 +101,7 @@ namespace Roar::Tests
         using namespace Roar::Literals;
         auto now = std::chrono::system_clock::now();
         const auto res = Curl::Request{}.emplaceSource<ChunkedSource>(1_MiB).put(url("/failPut"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::bad_request);
+        EXPECT_EQ(res.code(), 400);
         EXPECT_LT(std::chrono::system_clock::now() - now, std::chrono::seconds{1});
     }
 }
\ No newline at end of file
diff --git a/test/test_serve.hpp b/test/test_serve.hpp
index 994c7aca..b14080ba 100644
--- a/test/test_serve.hpp
+++ b/test/test_serve.hpp
@@ -373,35 +373,35 @@ namespace Roar::Tests
     {
         std::unordered_map<std::string, std::string> headers;
         const auto res = Curl::Request{}.headerSink(headers).head(url("/1/file.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200);
     }
 
     TEST_F(ServeTests, HeadRequestToNonExistingFileReturns404)
     {
         std::unordered_map<std::string, std::string> headers;
         const auto res = Curl::Request{}.headerSink(headers).head(url("/1/you_dont_exist.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::not_found);
+        EXPECT_EQ(res.code(), 404);
     }
 
     TEST_F(ServeTests, CannotMakeHeadRequestWhenNoFileIsSpecified)
     {
         std::unordered_map<std::string, std::string> headers;
         const auto res = Curl::Request{}.headerSink(headers).head(url("/nothingAllowed"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::method_not_allowed);
+        EXPECT_EQ(res.code(), 405);
     }
 
     TEST_F(ServeTests, CannotMakeHeadRequestWhenDownloadIsNotAllowed)
     {
         std::unordered_map<std::string, std::string> headers;
         const auto res = Curl::Request{}.headerSink(headers).head(url("/nothingAllowed/file.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::method_not_allowed);
+        EXPECT_EQ(res.code(), 405);
     }
 
     TEST_F(ServeTests, StringPathsTakePrecedence)
     {
         std::string body;
         const auto res = Curl::Request{}.sink(body).get(url("/1/bla"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200);
         EXPECT_EQ(body, "string");
     }
 
@@ -409,7 +409,7 @@ namespace Roar::Tests
     {
         std::string body;
         const auto res = Curl::Request{}.sink(body).get(url("/1/blub"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200);
         EXPECT_EQ(body, "regex");
     }
 
@@ -417,44 +417,44 @@ namespace Roar::Tests
     {
         std::unordered_map<std::string, std::string> headers;
         auto res = Curl::Request{}.headerSink(headers).options(url("/nothingAllowed"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::no_content);
+        EXPECT_EQ(res.code(), 204);
         EXPECT_EQ(headers.at("Allow"), "OPTIONS");
 
         res = Curl::Request{}.headerSink(headers).options(url("/allAllowed"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::no_content);
+        EXPECT_EQ(res.code(), 204);
         EXPECT_EQ(headers.at("Allow"), "OPTIONS, GET, HEAD, PUT, DELETE");
     }
 
     TEST_F(ServeTests, DisallowedDownloadReturnsMethodNotAllowed)
     {
         const auto res = Curl::Request{}.get(url("/nothingAllowed/file.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::method_not_allowed);
+        EXPECT_EQ(res.code(), 405);
     }
 
     TEST_F(ServeTests, DisallowedUploadReturnsMethodNotAllowed)
     {
         const auto res = Curl::Request{}.source("bla").put(url("/nothingAllowed/file.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::method_not_allowed);
+        EXPECT_EQ(res.code(), 405);
     }
 
     TEST_F(ServeTests, DisallowedDeleteReturnsMethodNotAllowed)
     {
         const auto res = Curl::Request{}.delete_(url("/nothingAllowed/file.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::method_not_allowed);
+        EXPECT_EQ(res.code(), 405);
     }
 
     TEST_F(ServeTests, DisallowedDeleteNonEmptyDirectoryReturnsForbidden)
     {
         EXPECT_TRUE(std::filesystem::exists(listener_->pathSupplier() / "nonEmptyDir"));
         const auto res = Curl::Request{}.delete_(url("/deleteAllowedButNotDirectories/nonEmptyDir"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::forbidden);
+        EXPECT_EQ(res.code(), 403);
     }
 
     TEST_F(ServeTests, CanDeleteEmptyDirectory)
     {
         EXPECT_TRUE(std::filesystem::exists(listener_->pathSupplier() / "emptyDir"));
         const auto res = Curl::Request{}.delete_(url("/allAllowed/emptyDir"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::no_content);
+        EXPECT_EQ(res.code(), 204);
         EXPECT_FALSE(std::filesystem::exists(listener_->pathSupplier() / "emptyDir"));
     }
 
@@ -462,52 +462,52 @@ namespace Roar::Tests
     {
         EXPECT_TRUE(std::filesystem::exists(listener_->pathSupplier() / "nonEmptyDir"));
         const auto res = Curl::Request{}.delete_(url("/allAllowed/nonEmptyDir"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::no_content);
+        EXPECT_EQ(res.code(), 204);
         EXPECT_FALSE(std::filesystem::exists(listener_->pathSupplier() / "nonEmptyDir"));
     }
 
     TEST_F(ServeTests, UserDeniedRequestReturnsForbidden)
     {
         const auto res = Curl::Request{}.get(url("/deny/file.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::forbidden);
+        EXPECT_EQ(res.code(), 403);
     }
 
     TEST_F(ServeTests, UserDeniedRequestWithHandledDoesWhatUserDoes)
     {
         const auto res = Curl::Request{}.get(url("/customDeny/file.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::bad_request);
+        EXPECT_EQ(res.code(), 400);
     }
 
     TEST_F(ServeTests, SecureServerOnlyAllowsSecureServes)
     {
         const auto res = Curl::Request{}.get(urlEncryptedServer("/1/file.txt", {.secure = false}));
-        EXPECT_EQ(res.code(), boost::beast::http::status::forbidden);
+        EXPECT_EQ(res.code(), 403);
     }
 
     TEST_F(ServeTests, SecureServerAllowUnsecureServesWhenAllowed)
     {
         const auto res = Curl::Request{}.get(urlEncryptedServer("/allAllowed/file.txt", {.secure = false}));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200);
     }
 
     TEST_F(ServeTests, UnrelatedMethodReturnsNotFound)
     {
         const auto res = Curl::Request{}.patch(url("/1/file.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::not_found);
+        EXPECT_EQ(res.code(), 404);
     }
 
     TEST_F(ServeTests, CanDownloadFile)
     {
         std::string body;
         const auto res = Curl::Request{}.sink(body).get(url("/allAllowed/file.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200);
         EXPECT_EQ(body, ServingListener::DummyFileContent);
     }
 
     TEST_F(ServeTests, CannotDownloadFileIfItDoesNotExist)
     {
         const auto res = Curl::Request{}.get(url("/allAllowed/file_404.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::not_found);
+        EXPECT_EQ(res.code(), 404);
     }
 
     TEST_F(ServeTests, CanDeleteFile)
@@ -521,7 +521,7 @@ namespace Roar::Tests
     {
         std::string body;
         const auto res = Curl::Request{}.sink(body).get(url("/allAllowed"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200);
         EXPECT_TRUE(body.starts_with("<!DOCTYPE"));
     }
 
@@ -529,21 +529,21 @@ namespace Roar::Tests
     {
         std::string body;
         const auto res = Curl::Request{}.sink(body).get(url("/1"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200);
         EXPECT_TRUE(body.starts_with(ServingListener::DummyFileContent));
     }
 
     TEST_F(ServeTests, DirectoryListingReturnsErrorIfNotAllowed)
     {
         const auto res = Curl::Request{}.get(url("/nothingAllowed/nonEmptyDir"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::method_not_allowed);
+        EXPECT_EQ(res.code(), 405);
     }
 
     TEST_F(ServeTests, CanUploadFile)
     {
         const auto res =
             Curl::Request{}.expect100Continue().source("Yes I am there.").put(url("/allAllowed/emptyDir/file.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200);
         std::ifstream reader{listener_->pathSupplier() / "emptyDir/file.txt", std::ios::binary};
         std::string body;
         std::getline(reader, body);
@@ -553,7 +553,7 @@ namespace Roar::Tests
     TEST_F(ServeTests, CanOverwriteFileIfAllowed)
     {
         const auto res = Curl::Request{}.expect100Continue().source("Yes I am there.").put(url("/allAllowed/file.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200);
         std::ifstream reader{listener_->pathSupplier() / "file.txt", std::ios::binary};
         std::string body;
         std::getline(reader, body);
@@ -563,21 +563,21 @@ namespace Roar::Tests
     TEST_F(ServeTests, CannotUploadWhereSomethingExistsThatIsNotARegularFile)
     {
         const auto res = Curl::Request{}.expect100Continue().source("Yes I am there.").put(url("/allAllowed/emptyDir"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::forbidden);
+        EXPECT_EQ(res.code(), 403);
     }
 
     TEST_F(ServeTests, CannotUploadToExistingFileWhenDisallowed)
     {
         const auto res =
             Curl::Request{}.expect100Continue().source("Yes I am there.").put(url("/overwriteNotAllowed/file.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::forbidden);
+        EXPECT_EQ(res.code(), 403);
     }
 
     TEST_F(ServeTests, CannotUploadFileWithout100ContinueHandling)
     {
         const auto res =
             Curl::Request{}.source("Yes I am there.").setHeader("Expect", "").put(url("/allAllowed/emptyDir/file.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::expectation_failed);
+        EXPECT_EQ(res.code(), 417);
     }
 
     // Test is not exhaustive.
@@ -586,21 +586,21 @@ namespace Roar::Tests
         const auto res =
             Curl::Request{}.source("Yes I am there.").setHeader("Expect", "").put(url("/deep/../../../file.txt"));
         // There is a file there, but should report as not_found.
-        EXPECT_EQ(res.code(), boost::beast::http::status::not_found);
+        EXPECT_EQ(res.code(), 404);
     }
 
     TEST_F(ServeTests, CanModifyPermissionsOnTheFly)
     {
         std::string body;
         const auto res = Curl::Request{}.sink(body).get(url("/nothingIsAllowedButIsOverruled/file.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200);
         EXPECT_EQ(body, ServingListener::DummyFileContent);
     }
 
     TEST_F(ServeTests, UnmodifiedDisallowedPermissionsAreStillDisallowed)
     {
         const auto res = Curl::Request{}.source("test").put(url("/nothingIsAllowedButIsOverruled/file.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::method_not_allowed);
+        EXPECT_EQ(res.code(), 405);
     }
 
     TEST_F(ServeTests, CanMakeRangeRequest)
@@ -610,7 +610,7 @@ namespace Roar::Tests
                              .setHeader(boost::beast::http::field::range, "bytes=1-3")
                              .sink(body)
                              .get(url("/allAllowed/file.txt"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::partial_content);
+        EXPECT_EQ(res.code(), 206);
         EXPECT_EQ(body, std::string{ServingListener::DummyFileContent}.substr(1, 2));
     }
 
@@ -618,8 +618,8 @@ namespace Roar::Tests
     {
         std::string body;
         const auto res = Curl::Request{}.sink(body).get(url("/index.html"));
-        EXPECT_EQ(res.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res.code(), 200);
         const auto res2 = Curl::Request{}.sink(body).get(url("/"));
-        EXPECT_EQ(res2.code(), boost::beast::http::status::ok);
+        EXPECT_EQ(res2.code(), 200);
     }
 }
\ No newline at end of file
diff --git a/test/test_web_socket.hpp b/test/test_web_socket.hpp
index e3277732..cdb2c576 100644
--- a/test/test_web_socket.hpp
+++ b/test/test_web_socket.hpp
@@ -77,7 +77,7 @@ namespace Roar::Tests
     {
         namespace http = boost::beast::http;
         auto res = Curl::Request{}.get(url("/ws"));
-        EXPECT_EQ(res.code(), http::status::upgrade_required);
+        EXPECT_EQ(res.code(), 426);
     }
 
     TEST_F(WebsocketTests, CanUpgradeToWebsocketSession)