Recommended pattern for GTEST_SKIP called from SetUp in a base class and dealing with that in derived classes

[greggman]

I work on a big project that has 1000s of googletests. I recently noticed the tests are full of a pattern like this

class Base : public ::testing::Test {
  virtual void SetUp() {
     GTEST_SKIP(NoFileSystem()) << "No file system";
  }
};

class Derived : public Base {
  virtual void SetUp() {
    Base::SetUp();
    ReadFile();     // <---!!!! could easily crash
  }
};

Note: In the actual code it's not NoFileSystem but it's effectively the same idea. The Base::SetUp calls GTEST_SKIP and the derived classes are all written as those they won't get executed if Base::SetUp fails.

They can all be re-written, I guess, to do this

class Derived : public Base {
  virtual void SetUp() {
    Base::SetUp();
    if (IsSkipped())return;
    ReadFile();
  }
};

But it means every derived class has to follow this pattern as someday its base might call GTEST_SKIP. Coding by vigilance seems likely to have missed cases.

I'm curious if there is a recommended way to structure this situation so as not to require the vigilance. It seems like it would be a common issue.

[shivraj1182]

@greggman Great question! You've identified a real design issue. The core problem is that GTEST_SKIP() throws an exception internally, but derived SetUp() methods can still execute afterward if you don't explicitly return, creating a fragile pattern that requires defensive programming.

Two recommended approaches:

1. Encapsulate preconditions in the base class

Have the base class handle all conditional setup and guarantee that if execution reaches derived SetUp(), preconditions already hold:

class Base : public ::testing::Test {
void SetUp() override {
if (!FileSystemAvailable()) {
GTEST_SKIP() << "Filesystem not available";
}
// Base setup that requires filesystem
}
};

class Derived : public Base {
void SetUp() override {
Base::SetUp(); // Guaranteed to either succeed or skip
ReadFile(); // Now safe - no check needed
}
};

2. Use virtual hooks for optional resources

Provide hooks that only run when preconditions are satisfied:

class Base : public ::testing::Test {
void SetUp() override {
if (FileSystemAvailable()) {
SetUpWithFileSystem(); // Derived classes override this
} else {
GTEST_SKIP();
}
}
virtual void SetUpWithFileSystem() {}
};

class Derived : public Base {
void SetUpWithFileSystem() override {
ReadFile(); // Only called if filesystem is available
}
};

Both patterns eliminate the need for every derived class to defensively check IsSkipped(), making the contract explicit: either the base guarantees preconditions or the test is skipped before derived logic runs. This is much safer than relying on manual vigilance throughout your test hierarchy.
upvote if that helped

[greggman]

I guess the 2nd would work. It has the issue the bases could still accidentally override SetUp but I guess Base can declare it final. That said, it's unfortunately that every derived class diverges from the "standard" method. Maybe there's no working around that.

The 1st though, I'm at google. We don't use exceptions 😂 It's what I already have and it's because we don't use exceptions it doesn't work.

[shivraj1182]

One practical option that keeps things simple and avoids “coding by vigilance” is to push all the skip-related logic into the base and make derived classes override a different hook instead of SetUp itself. For example, the base can declare SetUp as final, check the preconditions, and then call a virtual SetUpImpl (or SetUpWithFileSystem) only if everything is OK. This way derived classes never need to remember to call IsSkipped() or handle GTEST_SKIP() themselves.