Attempting to compile with gherkin support, and run GUnit tests. I've tried v1.0.0 and master (ef9327d). cmake 3.14.3, and make 4.21.1.

$ git clone https://github.com/cpp-testing/GUnit
$ cd GUnit
$ git submodule init
$ git submodule update
$ cd libs/gherkin-cpp
$ make lib
make[1]: Entering directory '/home/jamespharvey20/home/GUnit/libs/gherkin-cpp'
cd libs/gherkin-c && make libs
make[2]: Entering directory '/home/jamespharvey20/home/GUnit/libs/gherkin-cpp/libs/gherkin-c'
make[2]: *** No rule to make target 'libs'.  Stop.
make[2]: Leaving directory '/home/jamespharvey20/home/GUnit/libs/gherkin-cpp/libs/gherkin-c'
make[1]: *** [Makefile:20: gherkin-c] Error 2
make[1]: Leaving directory '/home/jamespharvey20/home/GUnit/libs/gherkin-cpp'
make: *** [Makefile:6: lib] Error 2

$ cd ../..
$ mkdir build
$ cd build
$ cmake ..
$ make
Scanning dependencies of target gtest
[  1%] Building CXX object libs/googletest/googlemock/gtest/CMakeFiles/gtest.dir/src/gtest-all.cc.o
[  3%] Linking CXX static library libgtest.a
[  3%] Built target gtest
Scanning dependencies of target gherkin_cpp-static
[  5%] Generating libgherkin-cpp-static
make[4]: *** No rule to make target 'libs'.  Stop.
make[3]: *** [Makefile:20: gherkin-c] Error 2
make[2]: *** [CMakeFiles/gherkin_cpp-static.dir/build.make:61: libgherkin-cpp-static] Error 2
make[1]: *** [CMakeFiles/Makefile2:785: CMakeFiles/gherkin_cpp-static.dir/all] Error 2
make: *** [Makefile:141: all] Error 2

Is using C++17 Structured Bindings to create the system under test and mock objects unimplemented?

I don't see uses of auto [ in the Boost DI or GUnit source trees, other than in the GUnit README.md and docs/cppnow-2017/index.html. I see the tutorial mentions this all the way back to c08dec4d (init).

As shown under GUnit.GMake - Tutorial by example - Test (V3 - C++17):

TEST(Test, ShouldPrintTextWhenUpdate) {
  using namespace testing;
  auto [sut, mocks] = make<example, NaggyMock>(); // create NaggyMocks when required

  EXPECT_CALL(mocks.mock<iconfig>(), (is_dumpable)()).WillOnce(Return(true));
  EXPECT_CALL(mocks.mock<iprinter>(), (print)("text"));

  sut.update();
}

And in the Toward Painless Testing video:

"should print read text"_test = [] {
   auto [app, mocks] = testing::make<App>();// creates System Under Test and mocks

   EXPECT_CALL(mocks<Readable>(), read).WillOnce(Return(42));
   EXPECT_CALL(mocks<Printable>(), print, 42);

   app.run();
};

I took your example/GMock.cpp, reduced it to only have the ShouldMakeExample test, and simplified that test to only make the objects using C++17 Structured Bindings as shown in the above tutorial and video.

#include "GUnit/GMock.h"
#include <gtest/gtest.h>
#include <stdexcept>
#include "GUnit/GMake.h"

class interface {
 public:
  virtual bool get() const = 0;
  virtual ~interface() = default;
};

class extended_interface : public interface {
 public:
  virtual void foo(bool) = 0;
  virtual void bar(bool) = 0;
};

class example {
 public:
  example(const interface& i, extended_interface& ei) : i(i), ei(ei) {}

  void update() {
    const auto value = i.get();
    if (value) {
      ei.foo(value);
    } else {
      ei.bar(value);
    }
  }

 private:
  const interface& i;
  extended_interface& ei;
};

