I am using some one's code base where CMAKE based unit test cases are present.
But unfortunately I did not find readme to execute these test cases.
But I tried to run the below commands to executes the test cases:
cmake -G Ninja ../
ninja test
While checking below command:
ninja clean
It is deleting some files except (*.prof) files
How can I delete ALL the generated files using ninja clean command .
Related
I can build my projects successfully with CMake, but can I use it to install the results?
With Make I add the target install and call that from the command line. I cannot figure out if this is possible with CMake.
The final goal is to install a static library, dynamic library and corresponding header files in a platform-portable way. How I imagine it would work: On Linux, copy to /usr/include and /usr/lib. On Windows it would probably be a user-provided folder with an include and lib folder.
The install rule suggests that something like this is possible. But how do I actually use it?
Currently I do the following:
mkdir build
cd build
cmake ..
cmake --build .
Here I would expect to do something like this:
cmake --install .
You can use the command cmake --build . --target install --config Debug for installation.
CMake's build tool mode supports further arguments that are of interest in this case.
You can select the target to build by --target option, the configuration to build by --config option, and pass arguments to the underlying build tool by means of the -- option. See the documentation (Build Tool Mode) for the build-tool-mode.
In CMake 3.15 and newer, you can use the simpler cmake --install command to Install a Project:
cmake --install . --config Debug
It additionally supports --prefix, --component and --strip.
You can use the install command on your CMakeLists that will generate installation rules for your project. A basic example is shown bellow but check the cmake documentation if you need something more complex.
project (Test)
add_executable(test main.cpp)
install(TARGETS test DESTINATION bin)
Then after generate the makefiles you can ust type sudo make install and the test application will be installed on system bin folder.
How is it possible to override bitbakes regular internal packaging function (do_package) and use CPack? So a normal CMake build looks like this:
cmake ../src
cmake --build ../src
cmake --build ../src --target install
So bitbake correctly handles all of this assuming I use the install command inside CMakeLists.txt and construct my recipes correctly. So building on that, I would like to use CMake's deb package generator to build my packages. Normally this would look something like this in a CMake build to generate the .deb packages after the above:
make package
or
cmake --build ../src/ --target package
I was hoping I didn't have to write a pile of custom functions.
Technically, yes. You'd have to reimplement do_package to call cmake and move the files into the right places.
Realistically, why? Packaging is mostly trivial.
I'd like to run a script after the 'package' target. add_custom_command with POST_BUILD doesn't work.
The make package command is expected to build, package and run the script. There should be no need for separate commands.
With reference to this question there is a so-called 'install' phase in CMake. I'm used to run CMake in a sequence that looks like this:
cmake ..
cmake --build . --config Debug
cmake --build . --config Release
Is there a cmake --install command line switch meant to be invoked after this?
Although I figure it is somehow related, I'm not looking for the so called install command here (I perceive this to be a function rather than a command, but this is likely a terminology issue).
No, this switch does not exist (until CMake 3.15, see my other answer).
If a project uses the install command, it generates the target install. You can call it with
cmake --build . --target install
This uses CMake's Build Tool Mode, which is an abstract interface for a couple of commands to the native build tool (e.g. make or Ninja) and can also be used to pass arbitrary arguments to the native build tool.
Beginning with version 3.15, CMake offers an install switch. From the release notes:
The "cmake(1)" command gained a new "--install" option. This may
be used after building a project to run installation without using
the generated build system or the native build tool.
Source: https://cmake.org/cmake/help/v3.15/release/3.15.html#id6
So you can use
cmake --install <dir> [--prefix <install-dir>]
The optional --prefix flag lets you override the CMAKE_INSTALL_PREFIX.
I'm new to using the Cmake command-line. Using the GUI I can specify a source directory and a build directory then generate. It works just fine.
When I run the command-line variant I don't get any output in the build directory.
cmake -G "Visual Studio 12 2013 Win64" --build C:\MySource\Build C:\MySource
I also get other errors because it's trying to use Win32 yet I specify Win64.
Leave out the --build option. When you do the cmake configure step (equivalent to what happens by the cmake gui), you do not use --build. After you have generated the solution and projects you may build with cmake --build . --config Debug. (You can also specify which target to build with --target MyTarget.)
cd c:\MySource\Build
cmake -G "Visual Studio 12 2013 Win64" C:\MySource
cmake --build . --config Debug
For the configure step (with the -G option), you may use a relative directory .. rather than the absolute path--either way is fine.