feat(net-http): StringContent takes an Encoding and serialises through it (#2070)

Measured on the old code: StringContent("\xc3\xa9", "utf-16", "text/plain")
announced `charset=utf-16` and emitted the two UTF-8 bytes c3 a9. A conforming
server reads two octets under a utf-16 label as ONE UTF-16 code unit and gets
U+A9C3 -- a different character, silently, with no diagnostic anywhere. The charset
was a label; the bytes were always the string's storage bytes.

.NET DOES NOT VALIDATE AGAINST THAT. It makes the contradiction UNREPRESENTABLE:
its constructor takes an Encoding, serialises through it (GetContentByteArray,
StringContent.cs:90-98) and labels the header with that same object's WebName
(:73). One object is both the serialiser and the label, so there is no second
source of truth for them to disagree about.

That is why the repair is a SIGNATURE change and not a check. A check would still
let a caller name a charset the body was not encoded in, and would only refuse the
charsets this port happened to recognise. The second parameter is now a
std::shared_ptr<System::Text::Encoding>, and nullptr means UTF-8 -- .NET's
`encoding ??= DefaultStringEncoding` at :53.

  StringContent("e")                              unchanged: c3 a9, charset=utf-8
  StringContent("e", "utf-16")                    no longer compiles
  StringContent("e", Encoding::Unicode())         e9 00, charset=utf-16
  StringContent("e", nullptr, "text/plain")       UTF-8

The web names are .NET's and were verified by probe before the change rather than
assumed: utf-8, utf-16, us-ascii, iso-8859-1, utf-32. The probe binary was deleted
afterwards, per the build-resource policy.

A PUBLIC SOURCE BREAK, landed under SA-2 with all five conditions discharged:

  1. migration note -- docs/Migration-StringContentEncoding.md
  2. negative consumer fixture --
     test/consumer/net_http_stringcontent_encoding_negative.cpp, three sites,
     including the two-argument StringContent(body, "utf-8") that is most likely to
     survive a careless migration. Fixture set grows to 36 fixtures / 197 sites.
  3. downstream ticket #2379
  4. the full gate
  5. measured impact -- neither cna nor mobile-eggbert references StringContent at
     all, ZERO sites in both. Neither was modified.

ONE CHECK BECAME UNNECESSARY AND IS KEPT ANYWAY. #2063 rejects a CR/LF/NUL in the
charset because it is concatenated into a Content-Type field. The charset can no
longer carry one, since it now comes from an Encoding's own web name -- the state
is unrepresentable rather than rejected, which is the stronger of the two. The check
stays because it costs nothing and a future encoding is not obliged to have a
well-formed name.

A NEW COMPONENT EDGE. Net.Http now depends on Text: the graph goes 41 modules / 92
edges to 41 / 93, and docs/ComponentCatalog.md is regenerated. There is no
alternative that keeps the count -- the whole point is to encode through
System::Text::Encoding, and a private copy of even one encoder would be the
duplication #2354 has just finished removing six of.

One gated pin inverted, two cases added. Three mutations, all caught: store the raw
string instead of encoding it; label the header utf-8 regardless of the encoding; a
null encoding means UTF-16 rather than UTF-8.

Gate: 17,320 run, 17,320 passed, 0 failed, 0 skipped across 38 executables, GREEN.
Module boundaries valid (41 modules, 93 edges). Negative fixtures OK (36 fixtures,
197 sites).

Author: robertvokac

CLAUDE.md

@@ -8,7 +8,7 @@ This file is generated from the CMake component registrations. Run
 `python3 scripts/generate_component_catalog.py` after changing module
 metadata, or use `--check` to verify that the committed catalogue is current.
 
-The graph contains **41 physical modules** and **92 direct production dependency edges**.
+The graph contains **41 physical modules** and **93 direct production dependency edges**.
 
 For each row, the component name and representative public header form a
 minimal consumer example using the template below:
@@ -57,7 +57,7 @@ for maintainers and are not part of the consumer include surface.
 | `IO.IsolatedStorage` | `modules/io-isolated-storage` | static | `Core.Base`, `IO` | `Storage` | — | — | `System/IO/IsolatedStorage/IsolatedStorage.hpp` |
 | `Net` | `modules/net` | static | `Collections.Core`, `ComponentModel`, `Core.Base`, `Uri` | — | — | `ws2_32` on Windows (private) | `System/Net/Cookie.hpp` |
 | `Net.Sockets` | `modules/net-sockets` | static | `Core.Base`, `IO`, `Net`, `Threading.Tasks` | — | — | — | `System/Net/Sockets/IPPacketInformation.hpp` |
-| `Net.Http` | `modules/net-http` | static | `Core.Base`, `IO`, `Net`, `Threading`, `Threading.Tasks` | `Uri` | `Net.Sockets` | — | `System/Net/Http/ByteArrayContent.hpp` |
+| `Net.Http` | `modules/net-http` | static | `Core.Base`, `IO`, `Net`, `Text`, `Threading`, `Threading.Tasks` | `Uri` | `Net.Sockets` | — | `System/Net/Http/ByteArrayContent.hpp` |
 | `Net.Http.Headers` | `modules/net-http-headers` | static | `Collections.Core`, `Core.Base`, `Uri` | `Net` | — | — | `System/Net/Http/Headers/AuthenticationHeaderValue.hpp` |
 | `Net.Http.Json` | `modules/net-http-json` | interface | `Core.Base`, `Net.Http`, `Text.Json`, `Threading.Tasks` | — | `Net.Sockets` | — | `System/Net/Http/Json/HttpClientJsonExtensions.hpp` |
 | `Net.Mime` | `modules/net-mime` | static | `Collections.Core`, `Core.Base` | — | — | — | `System/Net/Mime/ContentType.hpp` |

docs/ComponentCatalog.md

@@ -0,0 +1,110 @@
+<!-- SPDX-License-Identifier: MIT -->
+<!-- Copyright (c) Robert Vokac and contributors -->
+
+# Migration — `StringContent` takes an `Encoding`, not a charset string (ticket #2070)
+
+*2026-08-18.* `System::Net::Http::StringContent`'s second parameter changed from a charset
+**string** to a `std::shared_ptr<System::Text::Encoding>`, and the body is now **serialised
+through** that encoding.
+
+**This is a public source break.** Landed under `docs/StandingApprovals.md` SA-2, with all five
+conditions discharged — §7. No layout, vtable or `noexcept` concern; the type is header-only.
+
+---
+
+## 1. What was wrong
+
+The charset was a **label only**. The bytes emitted were always the string's UTF-8 storage bytes,
+so the declared charset and the payload could contradict each other:
+
+```cpp
+StringContent body("\xc3\xa9", "utf-16", "text/plain");
+// Content-Type: text/plain; charset=utf-16
+// body bytes:   c3 a9
+```
+
+`c3 a9` is `é` in UTF-8. A conforming server reads two octets under a `utf-16` label as **one**
+UTF-16 code unit and gets `U+A9C3` — a different character, silently, with no diagnostic anywhere.
+
+## 2. What .NET does, and why it is a different shape
+
+.NET does not validate against the contradiction. It makes the contradiction **unrepresentable**:
+
+```csharp
+public StringContent(string content, Encoding? encoding, string? mediaType)
+    : base(GetContentByteArray(content, encoding))          // serialise through it
+{
+    encoding ??= DefaultStringEncoding;                      // null means UTF-8
+    …
+    Headers.ContentType = new MediaTypeHeaderValue(mediaType, encoding.WebName);   // label from it
+}
+```
+*(`StringContent.cs:48-73`; `GetContentByteArray` is `:90-98`.)*
+
+One `Encoding` object is both the serialiser and the label, so there is no second source of truth
+for them to disagree about. That is why the repair is a **signature** change and not a validation
+check: a check would still let a caller name a charset the body was not encoded in, and would
+merely refuse the ones the port happened to recognise.
+
+## 3. What changed
+
+| Call | Was | Is |
+|---|---|---|
+| `StringContent("é")` | `c3 a9`, `charset=utf-8` | **unchanged** |
+| `StringContent("é", "utf-8", …)` | compiled | **does not compile** — pass `Encoding::UTF8()` |
+| `StringContent("é", "utf-16")` | `c3 a9` under a `utf-16` label | does not compile |
+| `StringContent("é", Encoding::Unicode())` | — | `e9 00`, `charset=utf-16` |
+| `StringContent("é", nullptr, …)` | — | UTF-8, matching `encoding ??= DefaultStringEncoding` |
+| `getCharSetProperty()` | whatever the caller said | the encoding's own `WebName`, always |
+
+`ReadAsString()` returns the **encoded** bytes as a `std::string`. Under a non-UTF-8 encoding
+those are not UTF-8 storage bytes and must not be treated as text; `ReadAsByteArray()` is the
+honest accessor for a non-UTF-8 body.
+
+## 4. To migrate
+
+```cpp
+StringContent body(text, "utf-16", "text/plain");                          // before
+StringContent body(text, System::Text::Encoding::Unicode(), "text/plain"); // after
+
+StringContent json(text, "utf-8", "application/json");                          // before
+StringContent json(text, System::Text::Encoding::UTF8(), "application/json");   // after
+
+StringContent plain(text);   // unchanged — still UTF-8, still text/plain
+```
+
+The web names are .NET's and were verified by probe: `utf-8`, `utf-16`, `us-ascii`,
+`iso-8859-1`, `utf-32`.
+
+## 5. One check became unnecessary and is kept anyway
+
+#2063 rejects a CR/LF/NUL in the charset, because it is concatenated into a `Content-Type` field.
+The charset can no longer carry one, since it now comes from an `Encoding`'s own web name — the
+state is unrepresentable rather than rejected, which is the stronger of the two. The check is kept
+because it costs nothing and a future encoding is not obliged to have a well-formed name.
+
+## 6. A new component edge
+
+`Net.Http` now depends on `Text`. The module graph goes **41 modules / 92 edges → 41 / 93**, and
+`docs/ComponentCatalog.md` is regenerated. There is no alternative that keeps the edge count: the
+whole point is to encode through `System::Text::Encoding`, and a private copy of even one encoder
+would be the duplication #2354 has just finished removing six of.
+
+## 7. SA-2's five conditions
+
+1. **Migration note** — this document.
+2. **Negative consumer fixture** — `test/consumer/net_http_stringcontent_encoding_negative.cpp`,
+   three sites, including the two-argument `StringContent(body, "utf-8")` most likely to survive a
+   careless migration. The fixture set grows to **36 fixtures / 197 sites**.
+3. **Downstream ticket** — #2379.
+4. **Full gate** — 17,320 run, 17,320 passed, 0 failed.
+5. **Measured impact** — neither `cna` nor `mobile-eggbert` references `StringContent` at all:
+   **zero sites in both**. Neither repository was modified.
+
+## 8. Evidence
+
+| Mutation | Caught |
+|---|---|
+| Store the raw string instead of encoding it (the pre-#2070 behaviour) | ✅ (2 tests) |
+| Label the header `utf-8` regardless of the encoding | ✅ (2 tests) |
+| A null encoding means UTF-16 rather than UTF-8 | ✅ (3 tests) |

docs/Migration-StringContentEncoding.md

@@ -5,7 +5,7 @@ sharp_runtime_register_module(
     NAME Net.Http
     TARGET sharp_runtime_net_http
     TYPE STATIC
-    PUBLIC_DEPENDENCIES Core.Base IO Net Threading Threading.Tasks
+    PUBLIC_DEPENDENCIES Core.Base IO Net Text Threading Threading.Tasks
     PRIVATE_DEPENDENCIES Uri
     TEST_DEPENDENCIES Net.Sockets
 )

modules/net-http/CMakeLists.txt

@@ -4,57 +4,80 @@
 #pragma once
 #include "System/Net/Http/HttpContent.hpp"
 #include "System/Net/Http/detail/HttpFieldValidation.hpp"
+#include "System/Text/Encoding.hpp"
+#include <memory>
 #include <string>
 #include <vector>
 
 namespace System::Net::Http {
 
 /** HTTP content backed by a plain text string, mirroring .NET System.Net.Http.StringContent. */
 class StringContent : public HttpContent {
-    std::string content_;
-    std::string mediaType_;
-    std::string charset_;
+    std::vector<SharpRuntime::bytecs> bytes_;
+    std::string                       mediaType_;
+    std::string                       charset_;
 public:
     /**
      * @brief Constructs StringContent from a plain text string.
      * @param content   The text body.
-     * @param charset   Character encoding; defaults to "utf-8".
-     * @param mediaType MIME type; defaults to "text/plain".
+     * @param encoding  The encoding to serialise @p content through; `nullptr` means UTF-8.
+     * @param mediaType MIME type; defaults to `"text/plain"`.
      *
-     * @throws System::FormatException if @p charset or @p mediaType contains a carriage
-     * return, a line feed or a NUL character.
+     * @throws System::FormatException if @p mediaType or the encoding's web name contains a
+     * carriage return, a line feed or a NUL character.
      *
-     * @note **Narrowing since ticket #2063** (SR-AUD-313, cause NH-B). Both values are
-     * concatenated into a `Content-Type: <mediaType>; charset=<charset>` field — by
+     * @note **Ticket #2070 (2026-08-18) changed this parameter from a charset STRING to an
+     * `Encoding`, which is a public source break.** The old signature let the declared charset
+     * and the emitted bytes contradict each other: `StringContent("\xc3\xa9", "utf-16")`
+     * labelled its body `charset=utf-16` and emitted the two UTF-8 bytes `c3 a9`, so a
+     * conforming server decoded them as a single UTF-16 code unit and got `U+A9C3` — a wrong
+     * character, silently, with no diagnostic anywhere.
+     *
+     * .NET makes that state **unrepresentable** rather than validating against it. Its
+     * constructor takes an `Encoding`, serialises through it
+     * (`GetContentByteArray`, StringContent.cs:90-98) and then labels the header with that same
+     * object's `WebName` (`:73`). One source of truth, so the two cannot disagree. `null` means
+     * UTF-8, which is `encoding ??= DefaultStringEncoding` at `:53`.
+     *
+     * @note **Narrowing since ticket #2063** (SR-AUD-313, cause NH-B). The media type and the
+     * charset are concatenated into a `Content-Type: <mediaType>; charset=<charset>` field — by
      * `HttpClientHandler::Send` on the wire and by `MultipartContent::ReadAsString` inside a
      * MIME part — so a CR/LF in either used to emit extra header fields. The **body** is not
-     * validated: it is payload, not a protocol field.
-     *
-     * @note The charset is a **label only**: the bytes emitted are always the storage bytes of
-     * @p content, so `StringContent("\xc3\xa9", "utf-16")` still emits `c3 a9`. Whether .NET
-     * encodes through the declared charset or treats the label as advisory is an open
-     * question with no repository-contained evidence — deferred ticket #2070, with the
-     * current behaviour pinned so no answer can land silently.
+     * validated: it is payload, not a protocol field. The charset can no longer carry one at
+     * all, since it now comes from an `Encoding`'s own web name, but the check is kept: it
+     * costs nothing and a future encoding is not required to have a well-formed name.
      */
-    explicit StringContent(const std::string& content,
-                           const std::string& charset   = "utf-8",
-                           const std::string& mediaType = "text/plain")
-        : content_(content), mediaType_(mediaType), charset_(charset) {
-        detail::ThrowIfControlCharacter(charset, "charset");
+    explicit StringContent(const std::string&                             content,
+                           const std::shared_ptr<System::Text::Encoding>& encoding = nullptr,
+                           const std::string&                             mediaType = "text/plain")
+        : mediaType_(mediaType) {
+        const auto& effective = encoding ? encoding : System::Text::Encoding::UTF8();
+        charset_ = effective->getWebNameProperty();
+        detail::ThrowIfControlCharacter(charset_, "charset");
         detail::ThrowIfControlCharacter(mediaType, "media type");
+        bytes_ = effective->GetBytes(content);
     }
 
-    /** Returns the content body as a string. */
-    [[nodiscard]] std::string ReadAsString() const override { return content_; }
+    /**
+     * @brief Returns the encoded body as a string of raw bytes.
+     *
+     * Under a non-UTF-8 encoding these are **not** UTF-8 storage bytes and must not be treated
+     * as text: `ReadAsString()` on a UTF-16 body returns the UTF-16 octets. That is the same
+     * thing .NET's `ByteArrayContent.ReadAsStringAsync` would do without a charset to decode by,
+     * and it is why `ReadAsByteArray()` is the honest accessor for a non-UTF-8 body.
+     */
+    [[nodiscard]] std::string ReadAsString() const override {
+        return std::string(bytes_.begin(), bytes_.end());
+    }
 
-    /** Returns the content body as a raw byte array (UTF-8 encoding assumed). */
+    /** Returns the content body as the raw bytes of the declared charset. */
     [[nodiscard]] std::vector<SharpRuntime::bytecs> ReadAsByteArray() const override {
-        return std::vector<SharpRuntime::bytecs>(content_.begin(), content_.end());
+        return bytes_;
     }
 
     /** Returns the MIME type of the content (e.g. "text/plain"). */
     [[nodiscard]] std::string getContentTypeProperty() const override { return mediaType_; }
-    /** Returns the character set of the content (e.g. "utf-8"). */
+    /** Returns the character set of the content — the encoding's own web name, always. */
     [[nodiscard]] std::string getCharSetProperty()     const override { return charset_; }
 };
 

modules/net-http/include/System/Net/Http/StringContent.hpp

@@ -18,6 +18,7 @@
 #include "System/Net/Http/HttpMethod.hpp"
 #include "System/Net/Http/HttpContent.hpp"
 #include "System/Net/Http/StringContent.hpp"
+#include "System/Text/Encoding.hpp"
 #include "System/Net/Http/ByteArrayContent.hpp"
 #include "System/Net/Http/HttpRequestMessage.hpp"
 #include "System/Net/Http/HttpResponseMessage.hpp"
@@ -147,7 +148,7 @@ TEST(StringContentTests, DefaultContentType) {
 }
 
 TEST(StringContentTests, CustomMediaType) {
-    StringContent c("{}", "utf-8", "application/json");
+    StringContent c("{}", System::Text::Encoding::UTF8(), "application/json");
     EXPECT_EQ(c.getContentTypeProperty(), "application/json");
     EXPECT_EQ(c.getCharSetProperty(), "utf-8");
 }
@@ -707,9 +708,9 @@ TEST(MultipartContentTests, ReadAsString_EmptyContent_JustBoundaries) {
 
 TEST(MultipartContentTests, ReadAsString_ThreeParts_ExactByteLayout) {
     MultipartContent c("mixed", "B");
-    c.Add(std::make_shared<StringContent>("one", "", ""));
-    c.Add(std::make_shared<StringContent>("two", "", ""));
-    c.Add(std::make_shared<StringContent>("three", "", ""));
+    c.Add(std::make_shared<StringContent>("one", nullptr, ""));
+    c.Add(std::make_shared<StringContent>("two", nullptr, ""));
+    c.Add(std::make_shared<StringContent>("three", nullptr, ""));
     std::string body = c.ReadAsString();
 
     EXPECT_EQ(body,
@@ -1712,8 +1713,11 @@ TEST(HttpControlCharacterTests, ParseStatusLine_ControlCharacter_ThrowsHttpReque
 
 TEST(HttpControlCharacterTests, ContentMediaTypeAndCharset_ControlCharacter_ThrowsFormatException) {
     for (const auto& bad : controlBearingFields()) {
-        EXPECT_THROW(StringContent("body", "utf-8", bad), System::FormatException);
-        EXPECT_THROW(StringContent("body", bad, "text/plain"), System::FormatException);
+        EXPECT_THROW(StringContent("body", System::Text::Encoding::UTF8(), bad),
+                     System::FormatException);
+        // #2070: the CHARSET can no longer carry a control character, because it is no longer a
+        // caller-supplied string -- it is the Encoding's own web name. The state is now
+        // unrepresentable rather than rejected, which is the stronger of the two.
         EXPECT_THROW(ByteArrayContent(std::vector<SharpRuntime::bytecs>{1, 2}, bad),
                      System::FormatException);
 
@@ -1728,7 +1732,7 @@ TEST(HttpControlCharacterTests, ContentMediaTypeAndCharset_ControlCharacter_Thro
 
 // The BODY is payload, not a protocol field, and must not be validated.
 TEST(HttpControlCharacterTests, ContentBodyWithControlCharacters_StillAccepted) {
-    StringContent content("line1\r\nline2\r\n", "utf-8", "text/plain");
+    StringContent content("line1\r\nline2\r\n", System::Text::Encoding::UTF8(), "text/plain");
     EXPECT_EQ(content.ReadAsString(), "line1\r\nline2\r\n");
     ByteArrayContent bytes(std::vector<SharpRuntime::bytecs>{'\r', '\n', 0, 'x'});
     EXPECT_EQ(bytes.ReadAsByteArray().size(), 4u);
@@ -2097,15 +2101,53 @@ TEST(NetHttpGatedBehaviourPins, Fix2069_TheStatusCodeDomainIsZeroToNineHundredNi
     EXPECT_EQ(response.getStatusCodeProperty(), HttpStatusCode::OK);
 }
 
-// #2070 (SR-AUD-317) -- the charset is a label; the bytes are always the
-// storage bytes. Whether .NET encodes through the label is unverified.
-TEST(NetHttpGatedBehaviourPins, Pin2070_StringContentEmitsStorageBytesUnderAnyCharsetLabel) {
-    StringContent content("\xc3\xa9", "utf-16", "text/plain");
-    auto bytes = content.ReadAsByteArray();
-    ASSERT_EQ(bytes.size(), 2u);
-    EXPECT_EQ(static_cast<unsigned>(bytes[0]), 0xc3u);
-    EXPECT_EQ(static_cast<unsigned>(bytes[1]), 0xa9u);
-    EXPECT_EQ(content.getCharSetProperty(), "utf-16");
+// #2070 (SR-AUD-317) RESOLVED, and the pin is inverted. The charset used to be a LABEL: the
+// bytes were always the storage bytes, so `StringContent("\xc3\xa9", "utf-16")` announced
+// charset=utf-16 and emitted the two UTF-8 bytes c3 a9. A conforming server decoded that pair as
+// one UTF-16 code unit and got U+A9C3 -- a wrong character, silently.
+//
+// .NET makes the contradiction UNREPRESENTABLE rather than validating against it: the
+// constructor takes an Encoding, serialises through it (StringContent.cs:90-98) and labels the
+// header with that same object's WebName (:73). One source of truth.
+TEST(NetHttpGatedBehaviourPins, Fix2070_TheBytesAreEncodedThroughTheDeclaredCharset) {
+    StringContent utf16("\xc3\xa9", System::Text::Encoding::Unicode(), "text/plain");
+    EXPECT_EQ(utf16.getCharSetProperty(), "utf-16");
+    const auto bytes = utf16.ReadAsByteArray();
+    ASSERT_EQ(bytes.size(), 2u) << "one UTF-16 code unit, not two UTF-8 storage bytes";
+    EXPECT_EQ(static_cast<unsigned>(bytes[0]), 0xe9u);
+    EXPECT_EQ(static_cast<unsigned>(bytes[1]), 0x00u);
+
+    // The default is UTF-8 and its bytes are the storage bytes, so nothing an ordinary caller
+    // does has moved.
+    StringContent def("\xc3\xa9");
+    EXPECT_EQ(def.getCharSetProperty(), "utf-8");
+    const auto defaultBytes = def.ReadAsByteArray();
+    ASSERT_EQ(defaultBytes.size(), 2u);
+    EXPECT_EQ(static_cast<unsigned>(defaultBytes[0]), 0xc3u);
+    EXPECT_EQ(static_cast<unsigned>(defaultBytes[1]), 0xa9u);
+    // ...and an explicit nullptr means the same thing, which is `encoding ??= DefaultStringEncoding`.
+    EXPECT_EQ(StringContent("\xc3\xa9", nullptr).ReadAsByteArray(), defaultBytes);
+    EXPECT_EQ(StringContent("\xc3\xa9", System::Text::Encoding::UTF8()).ReadAsByteArray(), defaultBytes);
+}
+
+TEST(NetHttpGatedBehaviourPins, Fix2070_TheLabelAndTheBytesCannotDisagreeForAnyEncoding) {
+    // The property, rather than one example of it: whatever encoding is handed in, the header
+    // names THAT encoding and the body is what THAT encoding produced. There is no third source.
+    struct Row { std::shared_ptr<System::Text::Encoding> encoding; const char* webName; };
+    const Row rows[] = {
+        {System::Text::Encoding::UTF8(), "utf-8"},
+        {System::Text::Encoding::Unicode(), "utf-16"},
+        {System::Text::Encoding::ASCII(), "us-ascii"},
+        {System::Text::Encoding::Latin1(), "iso-8859-1"},
+        {System::Text::Encoding::UTF32(), "utf-32"},
+    };
+    for (const Row& row : rows) {
+        SCOPED_TRACE(row.webName);
+        StringContent content("\xc3\xa9", row.encoding, "text/plain");
+        EXPECT_EQ(content.getCharSetProperty(), row.webName);
+        const auto expected = row.encoding->GetBytes(std::string("\xc3\xa9"));
+        EXPECT_EQ(content.ReadAsByteArray(), expected);
+    }
 }
 
 // #2071 (SR-AUD-318's limits half) LANDED. Response reads are bounded by