Grcov report - eval

1

use nms::interpreter::Interpreter;

2

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

3

4

#[test]

5

1

fn test_eval_nil() {

6

1

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

7

1

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

8

1

    assert_eq!(results, vec![Value::Nil]);

9

1

10

11

#[test]

12

1

fn test_eval_bool() {

13

1

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

14

1

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

15

1

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

16

1

17

18

#[test]

19

1

fn test_eval_empty_list_is_nil() {

20

1

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

21

1

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

22

1

23

24

#[test]

25

1

fn test_eval_false_is_nil() {

26

1

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

27

1

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

28

1

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

29

1

30

31

#[test]

32

1

fn test_eval_number() {

33

1

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

34

1

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

35

1

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

36

1

37

38

#[test]

39

1

fn test_eval_integer() {

40

1

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

41

1

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

42

1

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

43

1

44

45

#[test]

46

1

fn test_eval_string() {

47

1

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

48

1

    assert_eq!(

49

1

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

50

1

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

51

);

52

1

53

54

#[test]

55

1

fn test_eval_empty_string() {

56

1

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

57

1

    assert_eq!(

58

1

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

59

1

        vec![Value::String(String::new())]

60

);

61

1

62

63

#[test]

64

1

fn test_eval_string_with_unicode() {

65

1

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

66

1

    assert_eq!(

67

1

        interp.eval(r#""日本語""#).unwrap(),

68

1

        vec![Value::String("日本語".to_string())]

69

);

70

1

71

72

#[test]

73

1

fn test_eval_empty() {

74

1

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

75

1

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

76

1

    assert!(results.is_empty());

77

1

78

79

#[test]

80

1

fn test_eval_revision() {

81

1

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

82

1

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

83

1

    assert_eq!(results.len(), 1);

84

1

    match &results[0] {

85

1

        Value::String(s) => {

86

1

            assert!(!s.is_empty());

87

7

            assert!(s.chars().all(|c| c.is_ascii_hexdigit()));

88

89

        _ => panic!("expected string, got {:?}", results[0]),

90

91

1

92

93

#[test]

94

1

fn test_eval_undefined_symbol() {

95

1

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

96

1

    let result = interp.eval("unknown");

97

1

    assert!(result.is_err());

98

1

99

100

#[test]

101

1

fn test_eval_debug_call() {

102

1

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

103

1

    let results = interp.eval(r#"(debug "hello")"#).unwrap();

104

1

    assert_eq!(results, vec![Value::Nil]);

105

1

106

107

#[test]

108

1

fn test_eval_debug_variadic() {

109

1

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

110

1

    let results = interp.eval(r#"(debug "hello" revision 1 2 3)"#).unwrap();

111

1

    assert_eq!(results, vec![Value::Nil]);

112

1

113

114

#[test]

115

1

fn test_eval_debug_no_args() {

116

1

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

117

1

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

118

1

    assert_eq!(results, vec![Value::Nil]);

119

1