As of 59f5f4e024ebac38ec65fd69bbc21682113bbc45, this code does not terminate:

rc::check("", [] {
  *rc::gen::container<std::set<int>>(rc::gen::inRange(0, 1));
});

The same thing happens when generating an std::unordered_set, It works when using rc::gen::arbitrary<int>() and it works when generating an std::vector<int>.

Using GCC 6.3.1 and the -fsanitize=address,undefined compile flags, a project I've been testing using RapidCheck has been throwing the below failures (NB. the paths are munged to be more readable),

./include/rapidcheck/detail/BitStream.hpp:60:12: runtime error: shift exponent 64 is too large for 64-bit type 'uint64_t' (aka 'unsigned long')
SUMMARY: AddressSanitizer: undefined-behavior ./include/rapidcheck/detail/BitStream.hpp:60:12

./include/rapidcheck/detail/Utility.h:98:37: runtime error: left shift of negative value -2
SUMMARY: AddressSanitizer: undefined-behavior ./include/rapidcheck/detail/Utility.h:98:37

This PR aims to avoid these undefined bit-shift behaviors and -- in admittedly very loose, "Does it work on my machine?" tests -- seems to do the job.

I'm trying to add rapidcheck to my library. I've added the following headers to my file:

#include <boost/test/unit_test.hpp>
#include <rapidcheck/boost_test.h>

The Boost version I am using is 1.59.0, and I've tried using 1.61.0 as well. Both give this error

In file included from test/script_tests.cpp:31:0:
/home/chris/dev/rapidcheck/extras/boost_test/include/rapidcheck/boost_test.h: In function ‘void rc::detail::checkBoostTest(const string&, Testable&&)’:
/home/chris/dev/rapidcheck/extras/boost_test/include/rapidcheck/boost_test.h:14:26: error: ‘const class boost::unit_test::test_case’ has no member named ‘full_name’
   metadata.id = testCase.full_name();
                          ^
make[2]: *** [test/test_test_bitcoin-script_tests.o] Error 1
make[2]: Leaving directory `/home/chris/dev/bitcoin/src'
make[1]: *** [all-recursive] Error 1
make[1]: Leaving directory `/home/chris/dev/bitcoin/src'
make: *** [all-recursive] Error 1

Problem

A default build and install of rapidcheck builds the library with RTTI enabled. The headers in rapidcheck/include have RTTI disabled by default.

Symptom

Including the headers from rapidcheck/include in a compile that is linking against a default compile of rapidcheck.a results in SIGSEGV failures when an RC_ASSERT macro fails it's condition.

Expected Behavior

A default compile of rapidcheck should be usable by default with it's includes.

Suggested Solution(s)

1. Invert the RC_USE_RTTI define by changing it to RC_DONT_USE_RTTI, replace the #ifdefs with #ifndefs, and update the CMakeLists.txt to set RC_DONT_USE_RTTI if NOT RC_ENABLE_RTTI.
2. Change the default setting for RC_USE_RTTI to OFF in the CMakeLists.txt.

The following example of a falsifiable function gives a segfault when the RC_ASSERT receives FALSE:

#include<iostream>
#include<rapidcheck.h>

int myadd(int x,int y){
    if(x==7){return 1;}
    else{
        return x+y;
    }
}
void issame(int x,int y){


    bool res = myadd(x,y)==myadd(y,x); 
    
    std::cout<<x<<" , "<<y<<" ---> "<<myadd(x,y)<<" , "<<myadd(y,x)<<" res: "<<res<<std::endl;
    
    RC_ASSERT(res);

}

int main(){

    rc::check("issame",issame);
}

