mike
/
transcendental-lisp
1
1
Fork 0
Code Issues 10 Pull Requests Packages Projects Releases Wiki Activity

Convert sexpression test to kotlin

This commit is contained in:
Mike Cifelli 2018-08-11 10:17:19 -04:00
parent 16118a9a78
commit a556b69658
4 changed files with 227 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/main/resources/dlambda.lisp
View File

@ -4,10 +4,12 @@
(let ((arguments (gensym))) (let ((arguments (gensym)))
`(lambda (&rest ,arguments) `(lambda (&rest ,arguments)
(case (first, arguments), @(mapcar (case (first ,arguments)
(lambda (method)) ,@(mapcar
`(, (first method)) (lambda (method)
(apply (lambda, @(rest method)), (if (equal t (first method))) `(,(first method)
(apply (lambda ,@(rest method))
,(if (equal t (first method))
arguments arguments
`(rest, arguments)) `(rest ,arguments)))))
methods))))) methods)))))

224
src/test/kotlin/sexpression/SExpressionTest.java
View File

@ -1,224 +0,0 @@
package sexpression;
import function.UserDefinedFunction;
import org.junit.Test;
import sexpression.LispNumber.InvalidNumberException;
import java.math.BigInteger;
import java.util.Locale;
import static error.Severity.ERROR;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static testutil.TestUtilities.assertSExpressionsMatch;
import static testutil.TestUtilities.makeList;
public class SExpressionTest {
private void assertSExpressionMatchesString(String expected, SExpression sExpression) {
assertEquals(expected, sExpression.toString());
}
@Test
public void nil_ToString() {
String input = "NIL";
assertSExpressionMatchesString(input, Nil.INSTANCE);
}
@Test
public void number_ToString() {
String input = "12";
assertSExpressionMatchesString(input, new LispNumber(input));
}
@Test
public void numberValue_ToString() {
String expected = "12";
assertSExpressionMatchesString(expected, new LispNumber("12"));
}
@Test
public void string_ToString() {
String input = "\"hi\"";
assertSExpressionMatchesString(input, new LispString(input));
}
@Test
public void symbol_ToString() {
String input = "symbol";
assertSExpressionMatchesString(input.toUpperCase(Locale.ROOT), new Symbol(input));
}
@Test
public void simpleCons_ToString() {
String expected = "(1)";
Cons cons = makeList(new LispNumber("1"));
assertSExpressionMatchesString(expected, cons);
}
@Test
public void complexCons_ToString() {
String expected = "(1 A \"string\")";
Cons list = makeList(new LispNumber("1"), new Symbol("a"), new LispString("\"string\""));
assertSExpressionMatchesString(expected, list);
}
@Test
public void improperList_ToString() {
String expected = "(A . B)";
Cons list = new Cons(new Symbol("A"), new Symbol("B"));
assertSExpressionMatchesString(expected, list);
}
@Test
public void lambdaExpression_ToString() {
String expected = "(LAMBDA)";
LambdaExpression lambda = new LambdaExpression(makeList(new Symbol("lambda")),
new UserDefinedFunction("", Nil.INSTANCE, Nil.INSTANCE));
assertSExpressionMatchesString(expected, lambda);
}
@Test
public void lambdaExpression_GetLambdaExpression() {
String expected = "(LAMBDA)";
LambdaExpression lambda = new LambdaExpression(makeList(new Symbol("lambda")),
new UserDefinedFunction("", Nil.INSTANCE, Nil.INSTANCE));
assertSExpressionMatchesString(expected, lambda.getLambdaExpression());
}
@Test
public void lambdaExpression_GetFunction() {
String expected = "(LAMBDA)";
UserDefinedFunction function = new UserDefinedFunction(expected, Nil.INSTANCE, Nil.INSTANCE);
LambdaExpression lambda = new LambdaExpression(makeList(new Symbol("lambda")), function);
assertEquals(function, lambda.getFunction());
}
@Test
public void firstOfNilIsNil() {
assertEquals(Nil.INSTANCE, Nil.INSTANCE.getFirst());
}
@Test
public void restOfNilIsNil() {
assertEquals(Nil.INSTANCE, Nil.INSTANCE.getRest());
}
@Test
public void afterSettingFirstOfNil_ShouldStillBeNil() {
Cons nil = Nil.INSTANCE;
nil.setFirst(new LispNumber("2"));
assertEquals(Nil.INSTANCE, nil.getFirst());
}
@Test
public void afterSettingRestOfNil_ShouldStillBeNil() {
Cons nil = Nil.INSTANCE;
nil.setRest(new LispNumber("2"));
assertEquals(Nil.INSTANCE, nil.getRest());
}
@Test
public void numberValue() {
BigInteger value = new BigInteger("12");
LispNumber number = new LispNumber(value.toString());
assertEquals(value, number.getValue());
}
@Test(expected = InvalidNumberException.class)
public void invalidNumberText_ThrowsException() {
new LispNumber("a");
}
@Test
public void invalidNumberException_HasCorrectAttributes() {
try {
new LispNumber("a");
} catch (InvalidNumberException e) {
String message = e.getMessage();
assertEquals(ERROR, e.getSeverity());
assertNotNull(message);
assertTrue(message.length() > 0);
}
}
@Test
public void lispNumberConstants() {
assertEquals(BigInteger.ZERO, LispNumber.Companion.getZERO().getValue());
assertEquals(BigInteger.ONE, LispNumber.Companion.getONE().getValue());
}
@Test
public void backTickExpression_ToString() {
String expected = "`(TEST)";
SExpression backTick = new BackquoteExpression(makeList(new Symbol("TEST")));
assertSExpressionMatchesString(expected, backTick);
}
@Test
public void commaExpression_ToString() {
String expected = ",A";
SExpression comma = new CommaExpression(new Symbol("A"));
assertSExpressionMatchesString(expected, comma);
}
@Test
public void atSignExpression_ToString() {
String expected = "@A";
SExpression atSign = new AtSignExpression(new Symbol("A"));
assertSExpressionMatchesString(expected, atSign);
}
@Test
public void complexBackTickExpression_ToString() {
String expected = "`(LIST ,A ,@B)";
SExpression backTick = new BackquoteExpression(makeList(new Symbol("LIST"),
new CommaExpression(new Symbol("A")),
new CommaExpression(new AtSignExpression(new Symbol("B")))));
assertSExpressionMatchesString(expected, backTick);
}
@Test
public void backTickExpression_GetExpression() {
SExpression expression = makeList(new Symbol("TEST"));
BackquoteExpression backTick = new BackquoteExpression(expression);
assertSExpressionsMatch(expression, backTick.getExpression());
}
@Test
public void commaExpression_GetExpression() {
SExpression expression = new Symbol("A");
CommaExpression comma = new CommaExpression(expression);
assertSExpressionsMatch(expression, comma.getExpression());
}
@Test
public void atSignExpression_GetExpression() {
SExpression expression = new Symbol("A");
AtSignExpression atSign = new AtSignExpression(expression);
assertSExpressionsMatch(expression, atSign.getExpression());
}
}

