6

Hi I am reading through the implementation of std::optional here and I found the following lines in its unit testing files.

struct caller {
    template <class T> caller(T fun) { fun(); }
};
# define CAT2(X, Y) X ## Y
# define CAT(X, Y) CAT2(X, Y)
# define TEST(NAME) caller CAT(__VAR, __LINE__) = []

I don't really understand what do these lines do. caller seems to be a template to invoke functions, but how can it be used as caller CAT ...? What does X ## Y mean here? Later in the file, the user define unit tests using TEST, but they do not appear in any executable code (I mean they are not called in main function at least), so I am not even sure if the compiled binary actually run the tests. Could you explain what is going on here? Thanks!

Edit: pretty sure the tests are executed when I run the binary, but how is that achieved?

Bob Fang
  • 6,963
  • 10
  • 39
  • 72
  • It's interesting that the definition of macro `TEST(NAME)` doesn't use the `NAME` parameter. I'm guessing that's a mistake. You might also want to include an example of those the macro(s) are used. – Michael Burr Jul 24 '17 at 21:40
  • @MichaelBurr thanks for mentioning it. That is one of my questions as well. I forgot to put it in. – Bob Fang Jul 24 '17 at 21:40
  • 5
    the `CAT` and `CAT2` macros are [concatenating their token arguments](https://stackoverflow.com/a/1489985/4892076). – jaggedSpire Jul 24 '17 at 21:42
  • and `TEST` is used like so: `TEST(testname){}` – jaggedSpire Jul 24 '17 at 21:53
  • If you use Eclipse, it has a feature whereby you can see macro expansions and how they are extended, step by step, Netbeans has a macro expansion view, but just the final output. – Paul Floyd Jul 25 '17 at 08:37

1 Answers1

10

You can look at the output after the preprocessing ( -E for gcc)...

This is the code where I added a usage of the macro:

struct caller {
    template <class T> caller(T fun) { fun(); }
};
# define CAT2(X, Y) X ## Y
# define CAT(X, Y) CAT2(X, Y)
# define TEST(NAME) caller CAT(__VAR, __LINE__) = []

TEST(disengaged_ctor) { foo(); };

after preprocessing the last line turns to:

caller __VAR10 = []{ foo(); };

I am a bit puzzled about the __VAR and the unused NAME *. However, []{ foo(); } is a lambda that when used to create a caller gets invoked in the callers constructor.

* = I guess the idea is the following: Suppose you get a error message saying there is an error in __VAR10 then on line 10 you find TEST(disengaged_ctor), ie. the NAME of the failed test.

463035818_is_not_an_ai
  • 109,796
  • 11
  • 89
  • 185