kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/Tests/RunCMake/Syntax/RunCMakeTest.cmake

111 lines
3.0 KiB
CMake
Raw Normal View History

Add RunCMake.Syntax test to cover argument parsing Test basic unquoted and quoted argument parsing cases including failure on an unterminated string and an unterminated command invocation. Also cover arguments not separated by any spaces, which is accidentally allowed by the current parser.
2012-08-06 17:29:20 +04:00
include(RunCMake)
cmListFileLexer: Allow a leading UTF-8 Byte-Order-Mark (#11137) Teach the lexer to read a UTF-8, UTF-16 BE/LE, or UTF-32 BE/LE Byte-Order-Mark from the start of a file if any is present. Report an error on files using UTF-16 or UTF-32 and accept a UTF-8 or missing BOM.
2013-10-14 23:13:11 +04:00
run_cmake(BOM-UTF-8)
run_cmake(BOM-UTF-16-LE)
run_cmake(BOM-UTF-16-BE)
run_cmake(BOM-UTF-32-LE)
run_cmake(BOM-UTF-32-BE)
EVIS: Add tests for syntax corner cases and CMP0053 Include tests for: - @ expansion during normal execution - various characters in variable names for comparison between the new and the old parser - corner cases in the parsers - correct messages when behavior is different
2014-02-18 23:47:56 +04:00
run_cmake(CMP0053-At-OLD)
run_cmake(CMP0053-At-NEW)
run_cmake(CMP0053-At-WARN)
run_cmake(CMP0053-At-WARN-newlines)
run_cmake(CMP0053-WARN)
run_cmake(CMP0053-NUL)
run_cmake(CMP0053-ParenInENV)
run_cmake(CMP0053-ParenInQuotedENV)
Add RunCMake.Syntax test cases for command invocation styles Cover commands with whitespace present in allowed combinations. Also cover command error cases such as two on one line.
2013-02-17 05:10:21 +04:00
run_cmake(CommandSpaces)
run_cmake(CommandTabs)
run_cmake(CommandNewlines)
run_cmake(CommandComments)
run_cmake(CommandError0)
run_cmake(CommandError1)
Add Lua-style long brackets and long comments to CMake language Teach the CMake language parser to recognize Lua-style "long bracket" arguments. These start with two '[' separated by zero or more '=' characters e.g. "[[" or "[=[" or "[==[". They end with two ']' separated by the same number of '=' as the opening bracket. There is no nesting of brackets of the same level (number of '='). No escapes, variable expansion, or other processing is performed on the content between such brackets so they always represent exactly one argument. Also teach CMake to parse and ignore "long comment" syntax. A long comment starts with "#" immediately followed by an opening long bracket. It ends at the matching close long bracket. Teach the RunCMake.Syntax test to cover long bracket and long comment cases.
2013-08-06 23:58:22 +04:00
run_cmake(CommandError2)
Test foreach/function/macro handling of bracket arguments Bracket arguments recorded in command invocations inside foreach, function, and macro blocks should not have any replacements done when the arguments are replayed later. Teach the RunCMake.Syntax test to cover these cases.
2013-10-31 03:12:59 +04:00
run_cmake(ForEachBracket1)
run_cmake(FunctionBracket1)
run_cmake(MacroBracket1)
Add RunCMake.Syntax test to cover argument parsing Test basic unquoted and quoted argument parsing cases including failure on an unterminated string and an unterminated command invocation. Also cover arguments not separated by any spaces, which is accidentally allowed by the current parser.
2012-08-06 17:29:20 +04:00
run_cmake(String0)
run_cmake(String1)
Add \-continuation to CMake language quoted arguments Teach the CMake language lexer to treat the \-LF pair terminating a line ending in an odd number of backslashes inside a quoted argument as a continuation. Drop the pair from the returned quoted argument token text. This will allow long lines inside quoted argument strings to be divided across multiple lines in the source file. It will also allow quoted argument text to start on the line after the opening quote. For example, the code: set(x "\ ...") sets variable "x" to the value "..." with no opening newline. Previously an odd number of backslashes at the end of a line inside a quoted argument would put a \-LF pair (or a \-CR pair) literally in the argument. Then the command-argument evaluator would complain that the \-escape sequence is invalid. Therefore this syntax is available to use without changing behavior of valid existing code. Teach the RunCMake.Syntax test to cover cases of quoted arguments with lines ending in \, \\, and \\\. Odd counts are continuations.
2013-10-23 02:11:22 +04:00
run_cmake(StringBackslash)
cmListFileLexer: Convert CRLF -> LF newlines explicitly Read input files in binary mode instead of text mode and convert CRLF newlines to LF newlines explicitly in our own buffer. This is necessary to read CMake source files with CRLF newlines on platforms whose C runtime libraries do not transform newlines in text mode. For example, a Cygwin or Linux binary may not transform CRLF -> LF in files read from a Windows filesystem. Perform the conversion ourselves to ensure that multi-line string literals in CMake source files have LF newlines everywhere.
2013-10-14 21:54:19 +04:00
run_cmake(StringCRLF)
Add \-continuation to CMake language quoted arguments Teach the CMake language lexer to treat the \-LF pair terminating a line ending in an odd number of backslashes inside a quoted argument as a continuation. Drop the pair from the returned quoted argument token text. This will allow long lines inside quoted argument strings to be divided across multiple lines in the source file. It will also allow quoted argument text to start on the line after the opening quote. For example, the code: set(x "\ ...") sets variable "x" to the value "..." with no opening newline. Previously an odd number of backslashes at the end of a line inside a quoted argument would put a \-LF pair (or a \-CR pair) literally in the argument. Then the command-argument evaluator would complain that the \-escape sequence is invalid. Therefore this syntax is available to use without changing behavior of valid existing code. Teach the RunCMake.Syntax test to cover cases of quoted arguments with lines ending in \, \\, and \\\. Odd counts are continuations.
2013-10-23 02:11:22 +04:00
run_cmake(StringContinuation1)
run_cmake(StringContinuation2)
Add RunCMake.Syntax test to cover argument parsing Test basic unquoted and quoted argument parsing cases including failure on an unterminated string and an unterminated command invocation. Also cover arguments not separated by any spaces, which is accidentally allowed by the current parser.
2012-08-06 17:29:20 +04:00
run_cmake(StringNoSpace)
cmListFileLexer: Allow command names with one letter (#14181) Teach the lexer to treat a single letter as an identifier instead of an unquoted argument. Outside of a command invocation, the parser treats an identifier as a command name and an unquoted argument as an error. Inside of a command invocation, the parser treats an identifier as an unquoted argument. Therefore this change to the lexer will make what was previously an error case work with no other behavioral change.
2013-10-14 23:24:06 +04:00
run_cmake(OneLetter)
Add RunCMake.Syntax test to cover argument parsing Test basic unquoted and quoted argument parsing cases including failure on an unterminated string and an unterminated command invocation. Also cover arguments not separated by any spaces, which is accidentally allowed by the current parser.
2012-08-06 17:29:20 +04:00
run_cmake(Unquoted0)
run_cmake(Unquoted1)
EVIS: Add tests for syntax corner cases and CMP0053 Include tests for: - @ expansion during normal execution - various characters in variable names for comparison between the new and the old parser - corner cases in the parsers - correct messages when behavior is different
2014-02-18 23:47:56 +04:00
run_cmake(Unquoted2)
Add Lua-style long brackets and long comments to CMake language Teach the CMake language parser to recognize Lua-style "long bracket" arguments. These start with two '[' separated by zero or more '=' characters e.g. "[[" or "[=[" or "[==[". They end with two ']' separated by the same number of '=' as the opening bracket. There is no nesting of brackets of the same level (number of '='). No escapes, variable expansion, or other processing is performed on the content between such brackets so they always represent exactly one argument. Also teach CMake to parse and ignore "long comment" syntax. A long comment starts with "#" immediately followed by an opening long bracket. It ends at the matching close long bracket. Teach the RunCMake.Syntax test to cover long bracket and long comment cases.
2013-08-06 23:58:22 +04:00
run_cmake(Bracket0)
run_cmake(Bracket1)
run_cmake(Bracket2)
run_cmake(BracketBackslash)
run_cmake(BracketCRLF)
run_cmake(BracketComment0)
run_cmake(BracketComment1)
run_cmake(BracketComment2)
run_cmake(BracketComment3)
run_cmake(BracketComment4)
run_cmake(BracketComment5)
run_cmake(BracketNoSpace0)
run_cmake(BracketNoSpace1)
run_cmake(BracketNoSpace2)
run_cmake(BracketNoSpace3)
run_cmake(BracketNoSpace4)
run_cmake(BracketNoSpace5)
Add to RunCMake.Syntax test \-escape cases Add an Escape1 test case covering \-escape cases inside bracket, quoted, and unquoted arguments. Also cover comments immediately after quoted and unquoted arguments on lines containing \# escapes.
2013-10-29 18:21:50 +04:00
run_cmake(Escape1)
EVIS: Add tests for syntax corner cases and CMP0053 Include tests for: - @ expansion during normal execution - various characters in variable names for comparison between the new and the old parser - corner cases in the parsers - correct messages when behavior is different
2014-02-18 23:47:56 +04:00
run_cmake(Escape2)
run_cmake(EscapeCharsAllowed)
include("${RunCMake_SOURCE_DIR}/EscapeCharsDisallowed.cmake")
Add Lua-style long brackets and long comments to CMake language Teach the CMake language parser to recognize Lua-style "long bracket" arguments. These start with two '[' separated by zero or more '=' characters e.g. "[[" or "[=[" or "[==[". They end with two ']' separated by the same number of '=' as the opening bracket. There is no nesting of brackets of the same level (number of '='). No escapes, variable expansion, or other processing is performed on the content between such brackets so they always represent exactly one argument. Also teach CMake to parse and ignore "long comment" syntax. A long comment starts with "#" immediately followed by an opening long bracket. It ends at the matching close long bracket. Teach the RunCMake.Syntax test to cover long bracket and long comment cases.
2013-08-06 23:58:22 +04:00
run_cmake(ParenNoSpace0)
run_cmake(ParenNoSpace1)
run_cmake(ParenNoSpace2)
EVIS: Add tests for syntax corner cases and CMP0053 Include tests for: - @ expansion during normal execution - various characters in variable names for comparison between the new and the old parser - corner cases in the parsers - correct messages when behavior is different
2014-02-18 23:47:56 +04:00
run_cmake(ParenInVarName0)
run_cmake(ParenInVarName1)
Add RunCMake.Syntax test to cover argument parsing Test basic unquoted and quoted argument parsing cases including failure on an unterminated string and an unterminated command invocation. Also cover arguments not separated by any spaces, which is accidentally allowed by the current parser.
2012-08-06 17:29:20 +04:00
run_cmake(UnterminatedCall1)
cmListFileLexer: Fix line number after backslash in string If a line inside a string ends in a backslash count the following newline character as a line increment. Add a test covering this case to verify that subsequent line numbers are correct.
2012-08-06 17:41:10 +04:00
run_cmake(UnterminatedCall2)
Add RunCMake.Syntax test to cover argument parsing Test basic unquoted and quoted argument parsing cases including failure on an unterminated string and an unterminated command invocation. Also cover arguments not separated by any spaces, which is accidentally allowed by the current parser.
2012-08-06 17:29:20 +04:00
run_cmake(UnterminatedString)
EVIS: Add tests for syntax corner cases and CMP0053 Include tests for: - @ expansion during normal execution - various characters in variable names for comparison between the new and the old parser - corner cases in the parsers - correct messages when behavior is different
2014-02-18 23:47:56 +04:00
run_cmake(UnterminatedBrace0)
run_cmake(UnterminatedBrace1)
run_cmake(UnterminatedBrace2)
Add Lua-style long brackets and long comments to CMake language Teach the CMake language parser to recognize Lua-style "long bracket" arguments. These start with two '[' separated by zero or more '=' characters e.g. "[[" or "[=[" or "[==[". They end with two ']' separated by the same number of '=' as the opening bracket. There is no nesting of brackets of the same level (number of '='). No escapes, variable expansion, or other processing is performed on the content between such brackets so they always represent exactly one argument. Also teach CMake to parse and ignore "long comment" syntax. A long comment starts with "#" immediately followed by an opening long bracket. It ends at the matching close long bracket. Teach the RunCMake.Syntax test to cover long bracket and long comment cases.
2013-08-06 23:58:22 +04:00
run_cmake(UnterminatedBracket0)
run_cmake(UnterminatedBracket1)
run_cmake(UnterminatedBracketComment)
tests: Add variable expansion tests There are some corner cases in variable expansion which would be nice to capture before going and rewriting the variable expansion code. The majority of these are related to configuring files and strings with '@' in them in conjunction with @ONLY being specified. Another is testing for '(' usage inside of ENV variable references based on whether it is quoted or not.
2014-02-08 02:53:31 +04:00
# Variable expansion tests
run_cmake(ExpandInAt)
run_cmake(EscapedAt)
run_cmake(EscapeQuotes)
run_cmake(AtWithVariable)
run_cmake(AtWithVariableEmptyExpansion)
run_cmake(AtWithVariableAtOnly)
run_cmake(AtWithVariableEmptyExpansionAtOnly)
run_cmake(AtWithVariableFile)
run_cmake(AtWithVariableAtOnlyFile)
run_cmake(ParenInENV)
run_cmake(ParenInQuotedENV)
EVIS: Add tests for syntax corner cases and CMP0053 Include tests for: - @ expansion during normal execution - various characters in variable names for comparison between the new and the old parser - corner cases in the parsers - correct messages when behavior is different
2014-02-18 23:47:56 +04:00
# Variable name tests
run_cmake(NameWithSpaces)
run_cmake(NameWithTabs)
run_cmake(NameWithNewline)
run_cmake(NameWithCarriageReturn)
run_cmake(NameWithEscapedSpaces)
run_cmake(NameWithEscapedTabs)
run_cmake(NameWithSpacesQuoted)
run_cmake(NameWithTabsQuoted)
run_cmake(NameWithNewlineQuoted)
run_cmake(NameWithCarriageReturnQuoted)
run_cmake(NameWithEscapedSpacesQuoted)
run_cmake(NameWithEscapedTabsQuoted)
run_cmake(CMP0053-NameWithSpaces)
run_cmake(CMP0053-NameWithTabs)
run_cmake(CMP0053-NameWithNewline)
run_cmake(CMP0053-NameWithCarriageReturn)
run_cmake(CMP0053-NameWithEscapedSpaces)
run_cmake(CMP0053-NameWithEscapedTabs)
run_cmake(CMP0053-NameWithSpacesQuoted)
run_cmake(CMP0053-NameWithTabsQuoted)
run_cmake(CMP0053-NameWithNewlineQuoted)
run_cmake(CMP0053-NameWithCarriageReturnQuoted)
run_cmake(CMP0053-NameWithEscapedSpacesQuoted)
run_cmake(CMP0053-NameWithEscapedTabsQuoted)