add usage examples

Change-Id: I306b87c0350ae407bbea123a467970a4b4c81d87

example/BUILD.bazel

@@ -0,0 +1,106 @@
+load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_test")
+load("//rules:binary_log.bzl", "synchronized_binary_log")
+
+cc_binary(
+    name = "minimal_pass",
+    srcs = ["minimal_pass.cpp"],
+    deps = ["//:skytest"],
+)
+
+synchronized_binary_log(
+    name = "minimal_pass_log",
+    src = ":minimal_pass",
+)
+
+cc_binary(
+    name = "minimal_fail",
+    srcs = ["minimal_fail.cpp"],
+    deps = ["//:skytest"],
+)
+
+synchronized_binary_log(
+    name = "minimal_fail_log",
+    src = ":minimal_fail",
+)
+
+cc_test(
+    name = "binary_comparisons",
+    srcs = ["binary_comparisons.cpp"],
+    deps = ["//:skytest"],
+)
+
+cc_test(
+    name = "logical_operations",
+    srcs = ["logical_operations.cpp"],
+    deps = ["//:skytest"],
+)
+
+cc_binary(
+    name = "additional_output",
+    srcs = ["additional_output.cpp"],
+    deps = ["//:skytest"],
+)
+
+synchronized_binary_log(
+    name = "additional_output_log",
+    src = ":additional_output",
+)
+
+cc_binary(
+    name = "user_defined_predicates",
+    srcs = ["user_defined_predicates.cpp"],
+    deps = ["//:skytest"],
+)
+
+synchronized_binary_log(
+    name = "user_defined_predicates_log",
+    src = ":user_defined_predicates",
+)
+
+cc_binary(
+    name = "described_predicates_20",
+    srcs = ["described_predicates_20.cpp"],
+    copts = ["-std=c++20"],
+    deps = ["//:skytest"],
+)
+
+synchronized_binary_log(
+    name = "described_predicates_20_log",
+    src = ":described_predicates_20",
+)
+
+cc_binary(
+    name = "described_predicates",
+    srcs = ["described_predicates.cpp"],
+    deps = ["//:skytest"],
+)
+
+synchronized_binary_log(
+    name = "described_predicates_log",
+    src = ":described_predicates",
+)
+
+cc_test(
+    name = "type_parameterized",
+    srcs = ["type_parameterized.cpp"],
+    deps = ["//:skytest"],
+)
+
+cc_test(
+    name = "value_parameterized",
+    srcs = ["value_parameterized.cpp"],
+    deps = ["//:skytest"],
+)
+
+cc_test(
+    name = "param_ref_parameterized",
+    srcs = ["param_ref_parameterized.cpp"],
+    deps = ["//:skytest"],
+)
+
+cc_test(
+    name = "param_parameterized",
+    srcs = ["param_parameterized.cpp"],
+    copts = ["-std=c++20"],
+    deps = ["//:skytest"],
+)

example/additional_output.cpp

@@ -0,0 +1,20 @@
+#include "skytest/skytest.hpp"
+
+#include <utility>
+
+auto main() -> int
+{
+  using namespace skytest::literals;
+  using ::skytest::eq;
+  using ::skytest::expect;
+
+  "string-view-ish"_test = [] { return expect(eq(1, 2), "a message"); };
+
+  "ostream invocable closure"_test = [] {
+    const auto x = std::pair{1, 2};
+    const auto y = std::pair{2, 1};
+    return expect(eq(x, y), [=](auto& os) {
+      os << x.first << ", " << y.first << "\n";
+    });
+  };
+}

example/additional_output.log

@@ -0,0 +1,8 @@
+test `string-view-ish`...[CONSTEXPR FAIL] example/additional_output.cpp:11
+(1 == 2)
+a message
+test `ostream invocable closure`...[CONSTEXPR FAIL] example/additional_output.cpp:16
+(std::pair<int, int>{...} == std::pair<int, int>{...})
+1, 2
+
+0 tests passed | 2 tests failed

example/binary_comparisons.cpp

@@ -0,0 +1,20 @@
+#include "skytest/skytest.hpp"
+
+auto main() -> int
+{
+  using namespace skytest::literals;
+  using ::skytest::eq;
+  using ::skytest::expect;
+  using ::skytest::ge;
+  using ::skytest::gt;
+  using ::skytest::le;
+  using ::skytest::lt;
+  using ::skytest::ne;
+
+  "eq"_test = [] { return expect(eq(1, 1)); };
+  "ne"_test = [] { return expect(ne(1, 0)); };
+  "lt"_test = [] { return expect(lt(0, 1)); };
+  "gt"_test = [] { return expect(gt(1, 0)); };
+  "le"_test = [] { return expect(le(1, 1)); };
+  "ge"_test = [] { return expect(ge(1, 1)); };
+}

example/described_predicates.cpp

@@ -0,0 +1,25 @@
+
+#include "skytest/skytest.hpp"
+
+#include <array>
+#include <string_view>
+
+using namespace skytest::literals;
+using ::skytest::expect;
+using ::skytest::pred;
+
+struct empty_desc
+{
+  using notation_type = skytest::notation::function;
+  static constexpr auto symbol = std::string_view{"empty"};
+};
+
+static constexpr auto empty = pred(empty_desc{}, [](const auto& rng) {
+  return std::empty(rng);
+});
+
+auto main() -> int
+{
+
+  "empty array"_test = [] { return expect(empty(std::array{1, 2, 3})); };
+}

