16770817670

Committed 06 Aug 2025 07:46AM UTC coverage: 93.355% (-0.3%) from 93.675%

Build # 16770817670

Build Type

push

github

Committed by

Chik-Network

Commit Message

update 0.16.0

Run Details

526 of 581 new or added lines in 26 files covered. (90.53%)

1 existing line in 1 file now uncovered.

6294 of 6742 relevant lines covered (93.36%)

29671867.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

48.0

/src/error.rs

use crate::NodePtr;
use thiserror::Error;

pub type Result<T> = std::result::Result<T, EvalErr>;

#[derive(Debug, Error, PartialEq)]
pub enum EvalErr {
    #[error("bad encoding")]
    SerializationError,

    #[error("invalid backreference during deserialisation")]
    SerializationBackreferenceError,

    #[error("Out of Memory")]
    OutOfMemory,

    #[error("path into atom")]
    PathIntoAtom,

    #[error("too many pairs")]
    TooManyPairs,

    #[error("Too Many Atoms")]
    TooManyAtoms,

    #[error("cost exceeded or below zero")]
    CostExceeded,

    #[error("unknown softfork extension")]
    UnknownSoftforkExtension,

    #[error("softfork specified cost mismatch")]
    SoftforkCostMismatch,

    #[error("Internal Error: {1}")]
    InternalError(NodePtr, String),

    #[error("klvm raise")]
    Raise(NodePtr),

    #[error("Invalid Nil Terminator in operand list")]
    InvalidNilTerminator(NodePtr),

    #[error("Division by zero")]
    DivisionByZero(NodePtr),

    #[error("Value Stack Limit Reached")]
    ValueStackLimitReached(NodePtr),

    #[error("Environment Stack Limit Reached")]
    EnvironmentStackLimitReached(NodePtr),

    #[error("Shift too large")]
    ShiftTooLarge(NodePtr),

    #[error("Reserved operator")]
    Reserved(NodePtr),

    #[error("invalid operator")]
    Invalid(NodePtr),

    #[error("unimplemented operator")]
    Unimplemented(NodePtr),

    #[error("InvalidOperatorArg: {1}")]
    InvalidOpArg(NodePtr, String),

    #[error("InvalidAllocatorArg: {1}")]
    InvalidAllocArg(NodePtr, String),

    #[error("bls_pairing_identity failed")]
    BLSPairingIdentityFailed(NodePtr),

    #[error("bls_verify failed")]
    BLSVerifyFailed(NodePtr),

    #[error("Secp256 Verify Error: failed")]
    Secp256Failed(NodePtr),
}
impl From<std::io::Error> for EvalErr {
    fn from(_: std::io::Error) -> Self {
        EvalErr::SerializationError
    }
}

impl EvalErr {
    fn node(&self) -> Option<NodePtr> {
        match self {
            EvalErr::InternalError(node, _) => Some(*node),
            EvalErr::Raise(node) => Some(*node),
            EvalErr::InvalidNilTerminator(node) => Some(*node),
            EvalErr::DivisionByZero(node) => Some(*node),
            EvalErr::ValueStackLimitReached(node) => Some(*node),
            EvalErr::EnvironmentStackLimitReached(node) => Some(*node),
            EvalErr::ShiftTooLarge(node) => Some(*node),
            EvalErr::Reserved(node) => Some(*node),
            EvalErr::Invalid(node) => Some(*node),
            EvalErr::Unimplemented(node) => Some(*node),
            EvalErr::InvalidOpArg(node, _) => Some(*node),
            EvalErr::InvalidAllocArg(node, _) => Some(*node),
            EvalErr::BLSPairingIdentityFailed(node) => Some(*node),
            EvalErr::BLSVerifyFailed(node) => Some(*node),
            EvalErr::Secp256Failed(node) => Some(*node),
            _ => None,
        }
    }

    pub fn node_ptr(&self) -> NodePtr {
        // This is a convenience function to get the node pointer
        self.node().unwrap_or_default()
    }
}

