mirror of
https://github.com/tokio-rs/bytes.git
synced 2026-08-08 00:00:26 +02:00
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Eliza Weisman
|
612e0d8601 |
+39
-78
@@ -7,13 +7,11 @@ on:
|
||||
push:
|
||||
branches:
|
||||
- master
|
||||
schedule:
|
||||
- cron: '0 2 * * 0'
|
||||
|
||||
env:
|
||||
RUSTFLAGS: -Dwarnings
|
||||
RUST_BACKTRACE: 1
|
||||
nightly: nightly-2024-09-15
|
||||
nightly: nightly-2021-04-13
|
||||
|
||||
defaults:
|
||||
run:
|
||||
@@ -25,11 +23,11 @@ jobs:
|
||||
name: rustfmt
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install Rust
|
||||
run: rustup update stable
|
||||
run: rustup update stable && rustup default stable
|
||||
- name: Check formatting
|
||||
run: cargo fmt --all --check
|
||||
run: cargo fmt --all -- --check
|
||||
|
||||
# TODO
|
||||
# # Apply clippy lints
|
||||
@@ -37,7 +35,7 @@ jobs:
|
||||
# name: clippy
|
||||
# runs-on: ubuntu-latest
|
||||
# steps:
|
||||
# - uses: actions/checkout@v4
|
||||
# - uses: actions/checkout@v2
|
||||
# - name: Apply clippy lints
|
||||
# run: cargo clippy --all-features
|
||||
|
||||
@@ -50,11 +48,11 @@ jobs:
|
||||
name: minrust
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install cargo-hack
|
||||
uses: taiki-e/install-action@cargo-hack
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install Rust
|
||||
run: rustup update 1.39.0 && rustup default 1.39.0
|
||||
- name: Check
|
||||
run: cargo hack check --feature-powerset --optional-deps --rust-version
|
||||
run: . ci/test-stable.sh check
|
||||
|
||||
# Stable
|
||||
stable:
|
||||
@@ -63,109 +61,73 @@ jobs:
|
||||
matrix:
|
||||
os:
|
||||
- ubuntu-latest
|
||||
- ubuntu-22.04-arm # TODO: update to 24.04 when https://github.com/rust-lang/rust/issues/135867 solved
|
||||
- macos-latest
|
||||
- windows-latest
|
||||
runs-on: ${{ matrix.os }}
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install Rust
|
||||
# --no-self-update is necessary because the windows environment cannot self-update rustup.exe.
|
||||
run: rustup update stable --no-self-update
|
||||
- name: Install cargo-hack
|
||||
uses: taiki-e/install-action@cargo-hack
|
||||
run: rustup update stable --no-self-update && rustup default stable
|
||||
- name: Test
|
||||
run: ci/test-stable.sh test
|
||||
run: . ci/test-stable.sh test
|
||||
|
||||
# Nightly
|
||||
nightly:
|
||||
name: nightly
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install Rust
|
||||
run: rustup update $nightly && rustup default $nightly
|
||||
- name: Install cargo-hack
|
||||
uses: taiki-e/install-action@cargo-hack
|
||||
- name: Test
|
||||
run: ci/test-stable.sh test
|
||||
|
||||
panic-abort:
|
||||
name: panic=abort tests
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install Rust
|
||||
run: rustup update $nightly && rustup default $nightly
|
||||
- name: Run tests with -Cpanic=abort
|
||||
run: ci/panic-abort.sh
|
||||
run: . ci/test-stable.sh test
|
||||
|
||||
# Run tests on some extra platforms
|
||||
cross:
|
||||
name: cross
|
||||
strategy:
|
||||
matrix:
|
||||
include:
|
||||
- target: i686-unknown-linux-gnu
|
||||
os: ubuntu-latest
|
||||
- target: armv7-unknown-linux-gnueabihf
|
||||
os: ubuntu-22.04-arm # TODO: update to 24.04 when https://github.com/rust-lang/rust/issues/135867 solved
|
||||
- target: powerpc-unknown-linux-gnu
|
||||
os: ubuntu-latest
|
||||
- target: powerpc64-unknown-linux-gnu
|
||||
os: ubuntu-latest
|
||||
- target: wasm32-wasip1
|
||||
os: ubuntu-latest
|
||||
runs-on: ${{ matrix.os }}
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install Rust
|
||||
run: rustup update stable
|
||||
- uses: taiki-e/setup-cross-toolchain-action@v1
|
||||
with:
|
||||
target: ${{ matrix.target }}
|
||||
- name: Test
|
||||
run: cargo test --target ${{ matrix.target }}
|
||||
|
||||
# Build for no_std environment.
|
||||
no-std:
|
||||
target:
|
||||
- i686-unknown-linux-gnu
|
||||
- armv7-unknown-linux-gnueabihf
|
||||
- powerpc-unknown-linux-gnu
|
||||
- powerpc64-unknown-linux-gnu
|
||||
- wasm32-unknown-unknown
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install Rust
|
||||
run: rustup update stable
|
||||
- name: Install cargo-hack
|
||||
uses: taiki-e/install-action@cargo-hack
|
||||
# thumbv6m-none-eabi supports atomic, but not atomic CAS.
|
||||
# thumbv7m-none-eabi supports atomic CAS.
|
||||
- run: rustup target add thumbv6m-none-eabi thumbv7m-none-eabi
|
||||
# * --optional-deps is needed for serde feature
|
||||
# * --no-dev-deps is needed to avoid https://github.com/rust-lang/cargo/issues/4866
|
||||
- run: cargo hack build --target thumbv7m-none-eabi --feature-powerset --skip std,default --optional-deps --no-dev-deps
|
||||
# A sound way to provide atomic CAS on platforms without native atomic CAS is system-dependent.
|
||||
# portable-atomic provides major ways via cfgs and accepts user-defined implementations via critical-section feature.
|
||||
- run: cargo hack build --target thumbv6m-none-eabi --feature-powerset --skip std,default --optional-deps --no-dev-deps --features extra-platforms,extra-platforms/critical-section
|
||||
run: rustup update stable && rustup default stable
|
||||
- name: cross build --target ${{ matrix.target }}
|
||||
run: |
|
||||
cargo install cross
|
||||
cross build --target ${{ matrix.target }}
|
||||
if: matrix.target != 'wasm32-unknown-unknown'
|
||||
# WASM support
|
||||
- name: cargo build --target ${{ matrix.target }}
|
||||
run: |
|
||||
rustup target add ${{ matrix.target }}
|
||||
cargo build --target ${{ matrix.target }}
|
||||
if: matrix.target == 'wasm32-unknown-unknown'
|
||||
|
||||
# Sanitizers
|
||||
tsan:
|
||||
name: tsan
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install Rust
|
||||
run: rustup update $nightly && rustup default $nightly
|
||||
- name: Install rust-src
|
||||
run: rustup component add rust-src
|
||||
- name: ASAN / TSAN
|
||||
run: ci/tsan.sh
|
||||
|
||||
run: . ci/tsan.sh
|
||||
miri:
|
||||
name: miri
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install Rust
|
||||
run: rustup update $nightly && rustup default $nightly
|
||||
- uses: actions/checkout@v2
|
||||
- name: Miri
|
||||
run: ci/miri.sh
|
||||
|
||||
@@ -174,7 +136,7 @@ jobs:
|
||||
name: loom
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install Rust
|
||||
run: rustup update $nightly && rustup default $nightly
|
||||
- name: Loom tests
|
||||
@@ -190,13 +152,12 @@ jobs:
|
||||
- minrust
|
||||
- cross
|
||||
- tsan
|
||||
- miri
|
||||
- loom
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install Rust
|
||||
run: rustup update $nightly && rustup default $nightly
|
||||
run: rustup update stable && rustup default stable
|
||||
- name: Build documentation
|
||||
run: cargo doc --no-deps --all-features
|
||||
env:
|
||||
|
||||
-246
@@ -1,249 +1,3 @@
|
||||
# 1.11.0 (November 14th, 2025)
|
||||
|
||||
- Bump MSRV to 1.57 (#788)
|
||||
|
||||
### Fixed
|
||||
|
||||
- fix: `BytesMut` only reuse if src has remaining (#803)
|
||||
- Specialize `BytesMut::put::<Bytes>` (#793)
|
||||
- Reserve capacity in `BytesMut::put` (#794)
|
||||
- Change `BytesMut::remaining_mut` to use `isize::MAX` instead of `usize::MAX` (#795)
|
||||
|
||||
### Internal changes
|
||||
|
||||
- Guarantee address in `slice()` for empty slices. (#780)
|
||||
- Rename `Vtable::to_*` -> `Vtable::into_*` (#776)
|
||||
- Fix latest clippy warnings (#787)
|
||||
- Ignore `BytesMut::freeze` doctest on wasm (#790)
|
||||
- Move `drop_fn` of `from_owner` into vtable (#801)
|
||||
|
||||
# 1.10.1 (March 5th, 2025)
|
||||
|
||||
### Fixed
|
||||
|
||||
- Fix memory leak when using `to_vec` with `Bytes::from_owner` (#773)
|
||||
|
||||
# 1.10.0 (February 3rd, 2025)
|
||||
|
||||
### Added
|
||||
|
||||
- Add feature to support platforms without atomic CAS (#467)
|
||||
- `try_get_*` methods for `Buf` trait (#753)
|
||||
- Implement `Buf::chunks_vectored` for `Take` (#617)
|
||||
- Implement `Buf::chunks_vectored` for `VecDeque<u8>` (#708)
|
||||
|
||||
### Fixed
|
||||
|
||||
- Remove incorrect guarantee for `chunks_vectored` (#754)
|
||||
- Ensure that tests pass under `panic=abort` (#749)
|
||||
|
||||
# 1.9.0 (November 27, 2024)
|
||||
|
||||
### Added
|
||||
|
||||
- Add `Bytes::from_owner` to enable externally-allocated memory (#742)
|
||||
|
||||
### Documented
|
||||
|
||||
- Fix typo in Buf::chunk() comment (#744)
|
||||
|
||||
### Internal changes
|
||||
|
||||
- Replace BufMut::put with BufMut::put_slice in Writer impl (#745)
|
||||
- Rename hex_impl! to fmt_impl! and reuse it for fmt::Debug (#743)
|
||||
|
||||
# 1.8.0 (October 21, 2024)
|
||||
|
||||
- Guarantee address in `split_off`/`split_to` for empty slices (#740)
|
||||
|
||||
# 1.7.2 (September 17, 2024)
|
||||
|
||||
### Fixed
|
||||
|
||||
- Fix default impl of `Buf::{get_int, get_int_le}` (#732)
|
||||
|
||||
### Documented
|
||||
|
||||
- Fix double spaces in comments and doc comments (#731)
|
||||
|
||||
### Internal changes
|
||||
|
||||
- Ensure BytesMut::advance reduces capacity (#728)
|
||||
|
||||
# 1.7.1 (August 1, 2024)
|
||||
|
||||
This release reverts the following change due to a regression:
|
||||
|
||||
- Reuse capacity when possible in `<BytesMut as Buf>::advance` impl (#698)
|
||||
|
||||
The revert can be found at #726.
|
||||
|
||||
# 1.7.0 (July 31, 2024)
|
||||
|
||||
### Added
|
||||
|
||||
- Add conversion from `Bytes` to `BytesMut` (#695, #710)
|
||||
- Add reclaim method without additional allocation (#686)
|
||||
|
||||
### Documented
|
||||
|
||||
- Clarify how `BytesMut::zeroed` works (#714)
|
||||
- Clarify the behavior of `Buf::chunk` (#717)
|
||||
|
||||
### Changed
|
||||
|
||||
- Change length condition of `BytesMut::truncate`
|
||||
- Reuse capacity when possible in `<BytesMut as Buf>::advance` impl (#698)
|
||||
- Improve `must_use` suggestion of `BytesMut::split` (#699)
|
||||
|
||||
### Internal changes
|
||||
|
||||
- Use `ManuallyDrop` instead of `mem::forget` (#678)
|
||||
- Don't set `len` in `BytesMut::reserve` (#682)
|
||||
- Optimize `Bytes::copy_to_bytes` (#688)
|
||||
- Refactor `BytesMut::truncate` (#694)
|
||||
- Refactor `BytesMut::resize` (#696)
|
||||
- Reorder assertion in `Bytes::split_to`, `Bytes::split_off` (#689, #693)
|
||||
- Use `offset_from` in more places (#705)
|
||||
- Correct the wrong usage of `IntoIter` (#707)
|
||||
|
||||
# 1.6.1 (July 13, 2024)
|
||||
|
||||
This release fixes a bug where `Bytes::is_unique` returns incorrect values when
|
||||
the `Bytes` originates from a shared `BytesMut`. (#718)
|
||||
|
||||
# 1.6.0 (March 22, 2024)
|
||||
|
||||
### Added
|
||||
|
||||
- Add `Bytes::is_unique` (#643)
|
||||
|
||||
### Documented
|
||||
|
||||
- Fix changelog typo (#628)
|
||||
- Fix some spelling mistakes (#633)
|
||||
- Typo fix (#637)
|
||||
- Fix broken links (#639)
|
||||
- Add security policy (#649)
|
||||
|
||||
### Internal changes
|
||||
|
||||
- Move comment to correct constant (#629)
|
||||
- Various cleanup (#635)
|
||||
- Simplify `UninitSlice::as_uninit_slice_mut()` logic (#644)
|
||||
- Use `self.` instead of `Self::` (#642)
|
||||
- `BytesMut`: Assert alignment of `Shared` (#652)
|
||||
- Remove unnecessary namespace qualifier (#660)
|
||||
- Remove an unnecessary else branch (#662)
|
||||
- Remove unreachable else branch (#661)
|
||||
- make parameter mut in `From<Vec>` (#667)
|
||||
- Restore commented tests (#665)
|
||||
- Use `sub` instead of `offset` (#668)
|
||||
- Calculate original capacity only if necessary (#666)
|
||||
- `set_vec_pos` does not need a second parameter (#672)
|
||||
- `get_vec_pos`: use `&self` instead of `&mut self` (#670)
|
||||
- Refactor `split_at`/`split_to` (#663)
|
||||
- Use `Iterator` from the prelude (#673)
|
||||
- `copy_to_bytes`: Add panic section to docs (#676)
|
||||
- Remove redundant reserve call (#674)
|
||||
- Use `ManuallyDrop` instead of `mem::forget` (#675)
|
||||
|
||||
|
||||
# 1.5.0 (September 7, 2023)
|
||||
|
||||
### Added
|
||||
|
||||
- Add `UninitSlice::{new,uninit}` (#598, #599)
|
||||
- Implement `BufMut` for `&mut [MaybeUninit<u8>]` (#597)
|
||||
|
||||
### Changed
|
||||
|
||||
- Mark `BytesMut::extend_from_slice` as inline (#595)
|
||||
|
||||
# 1.4.0 (January 31, 2023)
|
||||
|
||||
### Added
|
||||
|
||||
- Make `IntoIter` constructor public (#581)
|
||||
|
||||
### Fixed
|
||||
|
||||
- Avoid large reallocations when freezing `BytesMut` (#592)
|
||||
|
||||
### Documented
|
||||
|
||||
- Document which functions require `std` (#591)
|
||||
- Fix duplicate "the the" typos (#585)
|
||||
|
||||
# 1.3.0 (November 20, 2022)
|
||||
|
||||
### Added
|
||||
|
||||
- Rename and expose `BytesMut::spare_capacity_mut` (#572)
|
||||
- Implement native-endian get and put functions for `Buf` and `BufMut` (#576)
|
||||
|
||||
### Fixed
|
||||
|
||||
- Don't have important data in unused capacity when calling reserve (#563)
|
||||
|
||||
### Documented
|
||||
|
||||
- `Bytes::new` etc should return `Self` not `Bytes` (#568)
|
||||
|
||||
# 1.2.1 (July 30, 2022)
|
||||
|
||||
### Fixed
|
||||
|
||||
- Fix unbounded memory growth when using `reserve` (#560)
|
||||
|
||||
# 1.2.0 (July 19, 2022)
|
||||
|
||||
### Added
|
||||
|
||||
- Add `BytesMut::zeroed` (#517)
|
||||
- Implement `Extend<Bytes>` for `BytesMut` (#527)
|
||||
- Add conversion from `BytesMut` to `Vec<u8>` (#543, #554)
|
||||
- Add conversion from `Bytes` to `Vec<u8>` (#547)
|
||||
- Add `UninitSlice::as_uninit_slice_mut()` (#548)
|
||||
- Add const to `Bytes::{len,is_empty}` (#514)
|
||||
|
||||
### Changed
|
||||
|
||||
- Reuse vector in `BytesMut::reserve` (#539, #544)
|
||||
|
||||
### Fixed
|
||||
|
||||
- Make miri happy (#515, #523, #542, #545, #553)
|
||||
- Make tsan happy (#541)
|
||||
- Fix `remaining_mut()` on chain (#488)
|
||||
- Fix amortized asymptotics of `BytesMut` (#555)
|
||||
|
||||
### Documented
|
||||
|
||||
- Redraw layout diagram with box drawing characters (#539)
|
||||
- Clarify `BytesMut::unsplit` docs (#535)
|
||||
|
||||
# 1.1.0 (August 25, 2021)
|
||||
|
||||
### Added
|
||||
|
||||
- `BufMut::put_bytes(self, val, cnt)` (#487)
|
||||
- Implement `From<Box<[u8]>>` for `Bytes` (#504)
|
||||
|
||||
### Changed
|
||||
|
||||
- Override `put_slice` for `&mut [u8]` (#483)
|
||||
- Panic on integer overflow in `Chain::remaining` (#482)
|
||||
- Add inline tags to `UninitSlice` methods (#443)
|
||||
- Override `copy_to_bytes` for Chain and Take (#481)
|
||||
- Keep capacity when unsplit on empty other buf (#502)
|
||||
|
||||
### Documented
|
||||
|
||||
- Clarify `BufMut` allocation guarantees (#501)
|
||||
- Clarify `BufMut::put_int` behavior (#486)
|
||||
- Clarify actions of `clear` and `truncate`. (#508)
|
||||
|
||||
# 1.0.1 (January 11, 2021)
|
||||
|
||||
### Changed
|
||||
|
||||
+8
-15
@@ -2,21 +2,23 @@
|
||||
|
||||
name = "bytes"
|
||||
# When releasing to crates.io:
|
||||
# - Update html_root_url.
|
||||
# - Update CHANGELOG.md.
|
||||
# - Create "v1.x.y" git tag.
|
||||
version = "1.11.0"
|
||||
edition = "2021"
|
||||
rust-version = "1.57"
|
||||
# - Update doc URL.
|
||||
# - Create "v1.0.x" git tag.
|
||||
version = "1.0.1"
|
||||
license = "MIT"
|
||||
authors = [
|
||||
"Carl Lerche <[email protected]>",
|
||||
"Sean McArthur <[email protected]>",
|
||||
]
|
||||
description = "Types and traits for working with bytes"
|
||||
documentation = "https://docs.rs/bytes/1.0.1/bytes/"
|
||||
repository = "https://github.com/tokio-rs/bytes"
|
||||
readme = "README.md"
|
||||
keywords = ["buffers", "zero-copy", "io"]
|
||||
categories = ["network-programming", "data-structures"]
|
||||
edition = "2018"
|
||||
|
||||
[features]
|
||||
default = ["std"]
|
||||
@@ -24,22 +26,13 @@ std = []
|
||||
|
||||
[dependencies]
|
||||
serde = { version = "1.0.60", optional = true, default-features = false, features = ["alloc"] }
|
||||
# Use portable-atomic crate to support platforms without atomic CAS.
|
||||
# See "no_std support" section in readme for more information.
|
||||
#
|
||||
# Enable require-cas feature to provide a better error message if the end user forgets to use the cfg or feature.
|
||||
extra-platforms = { package = "portable-atomic", version = "1.3", optional = true, default-features = false, features = ["require-cas"] }
|
||||
tracing = { version = "0.1.26", default-features = false }
|
||||
|
||||
[dev-dependencies]
|
||||
serde_test = "1.0"
|
||||
|
||||
[target.'cfg(loom)'.dev-dependencies]
|
||||
loom = "0.7"
|
||||
loom = "0.5"
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
rustdoc-args = ["--cfg", "docsrs"]
|
||||
|
||||
[lints.rust]
|
||||
unexpected_cfgs = { level = "warn", check-cfg = [
|
||||
'cfg(loom)',
|
||||
] }
|
||||
|
||||
@@ -27,21 +27,6 @@ Next, add this to your crate:
|
||||
use bytes::{Bytes, BytesMut, Buf, BufMut};
|
||||
```
|
||||
|
||||
## no_std support
|
||||
|
||||
To use `bytes` with no_std environment, disable the (enabled by default) `std` feature.
|
||||
|
||||
```toml
|
||||
[dependencies]
|
||||
bytes = { version = "1", default-features = false }
|
||||
```
|
||||
|
||||
To use `bytes` with no_std environment without atomic CAS, such as thumbv6m, you also need to enable
|
||||
the `extra-platforms` feature. See the [documentation for the `portable-atomic`
|
||||
crate](https://docs.rs/portable-atomic) for more information.
|
||||
|
||||
The MSRV when `extra-platforms` feature is enabled depends on the MSRV of `portable-atomic`.
|
||||
|
||||
## Serde support
|
||||
|
||||
Serde support is optional and disabled by default. To enable use the feature `serde`.
|
||||
@@ -51,17 +36,6 @@ Serde support is optional and disabled by default. To enable use the feature `se
|
||||
bytes = { version = "1", features = ["serde"] }
|
||||
```
|
||||
|
||||
The MSRV when `serde` feature is enabled depends on the MSRV of `serde`.
|
||||
|
||||
## Building documentation
|
||||
|
||||
When building the `bytes` documentation the `docsrs` option should be used, otherwise
|
||||
feature gates will not be shown. This requires a nightly toolchain:
|
||||
|
||||
```
|
||||
RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc
|
||||
```
|
||||
|
||||
## License
|
||||
|
||||
This project is licensed under the [MIT license](LICENSE).
|
||||
|
||||
@@ -1,9 +0,0 @@
|
||||
# Security Policy
|
||||
|
||||
Bytes is part of the Tokio project and uses the same security policy as [Tokio][tokio-security].
|
||||
|
||||
## Report a security issue
|
||||
|
||||
The process for reporting an issue is the same as for [Tokio][tokio-security]. This includes private reporting via security@tokio.rs.
|
||||
|
||||
[tokio-security]: https://github.com/tokio-rs/tokio/security/policy
|
||||
+1
-1
@@ -46,7 +46,7 @@ impl TestBuf {
|
||||
}
|
||||
impl Buf for TestBuf {
|
||||
fn remaining(&self) -> usize {
|
||||
self.buf.len() - self.pos
|
||||
return self.buf.len() - self.pos;
|
||||
}
|
||||
fn advance(&mut self, cnt: usize) {
|
||||
self.pos += cnt;
|
||||
|
||||
+3
-4
@@ -47,7 +47,7 @@ fn clone_static(b: &mut Bencher) {
|
||||
|
||||
b.iter(|| {
|
||||
for _ in 0..1024 {
|
||||
test::black_box(test::black_box(&bytes).clone());
|
||||
test::black_box(&bytes.clone());
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -58,7 +58,7 @@ fn clone_shared(b: &mut Bencher) {
|
||||
|
||||
b.iter(|| {
|
||||
for _ in 0..1024 {
|
||||
test::black_box(test::black_box(&bytes).clone());
|
||||
test::black_box(&bytes.clone());
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -70,7 +70,7 @@ fn clone_arc_vec(b: &mut Bencher) {
|
||||
|
||||
b.iter(|| {
|
||||
for _ in 0..1024 {
|
||||
test::black_box(test::black_box(&bytes).clone());
|
||||
test::black_box(&bytes.clone());
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -88,7 +88,6 @@ fn from_long_slice(b: &mut Bencher) {
|
||||
#[bench]
|
||||
fn slice_empty(b: &mut Bencher) {
|
||||
b.iter(|| {
|
||||
// `clone` is to convert to ARC
|
||||
let b = Bytes::from(vec![17; 1024]).clone();
|
||||
for i in 0..1000 {
|
||||
test::black_box(b.slice(i % 100..i % 100));
|
||||
|
||||
+4
-3
@@ -1,10 +1,11 @@
|
||||
#!/bin/bash
|
||||
set -e
|
||||
|
||||
MIRI_NIGHTLY=nightly-$(curl -s https://rust-lang.github.io/rustup-components-history/x86_64-unknown-linux-gnu/miri)
|
||||
echo "Installing latest nightly with Miri: $MIRI_NIGHTLY"
|
||||
rustup set profile minimal
|
||||
rustup default "$MIRI_NIGHTLY"
|
||||
rustup component add miri
|
||||
cargo miri setup
|
||||
|
||||
export MIRIFLAGS="-Zmiri-strict-provenance"
|
||||
|
||||
cargo miri test
|
||||
cargo miri test --target mips64-unknown-linux-gnuabi64
|
||||
|
||||
@@ -1,4 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
set -ex
|
||||
RUSTFLAGS="$RUSTFLAGS -Cpanic=abort -Zpanic-abort-tests" cargo test --all-features --test '*'
|
||||
Executable → Regular
+7
-5
@@ -4,6 +4,9 @@ set -ex
|
||||
|
||||
cmd="${1:-test}"
|
||||
|
||||
# Install cargo-hack for feature flag test
|
||||
cargo install cargo-hack
|
||||
|
||||
# Run with each feature
|
||||
# * --each-feature includes both default/no-default features
|
||||
# * --optional-deps is needed for serde feature
|
||||
@@ -11,15 +14,14 @@ cargo hack "${cmd}" --each-feature --optional-deps
|
||||
# Run with all features
|
||||
cargo "${cmd}" --all-features
|
||||
|
||||
cargo doc --no-deps --all-features
|
||||
|
||||
if [[ "${RUST_VERSION}" == "nightly"* ]]; then
|
||||
# Check benchmarks
|
||||
cargo check --benches
|
||||
|
||||
# Check minimal versions
|
||||
# Remove dev-dependencies from Cargo.toml to prevent the next `cargo update`
|
||||
# from determining minimal versions based on dev-dependencies.
|
||||
cargo hack --remove-dev-deps --workspace
|
||||
# Update Cargo.lock to minimal version dependencies.
|
||||
cargo update -Z minimal-versions
|
||||
cargo clean
|
||||
cargo update -Zminimal-versions
|
||||
cargo check --all-features
|
||||
fi
|
||||
|
||||
Executable → Regular
@@ -1 +0,0 @@
|
||||
msrv = "1.57"
|
||||
+78
-1966
File diff suppressed because it is too large
Load Diff
+74
-655
File diff suppressed because it is too large
Load Diff
+8
-5
@@ -1,5 +1,5 @@
|
||||
use crate::buf::{IntoIter, UninitSlice};
|
||||
use crate::{Buf, BufMut};
|
||||
use crate::{Buf, BufMut, Bytes};
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
use std::io::IoSlice;
|
||||
@@ -25,7 +25,9 @@ use std::io::IoSlice;
|
||||
/// assert_eq!(full[..], b"hello world"[..]);
|
||||
/// ```
|
||||
///
|
||||
/// [`Buf::chain`]: Buf::chain
|
||||
/// [`Buf::chain`]: trait.Buf.html#method.chain
|
||||
/// [`Buf`]: trait.Buf.html
|
||||
/// [`BufMut`]: trait.BufMut.html
|
||||
#[derive(Debug)]
|
||||
pub struct Chain<T, U> {
|
||||
a: T,
|
||||
@@ -133,7 +135,7 @@ where
|
||||
U: Buf,
|
||||
{
|
||||
fn remaining(&self) -> usize {
|
||||
self.a.remaining().saturating_add(self.b.remaining())
|
||||
self.a.remaining().checked_add(self.b.remaining()).unwrap()
|
||||
}
|
||||
|
||||
fn chunk(&self) -> &[u8] {
|
||||
@@ -169,7 +171,7 @@ where
|
||||
n
|
||||
}
|
||||
|
||||
fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
|
||||
fn copy_to_bytes(&mut self, len: usize) -> Bytes {
|
||||
let a_rem = self.a.remaining();
|
||||
if a_rem >= len {
|
||||
self.a.copy_to_bytes(len)
|
||||
@@ -196,7 +198,8 @@ where
|
||||
fn remaining_mut(&self) -> usize {
|
||||
self.a
|
||||
.remaining_mut()
|
||||
.saturating_add(self.b.remaining_mut())
|
||||
.checked_add(self.b.remaining_mut())
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
fn chunk_mut(&mut self) -> &mut UninitSlice {
|
||||
|
||||
+6
-1
@@ -2,6 +2,8 @@ use crate::Buf;
|
||||
|
||||
/// Iterator over the bytes contained by the buffer.
|
||||
///
|
||||
/// This struct is created by the [`iter`] method on [`Buf`].
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// Basic usage:
|
||||
@@ -17,6 +19,9 @@ use crate::Buf;
|
||||
/// assert_eq!(iter.next(), Some(b'c'));
|
||||
/// assert_eq!(iter.next(), None);
|
||||
/// ```
|
||||
///
|
||||
/// [`iter`]: trait.Buf.html#method.iter
|
||||
/// [`Buf`]: trait.Buf.html
|
||||
#[derive(Debug)]
|
||||
pub struct IntoIter<T> {
|
||||
inner: T,
|
||||
@@ -38,7 +43,7 @@ impl<T> IntoIter<T> {
|
||||
/// assert_eq!(iter.next(), Some(b'c'));
|
||||
/// assert_eq!(iter.next(), None);
|
||||
/// ```
|
||||
pub fn new(inner: T) -> IntoIter<T> {
|
||||
pub(crate) fn new(inner: T) -> IntoIter<T> {
|
||||
IntoIter { inner }
|
||||
}
|
||||
|
||||
|
||||
@@ -13,6 +13,8 @@
|
||||
//! See [`Buf`] and [`BufMut`] for more details.
|
||||
//!
|
||||
//! [rope]: https://en.wikipedia.org/wiki/Rope_(data_structure)
|
||||
//! [`Buf`]: trait.Buf.html
|
||||
//! [`BufMut`]: trait.BufMut.html
|
||||
|
||||
mod buf_impl;
|
||||
mod buf_mut;
|
||||
|
||||
+1
-1
@@ -5,7 +5,7 @@ use std::{cmp, io};
|
||||
/// A `Buf` adapter which implements `io::Read` for the inner value.
|
||||
///
|
||||
/// This struct is generally created by calling `reader()` on `Buf`. See
|
||||
/// documentation of [`reader()`](Buf::reader) for more
|
||||
/// documentation of [`reader()`](trait.Buf.html#method.reader) for more
|
||||
/// details.
|
||||
#[derive(Debug)]
|
||||
pub struct Reader<B> {
|
||||
|
||||
+3
-35
@@ -1,14 +1,11 @@
|
||||
use crate::Buf;
|
||||
use crate::{Buf, Bytes};
|
||||
|
||||
use core::cmp;
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
use std::io::IoSlice;
|
||||
|
||||
/// A `Buf` adapter which limits the bytes read from an underlying buffer.
|
||||
///
|
||||
/// This struct is generally created by calling `take()` on `Buf`. See
|
||||
/// documentation of [`take()`](Buf::take) for more details.
|
||||
/// documentation of [`take()`](trait.Buf.html#method.take) for more details.
|
||||
#[derive(Debug)]
|
||||
pub struct Take<T> {
|
||||
inner: T,
|
||||
@@ -148,40 +145,11 @@ impl<T: Buf> Buf for Take<T> {
|
||||
self.limit -= cnt;
|
||||
}
|
||||
|
||||
fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
|
||||
fn copy_to_bytes(&mut self, len: usize) -> Bytes {
|
||||
assert!(len <= self.remaining(), "`len` greater than remaining");
|
||||
|
||||
let r = self.inner.copy_to_bytes(len);
|
||||
self.limit -= len;
|
||||
r
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
|
||||
if self.limit == 0 {
|
||||
return 0;
|
||||
}
|
||||
|
||||
const LEN: usize = 16;
|
||||
let mut slices: [IoSlice<'a>; LEN] = [IoSlice::new(&[]); LEN];
|
||||
|
||||
let cnt = self
|
||||
.inner
|
||||
.chunks_vectored(&mut slices[..dst.len().min(LEN)]);
|
||||
let mut limit = self.limit;
|
||||
for (i, (dst, slice)) in dst[..cnt].iter_mut().zip(slices.iter()).enumerate() {
|
||||
if let Some(buf) = slice.get(..limit) {
|
||||
// SAFETY: We could do this safely with `IoSlice::advance` if we had a larger MSRV.
|
||||
let buf = unsafe { std::mem::transmute::<&[u8], &'a [u8]>(buf) };
|
||||
*dst = IoSlice::new(buf);
|
||||
return i + 1;
|
||||
} else {
|
||||
// SAFETY: We could do this safely with `IoSlice::advance` if we had a larger MSRV.
|
||||
let buf = unsafe { std::mem::transmute::<&[u8], &'a [u8]>(slice) };
|
||||
*dst = IoSlice::new(buf);
|
||||
limit -= slice.len();
|
||||
}
|
||||
}
|
||||
cnt
|
||||
}
|
||||
}
|
||||
|
||||
+6
-80
@@ -22,44 +22,6 @@ use core::ops::{
|
||||
pub struct UninitSlice([MaybeUninit<u8>]);
|
||||
|
||||
impl UninitSlice {
|
||||
/// Creates a `&mut UninitSlice` wrapping a slice of initialised memory.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::buf::UninitSlice;
|
||||
///
|
||||
/// let mut buffer = [0u8; 64];
|
||||
/// let slice = UninitSlice::new(&mut buffer[..]);
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn new(slice: &mut [u8]) -> &mut UninitSlice {
|
||||
unsafe { &mut *(slice as *mut [u8] as *mut [MaybeUninit<u8>] as *mut UninitSlice) }
|
||||
}
|
||||
|
||||
/// Creates a `&mut UninitSlice` wrapping a slice of uninitialised memory.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::buf::UninitSlice;
|
||||
/// use core::mem::MaybeUninit;
|
||||
///
|
||||
/// let mut buffer = [MaybeUninit::uninit(); 64];
|
||||
/// let slice = UninitSlice::uninit(&mut buffer[..]);
|
||||
///
|
||||
/// let mut vec = Vec::with_capacity(1024);
|
||||
/// let spare: &mut UninitSlice = vec.spare_capacity_mut().into();
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn uninit(slice: &mut [MaybeUninit<u8>]) -> &mut UninitSlice {
|
||||
unsafe { &mut *(slice as *mut [MaybeUninit<u8>] as *mut UninitSlice) }
|
||||
}
|
||||
|
||||
fn uninit_ref(slice: &[MaybeUninit<u8>]) -> &UninitSlice {
|
||||
unsafe { &*(slice as *const [MaybeUninit<u8>] as *const UninitSlice) }
|
||||
}
|
||||
|
||||
/// Create a `&mut UninitSlice` from a pointer and a length.
|
||||
///
|
||||
/// # Safety
|
||||
@@ -82,7 +44,7 @@ impl UninitSlice {
|
||||
pub unsafe fn from_raw_parts_mut<'a>(ptr: *mut u8, len: usize) -> &'a mut UninitSlice {
|
||||
let maybe_init: &mut [MaybeUninit<u8>] =
|
||||
core::slice::from_raw_parts_mut(ptr as *mut _, len);
|
||||
Self::uninit(maybe_init)
|
||||
&mut *(maybe_init as *mut [MaybeUninit<u8>] as *mut UninitSlice)
|
||||
}
|
||||
|
||||
/// Write a single byte at the specified offset.
|
||||
@@ -110,7 +72,7 @@ impl UninitSlice {
|
||||
unsafe { self[index..].as_mut_ptr().write(byte) }
|
||||
}
|
||||
|
||||
/// Copies bytes from `src` into `self`.
|
||||
/// Copies bytes from `src` into `self`.
|
||||
///
|
||||
/// The length of `src` must be the same as `self`.
|
||||
///
|
||||
@@ -162,32 +124,6 @@ impl UninitSlice {
|
||||
self.0.as_mut_ptr() as *mut _
|
||||
}
|
||||
|
||||
/// Return a `&mut [MaybeUninit<u8>]` to this slice's buffer.
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
/// The caller **must not** read from the referenced memory and **must not** write
|
||||
/// **uninitialized** bytes to the slice either. This is because `BufMut` implementation
|
||||
/// that created the `UninitSlice` knows which parts are initialized. Writing uninitialized
|
||||
/// bytes to the slice may cause the `BufMut` to read those bytes and trigger undefined
|
||||
/// behavior.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::BufMut;
|
||||
///
|
||||
/// let mut data = [0, 1, 2];
|
||||
/// let mut slice = &mut data[..];
|
||||
/// unsafe {
|
||||
/// let uninit_slice = BufMut::chunk_mut(&mut slice).as_uninit_slice_mut();
|
||||
/// };
|
||||
/// ```
|
||||
#[inline]
|
||||
pub unsafe fn as_uninit_slice_mut(&mut self) -> &mut [MaybeUninit<u8>] {
|
||||
&mut self.0
|
||||
}
|
||||
|
||||
/// Returns the number of bytes in the slice.
|
||||
///
|
||||
/// # Examples
|
||||
@@ -213,18 +149,6 @@ impl fmt::Debug for UninitSlice {
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<&'a mut [u8]> for &'a mut UninitSlice {
|
||||
fn from(slice: &'a mut [u8]) -> Self {
|
||||
UninitSlice::new(slice)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<&'a mut [MaybeUninit<u8>]> for &'a mut UninitSlice {
|
||||
fn from(slice: &'a mut [MaybeUninit<u8>]) -> Self {
|
||||
UninitSlice::uninit(slice)
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! impl_index {
|
||||
($($t:ty),*) => {
|
||||
$(
|
||||
@@ -233,14 +157,16 @@ macro_rules! impl_index {
|
||||
|
||||
#[inline]
|
||||
fn index(&self, index: $t) -> &UninitSlice {
|
||||
UninitSlice::uninit_ref(&self.0[index])
|
||||
let maybe_uninit: &[MaybeUninit<u8>] = &self.0[index];
|
||||
unsafe { &*(maybe_uninit as *const [MaybeUninit<u8>] as *const UninitSlice) }
|
||||
}
|
||||
}
|
||||
|
||||
impl IndexMut<$t> for UninitSlice {
|
||||
#[inline]
|
||||
fn index_mut(&mut self, index: $t) -> &mut UninitSlice {
|
||||
UninitSlice::uninit(&mut self.0[index])
|
||||
let maybe_uninit: &mut [MaybeUninit<u8>] = &mut self.0[index];
|
||||
unsafe { &mut *(maybe_uninit as *mut [MaybeUninit<u8>] as *mut UninitSlice) }
|
||||
}
|
||||
}
|
||||
)*
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
use alloc::collections::VecDeque;
|
||||
#[cfg(feature = "std")]
|
||||
use std::io;
|
||||
|
||||
use super::Buf;
|
||||
|
||||
@@ -18,22 +16,6 @@ impl Buf for VecDeque<u8> {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
fn chunks_vectored<'a>(&'a self, dst: &mut [io::IoSlice<'a>]) -> usize {
|
||||
if self.is_empty() || dst.is_empty() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
let (s1, s2) = self.as_slices();
|
||||
dst[0] = io::IoSlice::new(s1);
|
||||
if s2.is_empty() || dst.len() == 1 {
|
||||
return 1;
|
||||
}
|
||||
|
||||
dst[1] = io::IoSlice::new(s2);
|
||||
2
|
||||
}
|
||||
|
||||
fn advance(&mut self, cnt: usize) {
|
||||
self.drain(..cnt);
|
||||
}
|
||||
|
||||
+2
-2
@@ -5,7 +5,7 @@ use std::{cmp, io};
|
||||
/// A `BufMut` adapter which implements `io::Write` for the inner value.
|
||||
///
|
||||
/// This struct is generally created by calling `writer()` on `BufMut`. See
|
||||
/// documentation of [`writer()`](BufMut::writer) for more
|
||||
/// documentation of [`writer()`](trait.BufMut.html#method.writer) for more
|
||||
/// details.
|
||||
#[derive(Debug)]
|
||||
pub struct Writer<B> {
|
||||
@@ -78,7 +78,7 @@ impl<B: BufMut + Sized> io::Write for Writer<B> {
|
||||
fn write(&mut self, src: &[u8]) -> io::Result<usize> {
|
||||
let n = cmp::min(self.buf.remaining_mut(), src.len());
|
||||
|
||||
self.buf.put_slice(&src[..n]);
|
||||
self.buf.put(&src[0..n]);
|
||||
Ok(n)
|
||||
}
|
||||
|
||||
|
||||
+100
-624
File diff suppressed because it is too large
Load Diff
+205
-559
File diff suppressed because it is too large
Load Diff
+12
-3
@@ -25,7 +25,7 @@ impl Debug for BytesRef<'_> {
|
||||
} else if b == b'\0' {
|
||||
write!(f, "\\0")?;
|
||||
// ASCII printable
|
||||
} else if (0x20..0x7f).contains(&b) {
|
||||
} else if b >= 0x20 && b < 0x7f {
|
||||
write!(f, "{}", b as char)?;
|
||||
} else {
|
||||
write!(f, "\\x{:02x}", b)?;
|
||||
@@ -36,5 +36,14 @@ impl Debug for BytesRef<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
fmt_impl!(Debug, Bytes);
|
||||
fmt_impl!(Debug, BytesMut);
|
||||
impl Debug for Bytes {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> Result {
|
||||
Debug::fmt(&BytesRef(&self.as_ref()), f)
|
||||
}
|
||||
}
|
||||
|
||||
impl Debug for BytesMut {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> Result {
|
||||
Debug::fmt(&BytesRef(&self.as_ref()), f)
|
||||
}
|
||||
}
|
||||
|
||||
+14
-4
@@ -21,7 +21,17 @@ impl UpperHex for BytesRef<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
fmt_impl!(LowerHex, Bytes);
|
||||
fmt_impl!(LowerHex, BytesMut);
|
||||
fmt_impl!(UpperHex, Bytes);
|
||||
fmt_impl!(UpperHex, BytesMut);
|
||||
macro_rules! hex_impl {
|
||||
($tr:ident, $ty:ty) => {
|
||||
impl $tr for $ty {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> Result {
|
||||
$tr::fmt(&BytesRef(self.as_ref()), f)
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
hex_impl!(LowerHex, Bytes);
|
||||
hex_impl!(LowerHex, BytesMut);
|
||||
hex_impl!(UpperHex, Bytes);
|
||||
hex_impl!(UpperHex, BytesMut);
|
||||
|
||||
@@ -1,13 +1,3 @@
|
||||
macro_rules! fmt_impl {
|
||||
($tr:ident, $ty:ty) => {
|
||||
impl $tr for $ty {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> Result {
|
||||
$tr::fmt(&BytesRef(self.as_ref()), f)
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
mod debug;
|
||||
mod hex;
|
||||
|
||||
|
||||
+9
-74
@@ -3,15 +3,18 @@
|
||||
no_crate_inject,
|
||||
attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
|
||||
))]
|
||||
#![doc(html_root_url = "https://docs.rs/bytes/1.0.1")]
|
||||
#![no_std]
|
||||
#![cfg_attr(docsrs, feature(doc_cfg))]
|
||||
|
||||
//! Provides abstractions for working with bytes.
|
||||
//!
|
||||
//! The `bytes` crate provides an efficient byte buffer structure
|
||||
//! ([`Bytes`]) and traits for working with buffer
|
||||
//! ([`Bytes`](struct.Bytes.html)) and traits for working with buffer
|
||||
//! implementations ([`Buf`], [`BufMut`]).
|
||||
//!
|
||||
//! [`Buf`]: trait.Buf.html
|
||||
//! [`BufMut`]: trait.BufMut.html
|
||||
//!
|
||||
//! # `Bytes`
|
||||
//!
|
||||
//! `Bytes` is an efficient container for storing and operating on contiguous
|
||||
@@ -49,7 +52,9 @@
|
||||
//! `a` and `b` will share the underlying buffer and maintain indices tracking
|
||||
//! the view into the buffer represented by the handle.
|
||||
//!
|
||||
//! See the [struct docs](`Bytes`) for more details.
|
||||
//! See the [struct docs] for more details.
|
||||
//!
|
||||
//! [struct docs]: struct.Bytes.html
|
||||
//!
|
||||
//! # `Buf`, `BufMut`
|
||||
//!
|
||||
@@ -65,7 +70,7 @@
|
||||
//! ## Relation with `Read` and `Write`
|
||||
//!
|
||||
//! At first glance, it may seem that `Buf` and `BufMut` overlap in
|
||||
//! functionality with [`std::io::Read`] and [`std::io::Write`]. However, they
|
||||
//! functionality with `std::io::Read` and `std::io::Write`. However, they
|
||||
//! serve different purposes. A buffer is the value that is provided as an
|
||||
//! argument to `Read::read` and `Write::write`. `Read` and `Write` may then
|
||||
//! perform a syscall, which has the potential of failing. Operations on `Buf`
|
||||
@@ -110,73 +115,3 @@ fn abort() -> ! {
|
||||
panic!("abort");
|
||||
}
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
#[cfg(feature = "std")]
|
||||
fn saturating_sub_usize_u64(a: usize, b: u64) -> usize {
|
||||
match usize::try_from(b) {
|
||||
Ok(b) => a.saturating_sub(b),
|
||||
Err(_) => 0,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
#[cfg(feature = "std")]
|
||||
fn min_u64_usize(a: u64, b: usize) -> usize {
|
||||
match usize::try_from(a) {
|
||||
Ok(a) => usize::min(a, b),
|
||||
Err(_) => b,
|
||||
}
|
||||
}
|
||||
|
||||
/// Error type for the `try_get_` methods of [`Buf`].
|
||||
/// Indicates that there were not enough remaining
|
||||
/// bytes in the buffer while attempting
|
||||
/// to get a value from a [`Buf`] with one
|
||||
/// of the `try_get_` methods.
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub struct TryGetError {
|
||||
/// The number of bytes necessary to get the value
|
||||
pub requested: usize,
|
||||
|
||||
/// The number of bytes available in the buffer
|
||||
pub available: usize,
|
||||
}
|
||||
|
||||
impl core::fmt::Display for TryGetError {
|
||||
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
|
||||
write!(
|
||||
f,
|
||||
"Not enough bytes remaining in buffer to read value (requested {} but only {} available)",
|
||||
self.requested,
|
||||
self.available
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
impl std::error::Error for TryGetError {}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
impl From<TryGetError> for std::io::Error {
|
||||
fn from(error: TryGetError) -> Self {
|
||||
std::io::Error::new(std::io::ErrorKind::Other, error)
|
||||
}
|
||||
}
|
||||
|
||||
/// Panic with a nice error message.
|
||||
#[cold]
|
||||
fn panic_advance(error_info: &TryGetError) -> ! {
|
||||
panic!(
|
||||
"advance out of bounds: the len is {} but advancing by {}",
|
||||
error_info.available, error_info.requested
|
||||
);
|
||||
}
|
||||
|
||||
#[cold]
|
||||
fn panic_does_not_fit(size: usize, nbytes: usize) -> ! {
|
||||
panic!(
|
||||
"size too large: the integer type can fit {} bytes, but nbytes is {}",
|
||||
size, nbytes
|
||||
);
|
||||
}
|
||||
|
||||
+2
-5
@@ -1,10 +1,7 @@
|
||||
#[cfg(not(all(test, loom)))]
|
||||
pub(crate) mod sync {
|
||||
pub(crate) mod atomic {
|
||||
#[cfg(not(feature = "extra-platforms"))]
|
||||
pub(crate) use core::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
|
||||
#[cfg(feature = "extra-platforms")]
|
||||
pub(crate) use extra_platforms::{AtomicPtr, AtomicUsize, Ordering};
|
||||
pub(crate) use core::sync::atomic::{fence, AtomicPtr, AtomicUsize, Ordering};
|
||||
|
||||
pub(crate) trait AtomicMut<T> {
|
||||
fn with_mut<F, R>(&mut self, f: F) -> R
|
||||
@@ -26,7 +23,7 @@ pub(crate) mod sync {
|
||||
#[cfg(all(test, loom))]
|
||||
pub(crate) mod sync {
|
||||
pub(crate) mod atomic {
|
||||
pub(crate) use loom::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
|
||||
pub(crate) use loom::sync::atomic::{fence, AtomicPtr, AtomicUsize, Ordering};
|
||||
|
||||
pub(crate) trait AtomicMut<T> {}
|
||||
}
|
||||
|
||||
+69
-388
@@ -1,413 +1,77 @@
|
||||
#![warn(rust_2018_idioms)]
|
||||
|
||||
use ::bytes::{Buf, Bytes, BytesMut};
|
||||
use core::{cmp, mem};
|
||||
use std::collections::VecDeque;
|
||||
use bytes::Buf;
|
||||
#[cfg(feature = "std")]
|
||||
use std::io::IoSlice;
|
||||
|
||||
// A random 64-byte ascii string, with the first 8 bytes altered to
|
||||
// give valid representations of f32 and f64 (making them easier to compare)
|
||||
// and negative signed numbers when interpreting as big endian
|
||||
// (testing Sign Extension for `Buf::get_int' and `Buf::get_int_ne`).
|
||||
const INPUT: &[u8] = b"\xffFqrjrDqPhvTc45vvq33f6bJrUtyHESuTeklWKgYd64xgzxJwvAkpYYnpNJyZSRn";
|
||||
#[test]
|
||||
fn test_fresh_cursor_vec() {
|
||||
let mut buf = &b"hello"[..];
|
||||
|
||||
macro_rules! e {
|
||||
($big_endian_val:expr, $little_endian_val:expr) => {
|
||||
if cfg!(target_endian = "big") {
|
||||
$big_endian_val
|
||||
} else {
|
||||
$little_endian_val
|
||||
}
|
||||
};
|
||||
assert_eq!(buf.remaining(), 5);
|
||||
assert_eq!(buf.chunk(), b"hello");
|
||||
|
||||
buf.advance(2);
|
||||
|
||||
assert_eq!(buf.remaining(), 3);
|
||||
assert_eq!(buf.chunk(), b"llo");
|
||||
|
||||
buf.advance(3);
|
||||
|
||||
assert_eq!(buf.remaining(), 0);
|
||||
assert_eq!(buf.chunk(), b"");
|
||||
}
|
||||
|
||||
macro_rules! buf_tests {
|
||||
($make_input:ident) => {
|
||||
buf_tests!($make_input, true);
|
||||
};
|
||||
($make_input:ident, $checks_vectored_is_complete:expr) => {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn empty_state() {
|
||||
let buf = $make_input(&[]);
|
||||
assert_eq!(buf.remaining(), 0);
|
||||
assert!(!buf.has_remaining());
|
||||
assert!(buf.chunk().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fresh_state() {
|
||||
let buf = $make_input(INPUT);
|
||||
assert_eq!(buf.remaining(), 64);
|
||||
assert!(buf.has_remaining());
|
||||
|
||||
let chunk = buf.chunk();
|
||||
assert!(chunk.len() <= 64);
|
||||
assert!(INPUT.starts_with(chunk));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn advance() {
|
||||
let mut buf = $make_input(INPUT);
|
||||
buf.advance(8);
|
||||
assert_eq!(buf.remaining(), 64 - 8);
|
||||
assert!(buf.has_remaining());
|
||||
|
||||
let chunk = buf.chunk();
|
||||
assert!(chunk.len() <= 64 - 8);
|
||||
assert!(INPUT[8..].starts_with(chunk));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn advance_to_end() {
|
||||
let mut buf = $make_input(INPUT);
|
||||
buf.advance(64);
|
||||
assert_eq!(buf.remaining(), 0);
|
||||
assert!(!buf.has_remaining());
|
||||
|
||||
let chunk = buf.chunk();
|
||||
assert!(chunk.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn advance_past_end() {
|
||||
let mut buf = $make_input(INPUT);
|
||||
buf.advance(65);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(feature = "std")]
|
||||
fn chunks_vectored_empty() {
|
||||
let buf = $make_input(&[]);
|
||||
let mut bufs = [IoSlice::new(&[]); 16];
|
||||
|
||||
let n = buf.chunks_vectored(&mut bufs);
|
||||
assert_eq!(n, 0);
|
||||
assert!(bufs.iter().all(|buf| buf.is_empty()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(feature = "std")]
|
||||
fn chunks_vectored_is_complete() {
|
||||
let buf = $make_input(INPUT);
|
||||
let mut bufs = [IoSlice::new(&[]); 16];
|
||||
|
||||
let n = buf.chunks_vectored(&mut bufs);
|
||||
assert!(n > 0);
|
||||
assert!(n <= 16);
|
||||
|
||||
let bufs_concat = bufs[..n]
|
||||
.iter()
|
||||
.flat_map(|b| b.iter().copied())
|
||||
.collect::<Vec<u8>>();
|
||||
if $checks_vectored_is_complete {
|
||||
assert_eq!(bufs_concat, INPUT);
|
||||
} else {
|
||||
// If this panics then `buf` implements `chunks_vectored`.
|
||||
// Remove the `false` argument from `buf_tests!` for that type.
|
||||
assert!(bufs_concat.len() < INPUT.len());
|
||||
assert!(INPUT.starts_with(&bufs_concat));
|
||||
}
|
||||
|
||||
for i in n..16 {
|
||||
assert!(bufs[i].is_empty());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn copy_to_slice() {
|
||||
let mut buf = $make_input(INPUT);
|
||||
|
||||
let mut chunk = [0u8; 8];
|
||||
buf.copy_to_slice(&mut chunk);
|
||||
assert_eq!(buf.remaining(), 64 - 8);
|
||||
assert!(buf.has_remaining());
|
||||
assert_eq!(chunk, INPUT[..8]);
|
||||
|
||||
let chunk = buf.chunk();
|
||||
assert!(chunk.len() <= 64 - 8);
|
||||
assert!(INPUT[8..].starts_with(chunk));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn copy_to_slice_big() {
|
||||
let mut buf = $make_input(INPUT);
|
||||
|
||||
let mut chunk = [0u8; 56];
|
||||
buf.copy_to_slice(&mut chunk);
|
||||
assert_eq!(buf.remaining(), 64 - 56);
|
||||
assert!(buf.has_remaining());
|
||||
assert_eq!(chunk, INPUT[..56]);
|
||||
|
||||
let chunk = buf.chunk();
|
||||
assert!(chunk.len() <= 64 - 56);
|
||||
assert!(INPUT[56..].starts_with(chunk));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn copy_to_slice_to_end() {
|
||||
let mut buf = $make_input(INPUT);
|
||||
|
||||
let mut chunk = [0u8; 64];
|
||||
buf.copy_to_slice(&mut chunk);
|
||||
assert_eq!(buf.remaining(), 0);
|
||||
assert!(!buf.has_remaining());
|
||||
assert_eq!(chunk, INPUT);
|
||||
|
||||
assert!(buf.chunk().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn copy_to_slice_overflow() {
|
||||
let mut buf = $make_input(INPUT);
|
||||
|
||||
let mut chunk = [0u8; 65];
|
||||
buf.copy_to_slice(&mut chunk);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn copy_to_bytes() {
|
||||
let mut buf = $make_input(INPUT);
|
||||
|
||||
let chunk = buf.copy_to_bytes(8);
|
||||
assert_eq!(buf.remaining(), 64 - 8);
|
||||
assert!(buf.has_remaining());
|
||||
assert_eq!(chunk, INPUT[..8]);
|
||||
|
||||
let chunk = buf.chunk();
|
||||
assert!(chunk.len() <= 64 - 8);
|
||||
assert!(INPUT[8..].starts_with(chunk));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn copy_to_bytes_big() {
|
||||
let mut buf = $make_input(INPUT);
|
||||
|
||||
let chunk = buf.copy_to_bytes(56);
|
||||
assert_eq!(buf.remaining(), 64 - 56);
|
||||
assert!(buf.has_remaining());
|
||||
assert_eq!(chunk, INPUT[..56]);
|
||||
|
||||
let chunk = buf.chunk();
|
||||
assert!(chunk.len() <= 64 - 56);
|
||||
assert!(INPUT[56..].starts_with(chunk));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn copy_to_bytes_to_end() {
|
||||
let mut buf = $make_input(INPUT);
|
||||
|
||||
let chunk = buf.copy_to_bytes(64);
|
||||
assert_eq!(buf.remaining(), 0);
|
||||
assert!(!buf.has_remaining());
|
||||
assert_eq!(chunk, INPUT);
|
||||
|
||||
assert!(buf.chunk().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn copy_to_bytes_overflow() {
|
||||
let mut buf = $make_input(INPUT);
|
||||
|
||||
let _ = buf.copy_to_bytes(65);
|
||||
}
|
||||
|
||||
buf_tests!(number $make_input, get_u8, get_u8_overflow, u8, get_u8, 0xff);
|
||||
buf_tests!(number $make_input, get_i8, get_i8_overflow, i8, get_i8, 0xffu8 as i8);
|
||||
buf_tests!(number $make_input, get_u16_be, get_u16_be_overflow, u16, get_u16, 0xff46);
|
||||
buf_tests!(number $make_input, get_u16_le, get_u16_le_overflow, u16, get_u16_le, 0x46ff);
|
||||
buf_tests!(number $make_input, get_u16_ne, get_u16_ne_overflow, u16, get_u16_ne, e!(0xff46, 0x46ff));
|
||||
buf_tests!(number $make_input, get_i16_be, get_i16_be_overflow, i16, get_i16, 0xff46u16 as i16);
|
||||
buf_tests!(number $make_input, get_i16_le, get_i16_le_overflow, i16, get_i16_le, 0x46ff);
|
||||
buf_tests!(number $make_input, get_i16_ne, get_i16_ne_overflow, i16, get_i16_ne, e!(0xff46u16 as i16, 0x46ff));
|
||||
buf_tests!(number $make_input, get_u32_be, get_u32_be_overflow, u32, get_u32, 0xff467172);
|
||||
buf_tests!(number $make_input, get_u32_le, get_u32_le_overflow, u32, get_u32_le, 0x727146ff);
|
||||
buf_tests!(number $make_input, get_u32_ne, get_u32_ne_overflow, u32, get_u32_ne, e!(0xff467172, 0x727146ff));
|
||||
buf_tests!(number $make_input, get_i32_be, get_i32_be_overflow, i32, get_i32, 0xff467172u32 as i32);
|
||||
buf_tests!(number $make_input, get_i32_le, get_i32_le_overflow, i32, get_i32_le, 0x727146ff);
|
||||
buf_tests!(number $make_input, get_i32_ne, get_i32_ne_overflow, i32, get_i32_ne, e!(0xff467172u32 as i32, 0x727146ff));
|
||||
buf_tests!(number $make_input, get_u64_be, get_u64_be_overflow, u64, get_u64, 0xff4671726a724471);
|
||||
buf_tests!(number $make_input, get_u64_le, get_u64_le_overflow, u64, get_u64_le, 0x7144726a727146ff);
|
||||
buf_tests!(number $make_input, get_u64_ne, get_u64_ne_overflow, u64, get_u64_ne, e!(0xff4671726a724471, 0x7144726a727146ff));
|
||||
buf_tests!(number $make_input, get_i64_be, get_i64_be_overflow, i64, get_i64, 0xff4671726a724471u64 as i64);
|
||||
buf_tests!(number $make_input, get_i64_le, get_i64_le_overflow, i64, get_i64_le, 0x7144726a727146ff);
|
||||
buf_tests!(number $make_input, get_i64_ne, get_i64_ne_overflow, i64, get_i64_ne, e!(0xff4671726a724471u64 as i64, 0x7144726a727146ff));
|
||||
buf_tests!(number $make_input, get_u128_be, get_u128_be_overflow, u128, get_u128, 0xff4671726a7244715068765463343576);
|
||||
buf_tests!(number $make_input, get_u128_le, get_u128_le_overflow, u128, get_u128_le, 0x76353463547668507144726a727146ff);
|
||||
buf_tests!(number $make_input, get_u128_ne, get_u128_ne_overflow, u128, get_u128_ne, e!(0xff4671726a7244715068765463343576, 0x76353463547668507144726a727146ff));
|
||||
buf_tests!(number $make_input, get_i128_be, get_i128_be_overflow, i128, get_i128, 0xff4671726a7244715068765463343576u128 as i128);
|
||||
buf_tests!(number $make_input, get_i128_le, get_i128_le_overflow, i128, get_i128_le, 0x76353463547668507144726a727146ff);
|
||||
buf_tests!(number $make_input, get_i128_ne, get_i128_ne_overflow, i128, get_i128_ne, e!(0xff4671726a7244715068765463343576u128 as i128, 0x76353463547668507144726a727146ff));
|
||||
buf_tests!(number $make_input, get_f32_be, get_f32_be_overflow, f32, get_f32, f32::from_bits(0xff467172));
|
||||
buf_tests!(number $make_input, get_f32_le, get_f32_le_overflow, f32, get_f32_le, f32::from_bits(0x727146ff));
|
||||
buf_tests!(number $make_input, get_f32_ne, get_f32_ne_overflow, f32, get_f32_ne, f32::from_bits(e!(0xff467172, 0x727146ff)));
|
||||
buf_tests!(number $make_input, get_f64_be, get_f64_be_overflow, f64, get_f64, f64::from_bits(0xff4671726a724471));
|
||||
buf_tests!(number $make_input, get_f64_le, get_f64_le_overflow, f64, get_f64_le, f64::from_bits(0x7144726a727146ff));
|
||||
buf_tests!(number $make_input, get_f64_ne, get_f64_ne_overflow, f64, get_f64_ne, f64::from_bits(e!(0xff4671726a724471, 0x7144726a727146ff)));
|
||||
|
||||
buf_tests!(var_number $make_input, get_uint_be, get_uint_be_overflow, u64, get_uint, 3, 0xff4671);
|
||||
buf_tests!(var_number $make_input, get_uint_le, get_uint_le_overflow, u64, get_uint_le, 3, 0x7146ff);
|
||||
buf_tests!(var_number $make_input, get_uint_ne, get_uint_ne_overflow, u64, get_uint_ne, 3, e!(0xff4671, 0x7146ff));
|
||||
buf_tests!(var_number $make_input, get_int_be, get_int_be_overflow, i64, get_int, 3, 0xffffffffffff4671u64 as i64);
|
||||
buf_tests!(var_number $make_input, get_int_le, get_int_le_overflow, i64, get_int_le, 3, 0x7146ff);
|
||||
buf_tests!(var_number $make_input, get_int_ne, get_int_ne_overflow, i64, get_int_ne, 3, e!(0xffffffffffff4671u64 as i64, 0x7146ff));
|
||||
};
|
||||
(number $make_input:ident, $ok_name:ident, $panic_name:ident, $number:ty, $method:ident, $value:expr) => {
|
||||
#[test]
|
||||
fn $ok_name() {
|
||||
let mut buf = $make_input(INPUT);
|
||||
|
||||
let value = buf.$method();
|
||||
assert_eq!(buf.remaining(), 64 - mem::size_of::<$number>());
|
||||
assert!(buf.has_remaining());
|
||||
assert_eq!(value, $value);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn $panic_name() {
|
||||
let mut buf = $make_input(&[]);
|
||||
|
||||
let _ = buf.$method();
|
||||
}
|
||||
};
|
||||
(var_number $make_input:ident, $ok_name:ident, $panic_name:ident, $number:ty, $method:ident, $len:expr, $value:expr) => {
|
||||
#[test]
|
||||
fn $ok_name() {
|
||||
let mut buf = $make_input(INPUT);
|
||||
|
||||
let value = buf.$method($len);
|
||||
assert_eq!(buf.remaining(), 64 - $len);
|
||||
assert!(buf.has_remaining());
|
||||
assert_eq!(value, $value);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn $panic_name() {
|
||||
let mut buf = $make_input(&[]);
|
||||
|
||||
let _ = buf.$method($len);
|
||||
}
|
||||
};
|
||||
#[test]
|
||||
fn test_get_u8() {
|
||||
let mut buf = &b"\x21zomg"[..];
|
||||
assert_eq!(0x21, buf.get_u8());
|
||||
}
|
||||
|
||||
mod u8_slice {
|
||||
fn make_input(buf: &'static [u8]) -> &'static [u8] {
|
||||
buf
|
||||
}
|
||||
|
||||
buf_tests!(make_input);
|
||||
#[test]
|
||||
fn test_get_u16() {
|
||||
let mut buf = &b"\x21\x54zomg"[..];
|
||||
assert_eq!(0x2154, buf.get_u16());
|
||||
let mut buf = &b"\x21\x54zomg"[..];
|
||||
assert_eq!(0x5421, buf.get_u16_le());
|
||||
}
|
||||
|
||||
mod bytes {
|
||||
fn make_input(buf: &'static [u8]) -> impl Buf {
|
||||
Bytes::from_static(buf)
|
||||
}
|
||||
|
||||
buf_tests!(make_input);
|
||||
}
|
||||
|
||||
mod bytes_mut {
|
||||
fn make_input(buf: &'static [u8]) -> impl Buf {
|
||||
BytesMut::from(buf)
|
||||
}
|
||||
|
||||
buf_tests!(make_input);
|
||||
}
|
||||
|
||||
mod vec_deque {
|
||||
fn make_input(buf: &'static [u8]) -> impl Buf {
|
||||
let mut deque = VecDeque::new();
|
||||
|
||||
if !buf.is_empty() {
|
||||
// Construct |b|some bytes|a| `VecDeque`
|
||||
let mid = buf.len() / 2;
|
||||
let (a, b) = buf.split_at(mid);
|
||||
|
||||
deque.reserve_exact(buf.len() + 1);
|
||||
|
||||
let extra_space = deque.capacity() - b.len() - 1;
|
||||
deque.resize(extra_space, 0);
|
||||
|
||||
deque.extend(a);
|
||||
deque.drain(..extra_space);
|
||||
deque.extend(b);
|
||||
|
||||
let (a, b) = deque.as_slices();
|
||||
assert!(
|
||||
!a.is_empty(),
|
||||
"could not setup test - attempt to create discontiguous VecDeque failed"
|
||||
);
|
||||
assert!(
|
||||
!b.is_empty(),
|
||||
"could not setup test - attempt to create discontiguous VecDeque failed"
|
||||
);
|
||||
}
|
||||
|
||||
deque
|
||||
}
|
||||
|
||||
buf_tests!(make_input, true);
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_get_u16_buffer_underflow() {
|
||||
let mut buf = &b"\x21"[..];
|
||||
buf.get_u16();
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
mod cursor {
|
||||
use std::io::Cursor;
|
||||
#[test]
|
||||
fn test_bufs_vec() {
|
||||
let buf = &b"hello world"[..];
|
||||
|
||||
fn make_input(buf: &'static [u8]) -> impl Buf {
|
||||
Cursor::new(buf)
|
||||
}
|
||||
let b1: &[u8] = &mut [];
|
||||
let b2: &[u8] = &mut [];
|
||||
|
||||
buf_tests!(make_input);
|
||||
let mut dst = [IoSlice::new(b1), IoSlice::new(b2)];
|
||||
|
||||
assert_eq!(1, buf.chunks_vectored(&mut dst[..]));
|
||||
}
|
||||
|
||||
mod box_bytes {
|
||||
fn make_input(buf: &'static [u8]) -> impl Buf {
|
||||
Box::new(Bytes::from_static(buf))
|
||||
}
|
||||
#[test]
|
||||
fn test_vec_deque() {
|
||||
use std::collections::VecDeque;
|
||||
|
||||
buf_tests!(make_input);
|
||||
let mut buffer: VecDeque<u8> = VecDeque::new();
|
||||
buffer.extend(b"hello world");
|
||||
assert_eq!(11, buffer.remaining());
|
||||
assert_eq!(b"hello world", buffer.chunk());
|
||||
buffer.advance(6);
|
||||
assert_eq!(b"world", buffer.chunk());
|
||||
buffer.extend(b" piece");
|
||||
let mut out = [0; 11];
|
||||
buffer.copy_to_slice(&mut out);
|
||||
assert_eq!(b"world piece", &out[..]);
|
||||
}
|
||||
|
||||
mod chain_u8_slice {
|
||||
fn make_input(buf: &'static [u8]) -> impl Buf {
|
||||
let (a, b) = buf.split_at(buf.len() / 2);
|
||||
Buf::chain(a, b)
|
||||
}
|
||||
|
||||
buf_tests!(make_input);
|
||||
}
|
||||
|
||||
mod chain_small_big_u8_slice {
|
||||
fn make_input(buf: &'static [u8]) -> impl Buf {
|
||||
let mid = cmp::min(1, buf.len());
|
||||
let (a, b) = buf.split_at(mid);
|
||||
Buf::chain(a, b)
|
||||
}
|
||||
|
||||
buf_tests!(make_input);
|
||||
}
|
||||
|
||||
mod chain_limited_slices {
|
||||
fn make_input(buf: &'static [u8]) -> impl Buf {
|
||||
let buf3 = &buf[cmp::min(buf.len(), 3)..];
|
||||
let a = Buf::take(buf3, 0);
|
||||
let b = Buf::take(buf, 3);
|
||||
let c = Buf::take(buf3, usize::MAX);
|
||||
let d = buf;
|
||||
Buf::take(Buf::chain(Buf::chain(a, b), Buf::chain(c, d)), buf.len())
|
||||
}
|
||||
|
||||
buf_tests!(make_input, true);
|
||||
}
|
||||
|
||||
#[allow(unused_allocation)] // This is intentional.
|
||||
#[test]
|
||||
fn test_deref_buf_forwards() {
|
||||
struct Special;
|
||||
@@ -437,3 +101,20 @@ fn test_deref_buf_forwards() {
|
||||
assert_eq!((Box::new(Special) as Box<dyn Buf>).get_u8(), b'x');
|
||||
assert_eq!(Box::new(Special).get_u8(), b'x');
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn copy_to_bytes_less() {
|
||||
let mut buf = &b"hello world"[..];
|
||||
|
||||
let bytes = buf.copy_to_bytes(5);
|
||||
assert_eq!(bytes, &b"hello"[..]);
|
||||
assert_eq!(buf, &b" world"[..])
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn copy_to_bytes_overflow() {
|
||||
let mut buf = &b"hello world"[..];
|
||||
|
||||
let _bytes = buf.copy_to_bytes(12);
|
||||
}
|
||||
|
||||
+11
-163
@@ -3,13 +3,13 @@
|
||||
use bytes::buf::UninitSlice;
|
||||
use bytes::{BufMut, BytesMut};
|
||||
use core::fmt::Write;
|
||||
use core::mem::MaybeUninit;
|
||||
use core::usize;
|
||||
|
||||
#[test]
|
||||
fn test_vec_as_mut_buf() {
|
||||
let mut buf = Vec::with_capacity(64);
|
||||
|
||||
assert_eq!(buf.remaining_mut(), isize::MAX as usize);
|
||||
assert_eq!(buf.remaining_mut(), usize::MAX);
|
||||
|
||||
assert!(buf.chunk_mut().len() >= 64);
|
||||
|
||||
@@ -17,7 +17,7 @@ fn test_vec_as_mut_buf() {
|
||||
|
||||
assert_eq!(&buf, b"zomg");
|
||||
|
||||
assert_eq!(buf.remaining_mut(), isize::MAX as usize - 4);
|
||||
assert_eq!(buf.remaining_mut(), usize::MAX - 4);
|
||||
assert_eq!(buf.capacity(), 64);
|
||||
|
||||
for _ in 0..16 {
|
||||
@@ -27,14 +27,6 @@ fn test_vec_as_mut_buf() {
|
||||
assert_eq!(buf.len(), 68);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_vec_put_bytes() {
|
||||
let mut buf = Vec::new();
|
||||
buf.push(17);
|
||||
buf.put_bytes(19, 2);
|
||||
assert_eq!([17, 19, 19], &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_put_u8() {
|
||||
let mut buf = Vec::with_capacity(8);
|
||||
@@ -54,35 +46,7 @@ fn test_put_u16() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_put_int() {
|
||||
let mut buf = Vec::with_capacity(8);
|
||||
buf.put_int(0x1020304050607080, 3);
|
||||
assert_eq!(b"\x60\x70\x80", &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_put_int_nbytes_overflow() {
|
||||
let mut buf = Vec::with_capacity(8);
|
||||
buf.put_int(0x1020304050607080, 9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_put_int_le() {
|
||||
let mut buf = Vec::with_capacity(8);
|
||||
buf.put_int_le(0x1020304050607080, 3);
|
||||
assert_eq!(b"\x80\x70\x60", &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_put_int_le_nbytes_overflow() {
|
||||
let mut buf = Vec::with_capacity(8);
|
||||
buf.put_int_le(0x1020304050607080, 9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic(expected = "advance out of bounds: the len is 8 but advancing by 12")]
|
||||
#[should_panic(expected = "cannot advance")]
|
||||
fn test_vec_advance_mut() {
|
||||
// Verify fix for #354
|
||||
let mut buf = Vec::with_capacity(8);
|
||||
@@ -101,123 +65,16 @@ fn test_clone() {
|
||||
assert!(buf != buf2);
|
||||
}
|
||||
|
||||
fn do_test_slice_small<T: ?Sized>(make: impl Fn(&mut [u8]) -> &mut T)
|
||||
where
|
||||
for<'r> &'r mut T: BufMut,
|
||||
{
|
||||
let mut buf = [b'X'; 8];
|
||||
|
||||
let mut slice = make(&mut buf[..]);
|
||||
slice.put_bytes(b'A', 2);
|
||||
slice.put_u8(b'B');
|
||||
slice.put_slice(b"BCC");
|
||||
assert_eq!(2, slice.remaining_mut());
|
||||
assert_eq!(b"AABBCCXX", &buf[..]);
|
||||
|
||||
let mut slice = make(&mut buf[..]);
|
||||
slice.put_u32(0x61626364);
|
||||
assert_eq!(4, slice.remaining_mut());
|
||||
assert_eq!(b"abcdCCXX", &buf[..]);
|
||||
|
||||
let mut slice = make(&mut buf[..]);
|
||||
slice.put_u32_le(0x30313233);
|
||||
assert_eq!(4, slice.remaining_mut());
|
||||
assert_eq!(b"3210CCXX", &buf[..]);
|
||||
}
|
||||
|
||||
fn do_test_slice_large<T: ?Sized>(make: impl Fn(&mut [u8]) -> &mut T)
|
||||
where
|
||||
for<'r> &'r mut T: BufMut,
|
||||
{
|
||||
const LEN: usize = 100;
|
||||
const FILL: [u8; LEN] = [b'Y'; LEN];
|
||||
|
||||
let test = |fill: &dyn Fn(&mut &mut T, usize)| {
|
||||
for buf_len in 0..LEN {
|
||||
let mut buf = [b'X'; LEN];
|
||||
for fill_len in 0..=buf_len {
|
||||
let mut slice = make(&mut buf[..buf_len]);
|
||||
fill(&mut slice, fill_len);
|
||||
assert_eq!(buf_len - fill_len, slice.remaining_mut());
|
||||
let (head, tail) = buf.split_at(fill_len);
|
||||
assert_eq!(&FILL[..fill_len], head);
|
||||
assert!(tail.iter().all(|b| *b == b'X'));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
test(&|slice, fill_len| slice.put_slice(&FILL[..fill_len]));
|
||||
test(&|slice, fill_len| slice.put_bytes(FILL[0], fill_len));
|
||||
}
|
||||
|
||||
fn do_test_slice_put_slice_panics<T: ?Sized>(make: impl Fn(&mut [u8]) -> &mut T)
|
||||
where
|
||||
for<'r> &'r mut T: BufMut,
|
||||
{
|
||||
let mut buf = [b'X'; 4];
|
||||
let mut slice = make(&mut buf[..]);
|
||||
slice.put_slice(b"12345");
|
||||
}
|
||||
|
||||
fn do_test_slice_put_bytes_panics<T: ?Sized>(make: impl Fn(&mut [u8]) -> &mut T)
|
||||
where
|
||||
for<'r> &'r mut T: BufMut,
|
||||
{
|
||||
let mut buf = [b'X'; 4];
|
||||
let mut slice = make(&mut buf[..]);
|
||||
slice.put_bytes(b'1', 5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_slice_buf_mut_small() {
|
||||
do_test_slice_small(|x| x);
|
||||
fn test_mut_slice() {
|
||||
let mut v = vec![0, 0, 0, 0];
|
||||
let mut s = &mut v[..];
|
||||
s.put_u32(42);
|
||||
|
||||
assert_eq!(s.len(), 0);
|
||||
assert_eq!(&v, &[0, 0, 0, 42]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_slice_buf_mut_large() {
|
||||
do_test_slice_large(|x| x);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_slice_buf_mut_put_slice_overflow() {
|
||||
do_test_slice_put_slice_panics(|x| x);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_slice_buf_mut_put_bytes_overflow() {
|
||||
do_test_slice_put_bytes_panics(|x| x);
|
||||
}
|
||||
|
||||
fn make_maybe_uninit_slice(slice: &mut [u8]) -> &mut [MaybeUninit<u8>] {
|
||||
// SAFETY: [u8] has the same layout as [MaybeUninit<u8>].
|
||||
unsafe { core::mem::transmute(slice) }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_maybe_uninit_buf_mut_small() {
|
||||
do_test_slice_small(make_maybe_uninit_slice);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_maybe_uninit_buf_mut_large() {
|
||||
do_test_slice_large(make_maybe_uninit_slice);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_maybe_uninit_buf_mut_put_slice_overflow() {
|
||||
do_test_slice_put_slice_panics(make_maybe_uninit_slice);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_maybe_uninit_buf_mut_put_bytes_overflow() {
|
||||
do_test_slice_put_bytes_panics(make_maybe_uninit_slice);
|
||||
}
|
||||
|
||||
#[allow(unused_allocation)] // This is intentional.
|
||||
#[test]
|
||||
fn test_deref_bufmut_forwards() {
|
||||
struct Special;
|
||||
@@ -273,12 +130,3 @@ fn copy_from_slice_panics_if_different_length_2() {
|
||||
let slice = unsafe { UninitSlice::from_raw_parts_mut(data.as_mut_ptr(), 3) };
|
||||
slice.copy_from_slice(b"abcd");
|
||||
}
|
||||
|
||||
/// Test if with zero capacity BytesMut does not infinitely recurse in put from Buf
|
||||
#[test]
|
||||
fn test_bytes_mut_reuse() {
|
||||
let mut buf = BytesMut::new();
|
||||
buf.put(&[] as &[u8]);
|
||||
let mut buf = BytesMut::new();
|
||||
buf.put(&[1u8, 2, 3] as &[u8]);
|
||||
}
|
||||
|
||||
+100
-846
File diff suppressed because it is too large
Load Diff
@@ -6,7 +6,7 @@
|
||||
use std::alloc::{GlobalAlloc, Layout, System};
|
||||
use std::ptr;
|
||||
|
||||
use bytes::{Bytes, BytesMut};
|
||||
use bytes::Bytes;
|
||||
|
||||
#[global_allocator]
|
||||
static ODD: Odd = Odd;
|
||||
@@ -24,7 +24,8 @@ unsafe impl GlobalAlloc for Odd {
|
||||
};
|
||||
let ptr = System.alloc(new_layout);
|
||||
if !ptr.is_null() {
|
||||
ptr.offset(1)
|
||||
let ptr = ptr.offset(1);
|
||||
ptr
|
||||
} else {
|
||||
ptr
|
||||
}
|
||||
@@ -66,82 +67,3 @@ fn test_bytes_clone_drop() {
|
||||
let b1 = Bytes::from(vec);
|
||||
let _b2 = b1.clone();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytes_into_vec() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test cases where kind == KIND_VEC
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
assert_eq!(Vec::from(b1), vec);
|
||||
|
||||
// Test cases where kind == KIND_ARC, ref_cnt == 1
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
drop(b1.clone());
|
||||
assert_eq!(Vec::from(b1), vec);
|
||||
|
||||
// Test cases where kind == KIND_ARC, ref_cnt == 2
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
let b2 = b1.clone();
|
||||
assert_eq!(Vec::from(b1), vec);
|
||||
|
||||
// Test cases where vtable = SHARED_VTABLE, kind == KIND_ARC, ref_cnt == 1
|
||||
assert_eq!(Vec::from(b2), vec);
|
||||
|
||||
// Test cases where offset != 0
|
||||
let mut b1 = Bytes::from(vec.clone());
|
||||
let b2 = b1.split_off(20);
|
||||
|
||||
assert_eq!(Vec::from(b2), vec[20..]);
|
||||
assert_eq!(Vec::from(b1), vec[..20]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytesmut_from_bytes_vec() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test case where kind == KIND_VEC
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
let b1m = BytesMut::from(b1);
|
||||
assert_eq!(b1m, vec);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytesmut_from_bytes_arc_1() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test case where kind == KIND_ARC, ref_cnt == 1
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
drop(b1.clone());
|
||||
let b1m = BytesMut::from(b1);
|
||||
assert_eq!(b1m, vec);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytesmut_from_bytes_arc_2() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test case where kind == KIND_ARC, ref_cnt == 2
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
let b2 = b1.clone();
|
||||
let b1m = BytesMut::from(b1);
|
||||
assert_eq!(b1m, vec);
|
||||
|
||||
// Test case where vtable = SHARED_VTABLE, kind == KIND_ARC, ref_cnt == 1
|
||||
let b2m = BytesMut::from(b2);
|
||||
assert_eq!(b2m, vec);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytesmut_from_bytes_arc_offset() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test case where offset != 0
|
||||
let mut b1 = Bytes::from(vec.clone());
|
||||
let b2 = b1.split_off(20);
|
||||
let b1m = BytesMut::from(b1);
|
||||
let b2m = BytesMut::from(b2);
|
||||
|
||||
assert_eq!(b2m, vec[20..]);
|
||||
assert_eq!(b1m, vec[..20]);
|
||||
}
|
||||
|
||||
+39
-106
@@ -1,90 +1,61 @@
|
||||
#![cfg(not(miri))]
|
||||
use std::alloc::{GlobalAlloc, Layout, System};
|
||||
use std::ptr::null_mut;
|
||||
use std::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
|
||||
use std::{mem, ptr};
|
||||
|
||||
use bytes::{Buf, Bytes};
|
||||
|
||||
#[global_allocator]
|
||||
static LEDGER: Ledger = Ledger::new();
|
||||
static LEDGER: Ledger = Ledger;
|
||||
|
||||
const LEDGER_LENGTH: usize = 1024 * 1024;
|
||||
struct Ledger;
|
||||
|
||||
struct Ledger {
|
||||
alloc_table: [(AtomicPtr<u8>, AtomicUsize); LEDGER_LENGTH],
|
||||
}
|
||||
|
||||
impl Ledger {
|
||||
const fn new() -> Self {
|
||||
const ELEM: (AtomicPtr<u8>, AtomicUsize) =
|
||||
(AtomicPtr::new(null_mut()), AtomicUsize::new(0));
|
||||
let alloc_table = [ELEM; LEDGER_LENGTH];
|
||||
|
||||
Self { alloc_table }
|
||||
}
|
||||
|
||||
/// Iterate over our table until we find an open entry, then insert into said entry
|
||||
fn insert(&self, ptr: *mut u8, size: usize) {
|
||||
for (entry_ptr, entry_size) in self.alloc_table.iter() {
|
||||
// SeqCst is good enough here, we don't care about perf, i just want to be correct!
|
||||
if entry_ptr
|
||||
.compare_exchange(null_mut(), ptr, Ordering::SeqCst, Ordering::SeqCst)
|
||||
.is_ok()
|
||||
{
|
||||
entry_size.store(size, Ordering::SeqCst);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
panic!("Ledger ran out of space.");
|
||||
}
|
||||
|
||||
fn remove(&self, ptr: *mut u8) -> usize {
|
||||
for (entry_ptr, entry_size) in self.alloc_table.iter() {
|
||||
// set the value to be something that will never try and be deallocated, so that we
|
||||
// don't have any chance of a race condition
|
||||
//
|
||||
// dont worry, LEDGER_LENGTH is really long to compensate for us not reclaiming space
|
||||
if entry_ptr
|
||||
.compare_exchange(
|
||||
ptr,
|
||||
invalid_ptr(usize::MAX),
|
||||
Ordering::SeqCst,
|
||||
Ordering::SeqCst,
|
||||
)
|
||||
.is_ok()
|
||||
{
|
||||
return entry_size.load(Ordering::SeqCst);
|
||||
}
|
||||
}
|
||||
|
||||
panic!("Couldn't find a matching entry for {:x?}", ptr);
|
||||
}
|
||||
}
|
||||
const USIZE_SIZE: usize = mem::size_of::<usize>();
|
||||
|
||||
unsafe impl GlobalAlloc for Ledger {
|
||||
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
|
||||
let size = layout.size();
|
||||
let ptr = System.alloc(layout);
|
||||
self.insert(ptr, size);
|
||||
ptr
|
||||
if layout.align() == 1 && layout.size() > 0 {
|
||||
// Allocate extra space to stash a record of
|
||||
// how much space there was.
|
||||
let orig_size = layout.size();
|
||||
let size = orig_size + USIZE_SIZE;
|
||||
let new_layout = match Layout::from_size_align(size, 1) {
|
||||
Ok(layout) => layout,
|
||||
Err(_err) => return ptr::null_mut(),
|
||||
};
|
||||
let ptr = System.alloc(new_layout);
|
||||
if !ptr.is_null() {
|
||||
(ptr as *mut usize).write(orig_size);
|
||||
let ptr = ptr.offset(USIZE_SIZE as isize);
|
||||
ptr
|
||||
} else {
|
||||
ptr
|
||||
}
|
||||
} else {
|
||||
System.alloc(layout)
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
|
||||
let orig_size = self.remove(ptr);
|
||||
if layout.align() == 1 && layout.size() > 0 {
|
||||
let off_ptr = (ptr as *mut usize).offset(-1);
|
||||
let orig_size = off_ptr.read();
|
||||
if orig_size != layout.size() {
|
||||
panic!(
|
||||
"bad dealloc: alloc size was {}, dealloc size is {}",
|
||||
orig_size,
|
||||
layout.size()
|
||||
);
|
||||
}
|
||||
|
||||
if orig_size != layout.size() {
|
||||
panic!(
|
||||
"bad dealloc: alloc size was {}, dealloc size is {}",
|
||||
orig_size,
|
||||
layout.size()
|
||||
);
|
||||
let new_layout = match Layout::from_size_align(layout.size() + USIZE_SIZE, 1) {
|
||||
Ok(layout) => layout,
|
||||
Err(_err) => std::process::abort(),
|
||||
};
|
||||
System.dealloc(off_ptr as *mut u8, new_layout);
|
||||
} else {
|
||||
System.dealloc(ptr, layout);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytes_advance() {
|
||||
let mut bytes = Bytes::from(vec![10, 20, 30]);
|
||||
@@ -106,41 +77,3 @@ fn test_bytes_truncate_and_advance() {
|
||||
bytes.advance(1);
|
||||
drop(bytes);
|
||||
}
|
||||
|
||||
/// Returns a dangling pointer with the given address. This is used to store
|
||||
/// integer data in pointer fields.
|
||||
#[inline]
|
||||
fn invalid_ptr<T>(addr: usize) -> *mut T {
|
||||
let ptr = std::ptr::null_mut::<u8>().wrapping_add(addr);
|
||||
debug_assert_eq!(ptr as usize, addr);
|
||||
ptr.cast::<T>()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytes_into_vec() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test cases where kind == KIND_VEC
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
assert_eq!(Vec::from(b1), vec);
|
||||
|
||||
// Test cases where kind == KIND_ARC, ref_cnt == 1
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
drop(b1.clone());
|
||||
assert_eq!(Vec::from(b1), vec);
|
||||
|
||||
// Test cases where kind == KIND_ARC, ref_cnt == 2
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
let b2 = b1.clone();
|
||||
assert_eq!(Vec::from(b1), vec);
|
||||
|
||||
// Test cases where vtable = SHARED_VTABLE, kind == KIND_ARC, ref_cnt == 1
|
||||
assert_eq!(Vec::from(b2), vec);
|
||||
|
||||
// Test cases where offset != 0
|
||||
let mut b1 = Bytes::from(vec.clone());
|
||||
let b2 = b1.split_off(20);
|
||||
|
||||
assert_eq!(Vec::from(b2), vec[20..]);
|
||||
assert_eq!(Vec::from(b1), vec[..20]);
|
||||
}
|
||||
|
||||
@@ -133,28 +133,6 @@ fn vectored_read() {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chain_growing_buffer() {
|
||||
let mut buff = [b' '; 10];
|
||||
let mut vec = b"wassup".to_vec();
|
||||
|
||||
let mut chained = (&mut buff[..]).chain_mut(&mut vec).chain_mut(Vec::new()); // Required for potential overflow because remaining_mut for Vec is isize::MAX - vec.len(), but for chain_mut is usize::MAX
|
||||
|
||||
chained.put_slice(b"hey there123123");
|
||||
|
||||
assert_eq!(&buff, b"hey there1");
|
||||
assert_eq!(&vec, b"wassup23123");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chain_overflow_remaining_mut() {
|
||||
let mut chained = Vec::<u8>::new().chain_mut(Vec::new()).chain_mut(Vec::new());
|
||||
|
||||
assert_eq!(chained.remaining_mut(), usize::MAX);
|
||||
chained.put_slice(&[0; 256]);
|
||||
assert_eq!(chained.remaining_mut(), usize::MAX);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chain_get_bytes() {
|
||||
let mut ab = Bytes::copy_from_slice(b"ab");
|
||||
|
||||
+4
-4
@@ -1,11 +1,11 @@
|
||||
#![warn(rust_2018_idioms)]
|
||||
|
||||
use bytes::{buf::IntoIter, Bytes};
|
||||
use bytes::Bytes;
|
||||
|
||||
#[test]
|
||||
fn iter_len() {
|
||||
let buf = Bytes::from_static(b"hello world");
|
||||
let iter = IntoIter::new(buf);
|
||||
let iter = buf.iter();
|
||||
|
||||
assert_eq!(iter.size_hint(), (11, Some(11)));
|
||||
assert_eq!(iter.len(), 11);
|
||||
@@ -13,8 +13,8 @@ fn iter_len() {
|
||||
|
||||
#[test]
|
||||
fn empty_iter_len() {
|
||||
let buf = Bytes::new();
|
||||
let iter = IntoIter::new(buf);
|
||||
let buf = Bytes::from_static(b"");
|
||||
let iter = buf.iter();
|
||||
|
||||
assert_eq!(iter.size_hint(), (0, Some(0)));
|
||||
assert_eq!(iter.len(), 0);
|
||||
|
||||
@@ -1,86 +0,0 @@
|
||||
#![warn(rust_2018_idioms)]
|
||||
|
||||
use bytes::{buf::Limit, BufMut};
|
||||
|
||||
#[test]
|
||||
fn long_limit() {
|
||||
let buf = &mut [0u8; 10];
|
||||
let limit = buf.limit(100);
|
||||
assert_eq!(10, limit.remaining_mut());
|
||||
assert_eq!(&[0u8; 10], &limit.get_ref()[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn limit_get_mut() {
|
||||
let buf = &mut [0u8; 128];
|
||||
let mut limit = buf.limit(10);
|
||||
assert_eq!(10, limit.remaining_mut());
|
||||
assert_eq!(&mut [0u8; 128], &limit.get_mut()[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn limit_set_limit() {
|
||||
let buf = &mut [0u8; 128];
|
||||
let mut limit = buf.limit(10);
|
||||
assert_eq!(10, Limit::limit(&limit));
|
||||
limit.set_limit(5);
|
||||
assert_eq!(5, Limit::limit(&limit));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn limit_chunk_mut() {
|
||||
let buf = &mut [0u8; 20];
|
||||
let mut limit = buf.limit(10);
|
||||
assert_eq!(10, limit.chunk_mut().len());
|
||||
|
||||
let buf = &mut [0u8; 10];
|
||||
let mut limit = buf.limit(20);
|
||||
assert_eq!(10, limit.chunk_mut().len());
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic = "advance out of bounds"]
|
||||
fn limit_advance_mut_panic_1() {
|
||||
let buf = &mut [0u8; 10];
|
||||
let mut limit = buf.limit(100);
|
||||
unsafe {
|
||||
limit.advance_mut(50);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic = "cnt <= self.limit"]
|
||||
fn limit_advance_mut_panic_2() {
|
||||
let buf = &mut [0u8; 100];
|
||||
let mut limit = buf.limit(10);
|
||||
unsafe {
|
||||
limit.advance_mut(50);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn limit_advance_mut() {
|
||||
let buf = &mut [0u8; 100];
|
||||
let mut limit = buf.limit(10);
|
||||
unsafe {
|
||||
limit.advance_mut(5);
|
||||
}
|
||||
assert_eq!(5, limit.remaining_mut());
|
||||
assert_eq!(5, limit.chunk_mut().len());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn limit_into_inner() {
|
||||
let buf_arr = *b"hello world";
|
||||
let buf: &mut [u8] = &mut buf_arr.clone();
|
||||
let mut limit = buf.limit(4);
|
||||
let mut dst = vec![];
|
||||
|
||||
unsafe {
|
||||
limit.advance_mut(2);
|
||||
}
|
||||
|
||||
let buf = limit.into_inner();
|
||||
dst.put(&buf[..]);
|
||||
assert_eq!(*dst, b"llo world"[..]);
|
||||
}
|
||||
@@ -27,12 +27,3 @@ fn buf_read() {
|
||||
reader.read_line(&mut line).unwrap();
|
||||
assert_eq!("world", &line);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn get_mut() {
|
||||
let buf = &b"hello world"[..];
|
||||
let mut reader = buf.reader();
|
||||
let buf_mut = reader.get_mut();
|
||||
assert_eq!(11, buf_mut.remaining());
|
||||
assert_eq!(b"hello world", buf_mut);
|
||||
}
|
||||
|
||||
@@ -30,55 +30,3 @@ fn take_copy_to_bytes_panics() {
|
||||
let abcd = Bytes::copy_from_slice(b"abcd");
|
||||
abcd.take(2).copy_to_bytes(3);
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
#[test]
|
||||
fn take_chunks_vectored() {
|
||||
fn chain() -> impl Buf {
|
||||
Bytes::from([1, 2, 3].to_vec()).chain(Bytes::from([4, 5, 6].to_vec()))
|
||||
}
|
||||
|
||||
{
|
||||
let mut dst = [std::io::IoSlice::new(&[]); 2];
|
||||
let take = chain().take(0);
|
||||
assert_eq!(take.chunks_vectored(&mut dst), 0);
|
||||
}
|
||||
|
||||
{
|
||||
let mut dst = [std::io::IoSlice::new(&[]); 2];
|
||||
let take = chain().take(1);
|
||||
assert_eq!(take.chunks_vectored(&mut dst), 1);
|
||||
assert_eq!(&*dst[0], &[1]);
|
||||
}
|
||||
|
||||
{
|
||||
let mut dst = [std::io::IoSlice::new(&[]); 2];
|
||||
let take = chain().take(3);
|
||||
assert_eq!(take.chunks_vectored(&mut dst), 1);
|
||||
assert_eq!(&*dst[0], &[1, 2, 3]);
|
||||
}
|
||||
|
||||
{
|
||||
let mut dst = [std::io::IoSlice::new(&[]); 2];
|
||||
let take = chain().take(4);
|
||||
assert_eq!(take.chunks_vectored(&mut dst), 2);
|
||||
assert_eq!(&*dst[0], &[1, 2, 3]);
|
||||
assert_eq!(&*dst[1], &[4]);
|
||||
}
|
||||
|
||||
{
|
||||
let mut dst = [std::io::IoSlice::new(&[]); 2];
|
||||
let take = chain().take(6);
|
||||
assert_eq!(take.chunks_vectored(&mut dst), 2);
|
||||
assert_eq!(&*dst[0], &[1, 2, 3]);
|
||||
assert_eq!(&*dst[1], &[4, 5, 6]);
|
||||
}
|
||||
|
||||
{
|
||||
let mut dst = [std::io::IoSlice::new(&[]); 2];
|
||||
let take = chain().take(7);
|
||||
assert_eq!(take.chunks_vectored(&mut dst), 2);
|
||||
assert_eq!(&*dst[0], &[1, 2, 3]);
|
||||
assert_eq!(&*dst[1], &[4, 5, 6]);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user