Grcov report - bindings.rs

1

// Skipped under Miri: these tests compile+run wasm via wasmtime, whose

2

// Cranelift backend refuses to run under Miri.

3

#![cfg(not(miri))]

4

5

use nms::interpreter::Interpreter;

6

use scripting::nomiscript::{Fraction, Value};

7

8

// LET

9

10

#[test]

11

1

fn test_eval_let_basic() {

12

1

    let mut interp = Interpreter::new(false).unwrap();

13

1

    assert_eq!(

14

1

        interp.eval("(let ((x 1)) x)").unwrap(),

15

1

        vec![Value::Number(Fraction::from_integer(1))]

16

);

17

1

18

19

#[test]

20

1

fn test_eval_let_multiple_bindings() {

21

1

    let mut interp = Interpreter::new(false).unwrap();

22

1

    assert_eq!(

23

1

        interp.eval("(let ((x 1) (y 2)) (+ x y))").unwrap(),

24

1

        vec![Value::Number(Fraction::from_integer(3))]

25

);

26

1

27

28

#[test]

29

1

fn test_eval_let_parallel_semantics() {

30

1

    let mut interp = Interpreter::new(false).unwrap();

31

1

    assert_eq!(

32

1

        interp.eval("(let ((x 1)) (let ((x 10) (y x)) y))").unwrap(),

33

1

        vec![Value::Number(Fraction::from_integer(1))]

34

);

35

1

36

37

#[test]

38

1

fn test_eval_let_bare_variable() {

39

1

    let mut interp = Interpreter::new(false).unwrap();

40

1

    assert_eq!(

41

1

        interp.eval("(let ((x 1) (y)) y)").unwrap(),

42

1

        vec![Value::Nil]

43

);

44

1

45

46

#[test]

47

1

fn test_eval_let_multiple_body() {

48

1

    let mut interp = Interpreter::new(false).unwrap();

49

1

    assert_eq!(

50

1

        interp.eval("(let ((x 1)) (+ x 1) (+ x 2))").unwrap(),

51

1

        vec![Value::Number(Fraction::from_integer(3))]

52

);

53

1

54

55

#[test]

56

1

fn test_eval_let_nested() {

57

1

    let mut interp = Interpreter::new(false).unwrap();

58

1

    assert_eq!(

59

1

        interp

60

1

            .eval("(let ((x 1)) (let ((y (+ x 10))) (+ x y)))")

61

1

            .unwrap(),

62

1

        vec![Value::Number(Fraction::from_integer(12))]

63

);

64

1

65

66

#[test]

67

1

fn test_eval_let_no_body_error() {

68

1

    let mut interp = Interpreter::new(false).unwrap();

69

1

    assert!(interp.eval("(let ((x 1)))").is_err());

70

1

71

72

#[test]

73

1

fn test_eval_let_malformed_binding_error() {

74

1

    let mut interp = Interpreter::new(false).unwrap();

75

1

    assert!(interp.eval("(let ((1 2)) x)").is_err());

76

1

77

78

// LET*

79

80

#[test]

81

1

fn test_eval_let_star_sequential() {

82

1

    let mut interp = Interpreter::new(false).unwrap();

83

1

    assert_eq!(

84

1

        interp.eval("(let* ((a 1) (b (+ a 1))) b)").unwrap(),

85

1

        vec![Value::Number(Fraction::from_integer(2))]

86

);

87

1

88

89

#[test]

90

1

fn test_eval_let_star_chain() {

91

1

    let mut interp = Interpreter::new(false).unwrap();

92

1

    assert_eq!(

93

1

        interp

94

1

            .eval("(let* ((a 1) (b (+ a 1)) (c (+ a b))) c)")

95

1

            .unwrap(),

96

1

        vec![Value::Number(Fraction::from_integer(3))]

97

);

98

1

99

100

#[test]

101

1

fn test_eval_let_star_multiple_body() {

102

1

    let mut interp = Interpreter::new(false).unwrap();

103

1

    assert!(

104

1

        interp

105

1

            .eval("(let* ((a 1) (b (+ a 1))) (+ a b) (* a b c))")

106

1

            .is_err()

107

);

108

1

    assert_eq!(

109

1

        interp

110

1

            .eval("(let* ((a 1) (b (+ a 1))) (+ a b) (* a b))")

111

1

            .unwrap(),

112

1

        vec![Value::Number(Fraction::from_integer(2))]

113

);

114

1

115

116

#[test]

117

1

fn test_eval_let_star_no_body_error() {

118

1

    let mut interp = Interpreter::new(false).unwrap();

119

1

    assert!(interp.eval("(let* ((x 1)))").is_err());

120

1

121

122

#[test]

123

1

fn test_eval_let_in_defun() {

124

1

    let mut interp = Interpreter::new(false).unwrap();

125

1

    assert_eq!(

126

1

        interp

127

1

            .eval("(defun dist (x1 y1 x2 y2) (let ((dx (- x2 x1)) (dy (- y2 y1))) (+ (* dx dx) (* dy dy)))) (dist 0 0 3 4)")

128

1

            .unwrap(),

129

1

        vec![Value::Number(Fraction::from_integer(25))]

130

);

131

1

132

133

// DEFVAR

134

135

#[test]

136

1

fn test_eval_defvar() {

137

1

    let mut interp = Interpreter::new(false).unwrap();

138

1

    let results = interp.eval("(defvar *x* 42) *x*").unwrap();

139

1

    assert_eq!(results, vec![Value::Number(Fraction::from_integer(42))]);

140

1

141

142

#[test]

143

1

fn test_eval_defvar_no_reassign() {

144

1

    let mut interp = Interpreter::new(false).unwrap();

145

1

    let results = interp.eval("(defvar *x* 42) (defvar *x* 99) *x*").unwrap();

146

1

    assert_eq!(results, vec![Value::Number(Fraction::from_integer(42))]);

147

1

148

149

// DEFPARAMETER

150

151

#[test]

152

1

fn test_eval_defparameter_reassigns() {

153

1

    let mut interp = Interpreter::new(false).unwrap();

154

1

    let results = interp

155

1

        .eval("(defparameter *y* 42) (defparameter *y* 99) *y*")

156

1

        .unwrap();

157

1

    assert_eq!(results, vec![Value::Number(Fraction::from_integer(99))]);

158

1