File: FindGTest.cmake

package info (click to toggle)
cmake 4.1.0-1
  • links: PTS, VCS
  • area: main
  • in suites: experimental
  • size: 147,284 kB
  • sloc: ansic: 403,915; cpp: 290,772; sh: 4,102; python: 3,357; yacc: 3,106; lex: 1,189; f90: 532; asm: 471; lisp: 375; cs: 270; java: 266; fortran: 230; perl: 217; objc: 215; xml: 198; makefile: 97; javascript: 83; pascal: 63; tcl: 55; php: 25; ruby: 22
file content (491 lines) | stat: -rw-r--r-- 17,337 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
# file LICENSE.rst or https://cmake.org/licensing for details.

#[=======================================================================[.rst:
FindGTest
---------

Finds GoogleTest, the Google C++ testing and mocking framework:

.. code-block:: cmake

  find_package(GTest [...])

The GoogleTest framework also includes GoogleMock, a library for writing
and using C++ mock classes.  On some systems, GoogleMock may be distributed
as a separate package.

When both debug and release (optimized) variants of the GoogleTest and
GoogleMock libraries are available, this module selects the appropriate
variants based on the current :ref:`Build Configuration <Build Configurations>`.

.. versionadded:: 3.20
  If GoogleTest is built and installed using its CMake-based build system, it
  provides a :ref:`package configuration file <Config File Packages>`
  (``GTestConfig.cmake``) that can be used with :command:`find_package` in
  :ref:`Config mode`.  By default, this module now searches for that
  configuration file and, if found, returns the results without further
  action.  If the upstream configuration file is not found, this module falls
  back to :ref:`Module mode` and searches standard locations.

Imported Targets
^^^^^^^^^^^^^^^^

This module provides the following :ref:`Imported Targets`:

``GTest::gtest``
  .. versionadded:: 3.20

  Target encapsulating the usage requirements of the GoogleTest ``gtest``
  library, available if GoogleTest is found.  The ``gtest`` library provides
  the core GoogleTest testing framework functionality.

``GTest::gtest_main``
  .. versionadded:: 3.20

  Target encapsulating the usage requirements of the GoogleTest ``gtest_main``
  library, available if GoogleTest is found.  The ``gtest_main`` library
  provides a ``main()`` function, allowing tests to be run without defining
  one manually.

  Only link to ``GTest::gtest_main`` if GoogleTest should supply the
  ``main()`` function for the executable.  If the project is supplying its
  own ``main()`` implementation, link only to ``GTest::gtest``.

``GTest::gmock``
  .. versionadded:: 3.23

  Target encapsulating the usage requirements of the GoogleMock ``gmock``
  library, available if GoogleTest and its Mock library are found.  The
  ``gmock`` library provides facilities for writing and using mock classes
  in C++.

``GTest::gmock_main``
  .. versionadded:: 3.23

  Target encapsulating the usage requirements of the GoogleMock ``gmock_main``
  library, available if GoogleTest and ``gmock_main`` are found.  The
  ``gmock_main`` library provides a ``main()`` function, allowing GoogleMock
  tests to be run without defining one manually.

  Only link to ``GTest::gmock_main`` if GoogleTest should supply the
  ``main()`` function for the executable.  If project is supplying its own
  ``main()`` implementation, link only to ``GTest::gmock``.

Result Variables
^^^^^^^^^^^^^^^^

This module defines the following variables:

``GTest_FOUND``
  Boolean indicating whether GoogleTest is found.

Hints
^^^^^

This module accepts the following variables before calling
``find_package(GTest)``:

``GTEST_ROOT``
  The root directory of the GoogleTest installation (may also be set as an
  environment variable).  This variable is used only when GoogleTest is found
  in :ref:`Module mode`.

