Added support for Visual Studio. Added travis-ci build configuration. Added cmake build script for building with GCC, Clang, and Visual Studio Integrated fixes from another fork. Added reporter for catch testing library in addition to gtest.

discard_if seems to be broken:

  auto arb = ac::make_arbitrary<string, unsigned int>();
  arb.discard_if(
    [](string key, uint32_t m) {
      printf("key %s m %u\n", key.c_str(), m);
      return key.size() < 1;
    });

I see

key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 key m 0 Arguments exhausted after 0 tests.

• CMakeLists.txt: Adding cmake to allow simple compilation with visual studio.
• include/autocheck/generator.hpp: Removed the explicit initializer since visual studio cannot compile variadic templates like this, however it seems this is the default behavior anyway.
• include/autocheck/value.hpp: Removed the union at the cost of some memory since Visual Studio cannot compile unrestricted unions yet.
• test/check.cpp: Moved the failing test to a separate test to make the failure more explicit and describe the indent.
• test/generator_combinators.cpp: Added explicit capture of the factor.

Trying to compile the tutorials with gcc (4.7.2) results in errors like

/home/fugalh/tehcode/third-party/centos5.2-native/gcc/gcc-4.7.1/cc6c9dc/bin/g++ -std=gnu++11  -I../../include -o build/./insert_sorted.o -c insert_sorted.cpp
In file included from /mnt/gvfs/third-party/2abdfad61e1ced257651899c884f84346417ba37/centos5.2-native/gcc/gcc-4.7.1/cc6c9dc/bin/../lib/gcc/x86_64-redhat-linux-gnu/4.7.1/../../../../include/c++/4.7.1/bits/move.h:57:0,
                 from /mnt/gvfs/third-party/2abdfad61e1ced257651899c884f84346417ba37/centos5.2-native/gcc/gcc-4.7.1/cc6c9dc/bin/../lib/gcc/x86_64-redhat-linux-gnu/4.7.1/../../../../include/c++/4.7.1/bits/stl_pair.h:61,
                 from /mnt/gvfs/third-party/2abdfad61e1ced257651899c884f84346417ba37/centos5.2-native/gcc/gcc-4.7.1/cc6c9dc/bin/../lib/gcc/x86_64-redhat-linux-gnu/4.7.1/../../../../include/c++/4.7.1/utility:72,
                 from /mnt/gvfs/third-party/2abdfad61e1ced257651899c884f84346417ba37/centos5.2-native/gcc/gcc-4.7.1/cc6c9dc/bin/../lib/gcc/x86_64-redhat-linux-gnu/4.7.1/../../../../include/c++/4.7.1/algorithm:61,
                 from insert_sorted.cpp:1:
