fn test_defmacro_when() {

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

    let results = interp

        .eval("(defmacro when (test body) (list 'if test body))\n(when (> 3 2) \"yes\")")

        .unwrap();

    assert_eq!(results, vec![Value::String("yes".to_string())]);

}

fn test_defmacro_when_false() {

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

    let results = interp

        .eval("(defmacro when (test body) (list 'if test body))\n(when (> 2 3) \"yes\")")

        .unwrap();

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

}

fn test_defmacro_unless() {

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

    let results = interp

        .eval("(defmacro unless (test body) (list 'if test nil body))\n(unless #f \"yes\")")

        .unwrap();

    assert_eq!(results, vec![Value::String("yes".to_string())]);

}

fn test_defmacro_constant() {

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

    let results = interp

        .eval("(defmacro always-42 () 42)\n(always-42)")

        .unwrap();

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

}

fn test_defmacro_returns_name() {

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

    let results = interp.eval("(defmacro my-m (x) x)").unwrap();

    assert_eq!(results, vec![Value::Symbol("MY-M".to_string())]);

}

fn test_defmacro_arity_error() {

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

    let result = interp.eval("(defmacro when (test body) (list 'if test body))\n(when (> 3 2))");

    assert!(result.is_err());

}

fn test_defmacro_persistence() {

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

    interp

        .eval("(defmacro when (test body) (list 'if test body))")

        .unwrap();

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

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

}

fn test_defmacro_swap_args() {

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

    let results = interp

        .eval("(defmacro swap-sub (a b) (list '- b a))\n(swap-sub 1 10)")

        .unwrap();

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

}

fn test_defmacro_nested_expansion() {

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

    let results = interp

        .eval("(defmacro when (test body) (list 'if test body))\n(when (when #t #t) 42)")

        .unwrap();

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

}

fn test_defmacro_chained() {

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

    let results = interp

        .eval("(defmacro when (test body) (list 'if test body))\n(defmacro my-when (test body) (list 'when test body))\n(my-when (> 3 2) \"yes\")")

        .unwrap();

    assert_eq!(results, vec![Value::String("yes".to_string())]);

}

fn test_defmacro_bare_value_error() {

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

    interp

        .eval("(defmacro when (test body) (list 'if test body))")

        .unwrap();

    let err = interp.eval("when").unwrap_err();

    assert!(

        err.to_string().contains("macro"),

}

fn test_macroexpand_1_macro() {

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

    let results = interp

        .eval("(defmacro when (test body) (list 'if test body))\n(macroexpand-1 '(when #t 42))")

        .unwrap();

    assert_eq!(results, vec![Value::String("('IF #T 42)".to_string())]);

}

fn test_macroexpand_1_non_macro() {

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

    let results = interp.eval("(macroexpand-1 '(+ 1 2))").unwrap();

    assert_eq!(results, vec![Value::String("(+ 1 2)".to_string())]);

}

fn test_macroexpand_repeated() {

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

    let results = interp

        .eval("(defmacro when (test body) (list 'if test body))\n(defmacro my-when (test body) (list 'when test body))\n(macroexpand '(my-when #t 42))")

        .unwrap();

    assert_eq!(results, vec![Value::String("('IF #T 42)".to_string())]);

}

fn test_quasiquote_when() {

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

    let results = interp

        .eval("(defmacro when (test body) `(if ,test ,body))\n(when (> 3 2) \"yes\")")

        .unwrap();

    assert_eq!(results, vec![Value::String("yes".to_string())]);

}

fn test_quasiquote_unless() {

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

    let results = interp

        .eval("(defmacro unless (test body) `(if ,test nil ,body))\n(unless #f \"yes\")")

        .unwrap();

    assert_eq!(results, vec![Value::String("yes".to_string())]);

}

fn test_quasiquote_unquote_splicing() {

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

    let results = interp

        .eval("(defmacro listify (&rest xs) `(list ,@xs))\n(listify 1 2 3)")

        .unwrap();

    assert_eq!(results, vec![Value::String("(1 2 3)".to_string())]);

}

fn test_quasiquote_literal() {

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

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

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

}

fn test_quasiquote_symbol() {

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

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

    assert_eq!(results, vec![Value::Symbol("FOO".to_string())]);

}

fn test_unquote_outside_error() {

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

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

}

fn test_describe_macro() {

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

    let results = interp

        .eval("(defmacro when (test body) (list 'if test body))\n(describe when)")

        .unwrap();

    match &results[0] {

        Value::String(s) => {

            assert!(s.contains("WHEN is a macro"), "got: {s}");

}