1	use crate::NodePtr;
2	use thiserror::Error;
3
4	pub type Result<T> = std::result::Result<T, EvalErr>;
5
6	#[derive(Debug, Error, PartialEq)]
7	pub enum EvalErr {
8	#[error("bad encoding")]
9	SerializationError,
10
11	#[error("invalid backreference during deserialisation")]
12	SerializationBackreferenceError,
13
14	#[error("Out of Memory")]
15	OutOfMemory,
16
17	#[error("path into atom")]
18	PathIntoAtom,
19
20	#[error("too many pairs")]
21	TooManyPairs,
22
23	#[error("Too Many Atoms")]
24	TooManyAtoms,
25
26	#[error("cost exceeded or below zero")]
27	CostExceeded,
28
29	#[error("unknown softfork extension")]
30	UnknownSoftforkExtension,
31
32	#[error("softfork specified cost mismatch")]
33	SoftforkCostMismatch,
34
35	#[error("Internal Error: {1}")]
36	InternalError(NodePtr, String),
37
38	#[error("klvm raise")]
39	Raise(NodePtr),
40
41	#[error("Invalid Nil Terminator in operand list")]
42	InvalidNilTerminator(NodePtr),
43
44	#[error("Division by zero")]
45	DivisionByZero(NodePtr),
46
47	#[error("Value Stack Limit Reached")]
48	ValueStackLimitReached(NodePtr),
49
50	#[error("Environment Stack Limit Reached")]
51	EnvironmentStackLimitReached(NodePtr),
52
53	#[error("Shift too large")]
54	ShiftTooLarge(NodePtr),
55
56	#[error("Reserved operator")]
57	Reserved(NodePtr),
58
59	#[error("invalid operator")]
60	Invalid(NodePtr),
61
62	#[error("unimplemented operator")]
63	Unimplemented(NodePtr),
64
65	#[error("InvalidOperatorArg: {1}")]
66	InvalidOpArg(NodePtr, String),
67
68	#[error("InvalidAllocatorArg: {1}")]
69	InvalidAllocArg(NodePtr, String),
70
71	#[error("bls_pairing_identity failed")]
72	BLSPairingIdentityFailed(NodePtr),
73
74	#[error("bls_verify failed")]
75	BLSVerifyFailed(NodePtr),
76
77	#[error("Secp256 Verify Error: failed")]
78	Secp256Failed(NodePtr),
79	}
80	impl From<std::io::Error> for EvalErr {
81	fn from(_: std::io::Error) -> Self {	11✔
82	EvalErr::SerializationError	11✔
83	}	11✔
84	}
85
86	impl EvalErr {
87	fn node(&self) -> Option<NodePtr> {	92✔
88	match self {	92✔
NEW 89	EvalErr::InternalError(node, _) => Some(*node),	×
90	EvalErr::Raise(node) => Some(*node),	4✔
NEW 91	EvalErr::InvalidNilTerminator(node) => Some(*node),	×
NEW 92	EvalErr::DivisionByZero(node) => Some(*node),	×
NEW 93	EvalErr::ValueStackLimitReached(node) => Some(*node),	×
NEW 94	EvalErr::EnvironmentStackLimitReached(node) => Some(*node),	×
NEW 95	EvalErr::ShiftTooLarge(node) => Some(*node),	×
NEW 96	EvalErr::Reserved(node) => Some(*node),	×
NEW 97	EvalErr::Invalid(node) => Some(*node),	×
NEW 98	EvalErr::Unimplemented(node) => Some(*node),	×
NEW 99	EvalErr::InvalidOpArg(node, _) => Some(*node),	×
100	EvalErr::InvalidAllocArg(node, _) => Some(*node),	24✔
NEW 101	EvalErr::BLSPairingIdentityFailed(node) => Some(*node),	×
NEW 102	EvalErr::BLSVerifyFailed(node) => Some(*node),	×
NEW 103	EvalErr::Secp256Failed(node) => Some(*node),	×
104	_ => None,	64✔
105	}
106	}	92✔
107
108	pub fn node_ptr(&self) -> NodePtr {	92✔
109	// This is a convenience function to get the node pointer
110	self.node().unwrap_or_default()	92✔
111	}	92✔
112	}

Chik-Network / klvm_rs / 16770817670

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous