RunCMake.cmake 7.92 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
foreach(arg
    RunCMake_GENERATOR
    RunCMake_SOURCE_DIR
    RunCMake_BINARY_DIR
    )
  if(NOT DEFINED ${arg})
    message(FATAL_ERROR "${arg} not given!")
  endif()
endforeach()

function(run_cmake test)
12 13 14 15
  if(DEFINED ENV{RunCMake_TEST_FILTER} AND NOT test MATCHES "$ENV{RunCMake_TEST_FILTER}")
    return()
  endif()

16 17 18 19 20 21 22 23
  set(top_src "${RunCMake_SOURCE_DIR}")
  set(top_bin "${RunCMake_BINARY_DIR}")
  if(EXISTS ${top_src}/${test}-result.txt)
    file(READ ${top_src}/${test}-result.txt expect_result)
    string(REGEX REPLACE "\n+$" "" expect_result "${expect_result}")
  else()
    set(expect_result 0)
  endif()
24 25 26 27 28 29 30

  string(TOLOWER ${CMAKE_HOST_SYSTEM_NAME} platform_name)
  if(platform_name MATCHES cygwin)
    #remove all additional bits from cygwin name
    set(platform_name cygwin)
  endif()

31
  foreach(o out err)
32 33 34
    if(RunCMake-std${o}-file AND EXISTS ${top_src}/${RunCMake-std${o}-file})
      file(READ ${top_src}/${RunCMake-std${o}-file} expect_std${o})
      string(REGEX REPLACE "\n+$" "" expect_std${o} "${expect_std${o}}")
35 36 37
    elseif(EXISTS ${top_src}/${test}-std${o}-${platform_name}.txt)
      file(READ ${top_src}/${test}-std${o}-${platform_name}.txt expect_std${o})
      string(REGEX REPLACE "\n+$" "" expect_std${o} "${expect_std${o}}")
38
    elseif(EXISTS ${top_src}/${test}-std${o}.txt)
39 40 41 42 43 44
      file(READ ${top_src}/${test}-std${o}.txt expect_std${o})
      string(REGEX REPLACE "\n+$" "" expect_std${o} "${expect_std${o}}")
    else()
      unset(expect_std${o})
    endif()
  endforeach()
45 46 47 48 49 50 51
  if (NOT expect_stderr)
    if (NOT RunCMake_DEFAULT_stderr)
      set(RunCMake_DEFAULT_stderr "^$")
    endif()
    set(expect_stderr ${RunCMake_DEFAULT_stderr})
  endif()

52 53 54
  if (NOT RunCMake_TEST_SOURCE_DIR)
    set(RunCMake_TEST_SOURCE_DIR "${top_src}")
  endif()
55 56 57 58 59 60
  if(NOT RunCMake_TEST_BINARY_DIR)
    set(RunCMake_TEST_BINARY_DIR "${top_bin}/${test}-build")
  endif()
  if(NOT RunCMake_TEST_NO_CLEAN)
    file(REMOVE_RECURSE "${RunCMake_TEST_BINARY_DIR}")
  endif()
61
  file(MAKE_DIRECTORY "${RunCMake_TEST_BINARY_DIR}")
62 63 64 65 66
  if(RunCMake-prep-file AND EXISTS ${top_src}/${RunCMake-prep-file})
    include(${top_src}/${RunCMake-prep-file})
  else()
    include(${top_src}/${test}-prep.cmake OPTIONAL)
  endif()
67 68 69
  if(NOT DEFINED RunCMake_TEST_OPTIONS)
    set(RunCMake_TEST_OPTIONS "")
  endif()
70 71 72
  if(APPLE)
    list(APPEND RunCMake_TEST_OPTIONS -DCMAKE_POLICY_DEFAULT_CMP0025=NEW)
  endif()
73 74 75
  if(RunCMake_MAKE_PROGRAM)
    list(APPEND RunCMake_TEST_OPTIONS "-DCMAKE_MAKE_PROGRAM=${RunCMake_MAKE_PROGRAM}")
  endif()
