Rewrite term formatting tests for clarity

This commit is contained in:
Patrick Lühne 2020-04-08 13:27:56 +02:00
parent 3b7394a43e
commit 351d7cdd19
Signed by: patrick
GPG Key ID: 05F3611E97A70ABF
2 changed files with 298 additions and 437 deletions

View File

@ -381,7 +381,6 @@ mod tests
use crate::*;
use crate::format::terms::tests::*;
// Tests all neutral intermediates (such as 1-ary conjunction)
macro_rules! assert
{
($formula:expr, $output:expr) =>

View File

@ -259,6 +259,14 @@ pub(crate) mod tests
{
use crate::*;
macro_rules! assert
{
($term:expr, $output:expr) =>
{
assert_eq!(format($term), $output);
};
}
fn format(term: Box<ast::Term>) -> String
{
format!("{}", term)
@ -392,71 +400,68 @@ pub(crate) mod tests
#[test]
fn format_binary_operation()
{
assert_eq!(format(add(constant("a"), constant("b"))), "a + b");
assert_eq!(format(subtract(constant("a"), constant("b"))), "a - b");
assert_eq!(format(multiply(constant("a"), constant("b"))), "a * b");
assert_eq!(format(divide(constant("a"), constant("b"))), "a / b");
assert_eq!(format(modulo(constant("a"), constant("b"))), "a % b");
assert_eq!(format(exponentiate(constant("a"), constant("b"))), "a ** b");
assert!(add(constant("a"), constant("b")), "a + b");
assert!(subtract(constant("a"), constant("b")), "a - b");
assert!(multiply(constant("a"), constant("b")), "a * b");
assert!(divide(constant("a"), constant("b")), "a / b");
assert!(modulo(constant("a"), constant("b")), "a % b");
assert!(exponentiate(constant("a"), constant("b")), "a ** b");
}
#[test]
fn format_boolean()
{
assert_eq!(format(true_()), "true");
assert_eq!(format(false_()), "false");
assert!(true_(), "true");
assert!(false_(), "false");
}
#[test]
fn format_special_integer()
{
assert_eq!(format(infimum()), "#inf");
assert_eq!(format(supremum()), "#sup");
assert!(infimum(), "#inf");
assert!(supremum(), "#sup");
}
#[test]
fn format_integer()
{
assert_eq!(format(integer(0)), "0");
assert_eq!(format(integer(1)), "1");
assert_eq!(format(integer(10000)), "10000");
assert_eq!(format(integer(-1)), "-1");
assert_eq!(format(integer(-10000)), "-10000");
assert!(integer(0), "0");
assert!(integer(1), "1");
assert!(integer(10000), "10000");
assert!(integer(-1), "-1");
assert!(integer(-10000), "-10000");
}
#[test]
fn format_string()
{
assert_eq!(format(string("")), "\"\"");
assert_eq!(format(string(" ")), "\" \"");
assert_eq!(format(string(" ")), "\" \"");
assert_eq!(format(string("a")), "\"a\"");
assert_eq!(format(string("test test")), "\"test test\"");
assert_eq!(format(string("123 123")), "\"123 123\"");
assert_eq!(format(string("\ntest\n123\n")), "\"\\ntest\\n123\\n\"");
assert_eq!(format(string("\ttest\t123\t")), "\"\\ttest\\t123\\t\"");
assert_eq!(format(string("\\test\\123\\")), "\"\\\\test\\\\123\\\\\"");
assert_eq!(format(string("🙂test🙂123🙂")), "\"🙂test🙂123🙂\"");
assert!(string(""), "\"\"");
assert!(string(" "), "\" \"");
assert!(string(" "), "\" \"");
assert!(string("a"), "\"a\"");
assert!(string("test test"), "\"test test\"");
assert!(string("123 123"), "\"123 123\"");
assert!(string("\ntest\n123\n"), "\"\\ntest\\n123\\n\"");
assert!(string("\ttest\t123\t"), "\"\\ttest\\t123\\t\"");
assert!(string("\\test\\123\\"), "\"\\\\test\\\\123\\\\\"");
assert!(string("🙂test🙂123🙂"), "\"🙂test🙂123🙂\"");
}
#[test]
fn format_function()
{
assert_eq!(format(constant("a")), "a");
assert_eq!(format(constant("constant")), "constant");
assert_eq!(format(function("f", vec![constant("a")])), "f(a)");
assert_eq!(format(
function("f", vec![constant("a"), constant("b"), constant("c")])),
"f(a, b, c)");
assert_eq!(format(function("function", vec![constant("a"), constant("b"), constant("c")])),
assert!(constant("a"), "a");
assert!(constant("constant"), "constant");
assert!(function("f", vec![constant("a")]), "f(a)");
assert!(function("f", vec![constant("a"), constant("b"), constant("c")]), "f(a, b, c)");
assert!(function("function", vec![constant("a"), constant("b"), constant("c")]),
"function(a, b, c)");
assert_eq!(format(
function("function", vec![
exponentiate(absolute_value(multiply(constant("a"), integer(-20))), integer(2)),
string("test"),
function("f", vec![multiply(add(constant("b"), constant("c")),
subtract(constant("b"), constant("c"))), infimum(), variable("X")])])),
assert!(function("function", vec![
exponentiate(absolute_value(multiply(constant("a"), integer(-20))), integer(2)),
string("test"),
function("f", vec![multiply(add(constant("b"), constant("c")),
subtract(constant("b"), constant("c"))), infimum(), variable("X")])]),
"function(|a * -20| ** 2, \"test\", f((b + c) * (b - c), #inf, X))");
// TODO: escape functions that start with capital letters or that conflict with keywords
@ -475,232 +480,193 @@ pub(crate) mod tests
#[test]
fn format_variable()
{
assert_eq!(format(variable("X")), "X");
assert_eq!(format(variable("Variable")), "Variable");
assert!(variable("X"), "X");
assert!(variable("Variable"), "Variable");
}
#[test]
fn format_combination_boolean_and_lower()
{
assert_eq!(format(function("f", vec![true_(), true_(), true_()])), "f(true, true, true)");
assert_eq!(format(
function("f", vec![false_(), false_(), false_()])),
"f(false, false, false)");
assert!(function("f", vec![true_(), true_(), true_()]), "f(true, true, true)");
assert!(function("f", vec![false_(), false_(), false_()]), "f(false, false, false)");
assert_eq!(format(absolute_value(true_())), "|true|");
assert_eq!(format(absolute_value(false_())), "|false|");
assert!(absolute_value(true_()), "|true|");
assert!(absolute_value(false_()), "|false|");
assert_eq!(format(negative(true_())), "-true");
assert_eq!(format(negative(false_())), "-false");
assert!(negative(true_()), "-true");
assert!(negative(false_()), "-false");
assert_eq!(format(exponentiate(true_(), true_())), "true ** true");
assert_eq!(format(exponentiate(false_(), false_())), "false ** false");
assert!(exponentiate(true_(), true_()), "true ** true");
assert!(exponentiate(false_(), false_()), "false ** false");
assert_eq!(format(multiply(true_(), true_())), "true * true");
assert_eq!(format(multiply(false_(), false_())), "false * false");
assert!(multiply(true_(), true_()), "true * true");
assert!(multiply(false_(), false_()), "false * false");
assert_eq!(format(divide(true_(), true_())), "true / true");
assert_eq!(format(divide(false_(), false_())), "false / false");
assert!(divide(true_(), true_()), "true / true");
assert!(divide(false_(), false_()), "false / false");
assert_eq!(format(modulo(true_(), true_())), "true % true");
assert_eq!(format(modulo(false_(), false_())), "false % false");
assert!(modulo(true_(), true_()), "true % true");
assert!(modulo(false_(), false_()), "false % false");
assert_eq!(format(add(true_(), true_())), "true + true");
assert_eq!(format(add(false_(), false_())), "false + false");
assert!(add(true_(), true_()), "true + true");
assert!(add(false_(), false_()), "false + false");
assert_eq!(format(subtract(true_(), true_())), "true - true");
assert_eq!(format(subtract(false_(), false_())), "false - false");
assert!(subtract(true_(), true_()), "true - true");
assert!(subtract(false_(), false_()), "false - false");
}
#[test]
fn format_combination_special_integer_and_lower()
{
assert_eq!(format(
function("f", vec![infimum(), infimum(), infimum()])),
"f(#inf, #inf, #inf)");
assert_eq!(format(
function("f", vec![supremum(), supremum(), supremum()])),
"f(#sup, #sup, #sup)");
assert!(function("f", vec![infimum(), infimum(), infimum()]), "f(#inf, #inf, #inf)");
assert!(function("f", vec![supremum(), supremum(), supremum()]), "f(#sup, #sup, #sup)");
assert_eq!(format(absolute_value(infimum())), "|#inf|");
assert_eq!(format(absolute_value(supremum())), "|#sup|");
assert!(absolute_value(infimum()), "|#inf|");
assert!(absolute_value(supremum()), "|#sup|");
assert_eq!(format(negative(infimum())), "-#inf");
assert_eq!(format(negative(supremum())), "-#sup");
assert!(negative(infimum()), "-#inf");
assert!(negative(supremum()), "-#sup");
assert_eq!(format(exponentiate(infimum(), infimum())), "#inf ** #inf");
assert_eq!(format(exponentiate(supremum(), supremum())), "#sup ** #sup");
assert!(exponentiate(infimum(), infimum()), "#inf ** #inf");
assert!(exponentiate(supremum(), supremum()), "#sup ** #sup");
assert_eq!(format(multiply(infimum(), infimum())), "#inf * #inf");
assert_eq!(format(multiply(supremum(), supremum())), "#sup * #sup");
assert!(multiply(infimum(), infimum()), "#inf * #inf");
assert!(multiply(supremum(), supremum()), "#sup * #sup");
assert_eq!(format(divide(infimum(), infimum())), "#inf / #inf");
assert_eq!(format(divide(supremum(), supremum())), "#sup / #sup");
assert!(divide(infimum(), infimum()), "#inf / #inf");
assert!(divide(supremum(), supremum()), "#sup / #sup");
assert_eq!(format(modulo(infimum(), infimum())), "#inf % #inf");
assert_eq!(format(modulo(supremum(), supremum())), "#sup % #sup");
assert!(modulo(infimum(), infimum()), "#inf % #inf");
assert!(modulo(supremum(), supremum()), "#sup % #sup");
assert_eq!(format(add(infimum(), infimum())), "#inf + #inf");
assert_eq!(format(add(supremum(), supremum())), "#sup + #sup");
assert!(add(infimum(), infimum()), "#inf + #inf");
assert!(add(supremum(), supremum()), "#sup + #sup");
assert_eq!(format(subtract(infimum(), infimum())), "#inf - #inf");
assert_eq!(format(subtract(supremum(), supremum())), "#sup - #sup");
assert!(subtract(infimum(), infimum()), "#inf - #inf");
assert!(subtract(supremum(), supremum()), "#sup - #sup");
}
#[test]
fn format_combination_integer_and_lower()
{
assert_eq!(format(
function("f", vec![integer(0), integer(0), integer(0)])),
"f(0, 0, 0)");
assert_eq!(format(
function("f", vec![integer(10000), integer(10000), integer(10000)])),
assert!(function("f", vec![integer(0), integer(0), integer(0)]), "f(0, 0, 0)");
assert!(function("f", vec![integer(10000), integer(10000), integer(10000)]),
"f(10000, 10000, 10000)");
assert_eq!(format(
function("f", vec![integer(-10000), integer(-10000), integer(-10000)])),
assert!(function("f", vec![integer(-10000), integer(-10000), integer(-10000)]),
"f(-10000, -10000, -10000)");
assert_eq!(format(absolute_value(integer(0))), "|0|");
assert_eq!(format(absolute_value(integer(10000))), "|10000|");
assert_eq!(format(absolute_value(integer(-10000))), "|-10000|");
assert!(absolute_value(integer(0)), "|0|");
assert!(absolute_value(integer(10000)), "|10000|");
assert!(absolute_value(integer(-10000)), "|-10000|");
assert_eq!(format(negative(integer(0))), "-0");
assert_eq!(format(negative(integer(10000))), "-10000");
assert_eq!(format(negative(integer(-10000))), "--10000");
assert!(negative(integer(0)), "-0");
assert!(negative(integer(10000)), "-10000");
assert!(negative(integer(-10000)), "--10000");
assert_eq!(format(exponentiate(integer(0), integer(0))), "0 ** 0");
assert_eq!(format(exponentiate(integer(10000), integer(10000))), "10000 ** 10000");
assert_eq!(format(exponentiate(integer(-10000), integer(-10000))), "-10000 ** -10000");
assert!(exponentiate(integer(0), integer(0)), "0 ** 0");
assert!(exponentiate(integer(10000), integer(10000)), "10000 ** 10000");
assert!(exponentiate(integer(-10000), integer(-10000)), "-10000 ** -10000");
assert_eq!(format(multiply(integer(0), integer(0))), "0 * 0");
assert_eq!(format(multiply(integer(10000), integer(10000))), "10000 * 10000");
assert_eq!(format(multiply(integer(-10000), integer(-10000))), "-10000 * -10000");
assert!(multiply(integer(0), integer(0)), "0 * 0");
assert!(multiply(integer(10000), integer(10000)), "10000 * 10000");
assert!(multiply(integer(-10000), integer(-10000)), "-10000 * -10000");
assert_eq!(format(divide(integer(0), integer(0))), "0 / 0");
assert_eq!(format(divide(integer(10000), integer(10000))), "10000 / 10000");
assert_eq!(format(divide(integer(-10000), integer(-10000))), "-10000 / -10000");
assert!(divide(integer(0), integer(0)), "0 / 0");
assert!(divide(integer(10000), integer(10000)), "10000 / 10000");
assert!(divide(integer(-10000), integer(-10000)), "-10000 / -10000");
assert_eq!(format(modulo(integer(0), integer(0))), "0 % 0");
assert_eq!(format(modulo(integer(10000), integer(10000))), "10000 % 10000");
assert_eq!(format(modulo(integer(-10000), integer(-10000))), "-10000 % -10000");
assert!(modulo(integer(0), integer(0)), "0 % 0");
assert!(modulo(integer(10000), integer(10000)), "10000 % 10000");
assert!(modulo(integer(-10000), integer(-10000)), "-10000 % -10000");
assert_eq!(format(add(integer(0), integer(0))), "0 + 0");
assert_eq!(format(add(integer(10000), integer(10000))), "10000 + 10000");
assert_eq!(format(add(integer(-10000), integer(-10000))), "-10000 + -10000");
assert!(add(integer(0), integer(0)), "0 + 0");
assert!(add(integer(10000), integer(10000)), "10000 + 10000");
assert!(add(integer(-10000), integer(-10000)), "-10000 + -10000");
assert_eq!(format(subtract(integer(0), integer(0))), "0 - 0");
assert_eq!(format(subtract(integer(10000), integer(10000))), "10000 - 10000");
assert_eq!(format(subtract(integer(-10000), integer(-10000))), "-10000 - -10000");
assert!(subtract(integer(0), integer(0)), "0 - 0");
assert!(subtract(integer(10000), integer(10000)), "10000 - 10000");
assert!(subtract(integer(-10000), integer(-10000)), "-10000 - -10000");
}
#[test]
fn format_combination_string_and_lower()
{
assert_eq!(format(
function("f", vec![string(""), string(""), string("")])),
"f(\"\", \"\", \"\")");
assert_eq!(format(
function("f", vec![string("test 123"), string("test 123"), string("test 123")])),
assert!(function("f", vec![string(""), string(""), string("")]), "f(\"\", \"\", \"\")");
assert!(function("f", vec![string("test 123"), string("test 123"), string("test 123")]),
"f(\"test 123\", \"test 123\", \"test 123\")");
assert_eq!(format(
function("f", vec![string("\\a\nb🙂c\t"), string("\\a\nb🙂c\t"),
string("\\a\nb🙂c\t")])),
assert!(function("f", vec![string("\\a\nb🙂c\t"), string("\\a\nb🙂c\t"),
string("\\a\nb🙂c\t")]),
"f(\"\\\\a\\nb🙂c\\t\", \"\\\\a\\nb🙂c\\t\", \"\\\\a\\nb🙂c\\t\")");
assert_eq!(format(absolute_value(string(""))), "|\"\"|");
assert_eq!(format(absolute_value(string("test 123"))), "|\"test 123\"|");
assert_eq!(format(absolute_value(string("\\a\nb🙂c\t"))), "|\"\\\\a\\nb🙂c\\t\"|");
assert!(absolute_value(string("")), "|\"\"|");
assert!(absolute_value(string("test 123")), "|\"test 123\"|");
assert!(absolute_value(string("\\a\nb🙂c\t")), "|\"\\\\a\\nb🙂c\\t\"|");
assert_eq!(format(negative(string(""))), "-\"\"");
assert_eq!(format(negative(string("test 123"))), "-\"test 123\"");
assert_eq!(format(negative(string("\\a\nb🙂c\t"))), "-\"\\\\a\\nb🙂c\\t\"");
assert!(negative(string("")), "-\"\"");
assert!(negative(string("test 123")), "-\"test 123\"");
assert!(negative(string("\\a\nb🙂c\t")), "-\"\\\\a\\nb🙂c\\t\"");
assert_eq!(format(exponentiate(string(""), string(""))), "\"\" ** \"\"");
assert_eq!(format(
exponentiate(string("test 123"), string("test 123"))),
assert!(exponentiate(string(""), string("")), "\"\" ** \"\"");
assert!(exponentiate(string("test 123"), string("test 123")),
"\"test 123\" ** \"test 123\"");
assert_eq!(format(
exponentiate(string("\\a\nb🙂c\t"), string("\\a\nb🙂c\t"))),
assert!(exponentiate(string("\\a\nb🙂c\t"), string("\\a\nb🙂c\t")),
"\"\\\\a\\nb🙂c\\t\" ** \"\\\\a\\nb🙂c\\t\"");
assert_eq!(format(multiply(string(""), string(""))), "\"\" * \"\"");
assert_eq!(format(
multiply(string("test 123"), string("test 123"))),
"\"test 123\" * \"test 123\"");
assert_eq!(format(
multiply(string("\\a\nb🙂c\t"), string("\\a\nb🙂c\t"))),
assert!(multiply(string(""), string("")), "\"\" * \"\"");
assert!(multiply(string("test 123"), string("test 123")), "\"test 123\" * \"test 123\"");
assert!(multiply(string("\\a\nb🙂c\t"), string("\\a\nb🙂c\t")),
"\"\\\\a\\nb🙂c\\t\" * \"\\\\a\\nb🙂c\\t\"");
assert_eq!(format(divide(string(""), string(""))), "\"\" / \"\"");
assert_eq!(format(
divide(string("test 123"), string("test 123"))),
"\"test 123\" / \"test 123\"");
assert_eq!(format(
divide(string("\\a\nb🙂c\t"), string("\\a\nb🙂c\t"))),
assert!(divide(string(""), string("")), "\"\" / \"\"");
assert!(divide(string("test 123"), string("test 123")), "\"test 123\" / \"test 123\"");
assert!(divide(string("\\a\nb🙂c\t"), string("\\a\nb🙂c\t")),
"\"\\\\a\\nb🙂c\\t\" / \"\\\\a\\nb🙂c\\t\"");
assert_eq!(format(modulo(string(""), string(""))), "\"\" % \"\"");
assert_eq!(format(
modulo(string("test 123"), string("test 123"))),
"\"test 123\" % \"test 123\"");
assert_eq!(format(
modulo(string("\\a\nb🙂c\t"), string("\\a\nb🙂c\t"))),
assert!(modulo(string(""), string("")), "\"\" % \"\"");
assert!(modulo(string("test 123"), string("test 123")), "\"test 123\" % \"test 123\"");
assert!(modulo(string("\\a\nb🙂c\t"), string("\\a\nb🙂c\t")),
"\"\\\\a\\nb🙂c\\t\" % \"\\\\a\\nb🙂c\\t\"");
assert_eq!(format(add(string(""), string(""))), "\"\" + \"\"");
assert_eq!(format(
add(string("test 123"), string("test 123"))),
"\"test 123\" + \"test 123\"");
assert_eq!(format(
add(string("\\a\nb🙂c\t"), string("\\a\nb🙂c\t"))),
assert!(add(string(""), string("")), "\"\" + \"\"");
assert!(add(string("test 123"), string("test 123")), "\"test 123\" + \"test 123\"");
assert!(add(string("\\a\nb🙂c\t"), string("\\a\nb🙂c\t")),
"\"\\\\a\\nb🙂c\\t\" + \"\\\\a\\nb🙂c\\t\"");
assert_eq!(format(subtract(string(""), string(""))), "\"\" - \"\"");
assert_eq!(format(
subtract(string("test 123"), string("test 123"))),
"\"test 123\" - \"test 123\"");
assert_eq!(format(
subtract(string("\\a\nb🙂c\t"), string("\\a\nb🙂c\t"))),
assert!(subtract(string(""), string("")), "\"\" - \"\"");
assert!(subtract(string("test 123"), string("test 123")), "\"test 123\" - \"test 123\"");
assert!(subtract(string("\\a\nb🙂c\t"), string("\\a\nb🙂c\t")),
"\"\\\\a\\nb🙂c\\t\" - \"\\\\a\\nb🙂c\\t\"");
}
#[test]
fn format_combination_variable_and_lower()
{
assert_eq!(format(variable("X")), "X");
assert_eq!(format(variable("Variable")), "Variable");
assert!(variable("X"), "X");
assert!(variable("Variable"), "Variable");
assert_eq!(format(absolute_value(variable("X"))), "|X|");
assert_eq!(format(absolute_value(variable("Variable"))), "|Variable|");
assert!(absolute_value(variable("X")), "|X|");
assert!(absolute_value(variable("Variable")), "|Variable|");
assert_eq!(format(negative(variable("X"))), "-X");
assert_eq!(format(negative(variable("Variable"))), "-Variable");
assert!(negative(variable("X")), "-X");
assert!(negative(variable("Variable")), "-Variable");
assert_eq!(format(exponentiate(variable("X"), variable("X"))), "X ** X");
assert_eq!(format(
exponentiate(variable("Variable"), variable("Variable"))),
"Variable ** Variable");
assert!(exponentiate(variable("X"), variable("X")), "X ** X");
assert!(exponentiate(variable("Variable"), variable("Variable")), "Variable ** Variable");
assert_eq!(format(multiply(variable("X"), variable("X"))), "X * X");
assert_eq!(format(
multiply(variable("Variable"), variable("Variable"))),
"Variable * Variable");
assert!(multiply(variable("X"), variable("X")), "X * X");
assert!(multiply(variable("Variable"), variable("Variable")), "Variable * Variable");
assert_eq!(format(divide(variable("X"), variable("X"))), "X / X");
assert_eq!(format(
divide(variable("Variable"), variable("Variable"))), "Variable / Variable");
assert!(divide(variable("X"), variable("X")), "X / X");
assert!(divide(variable("Variable"), variable("Variable")), "Variable / Variable");
assert_eq!(format(modulo(variable("X"), variable("X"))), "X % X");
assert_eq!(format(
modulo(variable("Variable"), variable("Variable"))), "Variable % Variable");
assert!(modulo(variable("X"), variable("X")), "X % X");
assert!(modulo(variable("Variable"), variable("Variable")), "Variable % Variable");
assert_eq!(format(add(variable("X"), variable("X"))), "X + X");
assert_eq!(format(
add(variable("Variable"), variable("Variable"))), "Variable + Variable");
assert!(add(variable("X"), variable("X")), "X + X");
assert!(add(variable("Variable"), variable("Variable")), "Variable + Variable");
assert_eq!(format(subtract(variable("X"), variable("X"))), "X - X");
assert_eq!(format(
subtract(variable("Variable"), variable("Variable"))), "Variable - Variable");
assert!(subtract(variable("X"), variable("X")), "X - X");
assert!(subtract(variable("Variable"), variable("Variable")), "Variable - Variable");
}
#[test]
@ -711,332 +677,228 @@ pub(crate) mod tests
let f3 = || function("f", vec![constant("a")]);
let f4 = || function("function", vec![constant("a"), constant("b"), constant("c")]);
assert_eq!(format(absolute_value(f1())), "|a|");
assert_eq!(format(absolute_value(f2())), "|constant|");
assert_eq!(format(absolute_value(f3())), "|f(a)|");
assert_eq!(format(absolute_value(f4())), "|function(a, b, c)|");
assert_eq!(format(function("f", vec![absolute_value(constant("a"))])), "f(|a|)");
assert_eq!(format(
function("f", vec![absolute_value(constant("a")), absolute_value(constant("b")),
absolute_value(constant("c"))])),
assert!(absolute_value(f1()), "|a|");
assert!(absolute_value(f2()), "|constant|");
assert!(absolute_value(f3()), "|f(a)|");
assert!(absolute_value(f4()), "|function(a, b, c)|");
assert!(function("f", vec![absolute_value(constant("a"))]), "f(|a|)");
assert!(function("f", vec![absolute_value(constant("a")), absolute_value(constant("b")),
absolute_value(constant("c"))]),
"f(|a|, |b|, |c|)");
assert_eq!(format(negative(f1())), "-a");
assert_eq!(format(negative(f2())), "-constant");
assert_eq!(format(negative(f3())), "-f(a)");
assert_eq!(format(negative(f4())), "-function(a, b, c)");
assert_eq!(format(function("f", vec![negative(constant("a"))])), "f(-a)");
assert_eq!(format(
function("f", vec![negative(constant("a")), negative(constant("b")),
negative(constant("c"))])),
assert!(negative(f1()), "-a");
assert!(negative(f2()), "-constant");
assert!(negative(f3()), "-f(a)");
assert!(negative(f4()), "-function(a, b, c)");
assert!(function("f", vec![negative(constant("a"))]), "f(-a)");
assert!(function("f", vec![negative(constant("a")), negative(constant("b")),
negative(constant("c"))]),
"f(-a, -b, -c)");
assert_eq!(format(exponentiate(f1(), f1())), "a ** a");
assert_eq!(format(exponentiate(f2(), f2())), "constant ** constant");
assert_eq!(format(exponentiate(f3(), f3())), "f(a) ** f(a)");
assert_eq!(format(exponentiate(f4(), f4())), "function(a, b, c) ** function(a, b, c)");
assert_eq!(format(
function("f", vec![exponentiate(constant("a"), constant("b"))])),
"f(a ** b)");
assert_eq!(format(
function("f", vec![exponentiate(constant("a"), constant("b")),
exponentiate(constant("c"), constant("d")),
exponentiate(constant("e"), constant("f"))])),
assert!(exponentiate(f1(), f1()), "a ** a");
assert!(exponentiate(f2(), f2()), "constant ** constant");
assert!(exponentiate(f3(), f3()), "f(a) ** f(a)");
assert!(exponentiate(f4(), f4()), "function(a, b, c) ** function(a, b, c)");
assert!(function("f", vec![exponentiate(constant("a"), constant("b"))]), "f(a ** b)");
assert!(function("f", vec![exponentiate(constant("a"), constant("b")),
exponentiate(constant("c"), constant("d")),
exponentiate(constant("e"), constant("f"))]),
"f(a ** b, c ** d, e ** f)");
assert_eq!(format(multiply(f1(), f1())), "a * a");
assert_eq!(format(multiply(f2(), f2())), "constant * constant");
assert_eq!(format(multiply(f3(), f3())), "f(a) * f(a)");
assert_eq!(format(multiply(f4(), f4())), "function(a, b, c) * function(a, b, c)");
assert_eq!(format(function("f", vec![multiply(constant("a"), constant("b"))])), "f(a * b)");
assert_eq!(format(
function("f", vec![multiply(constant("a"), constant("b")),
multiply(constant("c"), constant("d")), multiply(constant("e"), constant("f"))])),
assert!(multiply(f1(), f1()), "a * a");
assert!(multiply(f2(), f2()), "constant * constant");
assert!(multiply(f3(), f3()), "f(a) * f(a)");
assert!(multiply(f4(), f4()), "function(a, b, c) * function(a, b, c)");
assert!(function("f", vec![multiply(constant("a"), constant("b"))]), "f(a * b)");
assert!(function("f", vec![multiply(constant("a"), constant("b")),
multiply(constant("c"), constant("d")), multiply(constant("e"), constant("f"))]),
"f(a * b, c * d, e * f)");
assert_eq!(format(divide(f1(), f1())), "a / a");
assert_eq!(format(divide(f2(), f2())), "constant / constant");
assert_eq!(format(divide(f3(), f3())), "f(a) / f(a)");
assert_eq!(format(divide(f4(), f4())), "function(a, b, c) / function(a, b, c)");
assert_eq!(format(function("f", vec![divide(constant("a"), constant("b"))])), "f(a / b)");
assert_eq!(format(
function("f", vec![divide(constant("a"), constant("b")),
divide(constant("c"), constant("d")), divide(constant("e"), constant("f"))])),
assert!(divide(f1(), f1()), "a / a");
assert!(divide(f2(), f2()), "constant / constant");
assert!(divide(f3(), f3()), "f(a) / f(a)");
assert!(divide(f4(), f4()), "function(a, b, c) / function(a, b, c)");
assert!(function("f", vec![divide(constant("a"), constant("b"))]), "f(a / b)");
assert!(function("f", vec![divide(constant("a"), constant("b")),
divide(constant("c"), constant("d")), divide(constant("e"), constant("f"))]),
"f(a / b, c / d, e / f)");
assert_eq!(format(modulo(f1(), f1())), "a % a");
assert_eq!(format(modulo(f2(), f2())), "constant % constant");
assert_eq!(format(modulo(f3(), f3())), "f(a) % f(a)");
assert_eq!(format(modulo(f4(), f4())), "function(a, b, c) % function(a, b, c)");
assert_eq!(format(function("f", vec![modulo(constant("a"), constant("b"))])), "f(a % b)");
assert_eq!(format(
function("f", vec![modulo(constant("a"), constant("b")),
modulo(constant("c"), constant("d")), modulo(constant("e"), constant("f"))])),
assert!(modulo(f1(), f1()), "a % a");
assert!(modulo(f2(), f2()), "constant % constant");
assert!(modulo(f3(), f3()), "f(a) % f(a)");
assert!(modulo(f4(), f4()), "function(a, b, c) % function(a, b, c)");
assert!(function("f", vec![modulo(constant("a"), constant("b"))]), "f(a % b)");
assert!(function("f", vec![modulo(constant("a"), constant("b")),
modulo(constant("c"), constant("d")), modulo(constant("e"), constant("f"))]),
"f(a % b, c % d, e % f)");
assert_eq!(format(add(f1(), f1())), "a + a");
assert_eq!(format(add(f2(), f2())), "constant + constant");
assert_eq!(format(add(f3(), f3())), "f(a) + f(a)");
assert_eq!(format(add(f4(), f4())), "function(a, b, c) + function(a, b, c)");
assert_eq!(format(function("f", vec![add(constant("a"), constant("b"))])), "f(a + b)");
assert_eq!(format(
function("f", vec![add(constant("a"), constant("b")),
add(constant("c"), constant("d")), add(constant("e"), constant("f"))])),
assert!(add(f1(), f1()), "a + a");
assert!(add(f2(), f2()), "constant + constant");
assert!(add(f3(), f3()), "f(a) + f(a)");
assert!(add(f4(), f4()), "function(a, b, c) + function(a, b, c)");
assert!(function("f", vec![add(constant("a"), constant("b"))]), "f(a + b)");
assert!(function("f", vec![add(constant("a"), constant("b")),
add(constant("c"), constant("d")), add(constant("e"), constant("f"))]),
"f(a + b, c + d, e + f)");
assert_eq!(format(subtract(f1(), f1())), "a - a");
assert_eq!(format(subtract(f2(), f2())), "constant - constant");
assert_eq!(format(subtract(f3(), f3())), "f(a) - f(a)");
assert_eq!(format(subtract(f4(), f4())), "function(a, b, c) - function(a, b, c)");
assert_eq!(format(function("f", vec![subtract(constant("a"), constant("b"))])), "f(a - b)");
assert_eq!(format(
function("f", vec![subtract(constant("a"), constant("b")),
subtract(constant("c"), constant("d")), subtract(constant("e"), constant("f"))])),
assert!(subtract(f1(), f1()), "a - a");
assert!(subtract(f2(), f2()), "constant - constant");
assert!(subtract(f3(), f3()), "f(a) - f(a)");
assert!(subtract(f4(), f4()), "function(a, b, c) - function(a, b, c)");
assert!(function("f", vec![subtract(constant("a"), constant("b"))]), "f(a - b)");
assert!(function("f", vec![subtract(constant("a"), constant("b")),
subtract(constant("c"), constant("d")), subtract(constant("e"), constant("f"))]),
"f(a - b, c - d, e - f)");
}
#[test]
fn format_combination_absolute_value_and_lower()
{
assert_eq!(format(absolute_value(absolute_value(constant("a")))), "||a||");
assert_eq!(format(absolute_value(negative(constant("a")))), "|-a|");
assert_eq!(format(negative(absolute_value(constant("a")))), "-|a|");
assert_eq!(format(absolute_value(add(constant("a"), constant("b")))), "|a + b|");
assert_eq!(format(
add(absolute_value(constant("a")), absolute_value(constant("b")))),
"|a| + |b|");
assert_eq!(format(absolute_value(subtract(constant("a"), constant("b")))), "|a - b|");
assert_eq!(format(
subtract(absolute_value(constant("a")), absolute_value(constant("b")))),
assert!(absolute_value(absolute_value(constant("a"))), "||a||");
assert!(absolute_value(negative(constant("a"))), "|-a|");
assert!(negative(absolute_value(constant("a"))), "-|a|");
assert!(absolute_value(add(constant("a"), constant("b"))), "|a + b|");
assert!(add(absolute_value(constant("a")), absolute_value(constant("b"))), "|a| + |b|");
assert!(absolute_value(subtract(constant("a"), constant("b"))), "|a - b|");
assert!(subtract(absolute_value(constant("a")), absolute_value(constant("b"))),
"|a| - |b|");
assert_eq!(format(absolute_value(multiply(constant("a"), constant("b")))), "|a * b|");
assert_eq!(format(
multiply(absolute_value(constant("a")), absolute_value(constant("b")))),
assert!(absolute_value(multiply(constant("a"), constant("b"))), "|a * b|");
assert!(multiply(absolute_value(constant("a")), absolute_value(constant("b"))),
"|a| * |b|");
assert_eq!(format(absolute_value(divide(constant("a"), constant("b")))), "|a / b|");
assert_eq!(format(
divide(absolute_value(constant("a")), absolute_value(constant("b")))),
"|a| / |b|");
assert_eq!(format(absolute_value(modulo(constant("a"), constant("b")))), "|a % b|");
assert_eq!(format(
modulo(absolute_value(constant("a")), absolute_value(constant("b")))),
"|a| % |b|");
assert_eq!(format(absolute_value(exponentiate(constant("a"), constant("b")))), "|a ** b|");
assert_eq!(format(
exponentiate(absolute_value(constant("a")), absolute_value(constant("b")))),
assert!(absolute_value(divide(constant("a"), constant("b"))), "|a / b|");
assert!(
divide(absolute_value(constant("a")), absolute_value(constant("b"))), "|a| / |b|");
assert!(absolute_value(modulo(constant("a"), constant("b"))), "|a % b|");
assert!(modulo(absolute_value(constant("a")), absolute_value(constant("b"))), "|a| % |b|");
assert!(absolute_value(exponentiate(constant("a"), constant("b"))), "|a ** b|");
assert!(exponentiate(absolute_value(constant("a")), absolute_value(constant("b"))),
"|a| ** |b|");
}
#[test]
fn format_combination_negative_and_lower()
{
assert_eq!(format(negative(negative(constant("a")))), "--a");
assert_eq!(format(add(negative(constant("a")), negative(constant("b")))), "-a + -b");
assert_eq!(format(negative(add(constant("a"), constant("b")))), "-(a + b)");
assert_eq!(format(subtract(negative(constant("a")), negative(constant("b")))), "-a - -b");
assert_eq!(format(negative(subtract(constant("a"), constant("b")))), "-(a - b)");
assert_eq!(format(multiply(negative(constant("a")), negative(constant("b")))), "-a * -b");
assert_eq!(format(negative(multiply(constant("a"), constant("b")))), "-(a * b)");
assert_eq!(format(divide(negative(constant("a")), negative(constant("b")))), "-a / -b");
assert_eq!(format(negative(divide(constant("a"), constant("b")))), "-(a / b)");
assert_eq!(format(modulo(negative(constant("a")), negative(constant("b")))), "-a % -b");
assert_eq!(format(negative(modulo(constant("a"), constant("b")))), "-(a % b)");
assert_eq!(format(exponentiate(negative(constant("a")), negative(constant("b")))), "-a ** -b");
assert_eq!(format(negative(exponentiate(constant("a"), constant("b")))), "-(a ** b)");
assert!(negative(negative(constant("a"))), "--a");
assert!(add(negative(constant("a")), negative(constant("b"))), "-a + -b");
assert!(negative(add(constant("a"), constant("b"))), "-(a + b)");
assert!(subtract(negative(constant("a")), negative(constant("b"))), "-a - -b");
assert!(negative(subtract(constant("a"), constant("b"))), "-(a - b)");
assert!(multiply(negative(constant("a")), negative(constant("b"))), "-a * -b");
assert!(negative(multiply(constant("a"), constant("b"))), "-(a * b)");
assert!(divide(negative(constant("a")), negative(constant("b"))), "-a / -b");
assert!(negative(divide(constant("a"), constant("b"))), "-(a / b)");
assert!(modulo(negative(constant("a")), negative(constant("b"))), "-a % -b");
assert!(negative(modulo(constant("a"), constant("b"))), "-(a % b)");
assert!(exponentiate(negative(constant("a")), negative(constant("b"))), "-a ** -b");
assert!(negative(exponentiate(constant("a"), constant("b"))), "-(a ** b)");
}
#[test]
fn format_combination_exponentiate_and_lower()
{
assert_eq!(format(
exponentiate(
exponentiate(constant("a"), constant("b")),
exponentiate(constant("c"), constant("d")))),
assert!(exponentiate(exponentiate(constant("a"), constant("b")),
exponentiate(constant("c"), constant("d"))),
"(a ** b) ** c ** d");
assert_eq!(format(
exponentiate(
multiply(constant("a"), constant("b")),
multiply(constant("c"), constant("d")))),
assert!(exponentiate(multiply(constant("a"), constant("b")),
multiply(constant("c"), constant("d"))),
"(a * b) ** (c * d)");
assert_eq!(format(
multiply(
exponentiate(constant("a"), constant("b")),
exponentiate(constant("c"), constant("d")))),
assert!(multiply(exponentiate(constant("a"), constant("b")),
exponentiate(constant("c"), constant("d"))),
"a ** b * c ** d");
assert_eq!(format(
exponentiate(
divide(constant("a"), constant("b")),
divide(constant("c"), constant("d")))),
assert!(exponentiate(divide(constant("a"), constant("b")),
divide(constant("c"), constant("d"))),
"(a / b) ** (c / d)");
assert_eq!(format(
divide(
exponentiate(constant("a"), constant("b")),
exponentiate(constant("c"), constant("d")))),
assert!(divide(exponentiate(constant("a"), constant("b")),
exponentiate(constant("c"), constant("d"))),
"a ** b / c ** d");
assert_eq!(format(
exponentiate(
modulo(constant("a"), constant("b")),
modulo(constant("c"), constant("d")))),
assert!(exponentiate(modulo(constant("a"), constant("b")),
modulo(constant("c"), constant("d"))),
"(a % b) ** (c % d)");
assert_eq!(format(
modulo(
exponentiate(constant("a"), constant("b")),
exponentiate(constant("c"), constant("d")))),
assert!(modulo(exponentiate(constant("a"), constant("b")),
exponentiate(constant("c"), constant("d"))),
"a ** b % c ** d");
assert_eq!(format(
exponentiate(
add(constant("a"), constant("b")),
add(constant("c"), constant("d")))),
assert!(exponentiate(add(constant("a"), constant("b")), add(constant("c"), constant("d"))),
"(a + b) ** (c + d)");
assert_eq!(format(
add(
exponentiate(constant("a"), constant("b")),
exponentiate(constant("c"), constant("d")))),
assert!(add(exponentiate(constant("a"), constant("b")),
exponentiate(constant("c"), constant("d"))),
"a ** b + c ** d");
assert_eq!(format(
exponentiate(
subtract(constant("a"), constant("b")),
subtract(constant("c"), constant("d")))),
assert!(exponentiate(subtract(constant("a"), constant("b")),
subtract(constant("c"), constant("d"))),
"(a - b) ** (c - d)");
assert_eq!(format(
subtract(
exponentiate(constant("a"), constant("b")),
exponentiate(constant("c"), constant("d")))),
assert!(subtract(exponentiate(constant("a"), constant("b")),
exponentiate(constant("c"), constant("d"))),
"a ** b - c ** d");
}
#[test]
fn format_combination_multiplicative_binary_operations_and_lower()
{
assert_eq!(format(
multiply(
multiply(constant("a"), constant("b")),
multiply(constant("c"), constant("d")))),
assert!(multiply(multiply(constant("a"), constant("b")),
multiply(constant("c"), constant("d"))),
"a * b * c * d");
assert_eq!(format(
multiply(
divide(constant("a"), constant("b")),
divide(constant("c"), constant("d")))),
assert!(multiply(divide(constant("a"), constant("b")),
divide(constant("c"), constant("d"))),
"a / b * c / d");
assert_eq!(format(
multiply(
modulo(constant("a"), constant("b")),
modulo(constant("c"), constant("d")))),
assert!(multiply(modulo(constant("a"), constant("b")),
modulo(constant("c"), constant("d"))),
"a % b * (c % d)");
assert_eq!(format(
divide(
multiply(constant("a"), constant("b")),
multiply(constant("c"), constant("d")))),
assert!(divide(multiply(constant("a"), constant("b")),
multiply(constant("c"), constant("d"))),
"a * b / (c * d)");
assert_eq!(format(
divide(
divide(constant("a"), constant("b")),
divide(constant("c"), constant("d")))),
assert!(divide(divide(constant("a"), constant("b")), divide(constant("c"), constant("d"))),
"a / b / (c / d)");
assert_eq!(format(
divide(
modulo(constant("a"), constant("b")),
modulo(constant("c"), constant("d")))),
assert!(divide(modulo(constant("a"), constant("b")), modulo(constant("c"), constant("d"))),
"a % b / (c % d)");
assert_eq!(format(
modulo(
multiply(constant("a"), constant("b")),
multiply(constant("c"), constant("d")))),
assert!(modulo(multiply(constant("a"), constant("b")),
multiply(constant("c"), constant("d"))),
"a * b % (c * d)");
assert_eq!(format(
modulo(
divide(constant("a"), constant("b")),
divide(constant("c"), constant("d")))),
assert!(modulo(divide(constant("a"), constant("b")), divide(constant("c"), constant("d"))),
"a / b % (c / d)");
assert_eq!(format(
modulo(
modulo(constant("a"), constant("b")),
modulo(constant("c"), constant("d")))),
assert!(modulo(modulo(constant("a"), constant("b")), modulo(constant("c"), constant("d"))),
"a % b % (c % d)");
assert_eq!(format(
multiply(
add(constant("a"), constant("b")),
add(constant("c"), constant("d")))),
assert!(multiply(add(constant("a"), constant("b")), add(constant("c"), constant("d"))),
"(a + b) * (c + d)");
assert_eq!(format(
add(
multiply(constant("a"), constant("b")),
multiply(constant("c"), constant("d")))),
assert!(add(multiply(constant("a"), constant("b")), multiply(constant("c"), constant("d"))),
"a * b + c * d");
assert_eq!(format(
multiply(
subtract(constant("a"), constant("b")),
subtract(constant("c"), constant("d")))),
assert!(multiply(subtract(constant("a"), constant("b")),
subtract(constant("c"), constant("d"))),
"(a - b) * (c - d)");
assert_eq!(format(
subtract(
multiply(constant("a"), constant("b")),
multiply(constant("c"), constant("d")))),
assert!(subtract(multiply(constant("a"), constant("b")),
multiply(constant("c"), constant("d"))),
"a * b - c * d");
assert_eq!(format(
divide(
add(constant("a"), constant("b")),
add(constant("c"), constant("d")))),
assert!(divide(add(constant("a"), constant("b")), add(constant("c"), constant("d"))),
"(a + b) / (c + d)");
assert_eq!(format(
add(
divide(constant("a"), constant("b")),
divide(constant("c"), constant("d")))),
assert!(add(divide(constant("a"), constant("b")), divide(constant("c"), constant("d"))),
"a / b + c / d");
assert_eq!(format(
divide(
subtract(constant("a"), constant("b")),
subtract(constant("c"), constant("d")))),
assert!(divide(subtract(constant("a"), constant("b")),
subtract(constant("c"), constant("d"))),
"(a - b) / (c - d)");
assert_eq!(format(
subtract(
divide(constant("a"), constant("b")),
divide(constant("c"), constant("d")))),
assert!(subtract(divide(constant("a"), constant("b")),
divide(constant("c"), constant("d"))),
"a / b - c / d");
assert_eq!(format(
modulo(
add(constant("a"), constant("b")),
add(constant("c"), constant("d")))),
assert!(modulo(add(constant("a"), constant("b")), add(constant("c"), constant("d"))),
"(a + b) % (c + d)");
assert_eq!(format(
add(
modulo(constant("a"), constant("b")),
modulo(constant("c"), constant("d")))),
assert!(add(modulo(constant("a"), constant("b")), modulo(constant("c"), constant("d"))),
"a % b + c % d");
assert_eq!(format(
modulo(
subtract(constant("a"), constant("b")),
subtract(constant("c"), constant("d")))),
assert!(modulo(subtract(constant("a"), constant("b")),
subtract(constant("c"), constant("d"))),
"(a - b) % (c - d)");
assert_eq!(format(
subtract(
modulo(constant("a"), constant("b")),
modulo(constant("c"), constant("d")))),
assert!(subtract(modulo(constant("a"), constant("b")),
modulo(constant("c"), constant("d"))),
"a % b - c % d");
}
#[test]
fn format_combination_additive_binary_operations_and_lower()
{
assert_eq!(format(
add(
add(constant("a"), constant("b")),
add(constant("c"), constant("d")))),
assert!(add(add(constant("a"), constant("b")), add(constant("c"), constant("d"))),
"a + b + c + d");
assert_eq!(format(
add(
subtract(constant("a"), constant("b")),
subtract(constant("c"), constant("d")))),
assert!(add(subtract(constant("a"), constant("b")), subtract(constant("c"), constant("d"))),
"a - b + c - d");
assert_eq!(format(
subtract(
add(constant("a"), constant("b")),
add(constant("c"), constant("d")))),
assert!(subtract(add(constant("a"), constant("b")), add(constant("c"), constant("d"))),
"a + b - (c + d)");
assert_eq!(format(
subtract(
subtract(constant("a"), constant("b")),
subtract(constant("c"), constant("d")))),
assert!(subtract(subtract(constant("a"), constant("b")),
subtract(constant("c"), constant("d"))),
"a - b - (c - d)");
}
}