qubit-codec 0.16.0

// =============================================================================
//    Copyright (c) 2026 Haixing Hu.
//
//    SPDX-License-Identifier: Apache-2.0
//
//    Licensed under the Apache License, Version 2.0.
// =============================================================================

use core::convert::Infallible;
use core::num::NonZeroUsize;

use qubit_codec::Codec;
use qubit_codec::DecodeFailure;
use qubit_codec::TranscodeEncodeErrorOf;
use qubit_codec::engine::EncodeContext;
use qubit_codec::engine::EncodeUnencodableAction;
use qubit_codec::engine::TranscodeEncodeHooks;

#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
struct UnitCodec;

#[derive(Clone, Copy, Debug, Eq, PartialEq, thiserror::Error)]
#[error("encode failed")]
struct UnitEncodeError;

impl Codec for UnitCodec {
    type Value = u8;
    type Unit = u8;
    type DecodeError = Infallible;
    type EncodeError = UnitEncodeError;

    const MIN_UNITS_PER_VALUE: usize = 1;

    const MAX_ENCODE_UNITS_PER_VALUE: usize = 1;

    const MAX_DECODE_UNITS_PER_VALUE: usize = 1;

    const MAX_ENCODE_RESET_UNITS: usize = 1;

    unsafe fn decode(
        &mut self,
        input: &[u8],
        input_index: usize,
    ) -> Result<(u8, NonZeroUsize), DecodeFailure<Self::DecodeError>> {
        Ok((input[input_index], NonZeroUsize::MIN))
    }

    unsafe fn encode(
        &mut self,
        value: &u8,
        output: &mut [u8],
        output_index: usize,
    ) -> Result<usize, Self::EncodeError> {
        output[output_index] = *value;
        Ok(1)
    }

    unsafe fn encode_reset(&mut self, _output: &mut [u8], _output_index: usize) -> Result<usize, Self::EncodeError> {
        Err(UnitEncodeError)
    }
}

#[derive(Clone, Debug, Default, Eq, PartialEq)]
struct DefaultOnlyHooks;

impl TranscodeEncodeHooks<UnitCodec> for DefaultOnlyHooks {
    fn handle_unencodable_encode(
        &mut self,
        _codec: &mut UnitCodec,
        _context: &EncodeContext<'_, u8>,
    ) -> Result<EncodeUnencodableAction<u8>, TranscodeEncodeErrorOf<UnitCodec>> {
        Ok(EncodeUnencodableAction::Reject)
    }
}

#[test]
fn test_transcode_encode_hooks_default_finish_is_noop() {
    let mut hooks = DefaultOnlyHooks;
    let mut codec = UnitCodec;
    let mut output = [0_u8; 1];

    let written = TranscodeEncodeHooks::<UnitCodec>::finish_hooks(&mut hooks, &mut codec, &mut output, 0)
        .expect("default finish should be a no-op");

    assert_eq!(0, written);
}

#[test]
fn test_transcode_encode_hooks_default_before_reset_is_noop() {
    let mut hooks = DefaultOnlyHooks;
    let mut codec = UnitCodec;

    TranscodeEncodeHooks::<UnitCodec>::reset_hooks(&mut hooks, &mut codec);
}

#[test]
fn test_transcode_encode_hooks_default_transcode_output_len_scales_with_codec_width() {
    let hooks = DefaultOnlyHooks;
    let codec = UnitCodec;

    let bound = TranscodeEncodeHooks::<UnitCodec>::max_transcode_output_len(&hooks, &codec, 5)
        .expect("default bound should fit the requested input length");

    assert_eq!(5, bound);
}

#[test]
fn test_transcode_encode_hooks_default_finish_output_len_is_zero() {
    let hooks = DefaultOnlyHooks;
    let codec = UnitCodec;

    let bound = TranscodeEncodeHooks::<UnitCodec>::max_finish_output_len(&hooks, &codec);

    assert_eq!(0, bound);
}