Installing Google Test (on OS X)
While in my previous post I boasted about the ease of using Google Test, I will admit it did take some effort to get working for my system. I can say, this is likely only because I didn't want to use XCode.
Here are some system details:
OS: OS X, 10.9.5
shell: zsh, via oh my zsh
compiler: g++, although gcc should work for every step
Below is a step by step showing how I got it all together for my system.
Warning: this is not meant to be exhaustive guide but instead will hopefully get some people past the installation confusion I had.
So, open up terminal and start C/P-ing:
Step 1: get the git
I cloned the GitHub repository right into ~/
but you can put it anywhere you want:
cd ~/
git clone https://github.com/google/googletest.git
Step 2: cmake
cmake is a tool which assesses your system in order to setup the parameters necessary for compiling and installing c/c++ programs/libraries.
Note: Installing cmake is not within the context of this tutorial but homebrew makes it easy.
We make a new folder inside of the Google Test git directory
cd ~/googletest/ #change to Google Test directory
mkdir install #make new directory
cd install #change to new directory
next, we run cmake
with a couple flags
cmake -DCMAKE_CXX_COMPILER="c++" -DCMAKE_CXX_FLAGS="-std=c++11 -stdlib=libc++" ../
-DCMAKE_CXX_COMPILER="c++"
changes the default compiler to g++
and -DCMAKE_CXX_FLAGS="-std=c++11 -stdlib=libc++"
sets the compiler to C++11 and the standard library to libc++
Step 3: make
Not to be confused with cmake
, this step takes the make
file created in the last step (basically a set of instructions for compiling the code) and uses it to compile and install the Google Test code.
make #compiles the code
sudo make install #installs the code
Note: the sudo
line will prompt for a password.
Step 4: setting path variables
Step 3 creates a shared library but my system wasn't setup to know where that was.
I use zsh
and so the next set of commands is for that shell. If your terminal is standard bash
, in the commands below replace .zshrc
with .bash_profile
and it should work:
echo "export CPLUS_INCLUDE_PATH=/usr/local/include" >> ~/.zshrc
echo "export LIBRARY_PATH=/usr/local/lib" >> ~/.zshrc
source ~/.zshrc #tell terminal there are new variables
The above commands create two environment variables (CPLUS_INCLUDE_PATH
and LIBRARY_PATH
). The first points to the location where all the system libraries are installed, this is where the header files for Google Test are. The second points to the location that all the shared libraries are installed on OS X.
During step 3, parts of Google Test was installed between these two directories.
Step 5: running your first test
This is the payoff.
First, we'll make a new directory and copy some files into it from the Google Test directory.
cd ~/
mkdir my_test
cd my_test
cp ~/googletest/googletest/samples/sample1.cc
cp ~/googletest/googletest/samples/sample1.h
cp ~/googletest/googletest/samples/sample1_unittest.cc
cp ~/googletest/googletest/src/gtest_main.cc ./
The first three files are for the first sample test included with Google Test.
The fourth file is a sample main
file which will run all the tests (in this case, just one). In the future you can copy this file (or even use it at its original location) for running your tests.
Next, we compile all the necessary files:
g++ -std=c++11 -stdlib=libc++ sample1_unittest.cc sample1.cc gtest_main.cc -lgtest -lpthread -o sample1
Important: this is the command you will use to compile your future tests. When that day comes, remember to change the .cc
files to match those of the code you've written.
Above you will see all of the .cc
file which were copied over. This step is compiling all of these files and will turn them into an executable.
You will also see two of the flags that we set during step 2.
Note: these flags are only necessary because I want to ensure i'm using C++11.
Additionally, you will see two flags for the linker. These flags beginning with -l
and are for shared libraries. Without setting the LIBRARY_PATH
in step 4, it is possible your system won't know where these are.
The last flag -o
tells the compiler to call the output file sample1
.
Now, as long as the compiler and linker were error free, the test can be run:
./sample1
The output of the test should print to the terminal screen.
Conclusion
If everything worked in from these steps you should now be able to write your own tests.
Take a look at sample1_unittest.cc
and the Google Test Primer to see how to structure your tests.