[ coverage ] Improve test coverages

ice1000 · ice1000 · commit 0e27bce41ab9 · 2018-01-14T13:47:07.000+08:00
diff --git a/src/main/kotlin/org/lice/Lice.kt b/src/main/kotlin/org/lice/Lice.kt
@@ -8,12 +8,10 @@ package org.lice
 
 import org.lice.core.SymbolList
 import org.lice.parse.*
-import org.lice.repl.Main
 import org.lice.util.InterpretException
 import org.lice.util.ParseException
 import java.io.File
-import java.nio.file.Path
-import java.nio.file.Paths
+import java.nio.file.*
 
 object Lice {
 	@JvmOverloads
@@ -25,7 +23,7 @@ object Lice {
 	@JvmOverloads
 	@JvmStatic
 	fun run(file: Path, symbolList: SymbolList = SymbolList()) =
-			Main.interpret(file, symbolList)
+			run(String(Files.readAllBytes(file)), symbolList)
 
 	@JvmOverloads
 	@JvmStatic
@@ -39,4 +37,9 @@ object Lice {
 		}
 		return null
 	}
+
+	@JvmOverloads
+	@JvmStatic
+	fun runBarely(code: String, symbolList: SymbolList = SymbolList()) =
+			Parser.parseTokenStream(Lexer(code)).accept(Sema(symbolList)).eval()
 }
diff --git a/src/main/kotlin/org/lice/parse/ASTNode.kt b/src/main/kotlin/org/lice/parse/ASTNode.kt
@@ -22,7 +22,8 @@ class ASTAtomicNode internal constructor(metaData: MetaData, val token: Token) :
 		Token.TokenType.DoubleNumber -> ValueNode(token.strValue.toDouble(), metaData)
 		Token.TokenType.StringLiteral -> ValueNode(token.strValue, metaData)
 		Token.TokenType.Identifier -> SymbolNode(sema.symbolList, token.strValue, metaData)
-		Token.TokenType.LispKwd, Token.TokenType.EOI -> throw ParseException("")
+		Token.TokenType.LispKwd, Token.TokenType.EOI ->
+			throw ParseException("Unexpected token '${token.strValue}'", metaData)
 	}
 }
 
