Grcov report - arithmetic.rs

1

use nms::interpreter::Interpreter;

2

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

3

4

#[test]

5

1

fn test_eval_add() {

6

1

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

7

1

    let results = interp.eval("(+ 1 2 3 4 5 6 7)").unwrap();

8

1

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

9

1

10

11

#[test]

12

1

fn test_eval_add_identity() {

13

1

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

14

1

    let results = interp.eval("(+)").unwrap();

15

1

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

16

1

17

18

#[test]

19

1

fn test_eval_add_fractions() {

20

1

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

21

1

    let results = interp.eval("(+ 0.5 0.25)").unwrap();

22

1

    assert_eq!(results, vec![Value::Number(Fraction::new(3, 4))]);

23

1

24

25

#[test]

26

1

fn test_eval_sub_negation() {

27

1

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

28

1

    assert_eq!(

29

1

        interp.eval("(- 5)").unwrap(),

30

1

        vec![Value::Number(Fraction::from_integer(-5))]

31

);

32

1

33

34

#[test]

35

1

fn test_eval_sub_binary() {

36

1

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

37

1

    assert_eq!(

38

1

        interp.eval("(- 10 3)").unwrap(),

39

1

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

40

);

41

1

42

43

#[test]

44

1

fn test_eval_sub_variadic() {

45

1

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

46

1

    assert_eq!(

47

1

        interp.eval("(- 100 10 20 30)").unwrap(),

48

1

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

49

);

50

1

51

52

#[test]

53

1

fn test_eval_sub_no_args_error() {

54

1

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

55

1

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

56

1

57

58

#[test]

59

1

fn test_eval_mul() {

60

1

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

61

1

    assert_eq!(

62

1

        interp.eval("(* 2 3 4)").unwrap(),

63

1

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

64

);

65

1

66

67

#[test]

68

1

fn test_eval_mul_identity() {

69

1

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

70

1

    assert_eq!(

71

1

        interp.eval("(*)").unwrap(),

72

1

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

73

);

74

1

75

76

#[test]

77

1

fn test_eval_mul_fractions() {

78

1

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

79

1

    assert_eq!(

80

1

        interp.eval("(* 0.5 0.5)").unwrap(),

81

1

        vec![Value::Number(Fraction::new(1, 4))]

82

);

83

1

84

85

#[test]

86

1

fn test_eval_div_reciprocal() {

87

1

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

88

1

    assert_eq!(

89

1

        interp.eval("(/ 4)").unwrap(),

90

1

        vec![Value::Number(Fraction::new(1, 4))]

91

);

92

1

93

94

#[test]

95

1

fn test_eval_div_binary() {

96

1

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

97

1

    assert_eq!(

98

1

        interp.eval("(/ 10 3)").unwrap(),

99

1

        vec![Value::Number(Fraction::new(10, 3))]

100

);

101

1

102

103

#[test]

104

1

fn test_eval_div_variadic() {

105

1

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

106

1

    assert_eq!(

107

1

        interp.eval("(/ 120 2 3 4)").unwrap(),

108

1

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

109

);

110

1

111

112

#[test]

113

1

fn test_eval_div_by_zero_error() {

114

1

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

115

1

    assert!(interp.eval("(/ 1 0)").is_err());

116

1

117

118

#[test]

119

1

fn test_eval_div_no_args_error() {

120

1

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

121

1

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

122

1

123

124

#[test]

125

1

fn test_eval_div_reciprocal_zero_error() {

126

1

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

127

1

    assert!(interp.eval("(/ 0)").is_err());

128

1

129

130

#[test]

131

1

fn test_eval_mod() {

132

1

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

133

1

    assert_eq!(

134

1

        interp.eval("(mod 10 3)").unwrap(),

135

1

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

136

);

137

1

138

139

#[test]

140

1

fn test_eval_mod_negative() {

141

1

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

142

1

    assert_eq!(

143

1

        interp.eval("(mod -1 5)").unwrap(),

144

1

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

145

);

146

1

147

148

#[test]

149

1

fn test_eval_mod_arity_error() {

150

1

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

151

1

    assert!(interp.eval("(mod 10)").is_err());

152

1

    assert!(interp.eval("(mod 10 3 2)").is_err());

153

1