Grcov report - control

1

use nms::interpreter::Interpreter;

2

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

3

4

// IF

5

6

#[test]

7

1

fn test_eval_if_true() {

8

1

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

9

1

    assert_eq!(

10

1

        interp.eval("(if #t 1 2)").unwrap(),

11

1

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

12

);

13

1

14

15

#[test]

16

1

fn test_eval_if_nil() {

17

1

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

18

1

    assert_eq!(

19

1

        interp.eval("(if nil 1 2)").unwrap(),

20

1

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

21

);

22

1

23

24

#[test]

25

1

fn test_eval_if_false_is_nil() {

26

1

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

27

1

    assert_eq!(

28

1

        interp.eval("(if #f 1 2)").unwrap(),

29

1

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

30

);

31

1

32

33

#[test]

34

1

fn test_eval_if_zero_is_truthy() {

35

1

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

36

1

    assert_eq!(

37

1

        interp.eval("(if 0 1 2)").unwrap(),

38

1

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

39

);

40

1

41

42

#[test]

43

1

fn test_eval_if_empty_string_is_truthy() {

44

1

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

45

1

    assert_eq!(

46

1

        interp.eval(r#"(if "" 1 2)"#).unwrap(),

47

1

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

48

);

49

1

50

51

#[test]

52

1

fn test_eval_if_no_else_false() {

53

1

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

54

1

    assert_eq!(interp.eval("(if nil 1)").unwrap(), vec![Value::Nil]);

55

1

56

57

#[test]

58

1

fn test_eval_if_no_else_true() {

59

1

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

60

1

    assert_eq!(

61

1

        interp.eval("(if #t 1)").unwrap(),

62

1

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

63

);

64

1

65

66

#[test]

67

1

fn test_eval_if_with_expressions() {

68

1

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

69

1

    assert_eq!(

70

1

        interp.eval("(if (= 1 1) (+ 10 20) (+ 30 40))").unwrap(),

71

1

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

72

);

73

1

    assert_eq!(

74

1

        interp.eval("(if (= 1 2) (+ 10 20) (+ 30 40))").unwrap(),

75

1

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

76

);

77

1

78

79

#[test]

80

1

fn test_eval_if_arity_error() {

81

1

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

82

1

    assert!(interp.eval("(if #t)").is_err());

83

1

    assert!(interp.eval("(if #t 1 2 3)").is_err());

84

1

85

86

// COND

87

88

#[test]

89

1

fn test_eval_cond_basic() {

90

1

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

91

1

    assert_eq!(

92

1

        interp.eval("(cond (#t 1))").unwrap(),

93

1

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

94

);

95

1

96

97

#[test]

98

1

fn test_eval_cond_second_clause() {

99

1

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

100

1

    assert_eq!(

101

1

        interp.eval("(cond (nil 1) (#t 2))").unwrap(),

102

1

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

103

);

104

1

105

106

#[test]

107

1

fn test_eval_cond_no_match() {

108

1

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

109

1

    assert_eq!(interp.eval("(cond (nil 1))").unwrap(), vec![Value::Nil]);

110

1

111

112

#[test]

113

1

fn test_eval_cond_no_clauses() {

114

1

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

115

1

    assert_eq!(interp.eval("(cond)").unwrap(), vec![Value::Nil]);

116

1

117

118

#[test]

119

1

fn test_eval_cond_test_only_clause() {

120

1

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

121

1

    assert_eq!(interp.eval("(cond (#t))").unwrap(), vec![Value::Bool(true)]);

122

1

123

124

#[test]

125

1

fn test_eval_cond_with_expressions() {

126

1

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

127

1

    assert_eq!(

128

1

        interp.eval("(cond ((= 1 1) (+ 10 20)))").unwrap(),

129

1

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

130

);

131

1

132

133

#[test]

134

1

fn test_eval_cond_third_clause() {

135

1

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

136

1

    assert_eq!(

137

1

        interp.eval("(cond (nil 1) (nil 2) (#t 3))").unwrap(),

138

1

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

139

);

140

1

141

142

#[test]

143

1

fn test_eval_cond_multiple_body() {

144

1

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

145

1

    assert_eq!(

146

1

        interp.eval("(cond (#t (+ 1 1) (+ 2 2)))").unwrap(),

147

1

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

148

);

149

1

150

151

// DO

152

153

#[test]

154

1

fn test_eval_do_countdown() {

155

1

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

156

1

    assert_eq!(

157

1

        interp

158

1

            .eval(r#"(do ((i 5 (- i 1))) ((= i 0) "done"))"#)

159

1

            .unwrap(),

160

1

        vec![Value::String("done".to_string())]

161

);

162

1

163

164

#[test]

165

1

fn test_eval_do_accumulator() {

166

1

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

167

1

    assert_eq!(

168

1

        interp

169

1

            .eval("(do ((i 0 (+ i 1)) (sum 0 (+ sum i))) ((= i 5) sum))")

170

1

            .unwrap(),

171

1

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

172

);

173

1

174

175

#[test]

176

1

fn test_eval_do_no_result_forms() {

177

1

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

178

1

    assert_eq!(

179

1

        interp.eval("(do ((i 3 (- i 1))) ((= i 0)))").unwrap(),

180

1

        vec![Value::Nil]

181

);

182

1

183

184

#[test]

185

1

fn test_eval_do_no_step() {

186

1

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

187

1

    assert_eq!(

188

1

        interp

189

1

            .eval("(do ((x 10) (i 3 (- i 1))) ((= i 0) x))")

190

1

            .unwrap(),

191

1

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

192

);

193

1

194

195

#[test]

196

1

fn test_eval_do_bare_var() {

197

1

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

198

1

    assert_eq!(

199

1

        interp.eval(r#"(do ((x)) ((eql x nil) "nil"))"#).unwrap(),

200

1

        vec![Value::String("nil".to_string())]

201

);

202

1

203

204

#[test]

205

1

fn test_eval_do_arity_error() {

206

1

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

207

1

    assert!(interp.eval("(do)").is_err());

208

1

    assert!(interp.eval("(do ())").is_err());

209

1

210

211

// DO*

212

213

#[test]

214

1

fn test_eval_do_star_sequential_init() {

215

1

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

216

1

    assert_eq!(

217

1

        interp

218

1

            .eval("(do* ((a 1) (b (+ a 1))) (#t (+ a b)))")

219

1

            .unwrap(),

220

1

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

221

);

222

1

223

224

#[test]

225

1

fn test_eval_do_star_sequential_step() {

226

1

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

227

1

    assert_eq!(

228

1

        interp

229

1

            .eval("(do* ((i 0 (+ i 1)) (j 0 i)) ((= i 3) j))")

230

1

            .unwrap(),

231

1

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

232

);

233

1