/mnt/gvfs/third-party/2abdfad61e1ced257651899c884f84346417ba37/centos5.2-native/gcc/gcc-4.7.1/cc6c9dc/bin/../lib/gcc/x86_64-redhat-linux-gnu/4.7.1/../../../../include/c++/4.7.1/type_traits: In instantiation of ‘struct std::_Result_of_impl<false, false, prop_insert_sorted_t, const int&, const std::vector<int, std::allocator<int> >&>’:
/mnt/gvfs/third-party/2abdfad61e1ced257651899c884f84346417ba37/centos5.2-native/gcc/gcc-4.7.1/cc6c9dc/bin/../lib/gcc/x86_64-redhat-linux-gnu/4.7.1/../../../../include/c++/4.7.1/type_traits:1857:12:   required from ‘class std::result_of<prop_insert_sorted_t(const int&, const std::vector<int>&)>’
../../include/autocheck/apply.hpp:16:3:   required by substitution of ‘template<class F, class ... Args> typename std::result_of<F(const Args& ...)>::type autocheck::apply(F, const std::tuple<_Elements ...>&) [with F = prop_insert_sorted_t; Args = {int, std::vector<int, std::allocator<int> >}]’
../../include/autocheck/check.hpp:48:7:   required from ‘void autocheck::check(Property, size_t, Arbitrary, const autocheck::reporter&, autocheck::classifier<Args ...>, bool) [with Args = {int, std::vector<int, std::allocator<int> >}; Property = prop_insert_sorted_t; Arbitrary = autocheck::arbitrary<autocheck::generator<int, void>, autocheck::generator<std::vector<int, std::allocator<int> >, void> >; size_t = long unsigned int]’
insert_sorted.cpp:40:55:   required from here
/mnt/gvfs/third-party/2abdfad61e1ced257651899c884f84346417ba37/centos5.2-native/gcc/gcc-4.7.1/cc6c9dc/bin/../lib/gcc/x86_64-redhat-linux-gnu/4.7.1/../../../../include/c++/4.7.1/type_traits:1834:9: error: no match for call to ‘(prop_insert_sorted_t) (const int&, const std::vector<int>&)’
insert_sorted.cpp:17:8: note: candidate is:
insert_sorted.cpp:19:8: note: template<class T> bool prop_insert_sorted_t::operator()(const T&, std::vector<_RealType>&)
insert_sorted.cpp:19:8: note:   template argument deduction/substitution failed:
In file included from /mnt/gvfs/third-party/2abdfad61e1ced257651899c884f84346417ba37/centos5.2-native/gcc/gcc-4.7.1/cc6c9dc/bin/../lib/gcc/x86_64-redhat-linux-gnu/4.7.1/../../../../include/c++/4.7.1/bits/move.h:57:0,
                 from /mnt/gvfs/third-party/2abdfad61e1ced257651899c884f84346417ba37/centos5.2-native/gcc/gcc-4.7.1/cc6c9dc/bin/../lib/gcc/x86_64-redhat-linux-gnu/4.7.1/../../../../include/c++/4.7.1/bits/stl_pair.h:61,
                 from /mnt/gvfs/third-party/2abdfad61e1ced257651899c884f84346417ba37/centos5.2-native/gcc/gcc-4.7.1/cc6c9dc/bin/../lib/gcc/x86_64-redhat-linux-gnu/4.7.1/../../../../include/c++/4.7.1/utility:72,
                 from /mnt/gvfs/third-party/2abdfad61e1ced257651899c884f84346417ba37/centos5.2-native/gcc/gcc-4.7.1/cc6c9dc/bin/../lib/gcc/x86_64-redhat-linux-gnu/4.7.1/../../../../include/c++/4.7.1/algorithm:61,
                 from insert_sorted.cpp:1:
/mnt/gvfs/third-party/2abdfad61e1ced257651899c884f84346417ba37/centos5.2-native/gcc/gcc-4.7.1/cc6c9dc/bin/../lib/gcc/x86_64-redhat-linux-gnu/4.7.1/../../../../include/c++/4.7.1/type_traits:1834:9: note:   types ‘std::vector<_RealType>’ and ‘const std::vector<int>’ have incompatible cv-qualifiers
‘
/mnt/gvfs/third-party/2abdfad61e1ced257651899c884f84346417ba37/centos5.2-native/gcc/gcc-4.7.1/cc6c9dc/bin/../lib/gcc/x86_64-redhat-linux-gnu/4.7.1/../../../../include/c++/4.7.1/type_traits:1834: confused by earlier errors, bailing out
make: *** [build/./insert_sorted.o] Error 1