``GTEST_MSVC_SEARCH``
  When compiling with MSVC, this variable controls which GoogleTest build
  variant to search for, based on the runtime library linkage model.  This
  variable is used only when GoogleTest is found in :ref:`Module mode` and
  accepts one of the following values:

  ``MD``
    (Default) Searches for shared library variants of GoogleTest that are
    built to link against the dynamic C runtime.  These libraries are
    typically compiled with the MSVC runtime flags ``/MD`` or ``/MDd`` (for
    Release or Debug, respectively).

  ``MT``
    Searches for static library variants of GoogleTest that are built to
    link against the static C runtime.  These libraries are typically
    compiled with the MSVC runtime flags ``/MT`` or ``/MTd``.

Deprecated Items
^^^^^^^^^^^^^^^^

Deprecated Variables
""""""""""""""""""""

The following variables are provided for backward compatibility:

``GTEST_INCLUDE_DIRS``
  .. deprecated:: 4.1
    Use the ``GTest::gtest`` imported target instead, which exposes the
    required include directories through its
    :prop_tgt:`INTERFACE_INCLUDE_DIRECTORIES` target property.

  Result variable that provides include directories containing headers
  needed to use GoogleTest.  This variable is only guaranteed to be available
  when GoogleTest is found in :ref:`Module mode`.

``GTEST_LIBRARIES``
  .. deprecated:: 4.1
    Use the ``GTest::gtest`` imported target instead.

  Result variable providing libraries needed to link against to use the
  GoogleTest ``gtest`` library.  Note that projects are also responsible
  for linking with an appropriate thread library in addition to the libraries
  specified by this variable.

``GTEST_MAIN_LIBRARIES``
  .. deprecated:: 4.1
    Use the ``GTest::gtest_main`` imported target instead.

  Result variable providing libraries needed to link against to use the
  GoogleTest ``gtest_main`` library.

``GTEST_BOTH_LIBRARIES``
  .. deprecated:: 4.1
    Use the ``GTest::gtest`` and ``GTest::gtest_main`` imported targets
    instead.

  Result variable providing both ``gtest`` and ``gtest_main`` libraries
  combined.

Deprecated Imported Targets
"""""""""""""""""""""""""""

For backward compatibility, this module also provides the following imported
targets (available since CMake 3.5):

``GTest::GTest``
  .. deprecated:: 3.20
    Use the ``GTest::gtest`` imported target instead.

  Imported target linking the ``GTest::gtest`` library.

``GTest::Main``
  .. deprecated:: 3.20
    Use the ``GTest::gtest_main`` imported target instead.

  Imported target linking the ``GTest::gtest_main`` library.

Examples
^^^^^^^^

Examples: Finding GoogleTest
""""""""""""""""""""""""""""

Finding GoogleTest:

.. code-block:: cmake

  find_package(GoogleTest)

Or, finding GoogleTest and making it required (if not found, processing stops
with an error message):

.. code-block:: cmake

  find_package(GoogleTest REQUIRED)

Examples: Using Imported Targets
""""""""""""""""""""""""""""""""

In the following example, the ``GTest::gtest`` imported target is linked to
a project target, which enables using the core GoogleTest testing framework:

.. code-block:: cmake

  find_package(GTest REQUIRED)

  target_link_libraries(foo PRIVATE GTest::gtest)

In the next example, the ``GTest::gtest_main`` imported target is also linked
to the executable, and a test is registered.  The ``GTest::gtest_main`` library
provides a ``main()`` function, so there is no need to write one manually.
The ``GTest::gtest`` library is still linked because the test code directly
uses things provided by ``GTest::gtest``, and good practice is to link directly
to libraries used directly.

.. code-block:: cmake

  enable_testing()

  find_package(GTest REQUIRED)

  add_executable(foo foo.cc)
  target_link_libraries(foo PRIVATE GTest::gtest GTest::gtest_main)

  add_test(NAME AllTestsInFoo COMMAND foo)

Deeper Integration With CTest
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

This module is commonly used with the :module:`GoogleTest` module, which
provides :command:`gtest_discover_tests` and :command:`gtest_add_tests`
commands to help integrate GoogleTest infrastructure with CTest:

.. code-block:: cmake

  find_package(GTest)
  target_link_libraries(example PRIVATE GTest::gtest GTest::gtest_main)

  include(GoogleTest)
  gtest_discover_tests(example)

  # ...