diff --git a/src/main/kotlin/org/lice/parse/Lexer.kt b/src/main/kotlin/org/lice/parse/Lexer.kt
@@ -7,12 +7,15 @@ class Lexer(sourceCode: String) {
 
 	private val sourceCode = sourceCode.toCharArray()
 	private var line = 1
-	private var col = 1
-	private var charIndex = 0
+	private var col: Int
+	private var charIndex: Int
 	private var tokenBuffer: MutableList<Token> = arrayListOf()
-	private var currentTokenIndex = 0
+	private var currentTokenIndex: Int = 0
 
 	init {
+		this.col = 1
+		this.charIndex = 0
+
 		doSplitTokens()
 	}
 
@@ -171,9 +174,12 @@ class Lexer(sourceCode: String) {
 				nextChar()
 			} else {
 				when (peekOneChar()) {
+					'0' -> builder.append('\u0000')
 					'n' -> builder.append('\n')
 					'f' -> builder.append('\u000C')
 					't' -> builder.append('\t')
+					'v' -> builder.append('\u000B')
+					'r' -> builder.append('\u000D')
 					'\\' -> builder.append('\\')
 					'"' -> builder.append('\"')
 					else -> throw ParseException("Illegal conversion sequence \\${peekOneChar()}",
@@ -215,7 +221,7 @@ class Lexer(sourceCode: String) {
 		private const val binDigits = "01"
 		private const val octDigits = "01234567"
 		private const val decDigits = "0123456789"
-		private const val hexDigits = "0123456789ABCDEF"
+		private const val hexDigits = "0123456789ABCDEFabcdef"
 		private const val blanks = " \u000C\n\t\r,"
 		private const val lispSymbols = "()"
 		private const val tokenDelimiters = blanks + lispSymbols + ";\u0000"
diff --git a/src/main/kotlin/org/lice/repl/Main.kt b/src/main/kotlin/org/lice/repl/Main.kt
@@ -1,37 +1,18 @@
+@file:JvmName("Main")
+
 package org.lice.repl
 
+import org.lice.Lice
 import org.lice.core.SymbolList
 import org.lice.lang.Echoer
-import org.lice.parse.*
-import org.lice.util.InterpretException
-import org.lice.util.ParseException
-import java.nio.file.*
+import java.nio.file.Paths
 
 /**
  * @author ice1000
  */
 
-object Main {
-
-	/**
-	 * interpret code in a file
-	 */
-	fun interpret(file: Path, symbolList: SymbolList): Any? {
-		val code = String(Files.readAllBytes(file))
-		try {
-			return Parser.parseTokenStream(Lexer(code)).accept(Sema(symbolList)).eval()
-		} catch (e: ParseException) {
-			e.prettyPrint(code.split("\n"))
-		} catch (e: InterpretException) {
-			e.prettyPrint(code.split("\n"))
-		}
-		return null
-	}
-
-	@JvmStatic
-	fun main(vararg args: String) {
-		Echoer.openOutput()
-		if (args.isEmpty()) println("Please specify an input file.")
-		else interpret(Paths.get(args.first()), SymbolList())
-	}
+fun main(args: Array<String>) {
+	Echoer.openOutput()
+	if (args.isEmpty()) println("Please specify an input file.")
+	else Lice.run(Paths.get(args.first()), SymbolList())
 }
diff --git a/src/main/kotlin/org/lice/util/Error.kt b/src/main/kotlin/org/lice/util/Error.kt
@@ -12,42 +12,50 @@ package org.lice.util
 
 import org.lice.model.MetaData
 
-private fun exceptionPrettyPrint(string: String, meta: MetaData, cachedCodeLines: List<String>) {
-	System.err.println("Error " + string)
-	if (meta.beginLine != -1)
-		System.err.print("At " + meta.beginLine)
-	if (meta.beginIndex != -1) {
-		System.err.print(":" + meta.beginIndex)
-	}
-	System.err.println(": " + string)
-	System.err.println(cachedCodeLines[meta.beginLine-1])
-	if (meta.beginIndex != -1) {
-		for (i: Int in meta.beginIndex.downTo(2))
-			System.err.print(' ')
-		System.err.print('^')
-		if (meta.endIndex != -1) {
-			for (i: Int in meta.endIndex.downTo(meta.beginIndex+2))
-				System.err.print('~')
+open class LiceException(string: String, @JvmField protected val meta: MetaData) : RuntimeException(string) {
+	protected fun prettify(cachedCodeLines: List<String>): String {
+		val builder = StringBuilder()
+		builder.appendln("Error " + message)
+		if (meta.beginLine != -1)
+			builder.append("At " + meta.beginLine)
+		if (meta.beginIndex != -1) {
+			builder.append(":" + meta.beginIndex)
+		}
+		builder.appendln(": " + message)
+		if (meta.beginLine != -1) {
+			builder.appendln(cachedCodeLines[meta.beginLine - 1])
+		}
+		if (meta.beginIndex != -1) {
+			for (i in meta.beginIndex.downTo(2))
+				builder.append(' ')
+			builder.append('^')
+			if (meta.endIndex != -1) {
+				for (i in meta.endIndex.downTo(meta.beginIndex + 2))
+					builder.append('~')
+			}
+			builder.appendln()
 		}
-		System.err.println()
+		builder.appendln()
+		return builder.toString()
 	}
-	System.err.println()
 }
 
-class ParseException(private val string: String, private val meta: MetaData = MetaData()) : RuntimeException(string) {
+class ParseException(string: String, meta: MetaData = MetaData()) : LiceException(string, meta) {
 	fun prettyPrint(cachedCodeLines: List<String>) {
-		exceptionPrettyPrint(string, meta, cachedCodeLines)
+		prettify(cachedCodeLines).let(System.err::println)
 	}
 }
 
-class InterpretException(private val string: String, private val meta: MetaData = MetaData()) : RuntimeException(string) {
+class InterpretException(string: String, meta: MetaData = MetaData()) :
+		LiceException(string, meta) {
 	fun prettyPrint(cachedCodeLines: List<String>) {
-		exceptionPrettyPrint(string, meta, cachedCodeLines)
+		prettify(cachedCodeLines).let(System.err::println)
 	}
 
 	companion object Factory {
-		fun undefinedVariable(name: String, meta: MetaData): Nothing
-				= throw InterpretException("undefined variable: $name", meta)
+		fun undefinedVariable(
+				name: String,
+				meta: MetaData): Nothing = throw InterpretException("undefined variable: $name", meta)
 
 		fun notSymbol(meta: MetaData): Nothing =
 				throw InterpretException("type mismatch: symbol expected.", meta)
diff --git a/src/test/kotlin/org/lice/parse/IntegratedTest.kt b/src/test/kotlin/org/lice/parse/IntegratedTest.kt
@@ -1,12 +1,15 @@
 package org.lice.parse
 
-import junit.framework.TestCase.assertEquals
 import org.intellij.lang.annotations.Language
 import org.junit.Test
+import org.lice.Lice
+import org.lice.core.SymbolList
+import org.lice.evalTo
+import kotlin.test.assertFails
 
 class IntegratedTest {
 	@Test
-	fun Test1() {
+	fun test1() {
 		@Language("Lice")
 		val srcCode = """
 (def fibonacci n
@@ -19,15 +22,15 @@ class IntegratedTest {
 (while (< i 20)
 	(|>
 		(print (fibonacci i))
-		(print ("
-"))
+		(print ("\n"))
 		(-> i (+ i 1))))
+(fibonacci 10)
 """
-		Parser.parseTokenStream(Lexer(srcCode)).accept(Sema()).eval()
+		srcCode evalTo 55
 	}
 
 	@Test
-	fun Test2() {
+	fun test2() {
 		@Language("Lice")
 		val srcCode = """
 (print (+ 1 1) "\n")
@@ -47,22 +50,21 @@ class IntegratedTest {
 
 (str->sym "ass")
 
-(print (format "ass %s can", "we") "
-")
+(print (format "ass %s can", "we") "\n")
 """
 		Parser.parseTokenStream(Lexer(srcCode)).accept(Sema()).eval()
 	}
 
 	@Test
-	fun Test3() {
+	fun test3() {
 		/// Intentionally empty translation unit
 		val srcCode = """
 """
-		Parser.parseTokenStream(Lexer(srcCode)).accept(Sema()).eval()
+		srcCode evalTo null
 	}
 
 	@Test
-	fun Test4() {
+	fun test4() {
 		val srcCode = """
 ; defining functions
 (def check
@@ -117,13 +119,33 @@ class IntegratedTest {
 ; calling the extern function
 (equals 1 1)
 """
-		Parser.parseTokenStream(Lexer(srcCode)).accept(Sema()).eval()
+		Lice.runBarely(srcCode)
 	}
 
-	@Test(timeout = 500)
-	fun Test5() {
-		assertEquals(233, Parser.parseTokenStream(Lexer("233")).accept(Sema()).eval())
-		assertEquals(0x233, Parser.parseTokenStream(Lexer("0x233")).accept(Sema()).eval())
-		assertEquals(0b10101, Parser.parseTokenStream(Lexer("0b10101")).accept(Sema()).eval())
+	@Test
+	fun test5() {
+		"233" evalTo 233
+		"0x233" evalTo 0x233
+		"0b10101" evalTo 0b10101
+	}
+
+	@Test
+	fun failTests() {
+		assertFails { Lice.runBarely("1a") }
+		assertFails { Lice.runBarely("0xz") }
+		assertFails { Lice.runBarely("0b2") }
+		assertFails { Lice.runBarely("0o9") }
+		assertFails { Lice.runBarely("undefined-variable") }
+		assertFails { Lice.runBarely("(+ (->str 1))") }
+		assertFails { Lice.runBarely("(def)") }
+		assertFails { Lice.runBarely("(def name)") }
+		assertFails { Lice.runBarely("(-> name)") }
+		assertFails { Lice.runBarely("(; 1)") }
+		assertFails { Lice.runBarely(""""\g"""") }
+		assertFails { Lice.runBarely("(") }
+		assertFails { Lice.runBarely(")") }
+		assertFails { Lice.runBarely("\"") }
+		assertFails { SymbolList().extractLiceFunction("undefined-function")(emptyList()) }
+		assertFails { SymbolList().extractLiceVariable("undefined-variable") }
 	}
 }
diff --git a/src/test/kotlin/org/lice/parse/LexIdentifierTest.kt b/src/test/kotlin/org/lice/parse/LexIdentifierTest.kt
@@ -6,7 +6,7 @@ import org.junit.Assert.assertEquals
 
 class LexIdentifierTest {
 
-	@Test(timeout = 100)
+	@Test
 	fun testLexIdentifier() {
 		val srcCode = "Fuck@dentifier"
 		val l = Lexer(srcCode)
@@ -15,7 +15,7 @@ class LexIdentifierTest {
 		assertEquals(Token.TokenType.EOI, l.peekOneToken().type)
 	}
 
-	@Test(timeout = 100)
+	@Test
 	fun testLexIdentifiers() {
 		val srcCode = "Fuck@dentifier _Yet1A2not->her@dentifier"
 		val l = Lexer(srcCode)
@@ -27,7 +27,7 @@ class LexIdentifierTest {
 		assertEquals(Token.TokenType.EOI, l.peekOneToken().type)
 	}
 
-	@Test(timeout = 100)
+	@Test
 	fun testLexIdentifiers2() {
 		val srcCode = "Fuck@dentifier,_Yet1A2not->her@dentifier"
 		val l = Lexer(srcCode)
diff --git a/src/test/kotlin/org/lice/parse/LexProgramTest.kt b/src/test/kotlin/org/lice/parse/LexProgramTest.kt
@@ -5,7 +5,7 @@ import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class LexProgramTest {
-	@Test(timeout = 100)
+	@Test
 	fun test1() {
 		@Language("Lice")
 		val src = """
@@ -65,7 +65,7 @@ class LexProgramTest {
 		l.nextToken()
 	}
 
-	@Test(timeout = 100)
+	@Test
 	fun test2() {
 		@Language("Lice")
 		val src = """
diff --git a/src/test/kotlin/org/lice/parse/LexStringTest.kt b/src/test/kotlin/org/lice/parse/LexStringTest.kt
@@ -13,7 +13,7 @@ class LexStringTest {
 	@JvmField
 	var thrown: ExpectedException = ExpectedException.none()
 
-	@Test(timeout = 100)
+	@Test
 	fun testLexString() {
 		@Language("Lice")
 		val srcCode = """"String""""
@@ -23,7 +23,7 @@ class LexStringTest {
 		assertEquals(Token.TokenType.EOI, l.peekOneToken().type)
 	}
 
-	@Test(timeout = 100)
+	@Test
 	fun testLexConversionSequence() {
 		@Language("Lice")
 		val srcCode = "\"Str\\ning\""
@@ -33,15 +33,15 @@ class LexStringTest {
 		assertEquals(Token.TokenType.EOI, l.peekOneToken().type)
 	}
 
-	@Test(timeout = 200)
+	@Test
 	fun testLexConversionSequenceFailed() {
 		thrown.expect(ParseException::class.java)
 		@Language("Lice")
 		val srcCode = "\"\\q\""
 		val l = Lexer(srcCode)
 	}
 
-	@Test(timeout = 200)
+	@Test
 	fun testMissingQuote() {
 		thrown.expect(ParseException::class.java)
 		val srcCode = "\"String without closing quote"
diff --git a/src/test/kotlin/org/lice/parse/LexerSandbox.kt b/src/test/kotlin/org/lice/parse/LexerSandbox.kt
@@ -3,7 +3,7 @@ package org.lice.parse
 import org.junit.Test
 
 class LexerSandbox {
-	@Test(timeout = 2000)
+	@Test
 	fun run() {
 		val srcCode = """
 """

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,8 @@ class ASTAtomicNode internal constructor(metaData: MetaData, val token: Token) :`
`22`	`22`	`Token.TokenType.DoubleNumber -> ValueNode(token.strValue.toDouble(), metaData)`
`23`	`23`	`Token.TokenType.StringLiteral -> ValueNode(token.strValue, metaData)`
`24`	`24`	`Token.TokenType.Identifier -> SymbolNode(sema.symbolList, token.strValue, metaData)`
`25`		`- Token.TokenType.LispKwd, Token.TokenType.EOI -> throw ParseException("")`
	`25`	`+ Token.TokenType.LispKwd, Token.TokenType.EOI ->`
	`26`	`+ throw ParseException("Unexpected token '${token.strValue}'", metaData)`
`26`	`27`	`}`
`27`	`28`	`}`
`28`	`29`