httpunk 0.4.5__tar.gz → 0.5.0__tar.gz

{httpunk-0.4.5 → httpunk-0.5.0}/Cargo.lock

@@ -10,9 +10,9 @@ checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 
 [[package]]
 name = "base64"
-version = "0.22.1"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
 
 [[package]]
 name = "bytes"
@@ -71,9 +71,9 @@ checksum = "1944426bf7d03f1d14f708785e4b33efd750b36d48a157b836b3efc15ede8e1d"
 
 [[package]]
 name = "h2"
-version = "0.4.19"
+version = "0.4.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef8e5e5a340588f4452631496976cf8636d4a7ecf600239fdc27615d2530bc16"
+checksum = "7d29020232d6aa3fb1daca64c1127cf662cf97f254ae16c18c05b8ab635fc118"
 dependencies = [
  "atomic-waker",
  "bytes",
@@ -134,12 +134,13 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "httpunk"
-version = "0.4.5"
+version = "0.5.0"
 dependencies = [
  "bytes",
  "h2",
  "http",
  "hyper",
+ "hyper-util",
  "mimalloc",
  "pyo3",
  "vendor-h2",
@@ -149,13 +150,12 @@ dependencies = [
 
 [[package]]
 name = "hyper"
-version = "1.11.1"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27b501faa50e7a26c3d3560ca625132f4078a17771f4810baf70475ae48cbe43"
+checksum = "2c3e324da4c95177d6291d4c8730197c0d1822f8a9766814a4a44fa5ab797c9c"
 dependencies = [
  "atomic-waker",
  "bytes",
- "futures-channel",
  "futures-core",
  "http",
  "http-body",
@@ -168,6 +168,25 @@ dependencies = [
  "want",
 ]
 
+[[package]]
+name = "hyper-util"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddc03d96684f9226b8a787cdb71488417b53ab5ea8fdb1dac946cb9431cc8bff"
+dependencies = [
+ "base64",
+ "bytes",
+ "futures-channel",
+ "http",
+ "http-body",
+ "hyper",
+ "ipnet",
+ "percent-encoding",
+ "pin-project-lite",
+ "tower-service",
+ "tracing",
+]
+
 [[package]]
 name = "indexmap"
 version = "2.14.0"
@@ -249,9 +268,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.29.2"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4688ddedf473e32662b9b067670129a8afb8c18e351482c70d62ba4a88171e8b"
+checksum = "229ca13b8a15bb0d1487b81ab975bfcd97513416499a8312011b6036e42e0de4"
 dependencies = [
  "libc",
  "once_cell",
@@ -263,18 +282,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.29.2"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f41027e41b4bd03f6e60f9f417fe24a6341a6bb744edd62b6f709f2a52ea30e9"
+checksum = "70130e2b6dd1ee589a8788026a429561ca5c40fa7a2fa7914c2282eddae24700"
 dependencies = [
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.29.2"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e591a95526fead067432c3b3a33fc74770b87b1e04e73671090d9c2055a2b327"
+checksum = "5e7ff73c555c286d212d4ce7e5fbda845a973c4f61bd5f160f5f2c3c2a04d1c4"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -282,9 +301,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.29.2"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73225868fc1cd84eef2c3c230ddb91273bf1de46aeb8a4248da76d32a0924a1c"
+checksum = "c46d2e5862c7bb8207e3b639f713dda3c499933444784154c11d013c5a691b60"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -294,9 +313,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.29.2"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "571575aa3749fa6216757dd47d2a3e7ef360f329a40f0666a9fbd14889024952"
+checksum = "38b89f066f2ae72a2aef52d1537ca2fcd104440ebfadee06e97aa90738a25b9b"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -333,9 +352,9 @@ checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90"
 
 [[package]]
 name = "syn"
-version = "2.0.119"
+version = "3.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -372,6 +391,12 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
 [[package]]
 name = "tracing"
 version = "0.1.44"
@@ -438,9 +463,9 @@ dependencies = [
 
 [[package]]
 name = "want"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+checksum = "ec4cdd0dd910afe868b7ef477227d8d538b46b3075031afee8a9f2acb0a2ed0b"
 dependencies = [
  "try-lock",
 ]

{httpunk-0.4.5 → httpunk-0.5.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "httpunk"
-version = "0.4.5"
+version = "0.5.0"
 description = "The Rust HTTP library for Python"
 authors = [
     "Giovanni Barillari <g@baro.dev>",
@@ -40,25 +40,27 @@ crate-type = ["cdylib"]
 
 [features]
 mimalloc = ["dep:mimalloc"]
-# Never enabled. Exists only so the optional crates.io `h2`/`hyper` deps are
-# referenced (no "unused optional dependency"), keeping them in Cargo.lock for
-# advisory scanning while they stay uncompiled. See the dependency comments.
-_audit = ["dep:h2", "dep:hyper"]
+# Never enabled. Exists only so the optional crates.io `h2`/`hyper`/`hyper-util`
+# deps are referenced (no "unused optional dependency"), keeping them in Cargo.lock
+# for advisory scanning while they stay uncompiled. See the dependency comments.
+_audit = ["dep:h2", "dep:hyper", "dep:hyper-util"]
 
 [dependencies]
 bytes = "1"
 http = "1.1"
 mimalloc = { version = "0.1.49", default-features = false, features = ["local_dynamic_tls"], optional = true }
-pyo3 = { version = "=0.29", features = ["extension-module", "generate-import-lib"] }
+pyo3 = { version = "=0.30", features = ["extension-module", "generate-import-lib"] }
 vendor-h2 = { path = "crates/vendor-h2" }
 vendor-hyper = { path = "crates/vendor-hyper", features = ["client", "server", "http1"] }
 vendor-hyper-util = { path = "crates/vendor-hyper-util" }
-# NOT compiled: the crates.io `h2`/`hyper` — vendored into crates/vendor-*/ (see
-# THIRD-PARTY.md). Optional + gated behind the never-enabled `_audit` feature so
-# the pinned versions land in Cargo.lock for `cargo audit` / Dependabot advisory
-# coverage without pulling them (and tokio) into the build.
-h2 = { version = "=0.4.19", optional = true }
-hyper = { version = "=1.11.1", optional = true, default-features = false, features = ["http1", "client", "server"] }
+# NOT compiled: the crates.io `h2`/`hyper`/`hyper-util`; their sans-IO code is
+# vendored into crates/vendor-*/ by scripts/vendor-*.sh. Optional + gated behind
+# the never-enabled `_audit` feature so the pinned versions land in Cargo.lock
+# for `cargo audit` / Dependabot advisory coverage without pulling them (and
+# tokio) into the build. hyper-util's client-proxy mirrors the vendored surface.
+h2 = { version = "=0.4.20", optional = true }
+hyper = { version = "=1.12.0", optional = true, default-features = false, features = ["http1", "client", "server"] }
+hyper-util = { version = "=0.1.21", optional = true, default-features = false, features = ["client-proxy"] }
 
 [profile.release]
 codegen-units = 1

{httpunk-0.4.5 → httpunk-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httpunk
-Version: 0.4.5
+Version: 0.5.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
@@ -8,7 +8,6 @@ Classifier: Operating System :: MacOS
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -28,7 +27,7 @@ Keywords: http,h10,h11,h2
 Home-Page: https://github.com/gi0baro/httpunk
 Author-email: Giovanni Barillari <g@baro.dev>
 License: BSD-3-Clause
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Funding, https://github.com/sponsors/gi0baro
 Project-URL: Homepage, https://github.com/gi0baro/httpunk

{httpunk-0.4.5 → httpunk-0.5.0}/crates/vendor-h2/Cargo.toml

@@ -1,5 +1,5 @@
-# Vendored hyperium/h2 (frame + hpack + sync proto pieces), byte-identical to
-# upstream — see ../../THIRD-PARTY.md. A workspace member crate so it owns its
+# Vendored hyperium/h2 (frame + hpack + sync proto pieces); scripts/vendor-h2.sh
+# enumerates every modification to upstream. A workspace member crate so it owns its
 # own crate root (upstream `crate::` paths resolve natively, no rewrite) and is
 # excluded from the main crate's fmt/clippy via `cargo fmt -p`.
 [package]

httpunk-0.5.0/crates/vendor-h2/UPSTREAM_VERSION

@@ -0,0 +1 @@
+0.4.20

{httpunk-0.4.5 → httpunk-0.5.0}/crates/vendor-h2/src/frame/go_away.rs

@@ -40,7 +40,17 @@ impl GoAway {
         &self.debug_data
     }
 
-    pub fn load(payload: &[u8]) -> Result<GoAway, Error> {
+    pub fn load(head: Head, payload: &[u8]) -> Result<GoAway, Error> {
+        debug_assert_eq!(head.kind(), crate::frame::Kind::GoAway);
+
+        // The GOAWAY frame applies to the connection, not a specific stream.
+        // An endpoint MUST treat a GOAWAY frame with a stream identifier
+        // other than 0x00 as a connection error (Section 5.4.1) of type
+        // PROTOCOL_ERROR.
+        if !head.stream_id().is_zero() {
+            return Err(Error::InvalidStreamId);
+        }
+
         if payload.len() < 8 {
             return Err(Error::BadFrameSize);
         }

{httpunk-0.4.5 → httpunk-0.5.0}/crates/vendor-h2/src/frame/headers.rs

@@ -381,7 +381,7 @@ impl PushPromise {
 
         // A promised request "that indicates the presence of a request body
         // MUST reset the promised stream with a stream error"
-        if let Some(content_length) = req.headers().get(header::CONTENT_LENGTH) {
+        for content_length in req.headers().get_all(header::CONTENT_LENGTH) {
             let parsed_length = parse_u64(content_length.as_bytes());
             if parsed_length != Ok(0) {
                 return Err(InvalidContentLength(parsed_length));
@@ -948,7 +948,7 @@ impl HeaderBlock {
                         }
                         if !self.is_over_size {
                             self.field_size += header_size;
-                            if let Err(_) = self.fields.try_append(name, value) {
+                            if self.fields.try_append(name, value).is_err() {
                                 // HeaderMap capacity exceeded — treat as over-size
                                 // so the stream is rejected downstream (RST_STREAM / 431)
                                 // instead of panicking on the 24,577th unique header.

{httpunk-0.4.5 → httpunk-0.5.0}/crates/vendor-h2/src/frame/mod.rs

@@ -153,8 +153,8 @@ pub enum Error {
 
     /// An invalid stream identifier was provided.
     ///
-    /// This is returned if a SETTINGS or PING frame is received with a stream
-    /// identifier other than zero.
+    /// This is returned if a SETTINGS, PING or GOAWAY frame is received with a
+    /// stream identifier other than zero.
     InvalidStreamId,
 
     /// A request or response is malformed.

httpunk-0.5.0/crates/vendor-h2/src/hpack/huffman/decode.rs

@@ -0,0 +1,349 @@
+//! Huffman decoding for HPACK (RFC 7541 §5.2).
+//!
+//! The decoder has a fast path which decodes 12 bits a time. The decoder
+//! looks the next 12 bits up in `FAST_TABLE`, which maps directly to either
+//! one or two symbols to decode. Since ASCII letters and digits have 5-7 bit
+//! codes, one lookup usually decodes two symbols at once.
+//!
+//! Two situations fall off this fast path:
+//!
+//! - Codes longer than 12 bits: control characters and bytes >= 0x80
+//! - The end of the input, when fewer than 12 bits remain.
+//!
+//! These are decoded by walking the generated `DECODE_TABLE` one input byte at a time.
+
+use crate::hpack::huffman::table::{DECODE_TABLE, ENCODE_CODES, ENCODE_CODE_LENGTHS};
+use crate::hpack::DecoderError;
+
+use bytes::BytesMut;
+
+// DECODE_TABLE (in the generated `table.rs`) is a series of 256-entry
+// tables, walked one input byte at a time. A leaf entry (BRANCH bit clear)
+// holds a decoded symbol and the number of bits its code used. A branch
+// entry (BRANCH bit set) holds the index of the table for the next byte.
+// No valid code leads back to table 0, so a branch to 0 means the input is
+// not a valid code.
+const BRANCH: u16 = 0x8000;
+const TABLE_INDEX_MASK: u16 = 0x7f00;
+const TABLE_WIDTH: usize = 256;
+
+// Maps each possible 12-bit chunk of input to the symbol(s) it starts
+// with. Entry layout (u32):
+//
+//   bits  0..8   first decoded byte
+//   bits  8..16  second decoded byte (if any)
+//   bits 16..24  number of symbols decoded: 1, 2, or 0, where 0 means the
+//                code is longer than 12 bits and the slow path must run
+//   bits 24..32  how many of the 12 bits the decoded symbols used
+const FAST_BITS: usize = 12;
+const FAST_DECODE_TABLE: [u32; 1 << FAST_BITS] = build_fast_table();
+
+const fn build_fast_table() -> [u32; 1 << FAST_BITS] {
+    let mut table = [0; 1 << FAST_BITS];
+
+    // First fill in every index that starts with one whole code
+    let mut a = 0;
+    while a < 256 {
+        let len1 = ENCODE_CODE_LENGTHS[a] as usize;
+        let code1 = ENCODE_CODES[a] as u64;
+        if len1 <= FAST_BITS {
+            let rem = FAST_BITS - len1;
+            let base = (code1 as usize) << rem;
+            let single = (1 << 16) | ((len1 as u32) << 24) | a as u32;
+            let mut i = 0;
+            while i < (1 << rem) {
+                table[base + i] = single;
+                i += 1;
+            }
+        }
+        a += 1;
+    }
+
+    // Overwrite the indices where a second whole code fit right after the first
+    let mut a = 0;
+    while a < 256 {
+        let len1 = ENCODE_CODE_LENGTHS[a] as usize;
+        let code1 = ENCODE_CODES[a] as u64;
+        // A second code needs at least 5 more bits (the shortest code)
+        if len1 + 5 <= FAST_BITS {
+            let rem = FAST_BITS - len1;
+            let mut b = 0;
+            while b < 256 {
+                let len2 = ENCODE_CODE_LENGTHS[b] as usize;
+                let code2 = ENCODE_CODES[b] as u64;
+                if len2 <= rem {
+                    let rem2 = rem - len2;
+                    let base = ((code1 as usize) << rem) | ((code2 as usize) << rem2);
+                    let pair =
+                        (2 << 16) | (((len1 + len2) as u32) << 24) | ((b as u32) << 8) | a as u32;
+                    let mut i = 0;
+                    while i < (1 << rem2) {
+                        table[base + i] = pair;
+                        i += 1;
+                    }
+                }
+                b += 1;
+            }
+        }
+        a += 1;
+    }
+
+    table
+}
+
+// Decodes one code of any length by walking DECODE_TABLE one input byte at
+// a time, and writes the symbol to `dst[*o]`. Used for codes longer than
+// FAST_BITS bits and for the tail of the input.
+//
+// Inlining avoids a 35% performance regression on ASCII benchmarks.
+#[inline(always)]
+fn decode_code_slow(
+    acc: &mut u64,
+    bits: &mut usize,
+    dst: &mut [u8],
+    o: &mut usize,
+) -> Result<(), DecoderError> {
+    let mut table = 0;
+    loop {
+        let e = DECODE_TABLE[table * TABLE_WIDTH + (*acc >> 56) as usize];
+        if e & BRANCH == 0 {
+            let used = (e >> 8) as usize;
+            if used > *bits {
+                return Err(DecoderError::InvalidHuffmanCode);
+            }
+            dst[*o] = e as u8;
+            *o += 1;
+            *acc <<= used;
+            *bits -= used;
+            return Ok(());
+        }
+        if *bits < 8 {
+            return Err(DecoderError::InvalidHuffmanCode);
+        }
+        table = ((e & TABLE_INDEX_MASK) >> 8) as usize;
+        if table == 0 {
+            return Err(DecoderError::InvalidHuffmanCode);
+        }
+        *acc <<= 8;
+        *bits -= 8;
+    }
+}
+
+// Decodes a Huffman encoded string into the provided buffer.
+pub fn decode(src: &[u8], buf: &mut BytesMut) -> Result<BytesMut, DecoderError> {
+    let len = src.len();
+    let base_len = buf.len();
+
+    // Reserve the worst case output size. Every code is at least 5 bits,
+    // so `len` input bytes can't decode to more than `len * 8 / 5` output
+    // bytes. One more byte covers the fast path always writing two bytes
+    // even when it decoded only one symbol.
+    buf.resize(base_len + len * 8 / 5 + 1, 0);
+    let dst = &mut buf[base_len..];
+    let mut o = 0;
+
+    let mut acc: u64 = 0;
+    let mut bits: usize = 0;
+    let mut pos: usize = 0;
+
+    'outer: loop {
+        // Fill the bit buffer. While 8 or more input bytes remain, load
+        // the next 8 in one go and count as many whole bytes as fit under
+        // the bits already in the buffer (bringing it to 56-63 bits). The
+        // bytes that didn't fit still land in the low end of `acc`; the
+        // next refill just ORs the same values over them, so no harm done.
+        if pos + 8 <= len {
+            let word = u64::from_be_bytes(src[pos..pos + 8].try_into().unwrap());
+            acc |= word >> bits;
+            pos += (63 - bits) >> 3; // bytes now accounted for in `bits`
+            bits |= 56; // equals bits + 8 * (bytes added)
+        } else {
+            while bits <= 56 && pos < len {
+                acc |= (src[pos] as u64) << (56 - bits);
+                pos += 1;
+                bits += 8;
+            }
+        }
+
+        while bits >= FAST_BITS {
+            let entry = FAST_DECODE_TABLE[(acc >> (64 - FAST_BITS)) as usize];
+            let count = (entry >> 16) & 0xff;
+            if count == 0 {
+                // The next code is longer than 12 bits. Refill first if it
+                // might not be in the buffer yet (the longest code is 30
+                // bits), then decode it by walking DECODE_TABLE.
+                if bits < 30 && pos < len {
+                    continue 'outer;
+                }
+                decode_code_slow(&mut acc, &mut bits, dst, &mut o)?;
+                continue;
+            }
+            let consumed = (entry >> 24) as usize;
+            dst[o] = entry as u8;
+            dst[o + 1] = (entry >> 8) as u8;
+            o += count as usize;
+            acc <<= consumed;
+            bits -= consumed;
+        }
+
+        if pos >= len {
+            break;
+        }
+    }
+
+    // Tail: the input is exhausted and fewer than 12 bits remain.
+    while bits > 0 {
+        // The encoder pads the last byte with up to 7 one-bits, which are
+        // valid only between symbols. Anything else must decode.
+        if bits < 8 && (acc >> (64 - bits)) == (1 << bits) - 1 {
+            break;
+        }
+        decode_code_slow(&mut acc, &mut bits, dst, &mut o)?;
+    }
+
+    buf.truncate(base_len + o);
+    Ok(buf.split())
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use bytes::BufMut;
+    use rand::rngs::StdRng;
+    use rand::{Rng, SeedableRng};
+
+    fn decode(src: &[u8]) -> Result<BytesMut, DecoderError> {
+        let mut buf = BytesMut::new();
+        super::decode(src, &mut buf)
+    }
+
+    // The simplest decoder we can write, used to double-check the real
+    // one: turn the input into a literal string of '0'/'1' characters and
+    // repeatedly strip off the first code that matches. No code is a
+    // prefix of another, so at most one can match. EOS (index 256) is left
+    // out on purpose: encoded EOS is an error per RFC 7541 §5.2.
+    fn reference_decode(src: &[u8]) -> Result<BytesMut, DecoderError> {
+        // Each symbol's code as a string of '0' and '1', e.g. "11111000".
+        let codes: Vec<String> = ENCODE_CODES
+            .iter()
+            .zip(ENCODE_CODE_LENGTHS.iter())
+            .map(|(&code, &len)| format!("{code:0len$b}", len = len as usize))
+            .collect();
+        let bits: String = src.iter().map(|byte| format!("{byte:08b}")).collect();
+
+        let mut decoded = BytesMut::new();
+        let mut remaining_bits: &str = &bits;
+        while let Some(sym) = (0..256).find(|&sym| remaining_bits.starts_with(&codes[sym])) {
+            decoded.put_u8(sym as u8);
+            remaining_bits = &remaining_bits[codes[sym].len()..];
+        }
+        // We expect anything that cannot be matched to be padding. Padding is
+        // fewer than 8 bits, and all ones.
+        if remaining_bits.len() >= 8 || remaining_bits.chars().any(|bit| bit == '0') {
+            return Err(DecoderError::InvalidHuffmanCode);
+        }
+        Ok(decoded)
+    }
+
+    #[test]
+    fn decode_single_byte() {
+        assert_eq!("o", decode(&[0b00111111]).unwrap());
+        assert_eq!("0", decode(&[7]).unwrap());
+        assert_eq!("A", decode(&[(0x21 << 2) + 3]).unwrap());
+    }
+
+    #[test]
+    fn single_char_multi_byte() {
+        assert_eq!("#", decode(&[255, 160 + 15]).unwrap());
+        assert_eq!("$", decode(&[255, 200 + 7]).unwrap());
+        assert_eq!("\x0a", decode(&[255, 255, 255, 240 + 3]).unwrap());
+    }
+
+    #[test]
+    fn multi_char() {
+        assert_eq!("!0", decode(&[254, 1]).unwrap());
+        assert_eq!(" !", decode(&[0b01010011, 0b11111000]).unwrap());
+    }
+
+    // Random (mostly invalid) byte strings must produce identical results to reference impl
+    #[test]
+    fn matches_reference_on_arbitrary_bytes() {
+        let mut rng = StdRng::seed_from_u64(0xdeadbeefcafe);
+
+        for _ in 0..10_000 {
+            let len = rng.gen_range(0..40);
+            let src: Vec<u8> = (0..len).map(|_| rng.gen()).collect();
+            assert_eq!(reference_decode(&src), decode(&src), "src={:?}", src);
+        }
+
+        // Bias toward high bytes to exercise long codes and EOS prefixes.
+        for _ in 0..10_000 {
+            let len = rng.gen_range(0..40);
+            let src: Vec<u8> = (0..len).map(|_| rng.gen::<u8>() | 0xe0).collect();
+            assert_eq!(reference_decode(&src), decode(&src), "src={:?}", src);
+        }
+    }
+
+    #[test]
+    fn rejects_eos_and_invalid_padding() {
+        assert_eq!(decode(&[0xff]), Err(DecoderError::InvalidHuffmanCode));
+        assert_eq!(
+            decode(&[0xff, 0xff, 0xff, 0xff]),
+            Err(DecoderError::InvalidHuffmanCode)
+        );
+        assert_eq!(decode(&[0]), Err(DecoderError::InvalidHuffmanCode));
+    }
+}
+
+/*
+// uncomment to run benchmarks
+#[cfg(test)]
+mod bench {
+    extern crate test;
+
+    use self::test::{black_box, Bencher};
+    use super::*;
+
+    use crate::hpack::huffman::encode;
+
+    fn decode_input(b: &mut Bencher, input: &[u8]) {
+        let mut encoded = BytesMut::new();
+        encode(input, &mut encoded);
+
+        let mut scratch = BytesMut::with_capacity(input.len() * 2);
+        b.bytes = encoded.len() as u64;
+        b.iter(|| {
+            let decoded = decode(black_box(encoded.as_ref()), &mut scratch).unwrap();
+            black_box(decoded);
+        });
+    }
+
+    #[bench]
+    fn decode_short_ascii(b: &mut Bencher) {
+        decode_input(b, b"www.example.com");
+    }
+
+    #[bench]
+    fn decode_header_value(b: &mut Bencher) {
+        decode_input(
+            b,
+            b"text/html,application/xhtml+xml,application/xml;q=0.9;q=0.8",
+        );
+    }
+
+    #[bench]
+    fn decode_long_ascii(b: &mut Bencher) {
+        decode_input(
+            b,
+            b"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:16.0) Gecko/20100101 Firefox/16.0",
+        );
+    }
+
+    #[bench]
+    fn decode_all_octets(b: &mut Bencher) {
+        let input: Vec<_> = (0..=u8::MAX).collect();
+        decode_input(b, &input);
+    }
+}
+*/