.. versionchanged:: 3.9
  Previous CMake versions defined the :command:`gtest_add_tests` command in
  this module.
#]=======================================================================]

include(${CMAKE_CURRENT_LIST_DIR}/GoogleTest.cmake)

function(__gtest_append_debugs _endvar _library)
    if(${_library} AND ${_library}_DEBUG)
        set(_output optimized ${${_library}} debug ${${_library}_DEBUG})
    else()
        set(_output ${${_library}})
    endif()
    set(${_endvar} ${_output} PARENT_SCOPE)
endfunction()

function(__gtest_find_library _name)
    find_library(${_name}
        NAMES ${ARGN}
        HINTS
            ENV GTEST_ROOT
            ${GTEST_ROOT}
        PATH_SUFFIXES ${_gtest_libpath_suffixes}
    )
    mark_as_advanced(${_name})
endfunction()

macro(__gtest_determine_windows_library_type _var)
    if(EXISTS "${${_var}}")
        file(TO_NATIVE_PATH "${${_var}}" _lib_path)
        get_filename_component(_name "${${_var}}" NAME_WE)
        cmake_policy(PUSH)
        cmake_policy(SET CMP0159 NEW) # file(STRINGS) with REGEX updates CMAKE_MATCH_<n>
        file(STRINGS "${${_var}}" _match REGEX "${_name}\\.dll" LIMIT_COUNT 1)
        cmake_policy(POP)
        if(NOT _match STREQUAL "")
            set(${_var}_TYPE SHARED PARENT_SCOPE)
        else()
            set(${_var}_TYPE UNKNOWN PARENT_SCOPE)
        endif()
        return()
    endif()
endmacro()

function(__gtest_determine_library_type _var)
    if(WIN32)
        # For now, at least, only Windows really needs to know the library type
        __gtest_determine_windows_library_type(${_var})
        __gtest_determine_windows_library_type(${_var}_RELEASE)
        __gtest_determine_windows_library_type(${_var}_DEBUG)
    endif()
    # If we get here, no determination was made from the above checks
    set(${_var}_TYPE UNKNOWN PARENT_SCOPE)
endfunction()

function(__gtest_import_library _target _var _config)
    if(_config)
        set(_config_suffix "_${_config}")
    else()
        set(_config_suffix "")
    endif()

    set(_lib "${${_var}${_config_suffix}}")
    if(EXISTS "${_lib}")
        if(_config)
            set_property(TARGET ${_target} APPEND PROPERTY
                IMPORTED_CONFIGURATIONS ${_config})
        endif()
        set_target_properties(${_target} PROPERTIES
            IMPORTED_LINK_INTERFACE_LANGUAGES${_config_suffix} "CXX")
        if(WIN32 AND ${_var}_TYPE STREQUAL SHARED)
            set_target_properties(${_target} PROPERTIES
                IMPORTED_IMPLIB${_config_suffix} "${_lib}")
        else()
            set_target_properties(${_target} PROPERTIES
                IMPORTED_LOCATION${_config_suffix} "${_lib}")
        endif()
    endif()
endfunction()

function(__gtest_define_backwards_compatible_library_targets)
    set(GTEST_BOTH_LIBRARIES ${GTEST_LIBRARIES} ${GTEST_MAIN_LIBRARIES} PARENT_SCOPE)

    # Add targets mapping the same library names as defined in
    # older versions of CMake's FindGTest
    if(NOT TARGET GTest::GTest)
        add_library(GTest::GTest INTERFACE IMPORTED)
        target_link_libraries(GTest::GTest INTERFACE GTest::gtest)
    endif()
    if(NOT TARGET GTest::Main)
        add_library(GTest::Main INTERFACE IMPORTED)
        target_link_libraries(GTest::Main INTERFACE GTest::gtest_main)
    endif()
endfunction()

#

include(FindPackageHandleStandardArgs)

# first specifically look for the CMake version of GTest
find_package(GTest QUIET NO_MODULE)

