clvm_tools_rs 0.4.0

tools for working with chialisp language; compiler, repl, python and wasm bindings
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use std::collections::HashMap;
use std::fs;
use std::rc::Rc;

use clvmr::Allocator;

use crate::classic::clvm_tools::clvmc::{compile_clvm, compile_clvm_text};
use crate::compiler::compiler::DefaultCompilerOpts;
use crate::compiler::comptypes::CompilerOpts;
use crate::tests::classic::run::read_json_from_file;

#[test]
fn test_compile_clvm_function_1() {
    let mut symbol_hash_table = HashMap::new();
    let bridge_hex_file = "validation_taproot.clvm2.hex";
    // Try to remove it if it exists.
    fs::remove_file(bridge_hex_file).ok();
    let _ = compile_clvm(
        "resources/tests/bridgeref/validation_taproot.clsp",
        bridge_hex_file,
        &["resources/tests/bridge-includes".to_string()],
        &mut symbol_hash_table,
    )
    .expect("should compile");
    let bridge_hex = fs::read_to_string(bridge_hex_file).expect("should have been created");
    fs::remove_file(bridge_hex_file).expect("should have existed");
    let read_in_hex_data =
        fs::read_to_string("resources/tests/bridgeref/validation_taproot.clvm.hex.reference")
            .expect("should exist");
    let read_in_symbol_data =
        read_json_from_file("resources/tests/bridgeref/validation_taproot.sym.reference");
    assert_eq!(bridge_hex, read_in_hex_data);
    for (key, value) in read_in_symbol_data.iter() {
        if key != "source_file" {
            assert_eq!(symbol_hash_table.get(key), Some(value));
        }
    }
}

#[test]
fn test_compile_clvm_with_previous_data() {
    let bridge_hex_file = "validation_taproot.clvm.hex";
    let bridge_hex =
        fs::read_to_string("resources/tests/bridgeref/validation_taproot.clvm.hex.reference")
            .expect("should have been created");
    let mut symbol_hash_table = HashMap::new();

    fs::write(bridge_hex_file, bridge_hex).expect("should write");
    compile_clvm(
        "resources/tests/bridgeref/validation_taproot.clsp",
        bridge_hex_file,
        &["resources/tests/bridge-includes".to_string()],
        &mut symbol_hash_table,
    )
    .expect("should compile");
    fs::remove_file(bridge_hex_file).expect("should have existed");
}

#[test]
fn test_classic_compile_error_output() {
    let mut allocator = Allocator::new();
    let mut symbols = HashMap::new();
    let path = "*test*";
    let content = "(mod (X) (xxx X))";
    let opts: Rc<dyn CompilerOpts> = Rc::new(DefaultCompilerOpts::new(path));
    let res = compile_clvm_text(
        &mut allocator,
        opts.clone(),
        &mut symbols,
        &content,
        &path,
        true,
    )
    .map_err(|e| e.format(&allocator, opts));
    assert_eq!(
        Err(
            "error can't compile (\"xxx\" 88), unknown operator compiling (\"xxx\" 88)".to_string()
        ),
        res
    );
}

#[test]
fn test_modern_compile_error_output() {
    let mut allocator = Allocator::new();
    let mut symbols = HashMap::new();
    let path = "*test*";
    let content = indoc! {
    "(mod (X)
           (include *standard-cl-23*)
           (+ X1 X)
           )
        "};
    let opts: Rc<dyn CompilerOpts> = Rc::new(DefaultCompilerOpts::new(path));
    let res = compile_clvm_text(
        &mut allocator,
        opts.clone(),
        &mut symbols,
        &content,
        &path,
        true,
    )
    .map_err(|e| e.format(&allocator, opts));
    assert_eq!(
        Err("*test*(3):4-*test*(3):6: Unbound use of X1 as a variable name".to_string()),
        res
    );
}