Added C++ version of parameterized sample

samples/CMakeLists.txt

@@ -29,6 +29,7 @@ set(SAMPLES
   simple.cc
   theories.cc
   redirect.cc
+  parameterized.cc
 )
 
 set(SCRIPTS

samples/parameterized.cc

@@ -0,0 +1,75 @@
+#include <criterion/parameterized.h>
+
+// Basic usage
+
+ParameterizedTestParameters(params, str) {
+    static const char *strings[] = {
+        "foo", "bar", "baz"
+    };
+
+    return cr_make_param_array(const char *, strings, sizeof (strings) / sizeof (const char *));
+}
+
+ParameterizedTest(const char **str, params, str) {
+    cr_assert_fail("Parameter: %s", *str);
+}
+
+// Multiple parameters must be coalesced in a single parameter
+
+struct parameter_tuple {
+    int i;
+    double d;
+};
+
+ParameterizedTestParameters(params, multiple) {
+    static struct parameter_tuple params[] = {
+        {1, 2},
+        {3, 4},
+        {5, 6},
+    };
+
+    return cr_make_param_array(struct parameter_tuple, params, sizeof (params) / sizeof (struct parameter_tuple));
+}
+
+ParameterizedTest(struct parameter_tuple *tup, params, multiple) {
+    cr_assert_fail("Parameters: (%d, %f)", tup->i, tup->d);
+}
+
+// Using dynamically generated parameters
+
+// you **MUST** use new_obj, new_arr, delete_obj, delete_arr instead of
+// the new, new[], delete and delete[] operators (respectively) to allocate and
+// deallocate dynamic memory in parameters, otherwise this will crash on
+// Windows builds of the test.
+
+// the criterion::allocator<T> allocator may be used with STL containers to
+// allocate objects with the functions described above.
+
+using criterion::new_obj;
+using criterion::new_arr;
+using criterion::delete_obj;
+using criterion::delete_arr;
+
+struct parameter_tuple_dyn {
+    int i;
+    std::unique_ptr<double, decltype(criterion::free)> d;
+
+    parameter_tuple_dyn() : i(0), d(nullptr, criterion::free) {}
+    parameter_tuple_dyn(int i, double *d) : i(i), d(d, criterion::free) {}
+};
+
+ParameterizedTestParameters(params, cleanup) {
+    static criterion::parameters<parameter_tuple_dyn> params;
+
+    params.push_back(parameter_tuple_dyn(1, new_obj<double>(2)));
+    params.push_back(parameter_tuple_dyn(3, new_obj<double>(4)));
+    params.push_back(parameter_tuple_dyn(5, new_obj<double>(6)));
+
+    // A criterion::parameters<T> can be returned in place of a
+    // criterion_test_params.
+    return params;
+}
+
+ParameterizedTest(parameter_tuple_dyn *tup, params, cleanup) {
+    cr_assert_fail("Parameters: (%d, %f)", tup->i, *tup->d);
+}