zerovec 0.11.6: zerovec::ule::VarULE

# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4

[[package]]
name = "sample-zerovec"
version = "1.0.0"
dependencies = [
 "zerovec",
]

[[package]]
name = "zerofrom"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272"

[[package]]
name = "zerovec"
version = "0.11.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239"
dependencies = [
 "zerofrom",
]

[package]
name = "sample-zerovec"
version = "1.0.0"
edition = "2021"
publish = false

[dependencies]
zerovec = "=0.11.6"

[[bin]]
name = "contract"
path = "test/contract.rs"

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify zerovec::ule::VarULE in pkg:cargo/zerovec@0.11.6
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:cargo/zerovec@0.11.6
Demonstrate these symbols/APIs:
  - zerovec::ule::VarULE

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:468864fb0db5375edf848e8af5617041ed60d61fc15002166b414f2d4a6142a8","contract":["VarULE::validate_bytes validates byte length and bit validity for dynamically-sized unaligned little-endian types","VarULE::parse_bytes parses valid byte buffers into typed dynamically-sized references and rejects invalid inputs","VarULE::as_bytes converts dynamically-sized VarULE references back into raw byte slices matching original data","VarULE::from_bytes_unchecked allows unsafe zero-copy casting from validated byte buffers","Custom dynamically-sized types implement VarULE to enforce byte-level validation invariants"],"goal":"verify zerovec::ule::VarULE in pkg:cargo/zerovec@0.11.6","kind":"HOW","packages":["pkg:cargo/zerovec@0.11.6"],"schemaVersion":1,"symbols":["zerovec::ule::VarULE"]},"contractCommand":["cargo","run","--offline"],"environment":{"arch":"x64","distro":"alpine","ecosystem":"cargo","libc":"musl","os":"linux","packageManager":"cargo","schemaVersion":1},"license":"MIT-0","packages":["pkg:cargo/zerovec@0.11.6"],"schemaVersion":1,"subject":"pkg:cargo/zerovec@0.11.6","symbols":["zerovec::ule::VarULE"],"verifierAdapter":"cargo@1"}

{
  "schemaVersion": 1,
  "goal": "verify zerovec::ule::VarULE in pkg:cargo/zerovec@0.11.6",
  "kind": "HOW",
  "packages": [
    "pkg:cargo/zerovec@0.11.6"
  ],
  "symbols": [
    "zerovec::ule::VarULE"
  ]
}

//! Clean-room verification sample for zerovec::ule::VarULE.

pub use zerovec::ule::VarULE;

use core::mem::size_of_val;
use zerovec::ule::{UleError, VarULE};
use zerovec::ZeroSlice;

#[repr(transparent)]
#[derive(Debug, PartialEq, Eq)]
struct AsciiStr(str);

impl AsciiStr {
    #[inline]
    fn as_str(&self) -> &str {
        &self.0
    }
}

unsafe impl VarULE for AsciiStr {
    fn validate_bytes(bytes: &[u8]) -> Result<(), UleError> {
        if bytes.is_ascii() {
            Ok(())
        } else {
            Err(UleError::parse::<Self>())
        }
    }

    #[inline]
    unsafe fn from_bytes_unchecked(bytes: &[u8]) -> &Self {
        &*(core::str::from_utf8_unchecked(bytes) as *const str as *const Self)
    }
}

fn main() {
    // 1. VarULE::validate_bytes validates byte length and bit validity for dynamically-sized unaligned little-endian types
    assert!(<str as VarULE>::validate_bytes(b"hello world").is_ok());
    assert!(<str as VarULE>::validate_bytes(&[0xFF, 0xFE]).is_err());
    let u32_bytes = [1u8, 0, 0, 0, 2, 0, 0, 0];
    assert!(<ZeroSlice<u32> as VarULE>::validate_bytes(&u32_bytes).is_ok());
    assert!(<ZeroSlice<u32> as VarULE>::validate_bytes(&[1u8, 2, 3]).is_err());

    // 2. VarULE::parse_bytes parses valid byte buffers into typed dynamically-sized references and rejects invalid inputs
    let s = <str as VarULE>::parse_bytes(b"ICU4X ZeroVec").expect("parse valid utf8");
    assert_eq!(s, "ICU4X ZeroVec");
    assert_eq!(size_of_val(s), 13);
    assert!(matches!(
        <str as VarULE>::parse_bytes(&[0xFF, 0xAA]),
        Err(UleError::ParseError { .. })
    ));

    let slice = <ZeroSlice<u32> as VarULE>::parse_bytes(&u32_bytes).expect("parse ZeroSlice");
    assert_eq!(slice.len(), 2);
    assert_eq!(slice.get(0), Some(1));
    assert_eq!(slice.get(1), Some(2));
    assert_eq!(size_of_val(slice), 8);
    assert!(matches!(
        <ZeroSlice<u32> as VarULE>::parse_bytes(&[1u8, 2, 3]),
        Err(UleError::InvalidLength { len: 3, .. })
    ));

    // 3. VarULE::as_bytes converts dynamically-sized VarULE references back into raw byte slices matching original data
    assert_eq!(s.as_bytes(), b"ICU4X ZeroVec");
    assert_eq!(slice.as_bytes(), &u32_bytes);

    // 4. VarULE::from_bytes_unchecked allows unsafe zero-copy casting from validated byte buffers
    let valid_buf = b"zero-copy string";
    assert!(<str as VarULE>::validate_bytes(valid_buf).is_ok());
    let unchecked_str = unsafe { <str as VarULE>::from_bytes_unchecked(valid_buf) };
    assert_eq!(unchecked_str, "zero-copy string");

    let valid_slice_bytes = [42u8, 0, 0, 0];
    assert!(<ZeroSlice<u32> as VarULE>::validate_bytes(&valid_slice_bytes).is_ok());
    let unchecked_slice = unsafe { <ZeroSlice<u32> as VarULE>::from_bytes_unchecked(&valid_slice_bytes) };
    assert_eq!(unchecked_slice.len(), 1);
    assert_eq!(unchecked_slice.get(0), Some(42));

    // 5. Custom dynamically-sized types implement VarULE to enforce byte-level validation invariants
    let valid_ascii = b"ValidAscii123";
    assert!(AsciiStr::validate_bytes(valid_ascii).is_ok());
    let ascii_parsed = AsciiStr::parse_bytes(valid_ascii).expect("valid ascii");
    assert_eq!(ascii_parsed.as_str(), "ValidAscii123");
    assert_eq!(ascii_parsed.as_bytes(), valid_ascii);

    let unchecked_ascii = unsafe { AsciiStr::from_bytes_unchecked(valid_ascii) };
    assert_eq!(unchecked_ascii, ascii_parsed);

    let invalid_ascii = [b'A', b'B', 0xFF];
    assert!(AsciiStr::validate_bytes(&invalid_ascii).is_err());
    assert!(matches!(
        AsciiStr::parse_bytes(&invalid_ascii),
        Err(UleError::ParseError { .. })
    ));

    println!("All zerovec::ule::VarULE contract assertions passed successfully.");
}