backhopper-core 0.37.0

Core types, snapshot I/O, store, and compatibility analysis for backhopper
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

// Copyright (C) 2026 Michael S. Klishin and Contributors
// SPDX-License-Identifier: Apache-2.0 OR MIT
// See LICENSE-APACHE and LICENSE-MIT for details.

use backhopper_core::compat::arg_shape::{ArgShape, satisfies_any};
use backhopper_core::model::names::RecordName;

#[test]
fn unknown_actual_matches_any_pattern() {
    let pattern = ArgShape::Atom { name: "x".into() };
    assert!(ArgShape::Unknown.satisfies(&pattern));
}

#[test]
fn unknown_pattern_matches_any_actual() {
    let actual = ArgShape::Atom { name: "x".into() };
    assert!(actual.satisfies(&ArgShape::Unknown));
}

#[test]
fn variable_pattern_matches_any_actual() {
    let actual = ArgShape::Atom { name: "x".into() };
    assert!(actual.satisfies(&ArgShape::Variable));
}

#[test]
fn variable_actual_matches_any_pattern() {
    let pattern = ArgShape::Atom { name: "x".into() };
    assert!(ArgShape::Variable.satisfies(&pattern));
}

#[test]
fn matching_atom_names_satisfy() {
    let a = ArgShape::Atom { name: "ok".into() };
    let b = ArgShape::Atom { name: "ok".into() };
    assert!(a.satisfies(&b));
}

#[test]
fn differing_atom_names_do_not_satisfy() {
    let a = ArgShape::Atom { name: "ok".into() };
    let b = ArgShape::Atom {
        name: "error".into(),
    };
    assert!(!a.satisfies(&b));
}

#[test]
fn equal_tuple_sizes_satisfy() {
    assert!(ArgShape::Tuple { size: 2 }.satisfies(&ArgShape::Tuple { size: 2 }));
}

#[test]
fn differing_tuple_sizes_do_not_satisfy() {
    assert!(!ArgShape::Tuple { size: 2 }.satisfies(&ArgShape::Tuple { size: 3 }));
}

#[test]
fn equal_record_names_satisfy() {
    let user = RecordName::new("user").unwrap();
    let a = ArgShape::Record { name: user.clone() };
    let b = ArgShape::Record { name: user };
    assert!(a.satisfies(&b));
}

#[test]
fn differing_record_names_do_not_satisfy() {
    let a = ArgShape::Record {
        name: RecordName::new("user").unwrap(),
    };
    let b = ArgShape::Record {
        name: RecordName::new("admin").unwrap(),
    };
    assert!(!a.satisfies(&b));
}

#[test]
fn different_concrete_kinds_do_not_satisfy() {
    assert!(!ArgShape::Integer.satisfies(&ArgShape::Float));
    assert!(!ArgShape::List.satisfies(&ArgShape::Binary));
    assert!(!ArgShape::String.satisfies(&ArgShape::Fun));
}

#[test]
fn empty_clauses_always_satisfies() {
    let args = vec![ArgShape::Atom { name: "x".into() }];
    assert!(satisfies_any(&args, &[]));
}

#[test]
fn clause_with_different_arity_does_not_match() {
    let args = vec![ArgShape::Atom { name: "x".into() }];
    let clauses = vec![vec![ArgShape::Variable, ArgShape::Variable]];
    assert!(!satisfies_any(&args, &clauses));
}

#[test]
fn first_clause_matches_short_circuits() {
    let args = vec![ArgShape::Atom {
        name: "start".into(),
    }];
    let clauses = vec![
        vec![ArgShape::Atom {
            name: "start".into(),
        }],
        vec![ArgShape::Atom {
            name: "stop".into(),
        }],
    ];
    assert!(satisfies_any(&args, &clauses));
}

#[test]
fn no_clause_matches_returns_false() {
    let args = vec![ArgShape::Atom {
        name: "restart".into(),
    }];
    let clauses = vec![
        vec![ArgShape::Atom {
            name: "start".into(),
        }],
        vec![ArgShape::Atom {
            name: "stop".into(),
        }],
    ];
    assert!(!satisfies_any(&args, &clauses));
}