example/described_predicates.log

@@ -0,0 +1,4 @@
+test `empty array`...[CONSTEXPR FAIL] example/described_predicates.cpp:24
+empty([1, 2, 3])
+
+0 tests passed | 1 test failed

example/described_predicates_20.cpp

@@ -0,0 +1,15 @@
+#include "skytest/skytest.hpp"
+
+#include <array>
+
+auto main() -> int
+{
+  using namespace skytest::literals;
+  using ::skytest::expect;
+  using ::skytest::function;
+  using ::skytest::pred;
+
+  static constexpr auto empty = pred(function<"∅">, std::ranges::empty);
+
+  "empty array"_test = [] { return expect(empty(std::array{1, 2, 3})); };
+}

example/logical_operations.cpp

@@ -0,0 +1,12 @@
+#include "skytest/skytest.hpp"
+
+auto main() -> int
+{
+  using namespace skytest::literals;
+  using ::skytest::expect;
+  using ::skytest::lt;
+
+  "and"_test = [] { return expect(lt(1, 2) and lt(2, 3)); };
+  "or"_test = [] { return expect(lt(3, 2) or lt(2, 3)); };
+  "not"_test = [] { return expect(not lt(1, 0)); };
+}

example/minimal_fail.cpp

@@ -0,0 +1,10 @@
+#include "skytest/skytest.hpp"
+
+auto main(int argc, char*[]) -> int
+{
+  using namespace skytest::literals;
+  using ::skytest::eq;
+  using ::skytest::expect;
+
+  "falsy"_test = [&] { return expect(eq(0, argc)); };
+}

example/minimal_fail.log

@@ -0,0 +1,4 @@
+test `falsy`...[FAIL] example/minimal_fail.cpp:9
+(0 == 1)
+
+0 tests passed | 1 test failed

example/minimal_pass.cpp

@@ -0,0 +1,9 @@
+#include "skytest/skytest.hpp"
+
+auto main() -> int
+{
+  using namespace skytest::literals;
+  using ::skytest::expect;
+
+  "truthy"_test = [] { return expect(true); };
+}

example/minimal_pass.log

@@ -0,0 +1,2 @@
+test `truthy`...[CONSTEXPR PASS]
+all tests passed (1 test)

example/param_parameterized.cpp

@@ -0,0 +1,14 @@
+#include "skytest/skytest.hpp"
+
+#include <array>
+
+auto main() -> int
+{
+  using namespace ::skytest::literals;
+  using ::skytest::expect;
+  using ::skytest::lt;
+  using ::skytest::param;
+
+  "with paramf"_test * param<std::array{1, 2, 3}> =  //
+      [](auto param) { return expect(lt(0, param)); };
+}

example/param_ref_parameterized.cpp

@@ -0,0 +1,23 @@
+#include "skytest/skytest.hpp"
+
+#include <array>
+#include <tuple>
+
+auto main() -> int
+{
+  using namespace ::skytest::literals;
+  using ::skytest::eq;
+  using ::skytest::expect;
+  using ::skytest::lt;
+  using ::skytest::param_ref;
+
+  static constexpr auto type_params = std::tuple{1.0F, 1.0};
+
+  "types with param_ref"_test * param_ref<type_params> =  //
+      [](auto param) { return expect(eq(1, param)); };
+
+  static constexpr auto value_params = std::array{1, 2, 3};
+
+  "values with param_ref"_test * param_ref<value_params> =  //
+      [](auto param) { return expect(lt(0, param)); };
+}

example/type_parameterized.cpp

@@ -0,0 +1,22 @@
+#include "skytest/skytest.hpp"
+
+#include <cmath>
+#include <complex>
+#include <tuple>
+
+auto main() -> int
+{
+  using namespace ::skytest::literals;
+  using ::skytest::eq;
+  using ::skytest::expect;
+  using ::skytest::types;
+
+  "typed"_test * std::tuple<int, float, std::complex<double>>{} =  //
+      [](auto param) { return expect(eq(0, std::abs(param))); };
+
+  "with types param"_test * types<int, float> =  //
+      [](auto type_id) {
+        using T = typename decltype(type_id)::type;
+        return expect(eq(T{}, T{} + T{}));
+      };
+}

example/user_defined_predicates.cpp

@@ -0,0 +1,17 @@
+#include "skytest/skytest.hpp"
+
+#include <array>
+#include <iterator>
+
+auto main() -> int
+{
+  using namespace skytest::literals;
+  using ::skytest::expect;
+  using ::skytest::pred;
+
+  static constexpr auto empty = pred([](const auto& rng) {
+    return std::empty(rng);
+  });
+
+  "empty array"_test = [] { return expect(empty(std::array{1, 2, 3})); };
+}

example/user_defined_predicates.log

@@ -0,0 +1,4 @@
+test `empty array`...[CONSTEXPR FAIL] example/user_defined_predicates.cpp:16
+(lambda at example/user_defined_predicates.cpp:12:38){}([1, 2, 3])
+
+0 tests passed | 1 test failed

example/value_parameterized.cpp

@@ -0,0 +1,13 @@
+#include "skytest/skytest.hpp"
+
+#include <vector>
+
+auto main() -> int
+{
+  using namespace ::skytest::literals;
+  using ::skytest::expect;
+  using ::skytest::lt;
+
+  "values"_test * std::vector{1, 2, 3} =  //
+      [](auto param) { return expect(lt(0, param)); };
+}