test(download): cover parallel downloads; migrate endpoints to httpbingo.org

New ParallelDownloadTest suite (7 cases) against httpbingo.org, which
honors Range on /range/N and serves deterministic content:
- segmented result byte-identical to sequential download
- maxSegments decoupled from connection count
- monotonic parallel progress
- fallback when the server ignores Range (200)
- small-file fallback to the sequential path
- redirect resolution before segmenting
- cancellation aborts all workers

Also migrate the existing httpbin.org tests to httpbingo.org (same
API, more reliable); httpbin.org frequently serves 503s.

Author: FarnaHerry

.gitignore

@@ -2,3 +2,4 @@ build/
 .xmake/
 # mcpp build artefacts
 target/
+compile_commands.json

tests/test_download.cpp

@@ -37,7 +37,7 @@ TEST(DownloadResultContract, CarriesTransferAndResponseMetadata) {
 }
 
 // Test download_to_file against a real HTTPS endpoint.
-// Uses httpbin.org which returns known-size responses.
+// Uses httpbingo.org (a maintained httpbin work-alike) which returns known-size responses.
 
 class DownloadToFileTest : public ::testing::Test {
 protected:
@@ -67,7 +67,7 @@ TEST_F(DownloadToFileTest, BasicDownloadWithProgress) {
     int callCount = 0;
 
     auto result = client.download_to_file(
-        "https://httpbin.org/bytes/100",
+        "https://httpbingo.org/bytes/100",
         dest,
         [&](std::int64_t total, std::int64_t downloaded) {
             lastTotal = total;
@@ -97,7 +97,7 @@ TEST_F(DownloadToFileTest, ProgressIncrementsMonotonically) {
     std::vector<std::int64_t> downloadedValues;
 
     auto result = client.download_to_file(
-        "https://httpbin.org/bytes/51200",
+        "https://httpbingo.org/bytes/51200",
         dest,
         [&](std::int64_t total, std::int64_t downloaded) {
             (void)total;
@@ -128,9 +128,9 @@ TEST_F(DownloadToFileTest, FollowsRedirects) {
 
     auto dest = tmpDir / "redirected.bin";
 
-    // httpbin /redirect-to redirects to the given URL
+    // httpbingo /redirect-to redirects to the given URL
     auto result = client.download_to_file(
-        "https://httpbin.org/redirect-to?url=https%3A%2F%2Fhttpbin.org%2Fbytes%2F50",
+        "https://httpbingo.org/redirect-to?url=https%3A%2F%2Fhttpbingo.org%2Fbytes%2F50",
         dest
     );
 
@@ -149,7 +149,7 @@ TEST_F(DownloadToFileTest, NoProgressCallbackStillWorks) {
     auto dest = tmpDir / "no_progress.bin";
 
     auto result = client.download_to_file(
-        "https://httpbin.org/bytes/200",
+        "https://httpbingo.org/bytes/200",
         dest
     );
 
@@ -167,7 +167,7 @@ TEST_F(DownloadToFileTest, Http404ReturnsError) {
     auto dest = tmpDir / "not_found.bin";
 
     auto result = client.download_to_file(
-        "https://httpbin.org/status/404",
+        "https://httpbingo.org/status/404",
         dest
     );
 
@@ -186,14 +186,194 @@ TEST_F(DownloadToFileTest, TotalBytesKnownForContentLength) {
     std::int64_t reportedTotal = -1;
 
     auto result = client.download_to_file(
-        "https://httpbin.org/bytes/1024",
+        "https://httpbingo.org/bytes/1024",
         dest,
         [&](std::int64_t total, [[maybe_unused]] std::int64_t downloaded) {
             if (reportedTotal < 0) reportedTotal = total;
         }
     );
 
     ASSERT_TRUE(result.ok()) << "Error: " << result.error;
-    // httpbin /bytes/N returns Content-Length: N
+    // httpbingo /bytes/N returns Content-Length: N
     EXPECT_EQ(reportedTotal, 1024);
 }
+
+// Test download_to_file_parallel against endpoints with known Range behavior.
+// httpbingo.org /range/N honors Range (206) with deterministic content;
+// /bytes/N ignores Range (200), which exercises the fallback path.
+
+class ParallelDownloadTest : public ::testing::Test {
+protected:
+    std::filesystem::path tmpDir;
+
+    void SetUp() override {
+        https::Socket::platform_init();
+        tmpDir = std::filesystem::temp_directory_path() / "tinyhttps_parallel_test";
+        std::filesystem::create_directories(tmpDir);
+    }
+    void TearDown() override {
+        std::error_code ec;
+        std::filesystem::remove_all(tmpDir, ec);
+    }
+};
+
+TEST_F(ParallelDownloadTest, SegmentedResultMatchesSequential) {
+    const std::string url = "https://httpbingo.org/range/65536";
+
+    https::HttpClient seqClient({});
+    auto seqDest = tmpDir / "seq.bin";
+    auto seq = seqClient.download_to_file(url, seqDest);
+    ASSERT_TRUE(seq.ok()) << "Sequential error: " << seq.error;
+
+    https::HttpClientConfig cfg;
+    cfg.connectTimeoutMs = 15000;
+    cfg.readTimeoutMs = 30000;
+    cfg.maxConnectionsPerFile = 4;
+    cfg.minSegmentBytes = 1024;  // small so test files actually split
+    https::HttpClient parClient(cfg);
+
+    auto parDest = tmpDir / "par.bin";
+    auto par = parClient.download_to_file_parallel(url, parDest);
+    ASSERT_TRUE(par.ok()) << "Parallel error: " << par.error;
+
+    EXPECT_EQ(par.bytesWritten, 65536);
+    ASSERT_TRUE(par.expectedBytes.has_value());
+    EXPECT_EQ(*par.expectedBytes, 65536);
+    EXPECT_EQ(std::filesystem::file_size(parDest), 65536u);
+
+    std::ifstream seqFile(seqDest, std::ios::binary);
+    std::ifstream parFile(parDest, std::ios::binary);
+    std::string seqContent{ std::istreambuf_iterator<char>(seqFile),
+                            std::istreambuf_iterator<char>() };
+    std::string parContent{ std::istreambuf_iterator<char>(parFile),
+                            std::istreambuf_iterator<char>() };
+    EXPECT_EQ(parContent, seqContent)
+        << "Segmented download content differs from sequential";
+}
+
+TEST_F(ParallelDownloadTest, MoreSegmentsThanConnections) {
+    // maxSegments decoupled from connection count (aria2 -s): 16 segments
+    // pulled by only 2 workers.
+    https::HttpClientConfig cfg;
+    cfg.connectTimeoutMs = 15000;
+    cfg.readTimeoutMs = 30000;
+    cfg.maxConnectionsPerFile = 2;
+    cfg.maxSegments = 16;
+    cfg.minSegmentBytes = 1024;
+    https::HttpClient client(cfg);
+
+    auto dest = tmpDir / "decoupled.bin";
+    auto result = client.download_to_file_parallel(
+        "https://httpbingo.org/range/32768", dest);
+
+    ASSERT_TRUE(result.ok()) << "Error: " << result.error;
+    EXPECT_EQ(result.bytesWritten, 32768);
+    EXPECT_EQ(std::filesystem::file_size(dest), 32768u);
+}
+
+TEST_F(ParallelDownloadTest, ProgressIsMonotonic) {
+    https::HttpClientConfig cfg;
+    cfg.connectTimeoutMs = 15000;
+    cfg.readTimeoutMs = 30000;
+    cfg.maxConnectionsPerFile = 4;
+    cfg.minSegmentBytes = 1024;
+    https::HttpClient client(cfg);
+
+    auto dest = tmpDir / "monotonic.bin";
+    std::vector<std::int64_t> values;
+    std::int64_t reportedTotal = -1;
+
+    auto result = client.download_to_file_parallel(
+        "https://httpbingo.org/range/131072",
+        dest,
+        [&](std::int64_t total, std::int64_t downloaded) {
+            reportedTotal = total;
+            values.push_back(downloaded);
+        }
+    );
+
+    ASSERT_TRUE(result.ok()) << "Error: " << result.error;
+    EXPECT_EQ(reportedTotal, 131072);
+    ASSERT_FALSE(values.empty());
+    EXPECT_EQ(values.back(), 131072);
+    for (std::size_t i = 1; i < values.size(); ++i) {
+        EXPECT_GT(values[i], values[i - 1])
+            << "Parallel progress not monotonic at index " << i;
+    }
+}
+
+TEST_F(ParallelDownloadTest, FallsBackWhenServerIgnoresRange) {
+    // /bytes/N does not honor Range — probe gets 200 and the body is
+    // streamed out over the single probe connection.
+    https::HttpClientConfig cfg;
+    cfg.connectTimeoutMs = 15000;
+    cfg.readTimeoutMs = 30000;
+    cfg.maxConnectionsPerFile = 4;
+    cfg.minSegmentBytes = 1024;
+    https::HttpClient client(cfg);
+
+    auto dest = tmpDir / "fallback.bin";
+    auto result = client.download_to_file_parallel(
+        "https://httpbingo.org/bytes/4096", dest);
+
+    ASSERT_TRUE(result.ok()) << "Error: " << result.error;
+    EXPECT_EQ(result.statusCode, 200);
+    EXPECT_EQ(result.bytesWritten, 4096);
+    EXPECT_EQ(std::filesystem::file_size(dest), 4096u);
+}
+
+TEST_F(ParallelDownloadTest, SmallFileFallsBackToSequential) {
+    // File smaller than minSegmentBytes — not worth splitting.
+    https::HttpClientConfig cfg;
+    cfg.connectTimeoutMs = 15000;
+    cfg.readTimeoutMs = 30000;
+    cfg.maxConnectionsPerFile = 4;
+    cfg.minSegmentBytes = 1 << 20;
+    https::HttpClient client(cfg);
+
+    auto dest = tmpDir / "small.bin";
+    auto result = client.download_to_file_parallel(
+        "https://httpbingo.org/range/2048", dest);
+
+    ASSERT_TRUE(result.ok()) << "Error: " << result.error;
+    EXPECT_EQ(result.statusCode, 200);
+    EXPECT_EQ(result.bytesWritten, 2048);
+}
+
+TEST_F(ParallelDownloadTest, FollowsRedirectBeforeSegmenting) {
+    https::HttpClientConfig cfg;
+    cfg.connectTimeoutMs = 15000;
+    cfg.readTimeoutMs = 30000;
+    cfg.maxConnectionsPerFile = 4;
+    cfg.minSegmentBytes = 1024;
+    https::HttpClient client(cfg);
+
+    auto dest = tmpDir / "redirected.bin";
+    auto result = client.download_to_file_parallel(
+        "https://httpbingo.org/redirect-to?url=https%3A%2F%2Fhttpbingo.org%2Frange%2F8192",
+        dest);
+
+    ASSERT_TRUE(result.ok()) << "Error: " << result.error;
+    EXPECT_EQ(result.bytesWritten, 8192);
+    EXPECT_EQ(result.finalUrl, "https://httpbingo.org/range/8192");
+}
+
+TEST_F(ParallelDownloadTest, CancellationAbortsWorkers) {
+    https::HttpClientConfig cfg;
+    cfg.connectTimeoutMs = 15000;
+    cfg.readTimeoutMs = 30000;
+    cfg.maxConnectionsPerFile = 4;
+    cfg.minSegmentBytes = 1024;
+    https::HttpClient client(cfg);
+
+    auto dest = tmpDir / "cancelled.bin";
+    auto result = client.download_to_file_parallel(
+        "https://httpbingo.org/range/524288",  // httpbingo /range caps at 512KiB
+        dest,
+        nullptr,
+        [] { return true; }  // cancel immediately
+    );
+
+    EXPECT_FALSE(result.ok());
+    EXPECT_EQ(result.error, "cancelled");
+}