# if we found the GTest cmake package then we are done, and
# can print what we found and return.
if(GTest_FOUND)
    find_package_handle_standard_args(GTest HANDLE_COMPONENTS CONFIG_MODE)

    set(GTEST_LIBRARIES      GTest::gtest)
    set(GTEST_MAIN_LIBRARIES GTest::gtest_main)

    __gtest_define_backwards_compatible_library_targets()

    return()
endif()

if(NOT DEFINED GTEST_MSVC_SEARCH)
    set(GTEST_MSVC_SEARCH MD)
endif()

set(_gtest_libpath_suffixes lib)
if(MSVC)
    if(GTEST_MSVC_SEARCH STREQUAL "MD")
        list(APPEND _gtest_libpath_suffixes
            msvc/gtest-md/Debug
            msvc/gtest-md/Release
            msvc/x64/Debug
            msvc/x64/Release
            msvc/2010/gtest-md/Win32-Debug
            msvc/2010/gtest-md/Win32-Release
            msvc/2010/gtest-md/x64-Debug
            msvc/2010/gtest-md/x64-Release
            )
    elseif(GTEST_MSVC_SEARCH STREQUAL "MT")
        list(APPEND _gtest_libpath_suffixes
            msvc/gtest/Debug
            msvc/gtest/Release
            msvc/x64/Debug
            msvc/x64/Release
            msvc/2010/gtest/Win32-Debug
            msvc/2010/gtest/Win32-Release
            msvc/2010/gtest/x64-Debug
            msvc/2010/gtest/x64-Release
            )
    endif()
endif()


find_path(GTEST_INCLUDE_DIR gtest/gtest.h
    HINTS
        $ENV{GTEST_ROOT}/include
        ${GTEST_ROOT}/include
)
mark_as_advanced(GTEST_INCLUDE_DIR)

if(MSVC AND GTEST_MSVC_SEARCH STREQUAL "MD")
    # The provided /MD project files for Google Test add -md suffixes to the
    # library names.
    __gtest_find_library(GTEST_LIBRARY            gtest-md  gtest)
    __gtest_find_library(GTEST_LIBRARY_DEBUG      gtest-mdd gtestd)
    __gtest_find_library(GTEST_MAIN_LIBRARY       gtest_main-md  gtest_main)
    __gtest_find_library(GTEST_MAIN_LIBRARY_DEBUG gtest_main-mdd gtest_maind)
    __gtest_find_library(GMOCK_LIBRARY            gmock-md  gmock)
    __gtest_find_library(GMOCK_LIBRARY_DEBUG      gmock-mdd gmockd)
    __gtest_find_library(GMOCK_MAIN_LIBRARY       gmock_main-md  gmock_main)
    __gtest_find_library(GMOCK_MAIN_LIBRARY_DEBUG gmock_main-mdd gmock_maind)
else()
    __gtest_find_library(GTEST_LIBRARY            gtest)
    __gtest_find_library(GTEST_LIBRARY_DEBUG      gtestd)
    __gtest_find_library(GTEST_MAIN_LIBRARY       gtest_main)
    __gtest_find_library(GTEST_MAIN_LIBRARY_DEBUG gtest_maind)
    __gtest_find_library(GMOCK_LIBRARY            gmock)
    __gtest_find_library(GMOCK_LIBRARY_DEBUG      gmockd)
    __gtest_find_library(GMOCK_MAIN_LIBRARY       gmock_main)
    __gtest_find_library(GMOCK_MAIN_LIBRARY_DEBUG gmock_maind)
endif()

find_package_handle_standard_args(GTest DEFAULT_MSG GTEST_LIBRARY GTEST_INCLUDE_DIR GTEST_MAIN_LIBRARY)

if(GMOCK_LIBRARY AND GMOCK_MAIN_LIBRARY)
    set(GMock_FOUND True)
else()
    set(GMock_FOUND False)
endif()