76 77 78 79 80 81
  if(RunCMake_TEST_OUTPUT_MERGE)
    set(actual_stderr_var actual_stdout)
    set(actual_stderr "")
  else()
    set(actual_stderr_var actual_stderr)
  endif()
82 83 84 85 86
  if(DEFINED RunCMake_TEST_TIMEOUT)
    set(maybe_timeout TIMEOUT ${RunCMake_TEST_TIMEOUT})
  else()
    set(maybe_timeout "")
  endif()
87 88 89 90 91 92 93
  if(RunCMake-stdin-file AND EXISTS ${top_src}/${RunCMake-stdin-file})
    set(maybe_input_file INPUT_FILE ${top_src}/${RunCMake-stdin-file})
  elseif(EXISTS ${top_src}/${test}-stdin.txt)
    set(maybe_input_file INPUT_FILE ${top_src}/${test}-stdin.txt)
  else()
    set(maybe_input_file "")
  endif()
94
  if(RunCMake_TEST_COMMAND)
95 96 97
    if(NOT RunCMake_TEST_COMMAND_WORKING_DIRECTORY)
      set(RunCMake_TEST_COMMAND_WORKING_DIRECTORY "${RunCMake_TEST_BINARY_DIR}")
    endif()
98 99
    execute_process(
      COMMAND ${RunCMake_TEST_COMMAND}
100
      WORKING_DIRECTORY "${RunCMake_TEST_COMMAND_WORKING_DIRECTORY}"
101
      OUTPUT_VARIABLE actual_stdout
102
      ERROR_VARIABLE ${actual_stderr_var}
103
      RESULT_VARIABLE actual_result
104
      ENCODING UTF8
105
      ${maybe_timeout}
106
      ${maybe_input_file}
107 108
      )
  else()
109 110 111 112 113
    if(RunCMake_GENERATOR_INSTANCE)
      set(_D_CMAKE_GENERATOR_INSTANCE "-DCMAKE_GENERATOR_INSTANCE=${RunCMake_GENERATOR_INSTANCE}")
    else()
      set(_D_CMAKE_GENERATOR_INSTANCE "")
    endif()
114 115 116 117 118
    if(NOT RunCMake_TEST_NO_SOURCE_DIR)
      set(maybe_source_dir "${RunCMake_TEST_SOURCE_DIR}")
    else()
      set(maybe_source_dir "")
    endif()
119
    execute_process(
120 121
      COMMAND ${CMAKE_COMMAND}
                ${maybe_source_dir}
122
                -G "${RunCMake_GENERATOR}"
123
                -A "${RunCMake_GENERATOR_PLATFORM}"
124
                -T "${RunCMake_GENERATOR_TOOLSET}"
125
                ${_D_CMAKE_GENERATOR_INSTANCE}
126
                -DRunCMake_TEST=${test}
127
                --no-warn-unused-cli
128 129 130
                ${RunCMake_TEST_OPTIONS}
      WORKING_DIRECTORY "${RunCMake_TEST_BINARY_DIR}"
      OUTPUT_VARIABLE actual_stdout
131
      ERROR_VARIABLE ${actual_stderr_var}
132
      RESULT_VARIABLE actual_result
133
      ENCODING UTF8
134
      ${maybe_timeout}
135
      ${maybe_input_file}
136 137
      )
  endif()
138
  set(msg "")
139
  if(NOT "${actual_result}" MATCHES "${expect_result}")
140
    string(APPEND msg "Result is [${actual_result}], not [${expect_result}].\n")
141
  endif()
142 143 144 145
  string(CONCAT ignore_line_regex
    "(^|\n)((==[0-9]+=="
    "|BullseyeCoverage"
    "|[a-z]+\\([0-9]+\\) malloc:"
146
    "|clang[^:]*: warning: the object size sanitizer has no effect at -O0, but is explicitly enabled:"
147 148
    "|Error kstat returned"
    "|Hit xcodebuild bug"
149 150 151 152 153 154

    "|LICENSE WARNING:"
    "|Your license to use PGI[^\n]*expired"
    "|Please obtain a new version at"
    "|contact PGI Sales at"

155
    "|[^\n]*xcodebuild[^\n]*warning: file type[^\n]*is based on missing file type"
156 157 158 159 160
    "|[^\n]*is a member of multiple groups"
    "|[^\n]*from Time Machine by path"
    "|[^\n]*Bullseye Testing Technology"
    ")[^\n]*\n)+"
    )
