zircon/system/ulib/zxtest/test/values_test.cc

// Copyright 2021 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <lib/fit/function.h>

#include <cstdlib>
#include <iostream>

#include <zxtest/base/assertion.h>
#include <zxtest/base/observer.h>
#include <zxtest/base/parameterized-value-impl.h>
#include <zxtest/base/runner.h>
#include <zxtest/base/test-case.h>
#include <zxtest/base/test-info.h>
#include <zxtest/base/types.h>
#include <zxtest/base/values.h>

namespace zxtest::test {

void TestValuesIn() {
  // Test std::vector
  auto c1 = std::vector<int>({0, 1, 2, 3});
  auto p1 = ::zxtest::ValuesIn(c1);
  ZX_ASSERT_MSG(p1.size() == c1.size(), "Resulting provider size does not match input size.");
  size_t i = 0;
  for (auto it = c1.begin(); it != c1.end(); ++it, ++i) {
    ZX_ASSERT_MSG(p1[i] == *it, "Expected %d, got %d", p1[i], *it);
  }

  // Test std::array
  auto c2 = cpp20::to_array<int>({4, 5, 6, 7});
  auto p2 = ::zxtest::ValuesIn(c2);
  ZX_ASSERT_MSG(p2.size() == c2.size(), "Resulting provider size does not match input size.");
  i = 0;
  for (auto it = c2.begin(); it != c2.end(); ++it, ++i) {
    ZX_ASSERT_MSG(p2[i] == *it, "Expected %d, got %d", p2[i], *it);
  }

  // TODO(https://fxbug.dev/42163520): This does not work. We still don't support bools in a vector.
  // auto c3 = std::vector<bool>({false, true});
  // auto p3 = ::zxtest::ValuesIn(c3);
  // ZX_ASSERT_MSG(p3.size() == c3.size(), "Resulting provider size does not match input
  // size."); i = 0; for (auto it = c3.begin(); it != c3.end(); ++it, ++i) {
  //   bool val = *it;
  //   ZX_ASSERT_MSG(p3[i] == val, "Expected %d, got %d", p3[i], val);
  // }

  auto c4 = cpp20::to_array<bool>({false, true});
  auto p4 = ::zxtest::ValuesIn(c4);
  ZX_ASSERT_MSG(p4.size() == c4.size(), "Resulting provider size does not match input size.");
  i = 0;
  for (auto it = c4.begin(); it != c4.end(); ++it, ++i) {
    bool val = *it;
    ZX_ASSERT_MSG(p4[i] == val, "Expected %d, got %d", p4[i], val);
  }
}

void TestValuesBool() {
  auto provider = ::zxtest::Bool();
  ZX_ASSERT_MSG(provider.size() == 2, "Provider size should be 2, got %zu.", provider.size());
  ZX_ASSERT_MSG(provider[0] != provider[1], "Bool values should not equal.");
}

void TestRange() {
  auto p1 = ::zxtest::Range(1, 9, 2);
  auto e1 = std::vector<int>({1, 3, 5, 7});
  ZX_ASSERT_MSG(p1.size() == e1.size(), "Resulting provider size: %zu. Expected: %zu", p1.size(),
                e1.size());
  for (size_t i = 0; i < e1.size(); ++i) {
    ZX_ASSERT(p1[i] == e1[i]);
  }

  auto p2 = ::zxtest::Range(1, 2, 2);
  auto e2 = std::vector<int>({1});
  ZX_ASSERT_MSG(p2.size() == e2.size(), "Resulting provider size: %zu. Expected: %zu", p2.size(),
                e2.size());
  for (size_t i = 0; i < e2.size(); ++i) {
    ZX_ASSERT(p2[i] == e2[i]);
  }

  auto p3 = ::zxtest::Range(1, 5);
  auto e3 = std::vector<int>({1, 2, 3, 4});
  ZX_ASSERT_MSG(p3.size() == e3.size(), "Resulting provider size: %zu. Expected: %zu", p3.size(),
                e3.size());
  for (size_t i = 0; i < e3.size(); ++i) {
    ZX_ASSERT(p3[i] == e3[i]);
  }

  auto p4 = ::zxtest::Range(8, 16, 2);
  auto e4 = std::vector<int>({8, 10, 12, 14});
  ZX_ASSERT_MSG(p4.size() == e4.size(), "Resulting provider size: %zu. Expected: %zu", p4.size(),
                e4.size());
  for (size_t i = 0; i < e4.size(); ++i) {
    ZX_ASSERT(p4[i] == e4[i]);
  }

  auto p5 = ::zxtest::Range(8.5, 16.3, 2.5);
  auto e5 = std::vector<double>({8.5, 11, 13.5, 16});
  ZX_ASSERT_MSG(p5.size() == e5.size(), "Resulting provider size: %zu. Expected: %zu", p5.size(),
                e5.size());
  for (size_t i = 0; i < e5.size(); ++i) {
    ZX_ASSERT(p5[i] == e5[i]);
  }

  auto p6 = ::zxtest::Range(7.99, 16.95, 2.98);
  auto e6 = std::vector<double>({7.99, 10.97, 13.95, 16.93});
  ZX_ASSERT_MSG(p6.size() == e6.size(), "Resulting provider size: %zu. Expected: %zu", p6.size(),
                e6.size());
  for (size_t i = 0; i < e6.size(); ++i) {
    ZX_ASSERT(p6[i] == e6[i]);
  }

  auto p7 = ::zxtest::Range(7.99, 9.999);
  auto e7 = std::vector<double>({7.99, 8.99, 9.99});
  ZX_ASSERT_MSG(p7.size() == e7.size(), "Resulting provider size: %zu. Expected: %zu", p7.size(),
                e7.size());
  for (size_t i = 0; i < e7.size(); ++i) {
    ZX_ASSERT(p7[i] == e7[i]);
  }
}

void TestValuesSimilarTypes() {
  // Failure would be a compilation error.
  ::zxtest::internal::ValueProvider<std::string> p1 = ::zxtest::Values("A", std::string("B"));
  ::zxtest::internal::ValueProvider<long> p2 = ::zxtest::Values(7, 1l, 5);
}

void TestValuesCombine() {
  // Same type
  auto c1 = ::zxtest::Combine(::zxtest::Values(10, 20, 30), ::zxtest::Values(15, 25, 35));
  std::vector<std::tuple<int, int>> e1 = {
      std::tuple(10, 15), std::tuple(10, 25), std::tuple(10, 35),
      std::tuple(20, 15), std::tuple(20, 25), std::tuple(20, 35),
      std::tuple(30, 15), std::tuple(30, 25), std::tuple(30, 35),
  };
  ZX_ASSERT_MSG(c1.size() == e1.size(), "Provider size should be %zu, got %zu.", e1.size(),
                c1.size());

  for (size_t i = 0; i < c1.size(); ++i) {
    ZX_ASSERT_MSG(e1[i] == c1[i], "Expected (%d, %d), got (%d, %d)", std::get<0>(e1[i]),
                  std::get<1>(e1[i]), std::get<0>(c1[i]), std::get<1>(c1[i]));
  }

  // Different types
  auto c2 = ::zxtest::Combine(::zxtest::Values(1.1, 2.2, 3.3), ::zxtest::Values(15, 25, 35));
  std::vector<std::tuple<double, int>> e2 = {
      std::tuple(1.1, 15), std::tuple(1.1, 25), std::tuple(1.1, 35),
      std::tuple(2.2, 15), std::tuple(2.2, 25), std::tuple(2.2, 35),
      std::tuple(3.3, 15), std::tuple(3.3, 25), std::tuple(3.3, 35),
  };
  ZX_ASSERT_MSG(c2.size() == e2.size(), "Provider size should be %zu, got %zu.", e2.size(),
                c2.size());

  for (size_t i = 0; i < c2.size(); ++i) {
    ZX_ASSERT_MSG(e2[i] == c2[i], "Expected (%lf, %d), got (%lf, %d)", std::get<0>(e2[i]),
                  std::get<1>(e2[i]), std::get<0>(c2[i]), std::get<1>(c2[i]));
  }

  // Combine with 3 parameters
  auto c3 = ::zxtest::Combine(::zxtest::Values(1.1, 2.2, 3.3), ::zxtest::Values(15, 25, 35),
                              ::zxtest::Values(150, 250, 350));
  std::vector<std::tuple<double, int, int>> e3 = {
      std::tuple(1.1, 15, 150), std::tuple(1.1, 15, 250), std::tuple(1.1, 15, 350),
      std::tuple(1.1, 25, 150), std::tuple(1.1, 25, 250), std::tuple(1.1, 25, 350),
      std::tuple(1.1, 35, 150), std::tuple(1.1, 35, 250), std::tuple(1.1, 35, 350),
      std::tuple(2.2, 15, 150), std::tuple(2.2, 15, 250), std::tuple(2.2, 15, 350),
      std::tuple(2.2, 25, 150), std::tuple(2.2, 25, 250), std::tuple(2.2, 25, 350),
      std::tuple(2.2, 35, 150), std::tuple(2.2, 35, 250), std::tuple(2.2, 35, 350),
      std::tuple(3.3, 15, 150), std::tuple(3.3, 15, 250), std::tuple(3.3, 15, 350),
      std::tuple(3.3, 25, 150), std::tuple(3.3, 25, 250), std::tuple(3.3, 25, 350),
      std::tuple(3.3, 35, 150), std::tuple(3.3, 35, 250), std::tuple(3.3, 35, 350),
  };
  ZX_ASSERT_MSG(c3.size() == e3.size(), "Provider size should be %zu, got %zu.", e3.size(),
                c3.size());

  for (size_t i = 0; i < c3.size(); ++i) {
    ZX_ASSERT_MSG(e3[i] == c3[i], "Expected (%lf, %d, %d), got (%lf, %d, %d)", std::get<0>(e3[i]),
                  std::get<1>(e3[i]), std::get<2>(e3[i]), std::get<0>(c3[i]), std::get<1>(c3[i]),
                  std::get<2>(c3[i]));
  }

  // Combine with 4 parameters
  auto c4 = ::zxtest::Combine(::zxtest::Values(1.1, 2.2), ::zxtest::Values(15, 25),
                              ::zxtest::Values(150, 250), ::zxtest::Values(105, 205));
  std::vector<std::tuple<double, int, int, int>> e4 = {
      std::tuple(1.1, 15, 150, 105), std::tuple(1.1, 15, 150, 205), std::tuple(1.1, 15, 250, 105),
      std::tuple(1.1, 15, 250, 205), std::tuple(1.1, 25, 150, 105), std::tuple(1.1, 25, 150, 205),
      std::tuple(1.1, 25, 250, 105), std::tuple(1.1, 25, 250, 205), std::tuple(2.2, 15, 150, 105),
      std::tuple(2.2, 15, 150, 205), std::tuple(2.2, 15, 250, 105), std::tuple(2.2, 15, 250, 205),
      std::tuple(2.2, 25, 150, 105), std::tuple(2.2, 25, 150, 205), std::tuple(2.2, 25, 250, 105),
      std::tuple(2.2, 25, 250, 205),
  };
  ZX_ASSERT_MSG(c4.size() == e4.size(), "Provider size should be %zu, got %zu.", e4.size(),
                c4.size());

  for (size_t i = 0; i < c4.size(); ++i) {
    ZX_ASSERT_MSG(e4[i] == c4[i], "Expected (%lf, %d, %d, %d), got (%lf, %d, %d, %d)",
                  std::get<0>(e4[i]), std::get<1>(e4[i]), std::get<2>(e4[i]), std::get<3>(e4[i]),
                  std::get<0>(c4[i]), std::get<1>(c4[i]), std::get<2>(c4[i]), std::get<3>(c4[i]));
  }
}

void TestTuplesCombine() {
  // Both tuples
  auto c1 = ::zxtest::Combine(
      ::zxtest::Values(std::tuple(10, 11), std::tuple(20, 21), std::tuple(30, 31)),
      ::zxtest::Values(std::tuple(15, 16), std::tuple(25, 26), std::tuple(35, 36)));
  std::vector<std::tuple<std::tuple<int, int>, std::tuple<int, int>>> e1 = {
      std::tuple(std::tuple(10, 11), std::tuple(15, 16)),
      std::tuple(std::tuple(10, 11), std::tuple(25, 26)),
      std::tuple(std::tuple(10, 11), std::tuple(35, 36)),
      std::tuple(std::tuple(20, 21), std::tuple(15, 16)),
      std::tuple(std::tuple(20, 21), std::tuple(25, 26)),
      std::tuple(std::tuple(20, 21), std::tuple(35, 36)),
      std::tuple(std::tuple(30, 31), std::tuple(15, 16)),
      std::tuple(std::tuple(30, 31), std::tuple(25, 26)),
      std::tuple(std::tuple(30, 31), std::tuple(35, 36)),
  };
  ZX_ASSERT_MSG(c1.size() == e1.size(), "Provider size should be %zu, got %zu.", e1.size(),
                c1.size());

  size_t c_size = std::tuple_size<std::remove_reference<decltype(c1[0])>::type>::value;
  size_t e_size = std::tuple_size<std::remove_reference<decltype(e1[0])>::type>::value;
  ZX_ASSERT_MSG(c_size == e_size, "Size is wrong: got %zu, expected %zu", c_size, e_size);

  for (size_t i = 0; i < c1.size(); ++i) {
    ZX_ASSERT(std::get<0>(e1[i]) == std::get<0>(c1[i]));
    ZX_ASSERT(std::get<1>(e1[i]) == std::get<1>(c1[i]));
  }

  // First tuple only
  auto c2 = ::zxtest::Combine(
      ::zxtest::Values(std::tuple(10, 11), std::tuple(20, 21), std::tuple(30, 31)),
      ::zxtest::Values(15, 25, 35));
  std::vector<std::tuple<std::tuple<int, int>, int>> e2 = {
      std::tuple(std::tuple(10, 11), 15), std::tuple(std::tuple(10, 11), 25),
      std::tuple(std::tuple(10, 11), 35), std::tuple(std::tuple(20, 21), 15),
      std::tuple(std::tuple(20, 21), 25), std::tuple(std::tuple(20, 21), 35),
      std::tuple(std::tuple(30, 31), 15), std::tuple(std::tuple(30, 31), 25),
      std::tuple(std::tuple(30, 31), 35),
  };
  ZX_ASSERT_MSG(c2.size() == e2.size(), "Provider size should be %zu, got %zu.", e2.size(),
                c2.size());

  c_size = std::tuple_size<std::remove_reference<decltype(c2[0])>::type>::value;
  e_size = std::tuple_size<std::remove_reference<decltype(e2[0])>::type>::value;
  ZX_ASSERT_MSG(c_size == e_size, "Size is wrong: got %zu, expected %zu", c_size, e_size);

  for (size_t i = 0; i < c2.size(); ++i) {
    ZX_ASSERT(std::get<0>(e2[i]) == std::get<0>(c2[i]));
    ZX_ASSERT(std::get<1>(e2[i]) == std::get<1>(c2[i]));
  }

  // Second tuple only
  auto c3 = ::zxtest::Combine(
      ::zxtest::Values(10, 20, 30),
      ::zxtest::Values(std::tuple(15, 16), std::tuple(25, 26), std::tuple(35, 36)));
  std::vector<std::tuple<int, std::tuple<int, int>>> e3 = {
      std::tuple(10, std::tuple(15, 16)), std::tuple(10, std::tuple(25, 26)),
      std::tuple(10, std::tuple(35, 36)), std::tuple(20, std::tuple(15, 16)),
      std::tuple(20, std::tuple(25, 26)), std::tuple(20, std::tuple(35, 36)),
      std::tuple(30, std::tuple(15, 16)), std::tuple(30, std::tuple(25, 26)),
      std::tuple(30, std::tuple(35, 36)),
  };
  ZX_ASSERT_MSG(c3.size() == e3.size(), "Provider size should be %zu, got %zu.", e3.size(),
                c3.size());

  c_size = std::tuple_size<std::remove_reference<decltype(c3[0])>::type>::value;
  e_size = std::tuple_size<std::remove_reference<decltype(e3[0])>::type>::value;
  ZX_ASSERT_MSG(c_size == e_size, "Size is wrong: got %zu, expected %zu", c_size, e_size);

  for (size_t i = 0; i < c3.size(); ++i) {
    ZX_ASSERT(std::get<0>(e3[i]) == std::get<0>(c3[i]));
    ZX_ASSERT(std::get<1>(e3[i]) == std::get<1>(c3[i]));
  }

  // Quad tuples
  auto c4 = ::zxtest::Combine(::zxtest::Values(std::tuple(10, 11), std::tuple(20, 21)),
                              ::zxtest::Values(std::tuple(15, 16), std::tuple(25, 26)),
                              ::zxtest::Values(std::tuple(1.5, 1.6), std::tuple(2.5, 2.6)),
                              ::zxtest::Values(std::tuple("a", "b")));
  std::vector<std::tuple<std::tuple<int, int>, std::tuple<int, int>, std::tuple<double, double>,
                         std::tuple<const char*, const char*>>>
      e4 = {
          std::tuple(std::tuple(10, 11), std::tuple(15, 16), std::tuple(1.5, 1.6),
                     std::tuple("a", "b")),
          std::tuple(std::tuple(10, 11), std::tuple(15, 16), std::tuple(2.5, 2.6),
                     std::tuple("a", "b")),
          std::tuple(std::tuple(10, 11), std::tuple(25, 26), std::tuple(1.5, 1.6),
                     std::tuple("a", "b")),
          std::tuple(std::tuple(10, 11), std::tuple(25, 26), std::tuple(2.5, 2.6),
                     std::tuple("a", "b")),
          std::tuple(std::tuple(20, 21), std::tuple(15, 16), std::tuple(1.5, 1.6),
                     std::tuple("a", "b")),
          std::tuple(std::tuple(20, 21), std::tuple(15, 16), std::tuple(2.5, 2.6),
                     std::tuple("a", "b")),
          std::tuple(std::tuple(20, 21), std::tuple(25, 26), std::tuple(1.5, 1.6),
                     std::tuple("a", "b")),
          std::tuple(std::tuple(20, 21), std::tuple(25, 26), std::tuple(2.5, 2.6),
                     std::tuple("a", "b")),
      };
  ZX_ASSERT_MSG(c4.size() == e4.size(), "Provider size should be %zu, got %zu.", e4.size(),
                c4.size());

  c_size = std::tuple_size<std::remove_reference<decltype(c4[0])>::type>::value;
  e_size = std::tuple_size<std::remove_reference<decltype(e4[0])>::type>::value;
  ZX_ASSERT_MSG(c_size == e_size, "Size is wrong: got %zu, expected %zu", c_size, e_size);

  for (size_t i = 0; i < c4.size(); ++i) {
    ZX_ASSERT(std::get<0>(e4[i]) == std::get<0>(c4[i]));
    ZX_ASSERT(std::get<1>(e4[i]) == std::get<1>(c4[i]));
    ZX_ASSERT(std::get<2>(e4[i]) == std::get<2>(c4[i]));
    ZX_ASSERT(std::get<3>(e4[i]) == std::get<3>(c4[i]));
  }

  // Mixed
  auto c5 = ::zxtest::Combine(::zxtest::Values(std::tuple(10, 11), std::tuple(20, 21)),
                              ::zxtest::Values(std::tuple(15, 16), std::tuple(25, 26)),
                              ::zxtest::Values(1.5, 2.5), ::zxtest::Values(std::tuple("a", "b")));
  std::vector<std::tuple<std::tuple<int, int>, std::tuple<int, int>, double,
                         std::tuple<const char*, const char*>>>
      e5 = {
          std::tuple(std::tuple(10, 11), std::tuple(15, 16), 1.5, std::tuple("a", "b")),
          std::tuple(std::tuple(10, 11), std::tuple(15, 16), 2.5, std::tuple("a", "b")),
          std::tuple(std::tuple(10, 11), std::tuple(25, 26), 1.5, std::tuple("a", "b")),
          std::tuple(std::tuple(10, 11), std::tuple(25, 26), 2.5, std::tuple("a", "b")),
          std::tuple(std::tuple(20, 21), std::tuple(15, 16), 1.5, std::tuple("a", "b")),
          std::tuple(std::tuple(20, 21), std::tuple(15, 16), 2.5, std::tuple("a", "b")),
          std::tuple(std::tuple(20, 21), std::tuple(25, 26), 1.5, std::tuple("a", "b")),
          std::tuple(std::tuple(20, 21), std::tuple(25, 26), 2.5, std::tuple("a", "b")),
      };
  ZX_ASSERT_MSG(c5.size() == e5.size(), "Provider size should be %zu, got %zu.", e5.size(),
                c5.size());

  c_size = std::tuple_size<std::remove_reference<decltype(c5[0])>::type>::value;
  e_size = std::tuple_size<std::remove_reference<decltype(e5[0])>::type>::value;
  ZX_ASSERT_MSG(c_size == e_size, "Size is wrong: got %zu, expected %zu", c_size, e_size);

  for (size_t i = 0; i < c5.size(); ++i) {
    ZX_ASSERT(std::get<0>(e5[i]) == std::get<0>(c5[i]));
    ZX_ASSERT(std::get<1>(e5[i]) == std::get<1>(c5[i]));
    ZX_ASSERT(std::get<2>(e5[i]) == std::get<2>(c5[i]));
    ZX_ASSERT(std::get<3>(e5[i]) == std::get<3>(c5[i]));
  }
}
}  // namespace zxtest::test