if(GTest_FOUND)
    set(GTEST_INCLUDE_DIRS ${GTEST_INCLUDE_DIR})
    __gtest_append_debugs(GTEST_LIBRARIES      GTEST_LIBRARY)
    __gtest_append_debugs(GTEST_MAIN_LIBRARIES GTEST_MAIN_LIBRARY)

    find_package(Threads QUIET)

    if(NOT TARGET GTest::gtest)
        __gtest_determine_library_type(GTEST_LIBRARY)
        add_library(GTest::gtest ${GTEST_LIBRARY_TYPE} IMPORTED)
        if(TARGET Threads::Threads)
            set_target_properties(GTest::gtest PROPERTIES
                INTERFACE_LINK_LIBRARIES Threads::Threads)
        endif()
        if(GTEST_LIBRARY_TYPE STREQUAL "SHARED")
            set_target_properties(GTest::gtest PROPERTIES
                INTERFACE_COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
        endif()
        if(GTEST_INCLUDE_DIRS)
            set_target_properties(GTest::gtest PROPERTIES
                INTERFACE_INCLUDE_DIRECTORIES "${GTEST_INCLUDE_DIRS}")
        endif()
        __gtest_import_library(GTest::gtest GTEST_LIBRARY "")
        __gtest_import_library(GTest::gtest GTEST_LIBRARY "RELEASE")
        __gtest_import_library(GTest::gtest GTEST_LIBRARY "DEBUG")
    endif()
    if(NOT TARGET GTest::gtest_main)
        __gtest_determine_library_type(GTEST_MAIN_LIBRARY)
        add_library(GTest::gtest_main ${GTEST_MAIN_LIBRARY_TYPE} IMPORTED)
        set_target_properties(GTest::gtest_main PROPERTIES
            INTERFACE_LINK_LIBRARIES "GTest::gtest")
        __gtest_import_library(GTest::gtest_main GTEST_MAIN_LIBRARY "")
        __gtest_import_library(GTest::gtest_main GTEST_MAIN_LIBRARY "RELEASE")
        __gtest_import_library(GTest::gtest_main GTEST_MAIN_LIBRARY "DEBUG")
    endif()

    __gtest_define_backwards_compatible_library_targets()
endif()

if(GMock_FOUND AND GTest_FOUND)
    if(NOT TARGET GTest::gmock)
        __gtest_determine_library_type(GMOCK_LIBRARY)
        add_library(GTest::gmock ${GMOCK_LIBRARY_TYPE} IMPORTED)
        set(_gmock_link_libraries "GTest::gtest")
        if(TARGET Threads::Threads)
            list(APPEND _gmock_link_libraries Threads::Threads)
        endif()
        set_target_properties(GTest::gmock PROPERTIES
            INTERFACE_LINK_LIBRARIES "${_gmock_link_libraries}")
        if(GMOCK_LIBRARY_TYPE STREQUAL "SHARED")
            set_target_properties(GTest::gmock PROPERTIES
                INTERFACE_COMPILE_DEFINITIONS "GMOCK_LINKED_AS_SHARED_LIBRARY=1")
        endif()
        if(GTEST_INCLUDE_DIRS)
            set_target_properties(GTest::gmock PROPERTIES
                INTERFACE_INCLUDE_DIRECTORIES "${GTEST_INCLUDE_DIRS}")
        endif()
        __gtest_import_library(GTest::gmock GMOCK_LIBRARY "")
        __gtest_import_library(GTest::gmock GMOCK_LIBRARY "RELEASE")
        __gtest_import_library(GTest::gmock GMOCK_LIBRARY "DEBUG")
    endif()
    if(NOT TARGET GTest::gmock_main)
        __gtest_determine_library_type(GMOCK_MAIN_LIBRARY)
        add_library(GTest::gmock_main ${GMOCK_MAIN_LIBRARY_TYPE} IMPORTED)
        set_target_properties(GTest::gmock_main PROPERTIES
            INTERFACE_LINK_LIBRARIES "GTest::gmock")
        __gtest_import_library(GTest::gmock_main GMOCK_MAIN_LIBRARY "")
        __gtest_import_library(GTest::gmock_main GMOCK_MAIN_LIBRARY "RELEASE")
        __gtest_import_library(GTest::gmock_main GMOCK_MAIN_LIBRARY "DEBUG")
    endif()
endif()