GTest not finding tests in separate compilation units

Question

I've got a program written in C++, with some subfolders containing libraries linked in. There's a top level SConscript, which calls SConscript files in the subfolders/libraries. Inside a library cpp, there is a GTest test function: ``` TEST(X, just_a_passing_test) { EXPECT_EQ(true, true); } ``` There is `main()` in the top level program source, which just calls GTests main, and has another GTest test within it: ``` int main(int argc, char** argv) { ::testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); } TEST(Dummy, should_pass){ EXPECT_EQ(true, true); } ``` Now the issue is that when I run the program, GTest only runs the test in the `main.cpp` source. Ignoring the test in the library. Now it gets bizarre when I reference an unrelated class in the same library cpp in `main.cpp`, in a no side-effect kind of way (eg. `SomeClass foo;`), the test magically appears. I've tried using -O0 and other tricks to force gcc to not optimize out code that isn't called. I've even tried Clan…

Accepted Answer

From the scene-setting one gathers that the library whose `gtest` test case goes missing is statically linked in the application build. Also that the GNU toolchain is in use.

The cause of the problem behaviour is straightforward. The test program contains no references to anything in the library that contains `TEST(X, just_a_passing_test)`. So the linker doesn't need to link any object file from that library to link the program. So it doesn't. So the `gtest` runtime doesn't find that test in the executable, because it's not there.

It helps to understand that a static library in GNU format is an archive of object files, adorned with a house-keeping header block and a global symbol table.

The OP discovered that by coding in the program an ad hoc reference to any public symbol in the problem library, he could "magically" compel its test case into the program.

No magic. To satisfy the reference to that public symbol, the linker is now obliged to link an object file from the library - the one that contains the definition of the symbol. And the OP imparts that the library is made from a `.cpp`. So there is only one object file in the library, and it contains the definition of the test case, too. With that object file in the linkage, the test case is in program.

The OP twiddled in vain with the compiler options, switching from GCC to clang, in search of a more respectable way to achieve the same end. The compiler is irrelevant. GCC or clang, it gets its linking done by the system linker, `ld` (unless unusual measures have been taken to replace it).

Is there a more respectable way to get `ld` to link an object file from a static library even when the program refers to no symbols in that object file?

There is. Say the problem program is `app` and the problem static library is `libcool.a`

Then the usual GCC commandline that links `app` resembles this, in the relevant points:

```
g++ -o app -L/path/to/the/libcool/archive -lcool
```

This delegates a commandline to `ld`, with additional linker options and libraries that `g++` deems to be defaults for the system where it finds itself.

When the linker comes to consider `-lcool`, it will figure out this is a request for the archive `/path/to/the/libcool/archive/libcool.a`. Then it will figure out whether at this point it has still got any unresolved symbol references in hand whose definitions are compiled in object files in `libcool.a`. If there are any, then it will link those object files into `app`. If not, then it links nothing from `libcool.a` and passes on.

But we know there are symbol definitions in `libcool.a` that we want to link, even though `app` does not refer to them. In that case, we can tell the linker to link the object files from `libcool.a` even though they are not referenced. More precisely, we can tell `g++` to tell the linker to do that, like so:

```
g++ -o app -L/path/to/the/libcool/archive -Wl,--whole-archive -lcool -Wl,-no-whole-archive
```

Those `-Wl,...` options tell `g++` to pass the options `...` to `ld`. The `--whole-archive` option tells `ld` to link all object files from subsequent archives, whether they are referenced or not, until further notice. The `-no-whole-archive` tells the `ld` to stop doing that and resume business as usual.

It may look as if `-Wl,-no-whole-archive` is redundant, as it's the last thing on the `g++` commandline. But it's not. Remember that `g++` appends system default libraries to the commandline, behind the scenes, before passing it to the `ld`. You definitely do not want `--whole-archive` to be in force when those default libraries are linked. (The linkage will fail with multiple definition errors).

Apply this solution to the problem case and `TEST(X, just_a_passing_test)` will be executed, without the hack of forcing the program to make some no-op reference into the object file that defines that test.

There's an obvious downside to this solution in the general case. If it happens that the library from which we want to force linkage of some unreferenced object file contains a bunch of other unreferenced object files that we really don't need. `--whole-archive` links them all of them too, and they're just bloat in the program.

The `--whole-archive` solution may be more respectable that the no-op reference hack, but it's not respectable. It doesn't even look respectable.

The real solution here is just to do the reasonable thing. If you want the linker to link the definition of something in your program, then don't keep that a secret from the linker. At least declare the thing in each compilation unit where you expect its definition to be used.

Doing the reasonable thing with `gtest` test-cases involves understanding that a `gtest` macro like `TEST(X, just_a_passing_test)` expands to a class definition, in this case:

```
class X_just_a_passing_test_Test : public ::testing::Test {
public: 
    X_just_a_passing_test_Test() {} 
private: 
    virtual void TestBody(); 
    static ::testing::TestInfo*…

GTest not finding tests in separate compilation units

Solution

Problem