Sometimes, 100 tests run without error (I.E. x hasn't been 7 in these 100 tests). When the function is falsified, it returns a segfault. Note that it doesn't stop the program right away.

Output:

Using configuration: seed=13664549568846329301

- issame
0 , 0 ---> 0 , 0 res: 1
0 , 0 ---> 0 , 0 res: 1
0 , 0 ---> 0 , 0 res: 1
-1 , 0 ---> -1 , -1 res: 1
0 , -1 ---> -1 , -1 res: 1
-1 , -2 ---> -3 , -3 res: 1
-1 , 1 ---> 0 , 0 res: 1
0 , 1 ---> 1 , 1 res: 1
0 , 2 ---> 2 , 2 res: 1
-1 , 1 ---> 0 , 0 res: 1
-1 , 3 ---> 2 , 2 res: 1
-1 , 7 ---> 6 , 1 res: 0
-1 , 7 ---> 6 , 1 res: 0
0 , 7 ---> 7 , 1 res: 0
0 , 7 ---> 7 , 1 res: 0
0 , 0 ---> 0 , 0 res: 1
0 , 4 ---> 4 , 4 res: 1
0 , 6 ---> 6 , 6 res: 1
0 , 7 ---> 7 , 1 res: 0
Segmentation fault (core dumped)

I've run into the need to generate fixed-size containers with unique elements (for generating valid CSR matrices); this PR adds the functionality into rapidcheck as additional overloads for gen::unique and gen::uniqueBy, similar to what's already there for gen::container.

These changes will

1. Address Issue #182 by allowing the user to install the library.

2. Allow the user to create a shared library instead of a static library as follows:

   cmake -DRC_SHARED_LIBRARY=ON .

You may prefer some other way of doing this, so feel free to reject this pull request.

I'm trying to construct an arbitrary 16-byte array of unsigned chars, representing an IPv6 address. Well, actually I'm trying to generate a Microsoft in6_addr structure, defined as

typedef struct in6_addr {
    union {
        UCHAR       Byte[16];
        USHORT      Word[8];
    } u;
} IN6_ADDR, *PIN6_ADDR, FAR *LPIN6_ADDR;

... but I'm falling at the first hurdle. I can ask for a std::array<Byte, 16> and apply reinterpret_cast in my test code, but I'd like to construct an Arbitrary instance for the type so I can use it to build Arbitrary instances for bigger objects. Is this possible?

Excellent work!

Trying RapidCheck out, I have one issue though. Using the gtest integration causes fixture to be initialized twice.

The following test case shows the problem:

struct TestFixture : public ::testing::Test {
   static int initCounter;

   TestFixture() {
      std::cout << "Creating fixture" << std::endl;
      initCounter ++;
   }

   ~TestFixture() {
      std::cout << "Destructing fixture" << std::endl;
      initCounter --;
   }
};

int TestFixture::initCounter = 0;

RC_GTEST_FIXTURE_PROP( TestFixture, TestInitCount, () ){
   std::cout << "RC_GTEST_FIXTURE_PROP(), initCounter: " << initCounter << std::endl;
}

TEST_F(TestFixture, ThisIsATest) {
   std::cout << "TEST_F(), initCounter: " << initCounter  << std::endl;
}

The output becomes:

Note: Google Test filter = TestFixture.*
[==========] Running 2 tests from 1 test case.
[----------] Global test environment set-up.
[----------] 2 tests from TestFixture
[ RUN      ] TestFixture.TestInitCount
Creating fixture
Creating fixture
RC_GTEST_FIXTURE_PROP(), initCounter: 2
Destructing fixture
Creating fixture
RC_GTEST_FIXTURE_PROP(), initCounter: 2
Destructing fixture
Creating fixture
RC_GTEST_FIXTURE_PROP(), initCounter: 2
Destructing fixture
Destructing fixture
[       OK ] TestFixture.TestInitCount (1 ms)
[ RUN      ] TestFixture.ThisIsATest
Creating fixture
TEST_F(), initCounter: 1
Destructing fixture
[       OK ] TestFixture.ThisIsATest (0 ms)
[----------] 2 tests from TestFixture (1 ms total)

[----------] Global test environment tear-down
[==========] 2 tests from 1 test case ran. (1 ms total)
[  PASSED  ] 2 tests.

In my case, this causes problems with code that has static members that can't be initialized twice.

Hi!

I encountered a problem with the following code:

#include <cassert>
#include <rapidcheck.h>
#include <thread>
#include <vector>

int main(int argc, char *argv[])
{
	return rc::check("generator", [&] {
		std::vector<std::thread> threads;
		for (int i = 0; i < 2; i++) {
			threads.emplace_back([&] {
				auto ret = *rc::gen::inRange<unsigned>(0, 10);
				assert(ret <= 10);
			});
		}
		for (auto &t : threads)
			t.join();
	});
}

Below is output from the program:

Using configuration: seed=8356093754809374738

- generator
terminate called after throwing an instance of 'std::runtime_error'
  what():  operator* is not allowed in this context

It looks like it's not possible to use generators from multiple thread. Is this expected? Is there some workaround for this?

I compiled my code using G++ 9.3.0-17ubuntu1~20.04 like this: g++ test.cpp /usr/lib/x86_64-linux-gnu/librapidcheck.a -lpthread

There are a couple of improvements made to the CMake files in order to make the export and import of the CMake targets more useful and, in general, make the library be as easily consumed as an external dependency as it is including it as sub-project - if RapidCheck is to be used in different package managers, this is essential.

The changes were motivated by the desire to add a port of RapidCheck to VCPKG (a C++ based package manager). Here is a description of the major changes:

• The install interface directories were not properly set, leading to the need to use "../rapidcheck.h" to access the primary library header. The fix for this is trivial.
• All the extra integration header-only libraries are now properly installed and exported so that these integration can now be used from an installed bundle of the library.
• The RC_INSTALL_ALL_EXTRAS CMake option is added to allow for an easier installation of the integrations without the need to require the inclusion and set up of the submodule projects in ext. This can be improved but it should be fine for an initial version.
• The RC_BUILD_SHARED_LIB is added to have finer control over the type of the RapidCheck library. This is done as to have greater control over what kind of library VCPKG (and possibly other package managers) can build. It does not make much sense to build as a shared library for now (as no symbols are exported explicitly, which is an issue on Windows) but it would be useful to have the infrastructure in place.

MSVC complains with:

shrink.hpp(182): error C2446: ':': no conversion from 'rc::Seq' to 'rc::Seq'

This is remedied by being explicit with the template argument.

Fixes #298

rapidcheck\shrink\shrink.hpp(182): error C2446: ':': no conversion from 'rc::Seq<bool>' to 'rc::Seq<int>'
rapidcheck\shrink\shrink.hpp(182): note: No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called

https://github.com/emil-e/rapidcheck/blob/master/include/rapidcheck/shrink/Shrink.hpp#L186

Seq<bool> boolean(bool value) { return value ? seq::just(false) : Seq<bool>(); }

This seems to be a compiler issue, but can be easily resolved by being explicit with the template argument

Seq<bool> boolean(bool value) { return value ? seq::just<bool>(false) : Seq<bool>(); }

Hey, thanks for the great library. I was wondering if it's possible to set RC_PARAMS with the GoogleTest integration from within the test. I tried setting the environment variable in my test suite constructor to no avail:

#include <gtest/gtest.h>
#include <cstdlib>
#include <rapidcheck/gtest.h>
#include <vector>

class TestSuite : public ::testing::Test {
  protected:
    TestSuite() {
      putenv("RC_PARAMS=max_success=100000");
    }
};

// ...

RC_GTEST_FIXTURE_PROP(TestSuite, RapidCheck, (std::vector<int> arg)) {
  // ...
  RC_ASSERT(/* ... */);
}

The only output from RapidCheck I see is like

Using configuration: seed=13725330511029654191

FWIW, using putenv from main did work, as in

#include <rapidcheck.h>
#include <vector>
#include <cstdlib>

int main() {
  putenv("RC_PARAMS=max_success=100000");
  rc::check("my property", [](std::vector<int>) { /* ... */ });
  return 0;
}

With that, I see

Using configuration: max_success=100000 seed=3088896386735555752

- my property
OK, passed 100000 tests

Thanks.

Hi!

I'm using commit 8fafda42e732164db58003e542196e94a28481f9 of rapidcheck, building on C++14 mode. When trying to bump the compiler to GCC 11.3.0 (from GCC 7.5.0) I get the following compile error:

external/rapidcheck/include/rapidcheck/seq/Create.hpp: In lambda function:
external/rapidcheck/include/rapidcheck/seq/Create.hpp:189:16: error: no matching function for call to 'map(rc::Seq<long unsigned int>, rc::seq::subranges(std::size_t, std::size_t)::<lambda(std::size_t)>::<lambda(std::size_t)>)'
  189 |                        return seq::map(
      |                ^       ~~~~~~~~~~~~~~~~
  190 |                            seq::range<std::size_t>(start, end - rangeSize + 1),
      |                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  191 |                            [=](std::size_t rangeStart) {
      |                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  192 |                              return std::make_pair(rangeStart,
      |                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  193 |                                                    rangeStart + rangeSize);
      |                                                    ~~~~~~~~~~~~~~~~~~~~~~~~
  194 |                            });
      |                 
external/rapidcheck/include/rapidcheck/seq/Transform.hpp:329:1: note: candidate: 'template<class T, class Mapper> rc::Seq<typename std::decay<typename std::result_of<Mapper(T, ...)>::type>::type> rc::seq::map(rc::Seq<T>, Mapper&&)'
  329 | Seq<Decay<typename rc::compat::return_type<Mapper,T>::type>> map(Seq<T> seq,
      | ^~~
external/rapidcheck/include/rapidcheck/seq/Transform.hpp:329:1: note:   template argument deduction/substitution failed:
external/rapidcheck/include/rapidcheck/seq/Transform.hpp: In substitution of 'template<class T, class Mapper> rc::Seq<typename std::decay<typename std::result_of<Mapper(T, ...)>::type>::type> rc::seq::map(rc::Seq<T>, Mapper&&) [with T = long unsigned int; Mapper = rc::seq::subranges(std::size_t, std::size_t)::<lambda(std::size_t)>::<lambda(std::size_t)>]':
external/rapidcheck/include/rapidcheck/seq/Create.hpp:189:16:   required from here
external/rapidcheck/include/rapidcheck/seq/Transform.hpp:329:1: error: invalid use of incomplete type 'struct std::result_of<rc::seq::subranges(std::size_t, std::size_t)::<lambda(std::size_t)>::<lambda(std::size_t)>(long unsigned int, ...)>'
external/gcc_x86/gcc-install/bin/../lib/gcc/x86_64-pc-linux-gnu/11.3.0/../../../../include/c++/11.3.0/type_traits:2372:36: note: declaration of 'struct std::result_of<rc::seq::subranges(std::size_t, std::size_t)::<lambda(std::size_t)>::<lambda(std::size_t)>(long unsigned int, ...)>'
 2372 |   template<typename _Signature>
      |                                    ^        

This happens when calling the function rc::gen::inRange<int>(0, N).

Do you have any feeling for what might be going on? Thanks!

I want to do two things:

1. see the distribution of the commands
2. see the distribution of the number of the commands per test run. In a particular example, I'm doing a circular buffer and I want to know how many tests execute more commands then the capacity of the buffer.

Using both RC_TAG or RC_CLASSIFY leads to a garbage stdout...