test: aac add test coverage for ParseError variants

clarity/src/vm/ast/definition_sorter/mod.rs

@@ -90,7 +90,7 @@ impl DefinitionSorter {
         let sorted_indexes = walker.get_sorted_dependencies(&self.graph);
 
         if let Some(deps) = walker.get_cycling_dependencies(&self.graph, &sorted_indexes) {
-            let functions_names = deps
+            let mut function_names = deps
                 .into_iter()
                 .filter_map(|i| {
                     let exp = &contract_ast.pre_expressions[i];
@@ -99,7 +99,10 @@ impl DefinitionSorter {
                 .map(|i| i.0.to_string())
                 .collect::<Vec<_>>();
 
-            let error = ParseError::new(ParseErrorKind::CircularReference(functions_names));
+            // Sorting function names to make the error contents deterministic
+            function_names.sort();
+
+            let error = ParseError::new(ParseErrorKind::CircularReference(function_names));
             return Err(error);
         }
 

clarity/src/vm/ast/mod.rs

@@ -238,6 +238,7 @@ pub fn build_ast<T: CostTracker>(
 mod test {
     use std::collections::HashMap;
 
+    use clarity_types::types::MAX_VALUE_SIZE;
     use stacks_common::types::StacksEpochId;
 
     use crate::vm::ast::build_ast;
@@ -447,4 +448,141 @@ mod test {
             }
         }
     }
+
+    #[test]
+    fn test_build_ast_error_exceeding_cost_balance_due_to_ast_parse() {
+        let limit = ExecutionCost {
+            read_count: u64::MAX,
+            write_count: u64::MAX,
+            read_length: u64::MAX,
+            write_length: u64::MAX,
+            runtime: 1,
+        };
+        let mut tracker = LimitedCostTracker::new_with_limit(StacksEpochId::Epoch33, limit);
+
+        let err = build_ast(
+            &QualifiedContractIdentifier::transient(),
+            "(define-constant my-const u1)",
+            &mut tracker,
+            ClarityVersion::Clarity4,
+            StacksEpochId::Epoch33,
+        )
+        .unwrap_err();
+
+        assert!(
+            matches!(*err.err, ParseErrorKind::CostBalanceExceeded(_, _)),
+            "Instead found: {err}"
+        );
+    }
+
+    #[test]
+    fn test_build_ast_error_exceeding_cost_balance_due_to_ast_cycle_detection_with_0_edges() {
+        let expected_ast_parse_cost = 1215;
+        let expected_cycle_det_cost = 72;
+        let expected_total = expected_ast_parse_cost + expected_cycle_det_cost;
+
+        let limit = ExecutionCost {
+            read_count: u64::MAX,
+            write_count: u64::MAX,
+            read_length: u64::MAX,
+            write_length: u64::MAX,
+            runtime: expected_ast_parse_cost,
+        };
+        let mut tracker = LimitedCostTracker::new_with_limit(StacksEpochId::Epoch33, limit);
+
+        let err = build_ast(
+            &QualifiedContractIdentifier::transient(),
+            "(define-constant a 0)(define-constant b 1)", // no dependency = 0 graph edge
+            &mut tracker,
+            ClarityVersion::Clarity4,
+            StacksEpochId::Epoch33,
+        )
+        .expect_err("Expected parse error, but found success!");
+
+        let total = match *err.err {
+            ParseErrorKind::CostBalanceExceeded(total, _) => total,
+            _ => panic!("Expected CostBalanceExceeded, but found: {err}"),
+        };
+
+        assert_eq!(expected_total, total.runtime);
+    }
+
+    #[test]
+    fn test_build_ast_error_exceeding_cost_balance_due_to_ast_cycle_detection_with_1_edge() {
+        let expected_ast_parse_cost = 1215;
+        let expected_cycle_det_cost = 213;
+        let expected_total = expected_ast_parse_cost + expected_cycle_det_cost;
+
+        let limit = ExecutionCost {
+            read_count: u64::MAX,
+            write_count: u64::MAX,
+            read_length: u64::MAX,
+            write_length: u64::MAX,
+            runtime: expected_ast_parse_cost,
+        };
+        let mut tracker = LimitedCostTracker::new_with_limit(StacksEpochId::Epoch33, limit);
+
+        let err = build_ast(
+            &QualifiedContractIdentifier::transient(),
+            "(define-constant a 0)(define-constant b a)", // 1 dependency = 1 graph edge
+            &mut tracker,
+            ClarityVersion::Clarity4,
+            StacksEpochId::Epoch33,
+        )
+        .expect_err("Expected parse error, but found success!");
+
+        let total = match *err.err {
+            ParseErrorKind::CostBalanceExceeded(total, _) => total,
+            _ => panic!("Expected CostBalanceExceeded, but found: {err}"),
+        };
+
+        assert_eq!(expected_total, total.runtime);
+    }
+
+    #[test]
+    fn test_build_ast_error_vary_stack_too_deep() {
+        // This contract pass the parse v2 MAX_NESTING_DEPTH but fails the [`VaryStackDepthChecker`]
+        let contract = {
+            let count = AST_CALL_STACK_DEPTH_BUFFER + (MAX_CALL_STACK_DEPTH as u64) - 1;
+            let body_start = "(list ".repeat(count as usize);
+            let body_end = ")".repeat(count as usize);
+            format!("{{ a: {body_start}u1 {body_end} }}")
+        };
+
+        let err = build_ast(
+            &QualifiedContractIdentifier::transient(),
+            &contract,
+            &mut (),
+            ClarityVersion::Clarity4,
+            StacksEpochId::Epoch33,
+        )
+        .expect_err("Expected parse error, but found success!");
+
+        assert!(
+            matches!(*err.err, ParseErrorKind::VaryExpressionStackDepthTooDeep),
+            "Instead found: {err}"
+        );
+    }
+
+    #[test]
+    fn test_build_ast_error_illegal_ascii_string_due_to_size() {
+        let contract = {
+            let string = "a".repeat(MAX_VALUE_SIZE as usize + 1);
+            format!("(define-constant my-str \"{string}\")")
+        };
+
+        let err = build_ast(
+            &QualifiedContractIdentifier::transient(),
+            &contract,
+            &mut (),
+            ClarityVersion::Clarity4,
+            StacksEpochId::Epoch33,
+        )
+        .expect_err("Expected parse error, but found success!");
+
+        assert!(
+            matches!(*err.err, ParseErrorKind::IllegalASCIIString(_)),
+            "Instead found: {err}"
+        );
+    }
 }

clarity/src/vm/ast/parser/v2/mod.rs

@@ -896,6 +896,12 @@ impl<'a> Parser<'a> {
                                 match Value::string_ascii_from_bytes(val.clone().into_bytes()) {
                                     Ok(s) => PreSymbolicExpression::atom_value(s),
                                     Err(_) => {
+                                        // Protect against console flooding and process hanging while running tests,
+                                        // using a purely arbitrary max chars limit.
+                                        // NOTE: A better place for this would be the enum itself, but then we need to write a custom Debug implementation
+                                        #[cfg(any(test, feature = "testing"))]
+                                        let val = ellipse_string_for_test(val, 128);
+
                                         self.add_diagnostic(
                                             ParseErrorKind::IllegalASCIIString(val.clone()),
                                             token.span.clone(),
@@ -1131,6 +1137,25 @@ pub fn parse_collect_diagnostics(
     (stmts, diagnostics, parser.success)
 }
 
+/// Test helper function to shorten big strings while running tests
+///
+/// This prevents both:
+///   - Console flooding with multi-megabyte output during test runs.
+///   - Potential test process blocking or hanging due to stdout buffering limits.
+///
+/// In case a the input `string` need to be shortned based on `max_chars`,
+/// the resulting string will be ellipsed showing the original character count.
+#[cfg(any(test, feature = "testing"))]
+fn ellipse_string_for_test(string: &str, max_chars: usize) -> String {
+    let char_count = string.chars().count();
+    if char_count <= max_chars {
+        string.into()
+    } else {
+        let shortened: String = string.chars().take(max_chars).collect();
+        format!("{shortened}...[{char_count}]")
+    }
+}
+
 #[cfg(test)]
 #[cfg(feature = "developer-mode")]
 mod tests {

clarity/src/vm/costs/mod.rs

@@ -854,6 +854,49 @@ impl LimitedCostTracker {
         };
         Ok(result)
     }
+
+    /// Create a [`LimitedCostTracker`] given an epoch id and an execution cost limit for testing purpose
+    ///
+    /// Autoconfigure itself loading all clarity const functions without the need of passing a clarity database
+    #[cfg(any(test, feature = "testing"))]
+    pub fn new_with_limit(epoch_id: StacksEpochId, limit: ExecutionCost) -> LimitedCostTracker {
+        use stacks_common::consts::CHAIN_ID_TESTNET;
+
+        let contract_name = LimitedCostTracker::default_cost_contract_for_epoch(epoch_id)
+            .expect("Failed retrieving cost contract!");
+        let boot_costs_id = boot_code_id(&contract_name, false);
+
+        let version = DefaultVersion::try_from(false, &boot_costs_id)
+            .expect("Failed defining default version!");
+
+        let mut cost_functions = HashMap::new();
+        for each in ClarityCostFunction::ALL {
+            let evaluator = ClarityCostFunctionEvaluator::Default(
+                ClarityCostFunctionReference {
+                    contract_id: boot_costs_id.clone(),
+                    function_name: each.get_name(),
+                },
+                each.clone(),
+                version,
+            );
+            cost_functions.insert(each, evaluator);
+        }
+
+        let cost_tracker = TrackerData {
+            cost_function_references: cost_functions,
+            cost_contracts: HashMap::new(),
+            contract_call_circuits: HashMap::new(),
+            limit,
+            memory_limit: CLARITY_MEMORY_LIMIT,
+            total: ExecutionCost::ZERO,
+            memory: 0,
+            epoch: epoch_id,
+            mainnet: false,
+            chain_id: CHAIN_ID_TESTNET,
+        };
+
+        LimitedCostTracker::Limited(cost_tracker)
+    }
 }
 
 impl TrackerData {