Writing fast tests that check timed behavior - c++

Question

I have the following class (dumbed down for the example, of course):
class file_handler_c {
public:
err_t init(int msecs);
err_t write(byte* buffer);
}
This class requires init to be called before any writes and then you can use this class to write to a file. However, after msecs milliseconds have passed, write stops writing to the file and returns an error.
My question is - how do you create a fast unit test for this behavior? Any small enough value will create a non-deterministic test that will sometimes fail due to other processes running on the machine. However, I want tests to be as fast as possible and not include any sleep or similar. I am using Google Test and Google Mock.

Answer 1

First of all I have to divert a little bit from your actual question. Please don't create interfaces like that. Whenever an object has been created, all its functions have to be callable until its lifetime ends. Informal lifetime constraints like "init() has to be called before write()", or even worse "always call close() before the destructor" can not be checked by the compiler and therefore are error prone.
Therefore I don't think, you should try to solve that issue in the test, but in the design of the code under test. Whenever it is hard to write a test, it is a sure bet, that your interfaces are flawed.
My suggestion is to separate timing and writing. Create a timer class like e.g. this one:
#include <memory>
#include <chrono>
template<typename T>
class Timer {
private:
std::chrono::milliseconds time_to_live;
std::shared_ptr<T> timed_object;
public:
template<typename... Arg>
Timer(std::chrono::milliseconds ttl, Arg... args):
time_to_live{ttl},
timed_object{std::make_shared<T>(args...)} {};
std::weak_ptr<T> get() { return {timed_object}; };
// ...
// when the defined time is over, timed_object will be set to nullptr somehow.
};
Use it like this:
#include <chrono>
#include <iostream>
#include <fstream>
int main(int, char**)
{
using namespace std::literals::chrono_literals;
auto timed_ostream = Timer<std::ofstream>{42ms, "filename"};
if( !timed_ostream.get().expired() ) {
// os is a shared_ptr. That guarantees, that the ostream will not
// be closed while you are still writing.
auto os = timed_ostream.get().lock();
(*os) << "whatever";
} // now os will be destroyed. The ofstream might be destroyed
// as well now, when the 42ms are over.
} // OK, here we destroy the timer and therefore the ofstream,
// if it is still alive.
With that interface you can easily write a simple test case with something else than an ostream, e.g. an int:
#include <chrono>
#include <cassert>
using namespace std::literals::chrono_literals;
void test_timed_object_valid_after_init()
{
auto clock = std::chrono::high_resolution_clock{};
auto start = clock.now();
auto timed_int = Timer<int>{2000ms,42}; // valid for 2000ms
assert(timed_int.get().expired()); // should still be here
} // The timer will be destroyed here. That destroys the shared_ptr
// and the object as well. The long lifetime does not matter.
void test_timed_object_invalid_after_time()
{
auto clock = std::chrono::high_resolution_clock{};
auto start = clock.now();
auto timed_int = Timer<int>{1ms,42}; // valid for 1ms
// you did not want sleep(), so we do busy waiting.
// Prefer usleep() instead.
// busy wait 1ms as exactly as possible.
while( clock.now() - start < 1ms ) {}
assert(timed_int.get().expired()); // should be gone now.
}
Note, that each testcase checks one single scenario here. Don't try and test the two requirements in a single test case. Then you either have to take a long lifetime for your object to check safely that it is there after initialization, or choose a short lifetime to check it is gone afterwards.
Beware: all the code in this posting should compile, but there might of course still be bugs somewhere. These are left as an exercise for the student ;-)