TEST(GMock, ShouldMakeExample) {
  using namespace testing;
  //GMock<interface> imock;
  //GMock<extended_interface> emock;

  //EXPECT_CALL(imock, (get)()).WillOnce(Return(false));
  //EXPECT_CALL(emock, (bar)(false)).Times(1);

  //auto sut = make<example>(imock, emock);

  //sut.update();

  auto [sut, mocks] = make<example>();
  // also tried
  // auto [sut, mocks] = make<example, NaggyMock>();
}

But it doesn't compile under clang 5.0.0:

In file included from example.cpp:4:

GMake.h:179:10: error: no matching constructor for initialization of 'example'
  return T(detail::convert(std::forward<TArgs>(args))...);
         ^
GMake.h:393:18: note: in instantiation of function template specialization 'testing::v1::detail::make_impl<example>' requested here
  return detail::make_impl(detail::identity<T>{}, std::forward<TArgs>(args)...);
                 ^
example.cpp:57:23: note: in instantiation of function template specialization 'testing::v1::make<example>' requested here
  auto [sut, mocks] = make<example>();
                      ^
example.cpp:25:7: note: candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 0 were provided
class example {
      ^
example.cpp:25:7: note: candidate constructor (the implicit move constructor) not viable: requires 1 argument, but 0 were provided
example.cpp:27:3: note: candidate constructor not viable: requires 2 arguments, but 0 were provided
  example(const interface& i, extended_interface& ei) : i(i), ei(ei) {}
  ^

Or gcc 7.2.0:

In file included from example.cpp:11:0:
GMake.h: In instantiation of ‘auto testing::v1::detail::make_impl(testing::v1::detail::identity<T>, TArgs&& ...) [with T = example; TArgs = {}]’:
GMake.h:393:27:   required from ‘auto testing::v1::make(TArgs&& ...) [with T = example; TArgs = {}]’
example.cpp:57:37:   required from here
GMake.h:179:10: error: no matching function for call to ‘example::example()’
   return T(detail::convert(std::forward<TArgs>(args))...);
          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
example.cpp:27:3: note: candidate: example::example(const interface&, extended_interface&)
   example(const interface& i, extended_interface& ei) : i(i), ei(ei) {}
   ^~~~~~~
example.cpp:27:3: note:   candidate expects 2 arguments, 0 provided
example.cpp:25:7: note: candidate: constexpr example::example(const example&)
 class example {
       ^~~~~~~
example.cpp:25:7: note:   candidate expects 1 argument, 0 provided
example.cpp:25:7: note: candidate: constexpr example::example(example&&)
example.cpp:25:7: note:   candidate expects 1 argument, 0 provided
example.cpp: In member function ‘virtual void GMock_ShouldMakeExample_Test::TestBody()’:
example.cpp:57:8: error: ‘void <anonymous>’ has incomplete type
   auto [sut, mocks] = make<example>();
        ^~~~~~~~~~~~

Because the line is the key for the scenario of a feature, if the same feature has scenarios in different files but at the same line number, the tests cannot be executed. I will create a pull request to solve this

I've been trying to mock "operator()" but keep failing.
Is there any way to do this?

I have seen that hippomocks supports mocking with multiple inheritance. I settled with GUnit because of the nicer expectation syntax.

How is GMock different that creating a vtable for an interface composed of multiple interfaces does not work? Or: What is a good starting point to get it to work in GMock?

Hello,
is there anyone working on gunit regarding integration of googletest 1.10.0?
Link: https://github.com/google/googletest/releases/tag/release-1.10.0

Best Regards,
thorsten

Compiling the first Google.Test example from README.md results in the following compilation error (with GCC 7.5.0 on Ubuntu 18.04):

/path/to/file.cpp:13:1: note: in expansion of macro ‘TEST_F’
 TEST_F(ExampleTest, ShouldReturnSumOf2Numbers) {
 ^~~~~~
/path/to/file.cpp:13:8: error: ‘ExampleTest’ was not declared in this scope
 TEST_F(ExampleTest, ShouldReturnSumOf2Numbers) {
        ^

The example declares a test fixture named CalcFixture but uses a different fixture name in TEST_F macro invocation.

“add_custom_command(TARGET ${out} COMMAND ${scenario} ./${out} --gtest_color=yes USES_TERMINAL)”
this is an error cmake configure，it should be
“add_custom_command(TARGET ${out} COMMAND ./${out} ${scenario} --gtest_color=yes USES_TERMINAL)”

the custom COMMAND should be "execute_file secnario=" not "secnario= execute_file"

After updating to googletest 1.14.0 (PR #93) it would be nice to have a official gunit release 1.14.0 as well

After the submodule of googletest has been updated to v1.13.0 by PR #85 it would be nice to create a official GUnit release.
I would suggest to release current master commit as v1.13.0.
For users it might be helpful/transparent that the gunit version is equivalent to its underlaying gtest version (at least MAJOR.MINOR).

when capturing a string with multiple words separated by spaces the captured variable only contains the first word

for example:
capturing this:
Given I type the following: 'this is a complex command'
with this:
Given("I type the following: '{command}'") = [] (std::string command) {
std::cout << command;
};
outputs the following:
this

Right now it only lists the name of the test fixture and not any of the SHOULD test cases:

GTest Version

GUnit Version

FakeIt supports up to offset1000, currently the GMock.h header file only supports up to offset127(int).

If a user of GUnit mocks an interface with more methods than this it causes a segmentation fault.

Would it be possible to increase the number of offsets support OR generate a better error message?

I try to use .feature files with the language option and found 2 bugs.

1. In GSteps.h need use "type" not "keyword" because "keyword" contains localized word.
   std::string keyword = children["type"];
2. The function read_data in GUnit/Detail/FileUtils.h read chars from utf8 files.
   I fixed this bug using UnicodeUtilities_read_code_point_from_utf8_source from gherkin-c library.

extern "C" {
typedef struct Utf8Source Utf8Source;
long UnicodeUtilities_read_code_point_from_utf8_source(Utf8Source* utf8_source);
Utf8Source* FileUtf8Source_new(FILE* file);
unsigned char Utf8Source_read(Utf8Source* utf8_source);
void Utf8Source_delete(Utf8Source* utf8_source);
}

inline std::wstring read_file(const std::string &feature) {
  FILE* file = fopen(feature.c_str(), "rb");
  if (!file) {
    throw std::runtime_error("File \"" + feature + "\" not found!");
  }
  std::wstring r;
  Utf8Source* utf8_source = FileUtf8Source_new(file);
  for(;;) {
    long code = UnicodeUtilities_read_code_point_from_utf8_source(utf8_source);
    if (code == WEOF) break;
    r+=(wchar_t)code;
  }
  Utf8Source_delete(utf8_source);
  fclose(file);
  return r;
}

When mocking an interface that inherits from multiple other interfaces, segmentation fault happens on EXPECT_CALL or call itself.
Example:

struct a
{
	virtual ~a() = default;
	virtual void func_a() = 0;
};
struct b
{
	virtual ~b() = default;
	virtual void func_b() = 0;
};
struct ab : public a, public b
{
	~ab() override = default;
};

auto mock = std::make_shared<testing::StrictGMock<ab>>();
std::shared_ptr<ab> obj = object(mock);
EXPECT_CALL(*mock, (func_a)()); // works as expected
obj->func_a(); // works as expected
EXPECT_CALL(*mock, (func_b)()); // may already crash
obj->func_b(); // latest here crash happens

When mocking or calling a function on the second interface a crash happens. I played around a little bit and observed crashes on EXPECT_CALL as well as on function call itself.
To me it seems that offset calculation for vtable doesn't work reliable for such cases. However unfortunately I couldn't find the exact reason for the issue. It may also depend on the used compiler. I observed the issue with clang-13.

This may be a duplicate of issue #12, however I'm unsure as the description is not very detailed there.

The original googlemock is pretty bad at supporting unique_ptr or rvalue references. Usually I went for the workaround outlined here: https://stackoverflow.com/questions/12088537/workaround-for-gmock-to-support-rvalue-reference
Now with GUnit/GMock how would I mock a method with && parameters and capture the value via utilities like SaveArg?

Is Windows support in roadmap?

Using current HEAD of the Github repository.

HOW TO REPEAT:

$ git clone --recursive https://github.com/cpp-testing/GUnit.git
...
Submodule 'libs/gherkin-c' (https://github.com/c-libs/gherkin-c.git) registered for path 'libs/gherkin-cpp/libs/gherkin-c'
Cloning into '/xxx/GUnit/libs/gherkin-cpp/libs/fmem'...
Cloning into '/xxx/GUnit/libs/gherkin-cpp/libs/gherkin-c'...
Submodule path 'libs/gherkin-cpp/libs/fmem': checked out xxx_hidden
error: no such remote ref 5d74068a21479d95f969a887f48cc04b45c6eac8  <== ERROR-HERE
Fetched in submodule path 'libs/gherkin-cpp/libs/gherkin-c', but it did not contain 5d74068a21479d95f969a887f48cc04b45c6eac8. Direct fetching of that commit failed.
...
Failed to recurse into submodule path 'libs/gherkin-cpp'
# -- NOTE: Fails due to libs/gherkin-cpp/libs/gherkin-c reference (or submodule ref in gherkin-cpp)

WORKAROUND: Enforce update all submodules on master branch

$ cd GUnit
$ git submodule foreach git checkout master 
...
$ mkdir build && cd build
$ cmake -G Ninja ..
$ ninja
...

NOTE: Description on build process is missing, too 😄

Having cloned recursively, using gcc 8.3.0, I get the following build failure:

[ 75%] Building CXX object CMakeFiles/test_GSteps.dir/test/GSteps.cpp.o
In file included from /home/jamespharvey20/home/code/gunit.recursive.git/libs/googletest/googletest/include/gtest/gtest.h:58,
                 from /home/jamespharvey20/home/code/gunit.recursive.git/include/GUnit/GSteps.h:10,
                 from /home/jamespharvey20/home/code/gunit.recursive.git/test/GSteps.cpp:8:
/home/jamespharvey20/home/code/gunit.recursive.git/test/GSteps.cpp: In member function ‘void testing::v1::GTEST<testing::v1::detail::string<'\"', 'C', 'o', 'n', 'v', 'e', 'r', 't', 'i',
 'b', 'l', 'e', '\"', '\000'>, testing::v1::detail::string<> >::TestBodyImpl(testing::v1::detail::TestRun&)’:
/home/jamespharvey20/home/code/gunit.recursive.git/test/GSteps.cpp:71:79: error: type qualifiers ignored on cast result type [-Werror=ignored-qualifiers]
     EXPECT_FALSE(static_cast<const bool>(detail::Convertible<std::string>{"0"}));
                                                                               ^
cc1plus: all warnings being treated as errors
make[2]: *** [CMakeFiles/test_GSteps.dir/build.make:63: CMakeFiles/test_GSteps.dir/test/GSteps.cpp.o] Error 1
make[1]: *** [CMakeFiles/Makefile2:748: CMakeFiles/test_GSteps.dir/all] Error 2
make: *** [Makefile:141: all] Error 2

I'm not doing it myself because I have never really edited the Wikipedia and, having just discovered GUnit, may include some wrong information (i.e. because I'm lazy). But this project could become more popular if included in https://en.wikipedia.org/wiki/List_of_unit_testing_frameworks#C++

I am aware that with GUnit there is no more need to have the SetUp and TearDown method declarations, but in my tests I still have it for my own organization.

So while using GUnit, I see that the SetUp method is being called twice. Find the stack of the first and second call attached.

You can see that in the second call the only difference is the extra GTEST<>::TestBody() call.

I see that there is a call in line 247 and 249 of GTest.h. After commenting it stops to call it twice.
I am not very familiar with the internals, is there a reason to call the SetUp and TearDown there?

Providing a singular macro for ASSERT/EXPECT is really nice & ergonomic!
Is there any way to pass in matchers, so that ASSERT/EXPECT_THAT macros could be replaced as well?

In short: SHOULD("") tests should also be exposed as single targets on the shell and they 'could' eventually also show up as individual tests in the tests run. At least they should be callable individually!

Given this example:

GTEST(MYFooTest, "MyBarTest") {

... some setup stuff ...

SHOULD("foo") {

}
SHOULD("bar") {

}

I'd like to call SHOULD tests explicitly!

Using GUnit one can run all tests:

./mytest --gunit_filter="*"

Or just a subset:

./mytest --gunit_filter="MYFooTest.*"

Or one explicit test:

./mytest --gunit_filter="MYFooTest.MyBarTest"

But one cannot call a SHOULD:

./mytest --gunit_filter="MYFooTest.MyBarTest.foo"

why?

In our code-base we have like 10 SHOULD calls and if one fails it is often hard to see which one does as the output can be quite huge. So I basically comment all n-1 SHOULD tests and uncomment them one by one to work them down. Which is of course total overkill.

I can find lots of code examples on how to use it (in example/) but there are no build system files (CMakeLists.txt) in those directories. Reading the top-level CMakeLists.txt, it sets up the test( file SCENARIO=) command, which seems like a good approach for the tests within this library:

/GUnit/
    example/*.cpp
    test/*.cpp

But more likely a typical app structure will be:

/app/
    test/*.cpp
    test/libs/GUnit/

(at least having the GUnit repo as a submodule somewhere in the app, and our test cpp files out-of-tree) So how should we source those test() commands from the GUnit CMakeLists.txt, or should we be copy/pasting them into our own files? Basically, what is your recommended way to use this in an existing project (and/or a new project, if that is different).

Also... my CI is running on Raspberry Pi's and previously using Catch2 + Trompeloeil (which are header-only). So you can imagine the process is pretty simple, barely even needing a Makefile. Now that I have to compile 80+ files (mostly gherkin-c, if I want support for Gherkin), it really slows down the overall test process. How much of the deps of this library can be compiled into a library? I know Google.Test likes to be compiled alongside the actual test sources so it has the correct compiler flags, does this still apply to the latest Google.Test, to GUnit, or the other libs?

If there was some way to replace all the GUnit submodules with a single library (at least to have that choice), that would be great. I'm not sure how the gherkin<->gtest integration works, but maybe some parts could be moved to an executable/runner?

What's the idea behind using get() instead of release() in std::move and static_pointer_cast functions?
It seems like the unique and shared pointers are doubled with that. Both destructors try to free the memory what leads to segmentation faults in some cases. A manual release() on one of the pointers helps here.

Of course it would be helpful to have the mock object still available even after move. Maybe it'd make sense to provide an empty Deleter to the new pointers to let the mock object free the memory.

Hello,
since last release some fixes/features have been merged.
Do you plan any next release soon?

CC: @mstaz

name conflict of class testing::internal::FunctionMocker
gcc 5.4.0 20160609

Below example is taken from the GUnit examples directory. I uncommented the EXPECT_CALL() line.

TEST(GMock, ShouldFailDueToUninterestingGetCall) {
  using namespace testing;
  StrictGMock<interface> mock;
  //EXPECT_CALL(mock, (get)())
  //    .WillOnce(Return(true));  // Comment to get an UNINTERESTING CALL
  static_cast<interface&>(mock).get();
}

GMock gives this output:

Uninteresting mock function call - returning default value.
    Function call: ()
          Returns: NULL

get() have boolean return type, so returning NULL is wrong. If I instead mock the interface the usual GMock way using MOCK_CONST_METHOD0(get, bool());, I get the expected:

Uninteresting mock function call - returning default value.
    Function call: get()
          Returns: false

Replace bool with e.g. std::string in the GUnit case, and you will get a segmentation fault when a 0 is interpreted as a std::string. (GMock will correctly return an empty string.)

Maybe the right thing to do in GUnit would be to have the default method trigger an assert instead of this non-working call to the wrong version of GMock:s default actions? It's still nicer to use GUnit even if you always have to do EXPECT_CALL() to set default return values in the tests. What is your thoughts about this?

Are there any RTTI information available for method names, that would make it possible to print the name of the stubbed method invoked?

linux.txt
osx.txt
Documentation says:

$mkdir build && cd build && cmake ..
$make && ctest

• Does not build on OSX 10.12 (using clang 8.1.0).
• Does not build on Ubunu 17.04 (using gcc 7.0.1).

If we are using the "Hi-Perf" Google.Mock feature
https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md#mocking-nonvirtual-methods

Then how does this affect the ideal use of GUnit?

• Can we still use the automatic mock generation?
• Can we still use GUnit.GMake? (since we are using derived class template args, not static_cast<iface&>)
• Can we still use Boost.DI? (I know, a question for a different repo)

Or any other trade-offs from using non-virtual methods?

Will c++20 concept support be added, if using gcc -std=c++2a -fconcepts or the clang saarraz fork with concepts? If so, any timeframe on that? I have no idea if it's implementable, and if so, how hard it would be. (Template metaprogramming makes my head hurt, and I can't believe you've been able to do what you have with this!)

This compiles, with a manual injection of a realFoo, if the make<...> line is removed:

#include "GUnit.h"
using namespace testing;

template<typename T>
concept bool Fooable = requires(T a) {
   { a.foo() } -> int;
};

class realFoo {
public:
   int foo() {
      return 0;
   }
};

template<Fooable foo>
class underTest {
public:
   underTest(foo x) : x{x} {
   }
private:
   foo x;
};

GTEST("Concepts") {
   realFoo foo;
   underTest manualUt{foo};
   auto [ut, mocks] = make<underTest, StrictGMock>();
}

With the line, gcc from git master gives:

concepts.gpp: In member function ‘void GTEST<testing::v1::detail::string<'\"', 'C', 'o', 'n', 'c', 'e', 'p', 't', 's', '\"', '\000'>, testing::v1::detail::string<> >::TestBodyImpl(testing::v1::detail::TestRun&)’:
concepts.gpp:28:52: error: no matching function for call to ‘make<template<class foo>  requires  Fooable<foo> class underTest, template<class T> using StrictGMock = testing::StrictMock<testing::v1::GMock<T> > >()’
   28 |    auto [ut, mocks] = make<underTest, StrictGMock>();
      |                                                    ^
In file included from include/GUnit.h:10,
                 from concepts.gpp:1:
include/GUnit/GMake.h:433:6: note: candidate: ‘template<class T, class ... TArgs> auto testing::v1::make(TArgs&& ...)’
  433 | auto make(TArgs &&... args) {
      |      ^~~~
include/GUnit/GMake.h:433:6: note:   template argument deduction/substitution failed:
include/GUnit/GMake.h:444:6: note: candidate: ‘template<class T, template<class> class TMock, class ... TMocks, typename std::enable_if<(testing::v1::detail::is_gmock<TMock>::value && std::is_same<testing::v1::detail::bool_list<testing::v1::detail::always<TMocks>::value ...>, testing::v1::detail::bool_list<testing::v1::detail::is_gmock_type<TMocks>::value
...> >::value), int>::type <anonymous>, class ... TArgs> auto testing::v1::make(TArgs&& ...)’
  444 | auto make(TArgs &&... args) {
      |      ^~~~
include/GUnit/GMake.h:444:6: note:   template argument deduction/substitution failed:

Hi, the repo weights 111.56 MB, not the best if I want to download it as an ExternalProject in cmake.

I will copy the include folder into my project by now, but you might want to have a look!
Nice work btw, thanks!

Hello,

Is it in the roadmap to implement ways to export the test results in cucumber json format? Such as:
https://relishapp.com/cucumber/cucumber/docs/formatters/json-output-formatter