Grcov report - bindings.rs

1

use nms::interpreter::Interpreter;

2

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

3

4

// LET

5

6

#[test]

7

1

fn test_eval_let_basic() {

8

1

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

9

1

    assert_eq!(

10

1

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

11

1

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

12

);

13

1

14

15

#[test]

16

1

fn test_eval_let_multiple_bindings() {

17

1

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

18

1

    assert_eq!(

19

1

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

20

1

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

21

);

22

1

23

24

#[test]

25

1

fn test_eval_let_parallel_semantics() {

26

1

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

27

1

    assert_eq!(

28

1

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

29

1

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

30

);

31

1

32

33

#[test]

34

1

fn test_eval_let_bare_variable() {

35

1

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

36

1

    assert_eq!(

37

1

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

38

1

        vec![Value::Nil]

39

);

40

1

41

42

#[test]

43

1

fn test_eval_let_multiple_body() {

44

1

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

45

1

    assert_eq!(

46

1

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

47

1

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

48

);

49

1

50

51

#[test]

52

1

fn test_eval_let_nested() {

53

1

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

54

1

    assert_eq!(

55

1

        interp

56

1

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

57

1

            .unwrap(),

58

1

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

59

);

60

1

61

62

#[test]

63

1

fn test_eval_let_no_body_error() {

64

1

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

65

1

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

66

1

67

68

#[test]

69

1

fn test_eval_let_malformed_binding_error() {

70

1

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

71

1

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

72

1

73

74

// LET*

75

76

#[test]

77

1

fn test_eval_let_star_sequential() {

78

1

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

79

1

    assert_eq!(

80

1

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

81

1

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

82

);

83

1

84

85

#[test]

86

1

fn test_eval_let_star_chain() {

87

1

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

88

1

    assert_eq!(

89

1

        interp

90

1

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

91

1

            .unwrap(),

92

1

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

93

);

94

1

95

96

#[test]

97

1

fn test_eval_let_star_multiple_body() {

98

1

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

99

1

    assert!(

100

1

        interp

101

1

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

102

1

            .is_err()

103

);

104

1

    assert_eq!(

105

1

        interp

106

1

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

107

1

            .unwrap(),

108

1

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

109

);

110

1

111

112

#[test]

113

1

fn test_eval_let_star_no_body_error() {

114

1

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

115

1

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

116

1

117

118

#[test]

119

1

fn test_eval_let_in_defun() {

120

1

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

121

1

    assert_eq!(

122

1

        interp

123

1

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

124

1

            .unwrap(),

125

1

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

126

);

127

1

128

129

// DEFVAR

130

131

#[test]

132

1

fn test_eval_defvar() {

133

1

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

134

1

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

135

1

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

136

1

137

138

#[test]

139

1

fn test_eval_defvar_no_reassign() {

140

1

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

141

1

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

142

1

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

143

1

144

145

// DEFPARAMETER

146

147

#[test]

148

1

fn test_eval_defparameter_reassigns() {

149

1

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

150

1

    let results = interp

151

1

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

152

1

        .unwrap();

153

1

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

154

1