Grcov report - comparison.rs

1

use nms::interpreter::Interpreter;

2

use scripting::nomiscript::Value;

3

4

#[test]

5

1

fn test_eval_num_eq() {

6

1

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

7

1

    assert_eq!(interp.eval("(= 1 1 1)").unwrap(), vec![Value::Bool(true)]);

8

1

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

9

1

10

11

#[test]

12

1

fn test_eval_num_eq_single() {

13

1

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

14

1

    assert_eq!(interp.eval("(= 42)").unwrap(), vec![Value::Bool(true)]);

15

1

16

17

#[test]

18

1

fn test_eval_num_neq() {

19

1

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

20

1

    assert_eq!(interp.eval("(/= 1 2 3)").unwrap(), vec![Value::Bool(true)]);

21

1

    assert_eq!(interp.eval("(/= 1 2 1)").unwrap(), vec![Value::Nil]);

22

1

23

24

#[test]

25

1

fn test_eval_num_lt() {

26

1

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

27

1

    assert_eq!(interp.eval("(< 1 2 3)").unwrap(), vec![Value::Bool(true)]);

28

1

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

29

1

30

31

#[test]

32

1

fn test_eval_num_gt() {

33

1

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

34

1

    assert_eq!(interp.eval("(> 3 2 1)").unwrap(), vec![Value::Bool(true)]);

35

1

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

36

1

37

38

#[test]

39

1

fn test_eval_num_le() {

40

1

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

41

1

    assert_eq!(

42

1

        interp.eval("(<= 1 2 2 3)").unwrap(),

43

1

        vec![Value::Bool(true)]

44

);

45

1

    assert_eq!(interp.eval("(<= 1 3 2)").unwrap(), vec![Value::Nil]);

46

1

47

48

#[test]

49

1

fn test_eval_num_ge() {

50

1

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

51

1

    assert_eq!(

52

1

        interp.eval("(>= 3 2 2 1)").unwrap(),

53

1

        vec![Value::Bool(true)]

54

);

55

1

    assert_eq!(interp.eval("(>= 1 2 3)").unwrap(), vec![Value::Nil]);

56

1

57

58

#[test]

59

1

fn test_eval_comparison_type_error() {

60

1

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

61

1

    assert!(interp.eval("(= 1 \"one\")").is_err());

62

1

    assert!(interp.eval("(< \"a\" \"b\")").is_err());

63

1

64

65

#[test]

66

1

fn test_eval_eql_numbers() {

67

1

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

68

1

    assert_eq!(interp.eval("(eql 1 1)").unwrap(), vec![Value::Bool(true)]);

69

1

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

70

1

71

72

#[test]

73

1

fn test_eval_eql_strings() {

74

1

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

75

1

    assert_eq!(

76

1

        interp.eval(r#"(eql "abc" "abc")"#).unwrap(),

77

1

        vec![Value::Bool(true)]

78

);

79

1

    assert_eq!(

80

1

        interp.eval(r#"(eql "abc" "def")"#).unwrap(),

81

1

        vec![Value::Nil]

82

);

83

1

84

85

#[test]

86

1

fn test_eval_eql_mixed_types() {

87

1

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

88

1

    assert_eq!(interp.eval(r#"(eql 1 "1")"#).unwrap(), vec![Value::Nil]);

89

1

90

91

#[test]

92

1

fn test_eval_eql_nil() {

93

1

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

94

1

    assert_eq!(

95

1

        interp.eval("(eql nil nil)").unwrap(),

96

1

        vec![Value::Bool(true)]

97

);

98

1

99

100

#[test]

101

1

fn test_eval_eql_arity_error() {

102

1

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

103

1

    assert!(interp.eval("(eql 1)").is_err());

104

1

    assert!(interp.eval("(eql 1 2 3)").is_err());

105

1

106

107

#[test]

108

1

fn test_eval_equal_strings() {

109

1

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

110

1

    assert_eq!(

111

1

        interp.eval(r#"(equal "hello" "hello")"#).unwrap(),

112

1

        vec![Value::Bool(true)]

113

);

114

1

    assert_eq!(

115

1

        interp.eval(r#"(equal "hello" "world")"#).unwrap(),

116

1

        vec![Value::Nil]

117

);

118

1

119

120

#[test]

121

1

fn test_eval_equal_numbers() {

122

1

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

123

1

    assert_eq!(

124

1

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

125

1

        vec![Value::Bool(true)]

126

);

127

1

128

129

#[test]

130

1

fn test_eval_equal_arity_error() {

131

1

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

132

1

    assert!(interp.eval("(equal 1)").is_err());

133

1