From add24979d50c298f1b8184e88ed1256537261ce1 Mon Sep 17 00:00:00 2001 From: Mike Cifelli Date: Sun, 4 Nov 2018 08:34:07 -0500 Subject: [PATCH] Convert predicates to kotlin --- .../function/builtin/predicate/ATOM.java | 28 ---------- .../kotlin/function/builtin/predicate/Atom.kt | 24 +++++++++ .../kotlin/function/builtin/predicate/EQ.java | 54 ------------------- .../function/builtin/predicate/EQUAL.java | 39 -------------- .../kotlin/function/builtin/predicate/Eq.kt | 45 ++++++++++++++++ .../function/builtin/predicate/Equal.kt | 36 +++++++++++++ .../function/builtin/predicate/LISTP.java | 27 ---------- .../function/builtin/predicate/Listp.kt | 23 ++++++++ .../function/builtin/predicate/NULL.java | 27 ---------- .../builtin/predicate/NUMERIC_GREATER.java | 54 ------------------- .../builtin/predicate/NUMERIC_LESS.java | 54 ------------------- .../kotlin/function/builtin/predicate/Null.kt | 23 ++++++++ .../builtin/predicate/NumericGreater.kt | 42 +++++++++++++++ .../function/builtin/predicate/NumericLess.kt | 46 ++++++++++++++++ .../kotlin/function/builtin/special/Case.kt | 2 +- .../{ATOMTest.java => AtomTest.java} | 2 +- .../predicate/{EQTest.java => EqTest.java} | 2 +- .../{EQUALTest.java => EqualTest.java} | 2 +- .../{LISTPTest.java => ListpTest.java} | 2 +- .../{NULLTest.java => NullTest.java} | 2 +- ...EATERTest.java => NumericGreaterTest.java} | 2 +- ...RIC_LESSTest.java => NumericLessTest.java} | 2 +- 22 files changed, 247 insertions(+), 291 deletions(-) delete mode 100644 src/main/kotlin/function/builtin/predicate/ATOM.java create mode 100644 src/main/kotlin/function/builtin/predicate/Atom.kt delete mode 100644 src/main/kotlin/function/builtin/predicate/EQ.java delete mode 100644 src/main/kotlin/function/builtin/predicate/EQUAL.java create mode 100644 src/main/kotlin/function/builtin/predicate/Eq.kt create mode 100644 src/main/kotlin/function/builtin/predicate/Equal.kt delete mode 100644 src/main/kotlin/function/builtin/predicate/LISTP.java create mode 100644 src/main/kotlin/function/builtin/predicate/Listp.kt delete mode 100644 src/main/kotlin/function/builtin/predicate/NULL.java delete mode 100644 src/main/kotlin/function/builtin/predicate/NUMERIC_GREATER.java delete mode 100644 src/main/kotlin/function/builtin/predicate/NUMERIC_LESS.java create mode 100644 src/main/kotlin/function/builtin/predicate/Null.kt create mode 100644 src/main/kotlin/function/builtin/predicate/NumericGreater.kt create mode 100644 src/main/kotlin/function/builtin/predicate/NumericLess.kt rename src/test/kotlin/function/builtin/predicate/{ATOMTest.java => AtomTest.java} (94%) rename src/test/kotlin/function/builtin/predicate/{EQTest.java => EqTest.java} (97%) rename src/test/kotlin/function/builtin/predicate/{EQUALTest.java => EqualTest.java} (97%) rename src/test/kotlin/function/builtin/predicate/{LISTPTest.java => ListpTest.java} (94%) rename src/test/kotlin/function/builtin/predicate/{NULLTest.java => NullTest.java} (94%) rename src/test/kotlin/function/builtin/predicate/{NUMERIC_GREATERTest.java => NumericGreaterTest.java} (95%) rename src/test/kotlin/function/builtin/predicate/{NUMERIC_LESSTest.java => NumericLessTest.java} (95%) diff --git a/src/main/kotlin/function/builtin/predicate/ATOM.java b/src/main/kotlin/function/builtin/predicate/ATOM.java deleted file mode 100644 index 022c6fc..0000000 --- a/src/main/kotlin/function/builtin/predicate/ATOM.java +++ /dev/null @@ -1,28 +0,0 @@ -package function.builtin.predicate; - -import function.ArgumentValidator; -import function.FunctionNames; -import function.LispFunction; -import sexpression.Cons; -import sexpression.Nil; -import sexpression.SExpression; -import sexpression.Symbol; - -@FunctionNames({ "ATOM", "ATOM?" }) -public class ATOM extends LispFunction { - - private ArgumentValidator argumentValidator; - - public ATOM(String name) { - this.argumentValidator = new ArgumentValidator(name); - this.argumentValidator.setExactNumberOfArguments(1); - } - - @Override - public SExpression call(Cons argumentList) { - argumentValidator.validate(argumentList); - SExpression argument = argumentList.getFirst(); - - return argument.isAtom() ? Symbol.Companion.getT() : Nil.INSTANCE; - } -} diff --git a/src/main/kotlin/function/builtin/predicate/Atom.kt b/src/main/kotlin/function/builtin/predicate/Atom.kt new file mode 100644 index 0000000..34184f3 --- /dev/null +++ b/src/main/kotlin/function/builtin/predicate/Atom.kt @@ -0,0 +1,24 @@ +package function.builtin.predicate + +import function.ArgumentValidator +import function.FunctionNames +import function.LispFunction +import sexpression.Cons +import sexpression.Nil +import sexpression.SExpression +import sexpression.Symbol + +@FunctionNames("ATOM", "ATOM?") +class Atom(name: String) : LispFunction() { + + private val argumentValidator = ArgumentValidator(name).apply { + setExactNumberOfArguments(1) + } + + override fun call(argumentList: Cons): SExpression { + argumentValidator.validate(argumentList) + val argument = argumentList.first + + return if (argument.isAtom) Symbol.T else Nil + } +} diff --git a/src/main/kotlin/function/builtin/predicate/EQ.java b/src/main/kotlin/function/builtin/predicate/EQ.java deleted file mode 100644 index cdfa72a..0000000 --- a/src/main/kotlin/function/builtin/predicate/EQ.java +++ /dev/null @@ -1,54 +0,0 @@ -package function.builtin.predicate; - -import function.ArgumentValidator; -import function.FunctionNames; -import function.LispFunction; -import sexpression.Cons; -import sexpression.Nil; -import sexpression.SExpression; -import sexpression.Symbol; - -@FunctionNames({ "EQ", "EQ?" }) -public class EQ extends LispFunction { - - private ArgumentValidator argumentValidator; - - public EQ(String name) { - this.argumentValidator = new ArgumentValidator(name); - this.argumentValidator.setExactNumberOfArguments(2); - } - - @Override - public SExpression call(Cons argumentList) { - argumentValidator.validate(argumentList); - - Cons rest = (Cons) argumentList.getRest(); - SExpression firstArgument = argumentList.getFirst(); - SExpression secondArgument = rest.getFirst(); - - return eq(firstArgument, secondArgument); - } - - private SExpression eq(SExpression firstArgument, SExpression secondArgument) { - if (isAtomPair(firstArgument, secondArgument)) - return atomEq(firstArgument, secondArgument); - - return listEq(firstArgument, secondArgument); - } - - private boolean isAtomPair(SExpression firstArgument, SExpression secondArgument) { - return firstArgument.isAtom() && secondArgument.isAtom(); - } - - private SExpression atomEq(SExpression firstArgument, SExpression secondArgument) { - return isEq(firstArgument, secondArgument) ? Symbol.Companion.getT() : Nil.INSTANCE; - } - - private boolean isEq(SExpression firstArgument, SExpression secondArgument) { - return firstArgument.toString().equals(secondArgument.toString()); - } - - private SExpression listEq(SExpression firstArgument, SExpression secondArgument) { - return (firstArgument == secondArgument) ? Symbol.Companion.getT() : Nil.INSTANCE; - } -} diff --git a/src/main/kotlin/function/builtin/predicate/EQUAL.java b/src/main/kotlin/function/builtin/predicate/EQUAL.java deleted file mode 100644 index df25f15..0000000 --- a/src/main/kotlin/function/builtin/predicate/EQUAL.java +++ /dev/null @@ -1,39 +0,0 @@ -package function.builtin.predicate; - -import function.ArgumentValidator; -import function.FunctionNames; -import function.LispFunction; -import sexpression.Cons; -import sexpression.Nil; -import sexpression.SExpression; -import sexpression.Symbol; - -@FunctionNames({ "EQUAL", "EQUAL?" }) -public class EQUAL extends LispFunction { - - public static boolean isEqual(SExpression firstArgument, SExpression secondArgument) { - return firstArgument.toString().equals(secondArgument.toString()); - } - - private ArgumentValidator argumentValidator; - - public EQUAL(String name) { - this.argumentValidator = new ArgumentValidator(name); - this.argumentValidator.setExactNumberOfArguments(2); - } - - @Override - public SExpression call(Cons argumentList) { - argumentValidator.validate(argumentList); - - Cons rest = (Cons) argumentList.getRest(); - SExpression firstArgument = argumentList.getFirst(); - SExpression secondArgument = rest.getFirst(); - - return equal(firstArgument, secondArgument); - } - - private SExpression equal(SExpression firstArgument, SExpression secondArgument) { - return isEqual(firstArgument, secondArgument) ? Symbol.Companion.getT() : Nil.INSTANCE; - } -} diff --git a/src/main/kotlin/function/builtin/predicate/Eq.kt b/src/main/kotlin/function/builtin/predicate/Eq.kt new file mode 100644 index 0000000..e5ed34d --- /dev/null +++ b/src/main/kotlin/function/builtin/predicate/Eq.kt @@ -0,0 +1,45 @@ +package function.builtin.predicate + +import function.ArgumentValidator +import function.FunctionNames +import function.LispFunction +import sexpression.Cons +import sexpression.Nil +import sexpression.SExpression +import sexpression.Symbol.Companion.T + +@FunctionNames("EQ", "EQ?") +class Eq(name: String) : LispFunction() { + + private val argumentValidator = ArgumentValidator(name).apply { + setExactNumberOfArguments(2) + } + + override fun call(argumentList: Cons): SExpression { + argumentValidator.validate(argumentList) + + val rest = argumentList.rest as Cons + val firstArgument = argumentList.first + val secondArgument = rest.first + + return eq(firstArgument, secondArgument) + } + + private fun eq(firstArgument: SExpression, secondArgument: SExpression) = + if (isAtomPair(firstArgument, secondArgument)) + atomEq(firstArgument, secondArgument) + else + listEq(firstArgument, secondArgument) + + private fun isAtomPair(firstArgument: SExpression, secondArgument: SExpression) = + firstArgument.isAtom && secondArgument.isAtom + + private fun atomEq(firstArgument: SExpression, secondArgument: SExpression) = + if (isEq(firstArgument, secondArgument)) T else Nil + + private fun isEq(firstArgument: SExpression, secondArgument: SExpression) = + firstArgument.toString() == secondArgument.toString() + + private fun listEq(firstArgument: SExpression, secondArgument: SExpression) = + if (firstArgument === secondArgument) T else Nil +} diff --git a/src/main/kotlin/function/builtin/predicate/Equal.kt b/src/main/kotlin/function/builtin/predicate/Equal.kt new file mode 100644 index 0000000..735fd9c --- /dev/null +++ b/src/main/kotlin/function/builtin/predicate/Equal.kt @@ -0,0 +1,36 @@ +package function.builtin.predicate + +import function.ArgumentValidator +import function.FunctionNames +import function.LispFunction +import sexpression.Cons +import sexpression.Nil +import sexpression.SExpression +import sexpression.Symbol.Companion.T + +@FunctionNames("EQUAL", "EQUAL?") +class Equal(name: String) : LispFunction() { + + private val argumentValidator = ArgumentValidator(name).apply { + setExactNumberOfArguments(2) + } + + override fun call(argumentList: Cons): SExpression { + argumentValidator.validate(argumentList) + + val rest = argumentList.rest as Cons + val firstArgument = argumentList.first + val secondArgument = rest.first + + return equal(firstArgument, secondArgument) + } + + private fun equal(firstArgument: SExpression, secondArgument: SExpression) = + if (isEqual(firstArgument, secondArgument)) T else Nil + + companion object { + + fun isEqual(firstArgument: SExpression, secondArgument: SExpression) = + firstArgument.toString() == secondArgument.toString() + } +} diff --git a/src/main/kotlin/function/builtin/predicate/LISTP.java b/src/main/kotlin/function/builtin/predicate/LISTP.java deleted file mode 100644 index 15b790e..0000000 --- a/src/main/kotlin/function/builtin/predicate/LISTP.java +++ /dev/null @@ -1,27 +0,0 @@ -package function.builtin.predicate; - -import function.ArgumentValidator; -import function.FunctionNames; -import function.LispFunction; -import sexpression.Cons; -import sexpression.Nil; -import sexpression.SExpression; -import sexpression.Symbol; - -@FunctionNames({ "LISTP", "LIST?" }) -public class LISTP extends LispFunction { - - private ArgumentValidator argumentValidator; - - public LISTP(String name) { - this.argumentValidator = new ArgumentValidator(name); - this.argumentValidator.setExactNumberOfArguments(1); - } - - @Override - public SExpression call(Cons argumentList) { - argumentValidator.validate(argumentList); - - return argumentList.getFirst().isList() ? Symbol.Companion.getT() : Nil.INSTANCE; - } -} diff --git a/src/main/kotlin/function/builtin/predicate/Listp.kt b/src/main/kotlin/function/builtin/predicate/Listp.kt new file mode 100644 index 0000000..fc67c70 --- /dev/null +++ b/src/main/kotlin/function/builtin/predicate/Listp.kt @@ -0,0 +1,23 @@ +package function.builtin.predicate + +import function.ArgumentValidator +import function.FunctionNames +import function.LispFunction +import sexpression.Cons +import sexpression.Nil +import sexpression.SExpression +import sexpression.Symbol.Companion.T + +@FunctionNames("LISTP", "LIST?") +class Listp(name: String) : LispFunction() { + + private val argumentValidator = ArgumentValidator(name).apply { + setExactNumberOfArguments(1) + } + + override fun call(argumentList: Cons): SExpression { + argumentValidator.validate(argumentList) + + return if (argumentList.first.isList) T else Nil + } +} diff --git a/src/main/kotlin/function/builtin/predicate/NULL.java b/src/main/kotlin/function/builtin/predicate/NULL.java deleted file mode 100644 index 4be61b8..0000000 --- a/src/main/kotlin/function/builtin/predicate/NULL.java +++ /dev/null @@ -1,27 +0,0 @@ -package function.builtin.predicate; - -import function.ArgumentValidator; -import function.FunctionNames; -import function.LispFunction; -import sexpression.Cons; -import sexpression.Nil; -import sexpression.SExpression; -import sexpression.Symbol; - -@FunctionNames({ "NULL", "NULL?" }) -public class NULL extends LispFunction { - - private ArgumentValidator argumentValidator; - - public NULL(String name) { - this.argumentValidator = new ArgumentValidator(name); - this.argumentValidator.setExactNumberOfArguments(1); - } - - @Override - public SExpression call(Cons argumentList) { - argumentValidator.validate(argumentList); - - return argumentList.getFirst().isNull() ? Symbol.Companion.getT() : Nil.INSTANCE; - } -} diff --git a/src/main/kotlin/function/builtin/predicate/NUMERIC_GREATER.java b/src/main/kotlin/function/builtin/predicate/NUMERIC_GREATER.java deleted file mode 100644 index 4c70522..0000000 --- a/src/main/kotlin/function/builtin/predicate/NUMERIC_GREATER.java +++ /dev/null @@ -1,54 +0,0 @@ -package function.builtin.predicate; - -import function.ArgumentValidator; -import function.FunctionNames; -import function.LispFunction; -import recursion.TailCall; -import sexpression.Cons; -import sexpression.LispNumber; -import sexpression.Nil; -import sexpression.SExpression; -import sexpression.Symbol; - -import static recursion.TailCalls.done; -import static recursion.TailCalls.tailCall; - -@FunctionNames({ ">" }) -public class NUMERIC_GREATER extends LispFunction { - - private ArgumentValidator argumentValidator; - - public NUMERIC_GREATER(String name) { - this.argumentValidator = new ArgumentValidator(name); - this.argumentValidator.setMinimumNumberOfArguments(1); - this.argumentValidator.setEveryArgumentExpectedType(LispNumber.class); - } - - @Override - public SExpression call(Cons argumentList) { - argumentValidator.validate(argumentList); - - return callTailRecursive(argumentList).invoke(); - } - - private TailCall callTailRecursive(Cons argumentList) { - Cons remainingArguments = (Cons) argumentList.getRest(); - - if (remainingArguments.isNull()) - return done(Symbol.Companion.getT()); - - SExpression firstArgument = argumentList.getFirst(); - SExpression secondArgument = remainingArguments.getFirst(); - LispNumber number1 = (LispNumber) firstArgument; - LispNumber number2 = (LispNumber) secondArgument; - - if (!isFirstGreater(number1, number2)) - return done(Nil.INSTANCE); - - return tailCall(() -> callTailRecursive(remainingArguments)); - } - - private boolean isFirstGreater(LispNumber number1, LispNumber number2) { - return number1.getValue().compareTo(number2.getValue()) > 0; - } -} diff --git a/src/main/kotlin/function/builtin/predicate/NUMERIC_LESS.java b/src/main/kotlin/function/builtin/predicate/NUMERIC_LESS.java deleted file mode 100644 index 8c2aadd..0000000 --- a/src/main/kotlin/function/builtin/predicate/NUMERIC_LESS.java +++ /dev/null @@ -1,54 +0,0 @@ -package function.builtin.predicate; - -import function.ArgumentValidator; -import function.FunctionNames; -import function.LispFunction; -import recursion.TailCall; -import sexpression.Cons; -import sexpression.LispNumber; -import sexpression.Nil; -import sexpression.SExpression; -import sexpression.Symbol; - -import static recursion.TailCalls.done; -import static recursion.TailCalls.tailCall; - -@FunctionNames({ "<" }) -public class NUMERIC_LESS extends LispFunction { - - private ArgumentValidator argumentValidator; - - public NUMERIC_LESS(String name) { - this.argumentValidator = new ArgumentValidator(name); - this.argumentValidator.setMinimumNumberOfArguments(1); - this.argumentValidator.setEveryArgumentExpectedType(LispNumber.class); - } - - @Override - public SExpression call(Cons argumentList) { - argumentValidator.validate(argumentList); - - return callTailRecursive(argumentList).invoke(); - } - - private TailCall callTailRecursive(Cons argumentList) { - Cons remainingArguments = (Cons) argumentList.getRest(); - - if (remainingArguments.isNull()) - return done(Symbol.Companion.getT()); - - SExpression firstArgument = argumentList.getFirst(); - SExpression secondArgument = remainingArguments.getFirst(); - LispNumber number1 = (LispNumber) firstArgument; - LispNumber number2 = (LispNumber) secondArgument; - - if (!isFirstLesser(number1, number2)) - return done(Nil.INSTANCE); - - return tailCall(() -> callTailRecursive(remainingArguments)); - } - - private boolean isFirstLesser(LispNumber number1, LispNumber number2) { - return number1.getValue().compareTo(number2.getValue()) < 0; - } -} diff --git a/src/main/kotlin/function/builtin/predicate/Null.kt b/src/main/kotlin/function/builtin/predicate/Null.kt new file mode 100644 index 0000000..3cac4ce --- /dev/null +++ b/src/main/kotlin/function/builtin/predicate/Null.kt @@ -0,0 +1,23 @@ +package function.builtin.predicate + +import function.ArgumentValidator +import function.FunctionNames +import function.LispFunction +import sexpression.Cons +import sexpression.Nil +import sexpression.SExpression +import sexpression.Symbol.Companion.T + +@FunctionNames("NULL", "NULL?") +class Null(name: String) : LispFunction() { + + private val argumentValidator = ArgumentValidator(name).apply { + setExactNumberOfArguments(1) + } + + override fun call(argumentList: Cons): SExpression { + argumentValidator.validate(argumentList) + + return if (argumentList.first.isNull) T else Nil + } +} diff --git a/src/main/kotlin/function/builtin/predicate/NumericGreater.kt b/src/main/kotlin/function/builtin/predicate/NumericGreater.kt new file mode 100644 index 0000000..9c9da56 --- /dev/null +++ b/src/main/kotlin/function/builtin/predicate/NumericGreater.kt @@ -0,0 +1,42 @@ +package function.builtin.predicate + +import function.ArgumentValidator +import function.FunctionNames +import function.LispFunction +import sexpression.Cons +import sexpression.LispNumber +import sexpression.Nil +import sexpression.SExpression +import sexpression.Symbol.Companion.T + +@FunctionNames(">") +class NumericGreater(name: String) : LispFunction() { + + private val argumentValidator = ArgumentValidator(name).apply { + setMinimumNumberOfArguments(1) + setEveryArgumentExpectedType(LispNumber::class.java) + } + + override fun call(argumentList: Cons): SExpression { + argumentValidator.validate(argumentList) + + return callTailRecursive(argumentList) + } + + private tailrec fun callTailRecursive(argumentList: Cons): SExpression { + val remainingArguments = argumentList.rest as Cons + + if (remainingArguments.isNull) + return T + + val firstArgument = argumentList.first + val secondArgument = remainingArguments.first + val number1 = firstArgument as LispNumber + val number2 = secondArgument as LispNumber + + return if (number1.value > number2.value) + callTailRecursive(remainingArguments) + else + Nil + } +} diff --git a/src/main/kotlin/function/builtin/predicate/NumericLess.kt b/src/main/kotlin/function/builtin/predicate/NumericLess.kt new file mode 100644 index 0000000..35fc8fd --- /dev/null +++ b/src/main/kotlin/function/builtin/predicate/NumericLess.kt @@ -0,0 +1,46 @@ +package function.builtin.predicate + +import function.ArgumentValidator +import function.FunctionNames +import function.LispFunction +import recursion.TailCall +import sexpression.Cons +import sexpression.LispNumber +import sexpression.Nil +import sexpression.SExpression + +import recursion.TailCalls.done +import recursion.TailCalls.tailCall +import sexpression.Symbol.Companion.T + +@FunctionNames("<") +class NumericLess(name: String) : LispFunction() { + + private val argumentValidator = ArgumentValidator(name).apply { + setMinimumNumberOfArguments(1) + setEveryArgumentExpectedType(LispNumber::class.java) + } + + override fun call(argumentList: Cons): SExpression { + argumentValidator.validate(argumentList) + + return callTailRecursive(argumentList) + } + + private tailrec fun callTailRecursive(argumentList: Cons): SExpression { + val remainingArguments = argumentList.rest as Cons + + if (remainingArguments.isNull) + return T + + val firstArgument = argumentList.first + val secondArgument = remainingArguments.first + val number1 = firstArgument as LispNumber + val number2 = secondArgument as LispNumber + + return if (number1.value < number2.value) + callTailRecursive(remainingArguments) + else + Nil + } +} diff --git a/src/main/kotlin/function/builtin/special/Case.kt b/src/main/kotlin/function/builtin/special/Case.kt index a5a7192..b9d6241 100644 --- a/src/main/kotlin/function/builtin/special/Case.kt +++ b/src/main/kotlin/function/builtin/special/Case.kt @@ -4,7 +4,7 @@ import function.ArgumentValidator import function.FunctionNames import function.LispSpecialFunction import function.builtin.Eval.Companion.eval -import function.builtin.predicate.EQUAL.isEqual +import function.builtin.predicate.Equal.Companion.isEqual import sexpression.Cons import sexpression.Nil import sexpression.SExpression diff --git a/src/test/kotlin/function/builtin/predicate/ATOMTest.java b/src/test/kotlin/function/builtin/predicate/AtomTest.java similarity index 94% rename from src/test/kotlin/function/builtin/predicate/ATOMTest.java rename to src/test/kotlin/function/builtin/predicate/AtomTest.java index 89dd78c..33e61cb 100644 --- a/src/test/kotlin/function/builtin/predicate/ATOMTest.java +++ b/src/test/kotlin/function/builtin/predicate/AtomTest.java @@ -9,7 +9,7 @@ import static testutil.TestUtilities.evaluateString; import static testutil.TypeAssertions.assertNil; import static testutil.TypeAssertions.assertT; -public class ATOMTest extends SymbolAndFunctionCleaner { +public class AtomTest extends SymbolAndFunctionCleaner { @Test public void atomIsAtom() { diff --git a/src/test/kotlin/function/builtin/predicate/EQTest.java b/src/test/kotlin/function/builtin/predicate/EqTest.java similarity index 97% rename from src/test/kotlin/function/builtin/predicate/EQTest.java rename to src/test/kotlin/function/builtin/predicate/EqTest.java index 32eca6e..7a825a2 100644 --- a/src/test/kotlin/function/builtin/predicate/EQTest.java +++ b/src/test/kotlin/function/builtin/predicate/EqTest.java @@ -9,7 +9,7 @@ import static testutil.TestUtilities.evaluateString; import static testutil.TypeAssertions.assertNil; import static testutil.TypeAssertions.assertT; -public class EQTest extends SymbolAndFunctionCleaner { +public class EqTest extends SymbolAndFunctionCleaner { @Test public void eqWithEqualAtoms() { diff --git a/src/test/kotlin/function/builtin/predicate/EQUALTest.java b/src/test/kotlin/function/builtin/predicate/EqualTest.java similarity index 97% rename from src/test/kotlin/function/builtin/predicate/EQUALTest.java rename to src/test/kotlin/function/builtin/predicate/EqualTest.java index 59a71e6..6270627 100644 --- a/src/test/kotlin/function/builtin/predicate/EQUALTest.java +++ b/src/test/kotlin/function/builtin/predicate/EqualTest.java @@ -9,7 +9,7 @@ import static testutil.TestUtilities.evaluateString; import static testutil.TypeAssertions.assertNil; import static testutil.TypeAssertions.assertT; -public class EQUALTest extends SymbolAndFunctionCleaner { +public class EqualTest extends SymbolAndFunctionCleaner { @Test public void equalWithTwoEqualAtoms() { diff --git a/src/test/kotlin/function/builtin/predicate/LISTPTest.java b/src/test/kotlin/function/builtin/predicate/ListpTest.java similarity index 94% rename from src/test/kotlin/function/builtin/predicate/LISTPTest.java rename to src/test/kotlin/function/builtin/predicate/ListpTest.java index 16a5f25..505b2c3 100644 --- a/src/test/kotlin/function/builtin/predicate/LISTPTest.java +++ b/src/test/kotlin/function/builtin/predicate/ListpTest.java @@ -9,7 +9,7 @@ import static testutil.TestUtilities.evaluateString; import static testutil.TypeAssertions.assertNil; import static testutil.TypeAssertions.assertT; -public class LISTPTest extends SymbolAndFunctionCleaner { +public class ListpTest extends SymbolAndFunctionCleaner { @Test public void listpWithList() { diff --git a/src/test/kotlin/function/builtin/predicate/NULLTest.java b/src/test/kotlin/function/builtin/predicate/NullTest.java similarity index 94% rename from src/test/kotlin/function/builtin/predicate/NULLTest.java rename to src/test/kotlin/function/builtin/predicate/NullTest.java index 913dc18..5bfe6f3 100644 --- a/src/test/kotlin/function/builtin/predicate/NULLTest.java +++ b/src/test/kotlin/function/builtin/predicate/NullTest.java @@ -9,7 +9,7 @@ import static testutil.TestUtilities.evaluateString; import static testutil.TypeAssertions.assertNil; import static testutil.TypeAssertions.assertT; -public class NULLTest extends SymbolAndFunctionCleaner { +public class NullTest extends SymbolAndFunctionCleaner { @Test public void nilIsNull() { diff --git a/src/test/kotlin/function/builtin/predicate/NUMERIC_GREATERTest.java b/src/test/kotlin/function/builtin/predicate/NumericGreaterTest.java similarity index 95% rename from src/test/kotlin/function/builtin/predicate/NUMERIC_GREATERTest.java rename to src/test/kotlin/function/builtin/predicate/NumericGreaterTest.java index 16e38bd..3be50d5 100644 --- a/src/test/kotlin/function/builtin/predicate/NUMERIC_GREATERTest.java +++ b/src/test/kotlin/function/builtin/predicate/NumericGreaterTest.java @@ -9,7 +9,7 @@ import static testutil.TestUtilities.evaluateString; import static testutil.TypeAssertions.assertNil; import static testutil.TypeAssertions.assertT; -public class NUMERIC_GREATERTest extends SymbolAndFunctionCleaner { +public class NumericGreaterTest extends SymbolAndFunctionCleaner { @Test public void greaterThanWithOneNumber_ReturnsT() { diff --git a/src/test/kotlin/function/builtin/predicate/NUMERIC_LESSTest.java b/src/test/kotlin/function/builtin/predicate/NumericLessTest.java similarity index 95% rename from src/test/kotlin/function/builtin/predicate/NUMERIC_LESSTest.java rename to src/test/kotlin/function/builtin/predicate/NumericLessTest.java index c2147d6..61bd837 100644 --- a/src/test/kotlin/function/builtin/predicate/NUMERIC_LESSTest.java +++ b/src/test/kotlin/function/builtin/predicate/NumericLessTest.java @@ -9,7 +9,7 @@ import static testutil.TestUtilities.evaluateString; import static testutil.TypeAssertions.assertNil; import static testutil.TypeAssertions.assertT; -public class NUMERIC_LESSTest extends SymbolAndFunctionCleaner { +public class NumericLessTest extends SymbolAndFunctionCleaner { @Test public void lessThanWithOneNumber_ReturnsT() {