unsplit 之后前后两段对调了

bytes = "=1.12.1"

use bytes::{BufMut, BytesMut};

#[path = "../common.rs"]
mod common;
use common::*;

fn fresh() -> BytesMut {
  let mut buf = BytesMut::with_capacity(64);
  buf.put_slice(b"aaabbbcccddd");
  buf
}

fn show(name: &str, buf: &BytesMut, d: Delta) {
  println!("{name:<28} {:?} len={} cap={}  {d}", std::str::from_utf8(buf).unwrap(), buf.len(), buf.capacity());
}

fn main() {
  // 1. 顺序对：前一段 unsplit 后一段
  let mut head = fresh();
  let tail = head.split_off(6);
  let (_, d) = count(|| head.unsplit(tail));
  show("head.unsplit(tail)", &head, d);

  // 2. 顺序反了：后一段 unsplit 前一段
  let mut tail = fresh();
  let head = tail.split_to(6);
  let (_, d) = count(|| tail.unsplit(head));
  show("tail.unsplit(head)", &tail, d);

  // 3. 顺序反了，用 try_unsplit：失败交回来，由调用方决定
  let mut tail = fresh();
  let head = tail.split_to(6);
  let (r, d) = count(|| tail.try_unsplit(head));
  match r {
    Ok(()) => show("tail.try_unsplit(head) Ok", &tail, d),
    Err(mut head) => {
      let (r2, d2) = count(|| head.try_unsplit(tail));
      println!("{:<28} Err {d}; swap -> {:?}", "tail.try_unsplit(head)", r2.is_ok());
      show("  head.try_unsplit(tail)", &head, d2);
    }
  }

  // 4. split_off 的位置超过 len，再并回来：后面那段容量丢了
  let mut buf = BytesMut::with_capacity(64);
  buf.put_slice(b"hello");
  let tail = buf.split_off(16);
  let (_, d) = count(|| buf.unsplit(tail));
  show("split_off(16) past len=5", &buf, d);

  // 5. 切出去的那段自己扩容过（#532）：不再相邻，退回拷贝
  let mut head = fresh();
  let mut tail = head.split_off(head.len() - 1); // tail: len=1 cap=53
  tail.put_bytes(b'z', 60); // 超过 53，tail reserve 到新的一块
  let (_, d) = count(|| head.unsplit(tail));
  println!("{:<28} len={} cap={}  {d}", "tail grew, then unsplit", head.len(), head.capacity());

  // 6. try_unsplit 对容量为 0 的 other 直接 Ok，不管它从哪来
  let mut buf = fresh();
  let (r, d) = count(|| buf.try_unsplit(BytesMut::new()));
  println!("{:<28} {:?}  {d}", "try_unsplit(BytesMut::new())", r.map_err(|_| ()));

  // 7. 对空的 BytesMut split，也会提升，分配 40 字节的 Shared
  let mut empty = BytesMut::new();
  let (part, d) = count(|| empty.split());
  println!("{:<28} part.len={} part.cap={}  {d}", "BytesMut::new().split()", part.len(), part.capacity());
  let mut buf = fresh();
  let (part, d) = count(|| buf.split_to(0));
  println!("{:<28} part.len={} part.cap={}  {d}", "split_to(0)", part.len(), part.capacity());
}

head.unsplit(tail)           "aaabbbcccddd" len=12 cap=64  alloc+0 realloc+0 (0B) free+0
tail.unsplit(head)           "cccdddaaabbb" len=12 cap=58  alloc+0 realloc+0 (0B) free+0
tail.try_unsplit(head)       Err alloc+0 realloc+0 (0B) free+0; swap -> true
  head.try_unsplit(tail)     "aaabbbcccddd" len=12 cap=64  alloc+0 realloc+0 (0B) free+0
split_off(16) past len=5     "hello" len=5 cap=16  alloc+0 realloc+0 (0B) free+0
tail grew, then unsplit      len=72 cap=128  alloc+0 realloc+1 (128B) free+1
try_unsplit(BytesMut::new()) Ok(())  alloc+0 realloc+0 (0B) free+0
BytesMut::new().split()      part.len=0 part.cap=0  alloc+1 realloc+0 (40B) free+0
split_to(0)                  part.len=0 part.cap=0  alloc+1 realloc+0 (40B) free+0

    pub fn unsplit(&mut self, other: BytesMut) {
        if self.is_empty() {
            *self = other;
            return;
        }

        if let Err(other) = self.try_unsplit(other) {
            self.extend_from_slice(other.as_ref());
        }
    }

        if other.capacity() == 0 {
            return Ok(());
        }