You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
289 lines
9.8 KiB
289 lines
9.8 KiB
cmake_minimum_required (VERSION 2.6)
|
|
project(StringFileTest)
|
|
include_directories(${StringFileTest_BINARY_DIR})
|
|
|
|
# Read file test
|
|
file(READ "${CMAKE_CURRENT_SOURCE_DIR}/InputFile.h.in" infile)
|
|
|
|
# Test reading a binary file into hex representation
|
|
file(READ "${CMAKE_CURRENT_SOURCE_DIR}/test.bin" hexContents HEX)
|
|
|
|
if("${hexContents}" STREQUAL "0001027700")
|
|
message("file(READ HEX) correctly read [${hexContents}]")
|
|
else()
|
|
message(SEND_ERROR "file(READ HEX) incorrectly read [${hexContents}], but expected was [0001027700]")
|
|
endif()
|
|
|
|
# file(STRINGS) test
|
|
file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/InputFile.h.in" infile_strings
|
|
LIMIT_COUNT 1 LIMIT_INPUT 1024 LIMIT_OUTPUT 1024
|
|
LENGTH_MINIMUM 10 LENGTH_MAXIMUM 23 REGEX include NEWLINE_CONSUME)
|
|
set(infile_strings_goal "#include \"includefile\"\n")
|
|
if("${infile_strings}" STREQUAL "${infile_strings_goal}")
|
|
message("file(STRINGS) correctly read [${infile_strings}]")
|
|
else()
|
|
message(SEND_ERROR
|
|
"file(STRINGS) incorrectly read [${infile_strings}]")
|
|
endif()
|
|
|
|
# test reading a file and getting its binary data as hex string
|
|
file(READ "${CMAKE_CURRENT_SOURCE_DIR}/main.srec" infilehex LIMIT 4 HEX)
|
|
if(NOT "${infilehex}" STREQUAL "53313036")
|
|
message(SEND_ERROR
|
|
"file(READ ... HEX) error, read: \"${infilehex}\", expected \"53313036\"")
|
|
endif()
|
|
|
|
|
|
# test that file(STRINGS) also work with Intel hex and Motorola S-record files
|
|
# this file has been created with "sdcc main.c"
|
|
file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/main.ihx" infile_strings REGEX INFO)
|
|
set(infile_strings_goal "INFO:compiler\\[SDCC-HEX\\]")
|
|
if("${infile_strings}" MATCHES "${infile_strings_goal}")
|
|
message("file(STRINGS) correctly read from hex file [${infile_strings}]")
|
|
else()
|
|
message(SEND_ERROR
|
|
"file(STRINGS) incorrectly read from hex file [${infile_strings}]")
|
|
endif()
|
|
|
|
# this file has been created with "sdcc main.c --out-fmt-s19"
|
|
file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/main.srec" infile_strings REGEX INFO)
|
|
set(infile_strings_goal "INFO:compiler\\[SDCC-SREC\\]")
|
|
if("${infile_strings}" MATCHES "${infile_strings_goal}")
|
|
message("file(STRINGS) correctly read from srec file [${infile_strings}]")
|
|
else()
|
|
message(SEND_ERROR
|
|
"file(STRINGS) incorrectly read from srec file [${infile_strings}]")
|
|
endif()
|
|
|
|
# String test
|
|
string(REGEX MATCH "[cC][mM][aA][kK][eE]" rmvar "CMake is great")
|
|
string(REGEX MATCHALL "[cC][mM][aA][kK][eE]" rmallvar "CMake is better than cmake or CMake")
|
|
string(REGEX REPLACE "[Aa][uU][tT][oO]([cC][oO][nN][fF]|[mM][aA][kK][eE])"
|
|
"CMake" rrepvar "People should use Autoconf and Automake")
|
|
string(COMPARE EQUAL "CMake" "Autoconf" nceqvar)
|
|
string(COMPARE EQUAL "CMake" "CMake" ceqvar)
|
|
string(COMPARE NOTEQUAL "CMake" "Autoconf" cneqvar)
|
|
string(COMPARE NOTEQUAL "CMake" "CMake" ncneqvar)
|
|
string(COMPARE LESS "before" "after" nclvar)
|
|
string(COMPARE LESS "max" "min" clvar)
|
|
string(COMPARE GREATER "before" "after" cgvar)
|
|
string(COMPARE GREATER "max" "min" ncgvar)
|
|
string(ASCII 67 109 97 107 101 savar)
|
|
string(TOUPPER "CMake" tuvar)
|
|
string(TOLOWER "CMake" tlvar)
|
|
string(REPLACE "Autoconf" "CMake" repvar "People should use Autoconf")
|
|
|
|
if("abc" STREQUAL "xyz")
|
|
message(SEND_ERROR "Problem with the if(STREQUAL), \"abc\" and \"xyz\" considered equal")
|
|
endif()
|
|
|
|
if("CMake is cool" MATCHES "(CMake) (is).+")
|
|
if(NOT "${CMAKE_MATCH_0}" STREQUAL "CMake is cool")
|
|
message(SEND_ERROR "CMAKE_MATCH_0 wrong: \"${CMAKE_MATCH_0}\", expected \"CMake is cool\"")
|
|
endif()
|
|
if(NOT "${CMAKE_MATCH_1}" STREQUAL "CMake")
|
|
message(SEND_ERROR "CMAKE_MATCH_1 wrong: \"${CMAKE_MATCH_1}\", expected \"CMake\"")
|
|
endif()
|
|
if(NOT "${CMAKE_MATCH_2}" STREQUAL "is")
|
|
message(SEND_ERROR "CMAKE_MATCH_2 wrong: \"${CMAKE_MATCH_2}\", expected \"is\"")
|
|
endif()
|
|
else()
|
|
message(SEND_ERROR "Problem with the if(MATCHES), no match found")
|
|
endif()
|
|
|
|
string(REGEX MATCH "(People).+CMake" matchResultVar "People should use CMake")
|
|
if(NOT "${matchResultVar}" STREQUAL "People should use CMake")
|
|
message(SEND_ERROR "string(REGEX MATCH) problem: \"${matchResultVar}\", expected \"People should use CMake\"")
|
|
endif()
|
|
if(NOT "${CMAKE_MATCH_0}" STREQUAL "People should use CMake")
|
|
message(SEND_ERROR "CMAKE_MATCH_0 wrong: \"${CMAKE_MATCH_0}\", expected \"People should use CMake\"")
|
|
endif()
|
|
if(NOT "${CMAKE_MATCH_1}" STREQUAL "People")
|
|
message(SEND_ERROR "CMAKE_MATCH_1 wrong: \"${CMAKE_MATCH_1}\", expected \"People\"")
|
|
endif()
|
|
if(NOT "${CMAKE_MATCH_2}" STREQUAL "")
|
|
message(SEND_ERROR "CMAKE_MATCH_2 wrong: \"${CMAKE_MATCH_2}\", expected empty string")
|
|
endif()
|
|
|
|
|
|
string(STRIP "
|
|
ST1
|
|
" ST1)
|
|
string(STRIP "ST2 " ST2)
|
|
string(STRIP " ST3" ST3)
|
|
|
|
foreach(var ST1 ST2 ST3)
|
|
if("${var}" STREQUAL "${${var}}")
|
|
message("[${var}] == [${${var}}]")
|
|
else()
|
|
message(SEND_ERROR "Problem with the STRIP command for ${var}: [${${var}}]")
|
|
endif()
|
|
endforeach()
|
|
|
|
string(SUBSTRING "People should use Autoconf" 7 10 substringres)
|
|
set(substringres "Everybody ${substringres} CMake")
|
|
|
|
string(LENGTH ${substringres} lengthres)
|
|
|
|
file(RELATIVE_PATH relpath "/usr/local/bin" "/usr/X11R6/bin/xnest")
|
|
|
|
# Escaping test
|
|
set(var "\\ \" \ \t \n \r \# \( \) \0")
|
|
message("Output: [${var}]")
|
|
set(var \\ \" \ \t \n \r \# \( \) \0)
|
|
message("Output: [${var}]")
|
|
|
|
# Make-style unquoted argument test
|
|
set(var $(VAR1)$(VAR2)/$(VAR3))
|
|
message("Output: [${var}]")
|
|
string(COMPARE EQUAL "${var}" "$(VAR1)$(VAR2)/$(VAR3)" result)
|
|
if(NOT result)
|
|
message(SEND_ERROR "Unquoted $(VAR) syntax is broken.")
|
|
endif()
|
|
|
|
# Obscure environment variable name
|
|
set("ENV{x+(y)}" "Obscure environment variable value")
|
|
message("Output: [$ENV{x+(y)}]")
|
|
if(NOT "$ENV{x+(y)}" STREQUAL "Obscure environment variable value")
|
|
message(SEND_ERROR "Environment variable \"ENV{x+(y)}\" does not work.")
|
|
endif()
|
|
|
|
# Make directories test
|
|
file(MAKE_DIRECTORY
|
|
"${CMAKE_CURRENT_BINARY_DIR}/Includes"
|
|
"${CMAKE_CURRENT_BINARY_DIR}/Directory1"
|
|
"${CMAKE_CURRENT_BINARY_DIR}/Directory2"
|
|
)
|
|
|
|
# Write results to the file (test write file)
|
|
set(file "${CMAKE_CURRENT_BINARY_DIR}/Includes/Values.h")
|
|
file(WRITE "${file}" "/* this file is generated */\n")
|
|
foreach(var
|
|
rmvar
|
|
rmallvar
|
|
rrepvar
|
|
repvar
|
|
relpath
|
|
substringres
|
|
lengthres
|
|
nceqvar
|
|
ceqvar
|
|
cneqvar
|
|
ncneqvar
|
|
nclvar
|
|
clvar
|
|
cgvar
|
|
ncgvar
|
|
savar
|
|
tuvar
|
|
tlvar)
|
|
file(APPEND "${file}" "#define ${var} \"${${var}}\"\n")
|
|
endforeach()
|
|
|
|
# Verify that the file was created recently.
|
|
if(NOT "${file}" IS_NEWER_THAN "${CMAKE_CURRENT_SOURCE_DIR}/InputFile.h.in")
|
|
message(FATAL_ERROR "if(FILE_IS_NEWER) does not seem to work.")
|
|
endif()
|
|
|
|
# Test configuration of the string
|
|
set(TEST_DEFINED 123)
|
|
set(TEST_NOT_DEFINED)
|
|
string(CONFIGURE "${infile}" infile+-/out @ONLY)
|
|
set(infile "${infile+-/out}")
|
|
|
|
# Write include file to a file
|
|
string(REGEX REPLACE "includefile" "${file}" outfile "${infile}")
|
|
file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/OutputFile.h-tmp" "${outfile}")
|
|
file(RENAME "${CMAKE_CURRENT_BINARY_DIR}/OutputFile.h-tmp"
|
|
"${CMAKE_CURRENT_BINARY_DIR}/OutputFile.h")
|
|
|
|
# Test file copy with relative paths
|
|
file(COPY .
|
|
DESTINATION src
|
|
FILE_PERMISSIONS OWNER_READ # test no OWNER_WRITE
|
|
DIRECTORY_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE
|
|
FILES_MATCHING PATTERN *.cxx # Only copy the main source file
|
|
REGEX /src$ EXCLUDE # Block recursion for in-source build
|
|
)
|
|
|
|
# Test file glob
|
|
file(GLOB_RECURSE src_files "${CMAKE_CURRENT_SOURCE_DIR}/*")
|
|
message("Files in ${CMAKE_CURRENT_SOURCE_DIR} are ${src_files}")
|
|
set(expr "${CMAKE_CURRENT_BINARY_DIR}/src/[sS][!a-su-zA-Z0-9][^a-qs-zA-Z0-9]ing?ile*.cxx")
|
|
message("Glob expression is [${expr}].")
|
|
file(GLOB src_files "${expr}")
|
|
message("Globbed files [${src_files}].")
|
|
add_executable(StringFileTest ${src_files})
|
|
|
|
set(expr "${CMAKE_CURRENT_SOURCE_DIR}/../*.cxx")
|
|
file(GLOB_RECURSE rel_src_files RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/.." "${expr}")
|
|
message("Globbed files [${rel_src_files}].")
|
|
|
|
# Test FOREACH range
|
|
message("Cheack if FOREACH with RANGE works")
|
|
macro(TEST_RANGE ARGS CHECK)
|
|
set(r)
|
|
foreach(a RANGE ${ARGS})
|
|
set(r ${r} ${a})
|
|
endforeach()
|
|
message("FOREACH with RANGE ${ARGS} produces ${r}")
|
|
if("x${r}x" MATCHES "^x${CHECK}x$")
|
|
else()
|
|
message(SEND_ERROR "The range resulted in: ${r} should be ${CHECK}")
|
|
endif()
|
|
endmacro()
|
|
TEST_RANGE("5" "0;1;2;3;4;5")
|
|
TEST_RANGE("3;5" "3;4;5")
|
|
TEST_RANGE("5;3" "5;4;3")
|
|
TEST_RANGE("3;10;2" "3;5;7;9")
|
|
TEST_RANGE("10;0;-3" "10;7;4;1")
|
|
|
|
# Test FOREACH IN signature
|
|
set(list1 "" a "")
|
|
set(list2 a "" b)
|
|
set(var_)
|
|
set(var_a)
|
|
set(var_b)
|
|
foreach(item IN LISTS list1 list2 ITEMS "" a "")
|
|
set(var_${item} "${var_${item}}x")
|
|
endforeach()
|
|
if(NOT "${var_}" STREQUAL "xxxxx")
|
|
message(FATAL_ERROR "count incorrect for \"\": [${var_}]")
|
|
endif()
|
|
if(NOT "${var_a}" STREQUAL "xxx")
|
|
message(FATAL_ERROR "count incorrect for \"a\": [${var_a}]")
|
|
endif()
|
|
if(NOT "${var_b}" STREQUAL "x")
|
|
message(FATAL_ERROR "count incorrect \"b\": [${var_b}]")
|
|
endif()
|
|
|
|
# Test SUBSTRING command
|
|
set(ST_INPUTSTRING "0123456789")
|
|
string(SUBSTRING ${ST_INPUTSTRING} 3 0 ST_EMPTY)
|
|
string(SUBSTRING ${ST_INPUTSTRING} 1 1 ST_ONE)
|
|
string(SUBSTRING ${ST_INPUTSTRING} 0 10 ST_ALL)
|
|
string(SUBSTRING ${ST_INPUTSTRING} 0 -1 ST_ALL_MINUS)
|
|
string(SUBSTRING ${ST_INPUTSTRING} 9 -1 ST_NINE)
|
|
|
|
if(ST_EMPTY)
|
|
message(SEND_ERROR "SUBSTRING with length 0 does not return an empty string")
|
|
endif()
|
|
if(NOT ST_ONE STREQUAL "1")
|
|
message(SEND_ERROR "SUBSTING command does not cut the correct selected character, was \"" ${ST_ONE} "\", should be \"1\"")
|
|
endif()
|
|
if(NOT ST_INPUTSTRING STREQUAL ST_ALL)
|
|
message(SEND_ERROR "SUBSTRING does not return the whole string when selected with length")
|
|
endif()
|
|
if(NOT ST_INPUTSTRING STREQUAL ST_ALL_MINUS)
|
|
message(SEND_ERROR "SUBSTRING does not return the whole string when selected with -1")
|
|
endif()
|
|
if(NOT ST_NINE STREQUAL "9")
|
|
message(SEND_ERROR "SUBSTRING does not return the tail when selected with -1")
|
|
endif()
|
|
|
|
string(MAKE_C_IDENTIFIER "1one-two$" MCI_1)
|
|
|
|
if(NOT MCI_1 STREQUAL _1one_two_)
|
|
message(SEND_ERROR "MAKE_C_IDENTIFIER did not create expected result.")
|
|
endif()
|