161
  foreach(o out err)
162
    string(REGEX REPLACE "\r\n" "\n" actual_std${o} "${actual_std${o}}")
163
    string(REGEX REPLACE "${ignore_line_regex}" "\\1" actual_std${o} "${actual_std${o}}")
164 165 166 167 168 169 170
    string(REGEX REPLACE "\n+$" "" actual_std${o} "${actual_std${o}}")
    set(expect_${o} "")
    if(DEFINED expect_std${o})
      if(NOT "${actual_std${o}}" MATCHES "${expect_std${o}}")
        string(REGEX REPLACE "\n" "\n expect-${o}> " expect_${o}
          " expect-${o}> ${expect_std${o}}")
        set(expect_${o} "Expected std${o} to match:\n${expect_${o}}\n")
171
        string(APPEND msg "std${o} does not match that expected.\n")
172 173 174
      endif()
    endif()
  endforeach()
175
  unset(RunCMake_TEST_FAILED)
176 177 178 179 180
  if(RunCMake-check-file AND EXISTS ${top_src}/${RunCMake-check-file})
    include(${top_src}/${RunCMake-check-file})
  else()
    include(${top_src}/${test}-check.cmake OPTIONAL)
  endif()
181 182 183
  if(RunCMake_TEST_FAILED)
    set(msg "${RunCMake_TEST_FAILED}\n${msg}")
  endif()
184 185
  if(msg AND RunCMake_TEST_COMMAND)
    string(REPLACE ";" "\" \"" command "\"${RunCMake_TEST_COMMAND}\"")
186
    string(APPEND msg "Command was:\n command> ${command}\n")
187
  endif()
188 189 190 191 192 193 194 195 196 197 198 199 200 201
  if(msg)
    string(REGEX REPLACE "\n" "\n actual-out> " actual_out " actual-out> ${actual_stdout}")
    string(REGEX REPLACE "\n" "\n actual-err> " actual_err " actual-err> ${actual_stderr}")
    message(SEND_ERROR "${test} - FAILED:\n"
      "${msg}"
      "${expect_out}"
      "Actual stdout:\n${actual_out}\n"
      "${expect_err}"
      "Actual stderr:\n${actual_err}\n"
      )
  else()
    message(STATUS "${test} - PASSED")
  endif()
endfunction()
202 203 204 205 206

function(run_cmake_command test)
  set(RunCMake_TEST_COMMAND "${ARGN}")
  run_cmake(${test})
endfunction()
207

208 209 210 211 212
function(run_cmake_with_options test)
  set(RunCMake_TEST_OPTIONS "${ARGN}")
  run_cmake(${test})
endfunction()

213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235
function(ensure_files_match expected_file actual_file)
  if(NOT EXISTS "${expected_file}")
    message(FATAL_ERROR "Expected file does not exist:\n  ${expected_file}")
  endif()
  if(NOT EXISTS "${actual_file}")
    message(FATAL_ERROR "Actual file does not exist:\n  ${actual_file}")
  endif()
  file(READ "${expected_file}" expected_file_content)
  file(READ "${actual_file}" actual_file_content)
  if(NOT "${expected_file_content}" STREQUAL "${actual_file_content}")
    message(FATAL_ERROR "Actual file content does not match expected:\n
    \n
      expected file: ${expected_file}\n
      expected content:\n
      ${expected_file_content}\n
    \n
      actual file: ${actual_file}\n
      actual content:\n
      ${actual_file_content}\n
    ")
  endif()
endfunction()

236 237
# Protect RunCMake tests from calling environment.
unset(ENV{MAKEFLAGS})