ppv-lite86 0.2.21: ppv_lite86::Machine

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

[[package]]
name = "ppv-lite86"
version = "0.2.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
dependencies = [
 "zerocopy",
]

[[package]]
name = "proc-macro2"
version = "1.0.107"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
dependencies = [
 "unicode-ident",
]

[[package]]
name = "quote"
version = "1.0.47"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
dependencies = [
 "proc-macro2",
]

[[package]]
name = "sample-ppv-lite86"
version = "0.1.0"
dependencies = [
 "ppv-lite86",
]

[[package]]
name = "syn"
version = "2.0.119"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
dependencies = [
 "proc-macro2",
 "quote",
 "unicode-ident",
]

[[package]]
name = "unicode-ident"
version = "1.0.26"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"

[[package]]
name = "zerocopy"
version = "0.8.57"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d35102a9f36d089ccae9e4c6802bc118be4487b80aaffc0ab4e0cf5ce92d2873"
dependencies = [
 "zerocopy-derive",
]

[[package]]
name = "zerocopy-derive"
version = "0.8.57"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "146c01f5ab44258da43cf276c74a2763db2ff3969c9c652c3f2de07041d0b2bc"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]

[package]
name = "sample-ppv-lite86"
version = "0.1.0"
edition = "2021"
publish = false

[dependencies]
ppv-lite86 = "=0.2.21"

[features]
default = ["std"]
std = []

[[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 ppv_lite86::Machine in pkg:cargo/ppv-lite86@0.2.21
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:cargo/ppv-lite86@0.2.21
Demonstrate these symbols/APIs:
  - ppv_lite86::Machine

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:d67c62f667bf30692ac597df98212eeea783331af98af05d89b353a5d52e49e9","contract":["Machine::vec creates vector from lane array and extracts elements via Vec4","Machine vector types support arithmetic addition and to_lanes conversion","Machine::unpack converts vec128_storage into SIMD vector type","Vector types support word rotations and lane shuffling","Machine::read_le reads byte slices and write_le writes them back","Machine supports 64-bit vector types and operations","dispatch macro safely dispatches to runtime Machine implementation"],"goal":"verify ppv_lite86::Machine in pkg:cargo/ppv-lite86@0.2.21","kind":"HOW","packages":["pkg:cargo/ppv-lite86@0.2.21"],"schemaVersion":1,"symbols":["ppv_lite86::Machine"]},"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/ppv-lite86@0.2.21"],"schemaVersion":1,"subject":"pkg:cargo/ppv-lite86@0.2.21","symbols":["ppv_lite86::Machine"],"verifierAdapter":"cargo@1"}

{
  "schemaVersion": 1,
  "goal": "verify ppv_lite86::Machine in pkg:cargo/ppv-lite86@0.2.21",
  "kind": "HOW",
  "packages": [
    "pkg:cargo/ppv-lite86@0.2.21"
  ],
  "symbols": [
    "ppv_lite86::Machine"
  ]
}

//! Clean-room verification sample for ppv-lite86.

pub use ppv_lite86::*;

use ppv_lite86::{
    dispatch, vec128_storage, LaneWords4, Machine, MultiLane, RotateEachWord32, StoreBytes, Vec4,
};

fn verify_machine_operations<M: Machine>(mach: M) {
    // 1. Machine::vec creates a vector from lane array and extracts elements via Vec4
    let a_lanes: [u32; 4] = [10, 20, 30, 40];
    let b_lanes: [u32; 4] = [1, 2, 3, 4];
    let va: M::u32x4 = mach.vec(a_lanes);
    let vb: M::u32x4 = mach.vec(b_lanes);
    assert_eq!(va.extract(0), 10);
    assert_eq!(va.extract(1), 20);
    assert_eq!(va.extract(2), 30);
    assert_eq!(va.extract(3), 40);

    // 2. Machine vector types support arithmetic addition and to_lanes conversion
    let vsum: M::u32x4 = va + vb;
    assert_eq!(vsum.to_lanes(), [11, 22, 33, 44]);

    // 3. Machine::unpack converts vec128_storage into vector type
    let storage = vec128_storage::from([100u32, 200, 300, 400]);
    let unpacked: M::u32x4 = mach.unpack(storage);
    assert_eq!(unpacked.to_lanes(), [100, 200, 300, 400]);

    // 4. Vector types support word rotations and lane shuffling
    let rot = va.rotate_each_word_right8();
    assert_eq!(rot.extract(0), 10u32.rotate_right(8));
    assert_eq!(rot.extract(1), 20u32.rotate_right(8));

    let shuf = va.shuffle_lane_words2301();
    assert_eq!(shuf.to_lanes(), [30, 40, 10, 20]);

    // 5. Machine::read_le reads byte slices and write_le writes them back
    let bytes: [u8; 16] = [
        1, 0, 0, 0,
        2, 0, 0, 0,
        3, 0, 0, 0,
        4, 0, 0, 0,
    ];
    let v_read: M::u32x4 = mach.read_le(&bytes);
    assert_eq!(v_read.to_lanes(), [1, 2, 3, 4]);

    let mut out_bytes = [0u8; 16];
    v_read.write_le(&mut out_bytes);
    assert_eq!(out_bytes, bytes);

    // 6. Machine supports 64-bit vector types and operations
    let v64: M::u64x2 = mach.vec([0x1122334455667788u64, 0x8877665544332211u64]);
    let v64_add = v64 + mach.vec([1u64, 2u64]);
    assert_eq!(v64_add.to_lanes(), [0x1122334455667789u64, 0x8877665544332213u64]);
}

dispatch!(mach, M, {
    fn run_contract_test() {
        verify_machine_operations(mach);
    }
});

fn main() {
    run_contract_test();
    println!("ppv_lite86::Machine contract assertions passed successfully.");
}