Struct concordium_std::test_infrastructure::ContractStateTest

pub struct ContractStateTest<T> {
    pub cursor: Cursor<T>,
}

Contract state for testing, mimicking the operations the scheduler allows, including the limit on the size of the maximum size of the contract state.

Fields

cursor: Cursor<T>

Trait Implementations

impl<T: AsMut<Vec<u8>> + AsMut<[u8]> + AsRef<[u8]>> HasContractState<ContractStateError> for ContractStateTest<T>

type ContractStateData = T

fn open(data: Self::ContractStateData) -> Self

Open the contract state. Only one instance can be opened at the same time.

fn size(&self) -> u32

Get the current size of contract state.

fn truncate(&mut self, new_size: u32)

Truncate the state to the given size. If the given size is more than the current state size this operation does nothing. The new position is at most at the end of the stream.

fn reserve(&mut self, len: u32) -> bool

Make sure that the memory size is at least that many bytes in size. Returns true iff this was successful. The new bytes are initialized as 0.

impl<T: AsRef<[u8]>> Read for ContractStateTest<T>

fn read(&mut self, buf: &mut [u8]) -> ParseResult<usize>

Read a number of bytes into the provided buffer. The returned value is Ok(n) if a read was successful, and n bytes were read (n could be 0).

pub fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), ParseError>

Read exactly the required number of bytes. If not enough bytes could be read the function returns Err(_), and the contents of the given buffer is unspecified.

pub fn read_u64(&mut self) -> Result<u64, ParseError>

Read a u64 in little-endian format.

pub fn read_u32(&mut self) -> Result<u32, ParseError>

Read a u32 in little-endian format.

pub fn read_u16(&mut self) -> Result<u16, ParseError>

Read a u16 in little-endian format.

pub fn read_u8(&mut self) -> Result<u8, ParseError>

Read a u8.

pub fn read_i64(&mut self) -> Result<i64, ParseError>

Read a i64 in little-endian format.

pub fn read_i32(&mut self) -> Result<i32, ParseError>

Read a i32 in little-endian format.

pub fn read_i16(&mut self) -> Result<i16, ParseError>

Read a i16 in little-endian format.

pub fn read_i8(&mut self) -> Result<i8, ParseError>

Read a i32 in little-endian format.

impl<T: AsRef<[u8]>> Seek for ContractStateTest<T>

type Err = ContractStateError

fn seek(&mut self, pos: SeekFrom) -> Result<u64, Self::Err>

Seek to the new position. If successful, return the new position from the beginning of the stream.

impl<T: AsMut<[u8]>> Write for ContractStateTest<T>

type Err = ContractStateError

fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Err>

Try to write the given buffer into the output stream. If writes are successful returns the number of bytes written.

pub fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Err>

Attempt to write the entirety of the buffer to the output by repeatedly calling write until either no more output can written, or writing fails.

pub fn write_u8(&mut self, x: u8) -> Result<(), Self::Err>

Write a single byte to the output.

pub fn write_u16(&mut self, x: u16) -> Result<(), Self::Err>

Write a u16 in little endian.

pub fn write_u32(&mut self, x: u32) -> Result<(), Self::Err>

Write a u32 in little endian.

pub fn write_u64(&mut self, x: u64) -> Result<(), Self::Err>

Write a u64 in little endian.

pub fn write_i8(&mut self, x: i8) -> Result<(), Self::Err>

Write a i8 to the output.

pub fn write_i16(&mut self, x: i16) -> Result<(), Self::Err>

Write a i16 in little endian.

pub fn write_i32(&mut self, x: i32) -> Result<(), Self::Err>

Write a i32 in little endian.

pub fn write_i64(&mut self, x: i64) -> Result<(), Self::Err>

Write a i64 in little endian.