zeolite-lang-0.24.1.0: example/highlighter/test/zeolite-tokenizing.0rt
/* -----------------------------------------------------------------------------
Copyright 2023-2024 Kevin P. Barry
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
----------------------------------------------------------------------------- */
// Author: Kevin P. Barry [ta0kira@gmail.com]
testcase "parsing tests" {
success TestChecker
}
concrete ParsingTester {
@type new (ZeoliteParseContext) -> (ParsingTester)
@value checkParsesAs (String, DefaultOrder<ZeoliteParsed>) -> ()
}
unittest parseZeoliteWhitespace {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteWhitespace>())
\ " \t \r\n" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " \t \r\n"))
\ " test" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
}
unittest parseZeoliteLineComment {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteLineComment>()
.include<ZeoliteWhitespace>())
\ "//12345\n//54321" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteLineComment", content: "//12345"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: "\n"))
.append(ZeoliteParsed.leaf(label: "ZeoliteLineComment", content: "//54321"))
\ "/ /" `tester.checkParsesAs` AlwaysEmpty.default()
}
unittest parseZeoliteBlockComment {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteBlockComment>()
.include<ZeoliteWhitespace>())
\ "/*/12345\n54321* */" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteBlockComment", content: "/*/12345\n54321* */"))
\ "/*comment*/ " `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteBlockComment", content: "/*comment*/"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
\ "/*forever " `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteBlockComment", content: "/*forever "))
\ "/ *" `tester.checkParsesAs` AlwaysEmpty.default()
}
unittest parseZeoliteUpperSymbol {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteUpperSymbol>())
\ "Hello123" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteCategoryName", content: "Hello123"))
\ "String" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteBuiltinCategory", content: "String"))
\ "Hello_123" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteCategoryName", content: "Hello"))
\ "hello" `tester.checkParsesAs` AlwaysEmpty.default()
\ "123Hello" `tester.checkParsesAs` AlwaysEmpty.default()
}
unittest parseZeoliteLowerSymbol {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteLowerSymbol>())
\ "hello123" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteFunctionOrVariableName", content: "hello123"))
\ "hello123:" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteArgLabel", content: "hello123:"))
\ "cleanup" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteControlKeyword", content: "cleanup"))
\ "immutable" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteTypeKeyword", content: "immutable"))
\ "concrete" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteContainKeyword", content: "concrete"))
\ "optional" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteStorageKeyword", content: "optional"))
\ "unittest" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteScopeQualifier", content: "unittest"))
\ "any" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteBuiltinCategory", content: "any"))
\ "identify" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteBuiltinFunction", content: "identify"))
\ "empty" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteBuiltinConstant", content: "empty"))
\ "hello_123" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteFunctionOrVariableName", content: "hello"))
// Only has a special label in testcase.
\ "compiler" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteFunctionOrVariableName", content: "compiler"))
\ "empty123" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteFunctionOrVariableName", content: "empty123"))
\ "identify:" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteBuiltinFunction", content: "identify"))
\ "Hello" `tester.checkParsesAs` AlwaysEmpty.default()
\ "123hello" `tester.checkParsesAs` AlwaysEmpty.default()
}
unittest parseZeoliteScopeQualifier {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteScopeQualifier>())
\ "@value" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteScopeQualifier", content: "@value"))
\ "@type" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteScopeQualifier", content: "@type"))
\ "@category" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteScopeQualifier", content: "@category"))
\ "@value something" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteScopeQualifier", content: "@value"))
\ "@local" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteError", content: "@local"))
}
unittest parseZeoliteOperator {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteOperator>())
\ "<-" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteAssignment", content: "<-"))
\ "<-|" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteAssignment", content: "<-|"))
\ "<->" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteAssignment", content: "<->"))
\ "->" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteAssignment", content: "->"))
\ ":" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteFunctionCall", content: ":"))
\ "." `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteFunctionCall", content: "."))
\ "&." `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteFunctionCall", content: "&."))
\ "?" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteFunctionCall", content: "?"))
\ "<<" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteOperator", content: "<<"))
\ ":.!%^&*-+|<>?=" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteOperator", content: ":.!%^&*-+|<>?="))
\ "<-||" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteOperator", content: "<-||"))
\ "&.call()" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteFunctionCall", content: "&."))
}
unittest parseZeoliteParamName {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteParamName>())
\ "#param123" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteParamName", content: "#param123"))
\ "#self" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteBuiltinParam", content: "#self"))
\ "#param_123" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteParamName", content: "#param"))
\ "#self123" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteParamName", content: "#self123"))
\ "param" `tester.checkParsesAs` AlwaysEmpty.default()
\ "#Param" `tester.checkParsesAs` AlwaysEmpty.default()
\ "#123param" `tester.checkParsesAs` AlwaysEmpty.default()
}
unittest parseZeoliteStringLiteral {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteStringLiteral>())
\ "\"hello\\n\\t\\0123\\xABC\\Q \\09c goodbye\"" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteStringLiteral", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteDoubleQuote", content: "\""))
.append(ZeoliteParsed.leaf(label: "ZeoliteQuotedChars", content: "hello"))
.append(ZeoliteParsed.leaf(label: "ZeoliteEscapedChar", content: "\\n"))
.append(ZeoliteParsed.leaf(label: "ZeoliteEscapedChar", content: "\\t"))
.append(ZeoliteParsed.leaf(label: "ZeoliteEscapedChar", content: "\\012"))
.append(ZeoliteParsed.leaf(label: "ZeoliteQuotedChars", content: "3"))
.append(ZeoliteParsed.leaf(label: "ZeoliteEscapedChar", content: "\\xAB"))
.append(ZeoliteParsed.leaf(label: "ZeoliteQuotedChars", content: "C"))
.append(ZeoliteParsed.leaf(label: "ZeoliteError", content: "\\Q"))
.append(ZeoliteParsed.leaf(label: "ZeoliteQuotedChars", content: " "))
.append(ZeoliteParsed.leaf(label: "ZeoliteError", content: "\\0"))
.append(ZeoliteParsed.leaf(label: "ZeoliteQuotedChars", content: "9c goodbye"))
.append(ZeoliteParsed.leaf(label: "ZeoliteDoubleQuote", content: "\""))))
\ "\"forever" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteStringLiteral", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteDoubleQuote", content: "\""))
.append(ZeoliteParsed.leaf(label: "ZeoliteQuotedChars", content: "forever"))))
}
unittest parseZeoliteCharLiteral {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteCharLiteral>())
\ "'a'" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteCharLiteral", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteSingleQuote", content: "'"))
.append(ZeoliteParsed.leaf(label: "ZeoliteQuotedChars", content: "a"))
.append(ZeoliteParsed.leaf(label: "ZeoliteSingleQuote", content: "'"))))
\ "'\\''" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteCharLiteral", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteSingleQuote", content: "'"))
.append(ZeoliteParsed.leaf(label: "ZeoliteEscapedChar", content: "\\'"))
.append(ZeoliteParsed.leaf(label: "ZeoliteSingleQuote", content: "'"))))
\ "'\\n'" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteCharLiteral", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteSingleQuote", content: "'"))
.append(ZeoliteParsed.leaf(label: "ZeoliteEscapedChar", content: "\\n"))
.append(ZeoliteParsed.leaf(label: "ZeoliteSingleQuote", content: "'"))))
\ "'\\xAB'" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteCharLiteral", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteSingleQuote", content: "'"))
.append(ZeoliteParsed.leaf(label: "ZeoliteEscapedChar", content: "\\xAB"))
.append(ZeoliteParsed.leaf(label: "ZeoliteSingleQuote", content: "'"))))
\ "'\\Q'" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteCharLiteral", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteSingleQuote", content: "'"))
.append(ZeoliteParsed.leaf(label: "ZeoliteError", content: "\\Q"))
.append(ZeoliteParsed.leaf(label: "ZeoliteSingleQuote", content: "'"))))
\ "''" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteCharLiteral", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteSingleQuote", content: "'"))
.append(ZeoliteParsed.leaf(label: "ZeoliteError", content: "'"))))
\ "'forever" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteCharLiteral", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteSingleQuote", content: "'"))
.append(ZeoliteParsed.leaf(label: "ZeoliteQuotedChars", content: "f"))
.append(ZeoliteParsed.leaf(label: "ZeoliteError", content: "o"))))
}
unittest parseZeoliteNumber {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteNumber>())
\ "123" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteNumber", content: "123"))
\ "123.456" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteNumber", content: "123.456"))
\ "123.456E123" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteNumber", content: "123.456E123"))
\ "+123" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteNumber", content: "+123"))
\ "-123" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteNumber", content: "-123"))
\ "123.456E+123" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteNumber", content: "123.456E+123"))
\ "123.456E-123" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteNumber", content: "123.456E-123"))
\ "\\b101.010" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteEscapedNumber", content: "\\b101.010"))
\ "\\o123.456" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteEscapedNumber", content: "\\o123.456"))
\ "\\d123.456" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteEscapedNumber", content: "\\d123.456"))
\ "\\x123.abc" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteEscapedNumber", content: "\\x123.abc"))
\ "123A" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteNumber", content: "123"))
\ "\\b0123" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteEscapedNumber", content: "\\b01"))
.append(ZeoliteParsed.leaf(label: "ZeoliteNumber", content: "23"))
\ "\\o12389" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteEscapedNumber", content: "\\o123"))
.append(ZeoliteParsed.leaf(label: "ZeoliteNumber", content: "89"))
\ "\\d123A" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteEscapedNumber", content: "\\d123"))
\ "\\xABCqq" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteEscapedNumber", content: "\\xABC"))
\ "-" `tester.checkParsesAs` AlwaysEmpty.default()
\ "+" `tester.checkParsesAs` AlwaysEmpty.default()
\ "\\" `tester.checkParsesAs` AlwaysEmpty.default()
\ "\\b" `tester.checkParsesAs` AlwaysEmpty.default()
\ "\\o" `tester.checkParsesAs` AlwaysEmpty.default()
\ "\\d" `tester.checkParsesAs` AlwaysEmpty.default()
\ "\\h" `tester.checkParsesAs` AlwaysEmpty.default()
}
unittest parseZeoliteBraceSection {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteBlockComment>()
.include<ZeoliteBraceSection>()
.include<ZeoliteWhitespace>())
\ "{ /*hello*/ }" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteBraceSection", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteOpenDelim", content: "{"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.leaf(label: "ZeoliteBlockComment", content: "/*hello*/"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.leaf(label: "ZeoliteCloseDelim", content: "}"))))
\ "{ /*forever*/" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteBraceSection", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteOpenDelim", content: "{"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.leaf(label: "ZeoliteBlockComment", content: "/*forever*/"))))
}
unittest parseZeoliteParenSection {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteBlockComment>()
.include<ZeoliteParenSection>()
.include<ZeoliteWhitespace>())
\ "( /*hello*/ )" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteParenSection", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteOpenDelim", content: "("))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.leaf(label: "ZeoliteBlockComment", content: "/*hello*/"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.leaf(label: "ZeoliteCloseDelim", content: ")"))))
\ "( /*forever*/" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteParenSection", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteOpenDelim", content: "("))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.leaf(label: "ZeoliteBlockComment", content: "/*forever*/"))))
}
unittest parseZeoliteSquareSection {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteBlockComment>()
.include<ZeoliteSquareSection>()
.include<ZeoliteWhitespace>())
\ "[ /*hello*/ ]" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteSquareSection", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteOpenDelim", content: "["))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.leaf(label: "ZeoliteBlockComment", content: "/*hello*/"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.leaf(label: "ZeoliteCloseDelim", content: "]"))))
\ "[ /*forever*/" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteSquareSection", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteOpenDelim", content: "["))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.leaf(label: "ZeoliteBlockComment", content: "/*forever*/"))))
}
unittest parseZeoliteTestcase {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteWhitespace>()
.include<ZeoliteLineComment>()
.include<ZeoliteBlockComment>()
.include<ZeoliteStringLiteral>()
.include<ZeoliteSquareSection>()
.include<ZeoliteNumber>()
.include<ZeoliteOperator>()
// ZeoliteTestcase also uses the above if available.
.include<ZeoliteTestcase>()
// These should be after ZeoliteTestcase.
.include<ZeoliteUpperSymbol>()
.include<ZeoliteLowerSymbol>())
String data <- "testcase \"my test\" {
success Checker<[A&B]> // <- enables lib/testing support
require compiler \"something\"
timeout 30
}"
\ data `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteTestcase", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteContainKeyword", content: "testcase"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.section(label: "ZeoliteStringLiteral", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteDoubleQuote", content: "\""))
.append(ZeoliteParsed.leaf(label: "ZeoliteQuotedChars", content: "my test"))
.append(ZeoliteParsed.leaf(label: "ZeoliteDoubleQuote", content: "\""))))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.section(label: "ZeoliteTestcaseSection", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteOpenDelim", content: "{"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: "\n "))
.append(ZeoliteParsed.leaf(label: "ZeoliteTestcaseKeyword", content: "success"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.leaf(label: "ZeoliteCategoryName", content: "Checker"))
.append(ZeoliteParsed.leaf(label: "ZeoliteOperator", content: "<"))
.append(ZeoliteParsed.section(label: "ZeoliteSquareSection", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteOpenDelim", content: "["))
.append(ZeoliteParsed.leaf(label: "ZeoliteCategoryName", content: "A"))
.append(ZeoliteParsed.leaf(label: "ZeoliteOperator", content: "&"))
.append(ZeoliteParsed.leaf(label: "ZeoliteCategoryName", content: "B"))
.append(ZeoliteParsed.leaf(label: "ZeoliteCloseDelim", content: "]"))))
.append(ZeoliteParsed.leaf(label: "ZeoliteOperator", content: ">"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.leaf(label: "ZeoliteLineComment", content: "// <- enables lib/testing support"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: "\n "))
.append(ZeoliteParsed.leaf(label: "ZeoliteTestcaseKeyword", content: "require"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.leaf(label: "ZeoliteTestcaseKeyword", content: "compiler"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.section(label: "ZeoliteStringLiteral", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteDoubleQuote", content: "\""))
.append(ZeoliteParsed.leaf(label: "ZeoliteQuotedChars", content: "something"))
.append(ZeoliteParsed.leaf(label: "ZeoliteDoubleQuote", content: "\""))))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: "\n "))
.append(ZeoliteParsed.leaf(label: "ZeoliteTestcaseKeyword", content: "timeout"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.leaf(label: "ZeoliteNumber", content: "30"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: "\n "))
.append(ZeoliteParsed.leaf(label: "ZeoliteCloseDelim", content: "}"))))))
\ "testcase { }" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteTestcase", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteContainKeyword", content: "testcase"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))))
}
unittest parseZeolitePragma {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeolitePragma>())
\ "$NoArgs$" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeolitePragma", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaDelim", content: "$"))
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaName", content: "NoArgs"))
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaDelim", content: "$"))))
\ "$SomeArgs[a, b, 123]$" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeolitePragma", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaDelim", content: "$"))
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaName", content: "SomeArgs"))
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaArgOpen", content: "["))
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaArg", content: "a, b, 123"))
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaArgClose", content: "]"))
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaDelim", content: "$"))))
\ "$NoArgs" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeolitePragma", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaDelim", content: "$"))
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaName", content: "NoArgs"))))
\ "$foo$" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeolitePragma", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaDelim", content: "$"))))
\ "$NoArgs#" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeolitePragma", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaDelim", content: "$"))
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaName", content: "NoArgs"))
.append(ZeoliteParsed.leaf(label: "ZeoliteError", content: "#"))))
\ "$SomeArgs[args" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeolitePragma", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaDelim", content: "$"))
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaName", content: "SomeArgs"))
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaArgOpen", content: "["))
.append(ZeoliteParsed.leaf(label: "ZeolitePragmaArg", content: "args"))))
}
unittest parseZeoliteExtras {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteExtras>())
\ "_" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteIgnore", content: "_"))
\ "\\" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteDiscard", content: "\\"))
\ "`" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteTick", content: "`"))
\ "," `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteComma", content: ","))
\ ";" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteError", content: ";"))
\ "#" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteError", content: "#"))
\ "@" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteError", content: "@"))
}
unittest integration {
ParsingTester tester <- ParsingTester.new(ZeoliteParseContext.new()
.include<ZeoliteWhitespace>()
.include<ZeoliteLineComment>()
.include<ZeoliteBlockComment>()
.include<ZeolitePragma>()
.include<ZeoliteStringLiteral>()
.include<ZeoliteCharLiteral>()
.include<ZeoliteTestcase>()
.include<ZeoliteUpperSymbol>()
.include<ZeoliteLowerSymbol>()
.include<ZeoliteParamName>()
.include<ZeoliteBraceSection>())
\ "{Category #param}\"string\\n\" /*/ done*/\n" `tester.checkParsesAs` Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.section(label: "ZeoliteBraceSection", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteOpenDelim", content: "{"))
.append(ZeoliteParsed.leaf(label: "ZeoliteCategoryName", content: "Category"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.leaf(label: "ZeoliteParamName", content: "#param"))
.append(ZeoliteParsed.leaf(label: "ZeoliteCloseDelim", content: "}"))))
.append(ZeoliteParsed.section(label: "ZeoliteStringLiteral", Vector<ZeoliteParsed>.new()
.append(ZeoliteParsed.leaf(label: "ZeoliteDoubleQuote", content: "\""))
.append(ZeoliteParsed.leaf(label: "ZeoliteQuotedChars", content: "string"))
.append(ZeoliteParsed.leaf(label: "ZeoliteEscapedChar", content: "\\n"))
.append(ZeoliteParsed.leaf(label: "ZeoliteDoubleQuote", content: "\""))))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: " "))
.append(ZeoliteParsed.leaf(label: "ZeoliteBlockComment", content: "/*/ done*/"))
.append(ZeoliteParsed.leaf(label: "ZeoliteWhitespace", content: "\n"))
}
define ParsingTester {
$ReadOnlyExcept[]$
@value ZeoliteParseContext context
new (context) {
return delegate -> #self
}
checkParsesAs (originalData, expected) {
TextStream input <- TextStream.new(originalData)
DefaultOrder<ZeoliteParsed> output <- defer
\ StreamTokenizer:new(context: context, tokenizer: context.defaultTokenizer())
.tokenizeAll(input, (output <- Vector<ZeoliteParsed>.new()))
// Match output.
\ output `Matches:tryWith` CheckSequence:matches(CheckSequence:using(expected))
// Serialize output.
[Append<Formatted> & Build<String>] builder <- String.builder()
UnformattedFormatter formatter <- UnformattedFormatter.new()
traverse (output.defaultOrder() -> ZeoliteParsed parsed) {
\ builder.append(parsed.formatWith(formatter))
}
// Append unparsed remainder.
while (`present` input.current()) {
\ input.forward()
}
// This will be included in the output of failing tests.
\ BasicOutput.stderr()
.append("Remaining content: \"")
.append(CharType.escapeBreaks(input.preview()))
.append("\"\n")
\ builder.append(input.take())
// Check that all data is accounted for.
\ builder.build() `Matches:tryWith` CheckValue:equals(originalData)
}
}