When we changed out the const overload in apply.hpp (https://github.com/thejohnfreeman/autocheck/commit/fb2967d807a23522e46aa517b7e271a04cc58fc2) We get the cryptic message:

$ make
/home/fugalh/tehcode/third-party/centos5.2-native/gcc/gcc-4.7.1/cc6c9dc/bin/g++ -std=gnu++11 -I../../include  -I/home/fugalh/local/include  -I../../include -std=c++11 -o build/./insert_sorted.o -c insert_sorted.cpp
‘
../../include/autocheck/arbitrary.hpp:53: confused by earlier errors, bailing out
make: *** [build/./insert_sorted.o] Error 1

Hi,

The first fix just gets rid of an annoying warning that comes if asserts are turned off. If asserts are turned off, the p object in value.hpp is never used.

The second is in the floating point generator and was causing serious problems. The code was taking the negative of a size_t, which on most platforms is an unsigned int. The negative of an unsigned int is undefined. So, I first convert to a generic floating point value and then negate that.

Cheers, Ben

As unrestricted unions are not used for Visual Studio 2013, default

T  object;

field is created in value template class default contructor. But as allocation is initialized with None this default object leaks, when we start to generate test values. So, for example, there is a memory leak in the following code, if it is compiled by Visual Studio 2013:

autocheck::check<std::string>([](const std::string& str) { return true; });

Patch fixes this leakage and turns on unrestricted union usage for Visual Studio 2015+.

MSVC chokes on parameter-pack expansion in a couple contexts, so I pretty much just shook the code around until it stopped complaining. As far as I can tell the Gens... related changes have no semantic difference, they just entertain the compiler in slightly different ways.

The SignedIntegral change here I think is more legit. Previous code was negating an unsigned type (size_t). Probably would have underflowed.

Doesn't look like it has a generator for double or float yet? Probably just needs something like

template <typename Double>                                                                                                                                                                                                          
class generator<                                                                                                                                                                                                                    
Double,                                                                                                                                                                                                                           
  typename std::enable_if<                                                                                                                                                                                                          
    is_one_of<Double, double, float>::value                                                                                                                                                                                         
  >::type                                                                                                                                                                                                                           
>                                                                                                                                                                                                                                   
{                                                                                                                                                                                                                                   
public:                                                                                                                                                                                                                           
  typedef Double result_type;                                                                                                                                                                                                     

  result_type operator() (size_t size) {                                                                                                                                                                                          
    /* Distribution is non-static. */                                                                                                                                                                                             
    std::uniform_real_distribution<Double> dist(0, size);                                                                                                                                                                         
    auto rv = dist(rng());                                                                                                                                                                                                        
    return rv;                                                                                                                                                                                                                    
  }                                                                                                                                                                                                                               

};

I've extended list_generator so it can be used with more std container, e.g. std::set, and added a default std::tuple generator using cons_generator.

There's also some fixes for building with C++17

Good Morning John,

I'm using autocheck, with great success, and I now want to generate values within a range.

I am testing some date functions and I want to generate years between [1970, 2015] inclusively. I tried the ac::fix() combinator, but that just sets an upper limit on the generated value.

I see how I can use discard_if() to throw away values that don't match, but that feels so wasteful. Additionally, I want to generate days, months and years so I'd throw away a lot of data before I generated a valid tuple of values.

How would you recommend generating a range, and if it doesn't exist in autocheck today, what guidance could you provide to how I should add this feature?

Thank you for your time.

Sincerely, Jeremy Wright

Any interest in code for shrinking? I gather you're doing a sort of minimalist SmallCheck-style "expand outwards slowly" approach, but there's still plenty of opportunity for someone to generate non-minimal failures here, I think?

Edit: I should say, if you are interested, I'd be happy to try sketching such code. Just curious what thoughts you have on the matter. This is a tasteful little library and I'd like to follow your design preferences.

Hi,

apparently it is possible to use the library on older G++, like version 4.6.3 included in Ubuntu 12.04 LTS, by applying a minor fix; I'm pasting it here in case it is useful for anybody.

@thejohnfreeman Feel free to close this issue as wontfix, because old compilers generally won't support c++11 properly.

Index: autocheck/include/autocheck/value.hpp
===================================================================
--- autocheck/include/autocheck/value.hpp   (original)
+++ autocheck/include/autocheck/value.hpp   (new)
@@ -12,15 +12,15 @@
         None,
         Static,
         Heap
-      }    allocation = None;
+      }   allocation /* = None */;

       union {
-        T* pointer = nullptr;
+        T* pointer /* = nullptr */;
         T  object;
       };

     public:
-      value() {}
+      value() : allocation(None), pointer(nullptr) {}

       value(const value& copy) { *this = copy; }

Although complex code, like generators for classes and enums, seems to break the compiler, the autocheck library is still very useful on pre-c++11 compilers.