210
src/test/kotlin/sexpression/SExpressionTest.kt Normal file
View File

@ -0,0 +1,210 @@
package sexpression
import function.UserDefinedFunction
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Assertions.assertThrows
import org.junit.jupiter.api.Test
import sexpression.LispNumber.InvalidNumberException
import testutil.TestUtilities.assertIsErrorWithMessage
import testutil.TestUtilities.assertSExpressionsMatch
import testutil.TestUtilities.makeList
import java.math.BigInteger
import java.util.Locale
class SExpressionTest {
private fun assertSExpressionMatchesString(expected: String, sExpression: SExpression) {
assertThat(sExpression.toString()).isEqualTo(expected)
}
@Test
fun `nil to string`() {
val input = "NIL"
assertSExpressionMatchesString(input, Nil)
}
@Test
fun `number to string`() {
val input = "12"
assertSExpressionMatchesString(input, LispNumber(input))
}
@Test
fun `string to string`() {
val input = "\"hi\""
assertSExpressionMatchesString(input, LispString(input))
}
@Test
fun `symbol to string`() {
val input = "symbol"
assertSExpressionMatchesString(input.toUpperCase(Locale.ROOT), Symbol(input))
}
@Test
fun `simple cons to string`() {
val expected = "(1)"
val cons = makeList(LispNumber("1"))
assertSExpressionMatchesString(expected, cons)
}
@Test
fun `complex cons to string`() {
val expected = "(1 A \"string\")"
val list = makeList(LispNumber("1"), Symbol("a"), LispString("\"string\""))
assertSExpressionMatchesString(expected, list)
}
@Test
fun `improper list to string`() {
val expected = "(A . B)"
val list = Cons(Symbol("A"), Symbol("B"))
assertSExpressionMatchesString(expected, list)
}
@Test
fun `lambda expression to string`() {
val expected = "(LAMBDA)"
val lambda = LambdaExpression(makeList(Symbol("lambda")),
UserDefinedFunction("", Nil, Nil))
assertSExpressionMatchesString(expected, lambda)
}
@Test
fun `get lambda expression from lambda`() {
val expected = "(LAMBDA)"
val lambda = LambdaExpression(makeList(Symbol("lambda")),
UserDefinedFunction("", Nil, Nil))
assertSExpressionMatchesString(expected, lambda.lambdaExpression)
}
@Test
fun `get function from lambda`() {
val expected = "(LAMBDA)"
val function = UserDefinedFunction(expected, Nil, Nil)
val lambda = LambdaExpression(makeList(Symbol("lambda")), function)
assertThat(lambda.function).isEqualTo(function)
}
@Test
fun `first of nil is nil`() {
assertThat(Nil.first).isEqualTo(Nil)
}
@Test
fun `rest of nil is nil`() {
assertThat(Nil.rest).isEqualTo(Nil)
}
@Test
fun `cannot change first of nil`() {
val nil = Nil
nil.first = LispNumber("2")
assertThat(nil.first).isEqualTo(Nil)
}
@Test
fun `cannot change rest of nil`() {
val nil = Nil
nil.rest = LispNumber("2")
assertThat(nil.rest).isEqualTo(Nil)
}
@Test
fun `number value`() {
val value = BigInteger("12")
val number = LispNumber(value.toString())
assertThat(number.value).isEqualTo(value)
}
@Test
fun `invalid number text throws an exception`() {
assertThrows(InvalidNumberException::class.java) { LispNumber("a") }
}
@Test
fun `InvalidNumberException is cool`() {
try {
LispNumber("a")
} catch (e: InvalidNumberException) {
assertIsErrorWithMessage(e)
}
}
@Test
fun `lisp number constants are accurate`() {
assertThat(LispNumber.ZERO.value).isEqualTo(BigInteger.ZERO)
assertThat(LispNumber.ONE.value).isEqualTo(BigInteger.ONE)
}
@Test
fun `back tick expression to string`() {
val expected = "`(TEST)"
val backTick = BackquoteExpression(makeList(Symbol("TEST")))
assertSExpressionMatchesString(expected, backTick)
}
@Test
fun `comma expression to string`() {
val expected = ",A"
val comma = CommaExpression(Symbol("A"))
assertSExpressionMatchesString(expected, comma)
}
@Test
fun `at sign expression to string`() {
val expected = "@A"
val atSign = AtSignExpression(Symbol("A"))
assertSExpressionMatchesString(expected, atSign)
}
@Test
fun `complex back tick expression to string`() {
val expected = "`(LIST ,A ,@B)"
val backTick = BackquoteExpression(makeList(Symbol("LIST"),
CommaExpression(Symbol("A")),
CommaExpression(AtSignExpression(Symbol("B")))))
assertSExpressionMatchesString(expected, backTick)
}
@Test
fun `get expression from back tick expression`() {
val expression = makeList(Symbol("TEST"))
val backTick = BackquoteExpression(expression)
assertSExpressionsMatch(expression, backTick.expression)
}
@Test
fun `get expression from comma expression`() {
val expression = Symbol("A")
val comma = CommaExpression(expression)
assertSExpressionsMatch(expression, comma.expression)
}
@Test
fun `get expression from at sign expression`() {
val expression = Symbol("A")
val atSign = AtSignExpression(expression)
assertSExpressionsMatch(expression, atSign.expression)
}
}