Struct MockEngine 

pub struct MockEngine { /* private fields */ }

Implementations

impl MockEngine

pub fn new(cfg: EngineConfig) -> MockEngine

pub fn refusing_admits( self, refuse: fn(&LaneAdmit) -> bool, status: Status, ) -> MockEngine

pub fn with_capability_descriptor(self, record: impl Into<String>) -> MockEngine

pub fn config(&self) -> &EngineConfig

pub fn bundle_fingerprint(&self) -> u64

pub fn lane_sequence(&self, lane_tag: u64) -> Option<SeqHandle>

pub fn lane_committed(&self, lane_tag: u64) -> Option<&[u32]>

pub fn create_sequence(&mut self) -> SeqHandle

pub fn space_valid_len(&self, seq: SeqHandle, space_id: u32) -> Option<u64>

pub fn space_taint(&self, seq: SeqHandle, space_id: u32) -> Option<u32>

pub fn pool_used(&self) -> u64

pub fn force_finish(&mut self, lane_tag: u64, finish: u32)

pub fn inject_fault(&mut self, lane_tag: u64, code: u32)

pub fn grant_certs_for_test(&mut self, strategy_id: &str, certs: Vec<Cert>)

pub fn make_cert( &mut self, exactness: u8, sampling_modes: u8, param_domain: u32, grammar_allowed: bool, admissible_host_identities: Vec<[u8; 32]>, ) -> Cert

Trait Implementations

impl Engine for MockEngine

fn capability_descriptor(&self) -> Option<String>

fn embed(&mut self, tokens: &[u32]) -> Result<Vec<f32>, Status>

fn logit_bias_create( &mut self, tokens: &[i32], values: &[f32], ) -> Result<u32, Status>

fn logit_bias_free(&mut self, _handle: u32) -> Result<(), Status>

fn transcribe( &mut self, _audio_path: &str, params: &TranscribeParams, on_segment: Option<SegmentSink<'_>>, ) -> Result<Transcription, Status>

fn lora_load(&mut self, _adapter_path: &str) -> Result<(), Status>

fn lora_unload(&mut self) -> Result<(), Status>

fn tick<'a>( &'a mut self, plan: &TickPlan, arena: &RecordArena, rings: &mut dyn Rings, ) -> Result<&'a TickEvents, Status>

fn pump(&mut self)

fn state_spaces(&self) -> &[StateSpaceDesc]

fn grammar_create(&mut self, json_schema: &str) -> Result<u32, Status>

fn grammar_create_structural(&mut self, tag_json: &str) -> Result<u32, Status>

fn grammar_free(&mut self, handle: u32) -> Result<(), Status>

fn strategy_register( &mut self, reg: &StrategyRegistration, ) -> Result<&StrategyGrant, Status>

fn space_match( &mut self, space_id: u32, span_tokens: &[u32], _media_deps: &[[u8; 32]], ) -> Result<&MatchResult, Status>

fn seed_acquire( &mut self, span_tokens: &[u32], prefix_len: u64, determinism_class: u8, ) -> Result<u64, Status>

fn media_probe(&mut self, _image_path: &str) -> Result<MediaInfo, Status>

fn media_encode(&mut self, image_path: &str) -> Result<(u64, MediaInfo), Status>

fn media_release(&mut self, media_handle: u64) -> Result<(), Status>

fn media_bind( &mut self, lane_tag: u64, media_handle: u64, token_offset: u32, ) -> Result<(), Status>

fn seed_adopt( &mut self, seq: SeqHandle, span_tokens: &[u32], ) -> Result<u64, Status>

fn seed_lease_ticks(&self) -> Option<u64>

fn seed_release(&mut self, seed_handle: u64) -> Result<(), Status>

fn seq_fork( &mut self, parent: SeqHandle, _flags: u32, ) -> Result<SeqHandle, Status>

fn lane_sequence(&self, lane_tag: u64) -> Option<SeqHandle>

fn create_sequence(&mut self) -> Result<SeqHandle, Status>

fn free_sequence(&mut self, seq: SeqHandle) -> Result<(), Status>

fn publish_sequence( &mut self, seq: SeqHandle, tokens: &[u32], ) -> Result<(), Status>

fn space_export_size( &mut self, seq: SeqHandle, space_id: u32, range: TokenRange, encoding: u8, ) -> Result<(u64, u64), Status>

fn space_snapshot( &mut self, seq: SeqHandle, space_id: u32, boundary_pos: u64, dst_len: u64, sizing_gen: u64, ) -> Result<OpHandle, Status>

fn space_snapshot_boundary( &mut self, seq: SeqHandle, space_id: u32, cap: u64, ) -> Result<u64, Status>

fn space_restore( &mut self, seq: SeqHandle, space_id: u32, src: &[u8], ) -> Result<OpHandle, Status>

fn space_trim( &mut self, seq: SeqHandle, space_id: u32, new_len: u64, ) -> Result<(), Status>

fn space_demote( &mut self, seq: SeqHandle, space_id: u32, range: TokenRange, encoding: u8, dst_len: u64, sizing_gen: u64, ) -> Result<OpHandle, Status>

fn space_promote( &mut self, seq: SeqHandle, space_id: u32, _range: TokenRange, src: &[u8], ) -> Result<OpHandle, Status>

fn op_poll(&mut self, op: OpHandle) -> Result<OpStatus, Status>

fn take_op_output(&mut self, op: OpHandle) -> Option<Vec<u8>>

fn n_layers(&self) -> u32

fn forward_stage( &mut self, tokens: &[u32], start_layer: u32, end_layer: u32, hidden_in: Option<Vec<u8>>, ) -> Result<StageOutput, Status>

fn op_cancel(&mut self, op: OpHandle) -> Result<(), Status>

fn cache_evict( &mut self, evictable_cache_classes: u64, protected_quota_bytes: u64, max_evict_bytes: u64, bytes_target: u64, ) -> Result<u64, Status>

fn attach_ring(&mut self, _ring: &RingAttachment) -> Result<(), Status>

fn kv_bits(&self) -> u32

fn space_match_ref( &mut self, space_id: u32, _span: &TokenRef, span_tokens: &[u32], media_deps: &[[u8; 32]], ) -> Result<&MatchResult, Status>

fn seed_acquire_ref( &mut self, _span: &TokenRef, span_tokens: &[u32], prefix_len: u64, determinism_class: u8, ) -> Result<u64, Status>

fn seed_adopt_ref( &mut self, seq: SeqHandle, _span: &TokenRef, span_tokens: &[u32], ) -> Result<u64, Status>

fn lora_id(&self) -> Option<String>

fn unpublish(&mut self, _tokens: &[u32]) -> Result<(), Status>

Drops the prefix-cache entry published under exactly tokens, unless a seed holds it; none there is not an error.

fn cache_evict_entries( &mut self, _keys: &[([u8; 32], [u8; 32])], ) -> Result<(), Status>

impl EngineInspect for MockEngine

fn lane_committed(&self, lane_tag: u64) -> Option<&[u32]>

fn inject_fault(&mut self, lane_tag: u64, code: u32)