[libc++][test] add vector<bool>::reference tests

[philnik]

Summary

Add test coverage for vector<bool>::reference

[• Quuxplusone]

Thanks for doing this!

libcxx/test/std/containers/sequences/vector.bool/reference/assign.pass.cpp

1 ↗

(On Diff #401613)

Naming-wise, IMO we should have assign_bool.pass.cpp and assign_copy.pass.cpp, or something along those lines: the important things are to put the name of the overload set first so that everything in the same overload set sorts together when you ls, and the parameter types explicitly afterward so that you can tell which file contains the overload you care about today.

Functionality-wise, I'd like to see a test that assigns false as well as true; and I'd like to see it come ready-made for constexprifying. Something like:

bool test() {
  std::vector<bool> vec;
  typedef std::vector<bool>::reference Ref;
  vec.push_back(true);
  vec.push_back(false);
  vec.push_back(true);
  vec.push_back(false);
  Ref r0 = vec[0];
  Ref r1 = vec[1];
  {
    vec[0] = false;
    vec[1] = true;
    r0 = r1;
    assert(vec[0]);
    assert(vec[1]);
  }
  {
    vec[0] = true;
    vec[1] = false;
    r0 = r1;
    assert(!vec[0]);
    assert(!vec[1]);
  }
  // And then repeat the same two tests for `std::move(r1)`?
  // And then repeat the same two tests for `static_cast<const Ref&>(r1)`??
  return true;
}

int main(int, char**) {
  test();
  // when constexpr vector is implemented, all we have to do is static_assert(test());

  return 0;
}

All your mains should end with return 0; as well as taking argc, argv, because freestanding wants that.

libcxx/test/std/containers/sequences/vector.bool/reference/copy_ctor.pass.cpp

1 ↗

(On Diff #401613)

ctor_copy.pass.cpp or something along those lines.

Btw, I think it'd be nice also to have some trivial-special-member tests, e.g.

LIBCPP_STATIC_ASSERT(!std::is_trivially_constructible<Ref>::value, "");
LIBCPP_STATIC_ASSERT(!std::is_trivially_copy_constructible<Ref>::value, "");
LIBCPP_STATIC_ASSERT(!std::is_trivially_move_constructible<Ref>::value, "");
LIBCPP_STATIC_ASSERT(!std::is_trivially_copy_assignable<Ref>::value, "");
LIBCPP_STATIC_ASSERT(!std::is_trivially_move_assignable<Ref>::value, "");
LIBCPP_STATIC_ASSERT(!std::is_trivially_destructible<Ref>::value, "");

just so we don't break those ABIs by accident. These can go into something like reference/triviality.compile.pass.cpp.

libcxx/test/std/containers/sequences/vector.bool/reference/flip.pass.cpp

24

Let's test !vec[0] directly, and also test that e.g. vec[1] remains unmodified.

libcxx/test/std/containers/sequences/vector.bool/reference/operator_bool.pass.cpp

25

Throw in a static_assert(std::is_convertible<Ref, bool>::value, ""); somewhere near the top.
Test a simple bool b = true_ref; assert(b); because I believe all you're testing right now is contextual conversion to bool, and actually it looks like the standard requires implicit conversion, so we should test an implicit conversion.

[philnik]

• Address comments

[• Quuxplusone]

LGTM % a couple last nits!

libcxx/test/std/containers/sequences/vector.bool/reference/assign_bool.pass.cpp

25

Here as well, please test with both true and false.

libcxx/test/std/containers/sequences/vector.bool/reference/ctor_copy.pass.cpp

23

This test feels insufficient — it's just testing that ref2 refers to some true boolean, not that it refers to the same vec[0] "object" — but I have no great ideas for what would be better here. (We want to test &ref == &ref2 but of course that doesn't work because vector<bool>.)

libcxx/test/std/containers/sequences/vector.bool/reference/flip.pass.cpp

24

IMO you could remove assert(!ref) and assert(ref) at this point (lines 22-24, 26, 30), but this is fine too.

[philnik]

• Address comments

[philnik]

• Rebased
• Fix CI

[• Quuxplusone]

libcxx/test/std/containers/sequences/vector.bool/reference/ctor_copy.pass.cpp

23

I guess what you could do here is

Ref ref2 = ref;
assert(ref == ref2 && ref2 == true);
ref.flip();
assert(ref == ref2 && ref2 == false);

No biggie.

[philnik]

• Update ctor_copy.pass.cpp

[ldionne]

I only skimmed but this looks OK. I'm surprised we didn't have any tests for that. Please just make sure you looked carefully to avoid duplicating tests that might already exist, but if that's really adding coverage, thanks a lot for doing this!

libcxx/test/std/containers/sequences/vector.bool/reference/assign_bool.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// reference& operator=(bool)
+
+#include <cassert>
+#include <vector>
+
+bool test() {
+  std::vector<bool> vec;
+  typedef std::vector<bool>::reference Ref;
+  vec.push_back(true);
+  vec.push_back(false);
+  Ref ref = vec[0];
+  const Ref cref = vec[0];
+
+  assert(ref);
+  ref = false;
+  assert(!vec[0]);
+  assert(!vec[1]);
+  ref = true;
+  assert(vec[0]);
+  assert(!vec[1]);
+
+  assert(cref);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

libcxx/test/std/containers/sequences/vector.bool/reference/assign_copy.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// reference& operator=(const reference&)
+
+#include <cassert>
+#include <vector>
+
+bool test() {
+  std::vector<bool> vec;
+  typedef std::vector<bool>::reference Ref;
+  vec.push_back(true);
+  vec.push_back(false);
+  Ref ref1 = vec[0];
+  Ref ref2 = vec[1];
+  ref2 = ref1;
+  // Ref&
+  {
+    vec[0] = false;
+    vec[1] = true;
+    ref1 = ref2;
+    assert(vec[0]);
+    assert(vec[1]);
+  }
+  {
+    vec[0] = true;
+    vec[1] = false;
+    ref1 = ref2;
+    assert(!vec[0]);
+    assert(!vec[1]);
+  }
+  // Ref&&
+  {
+    vec[0] = false;
+    vec[1] = true;
+    ref1 = std::move(ref2);
+    assert(vec[0]);
+    assert(vec[1]);
+  }
+  {
+    vec[0] = true;
+    vec[1] = false;
+    ref1 = std::move(ref2);
+    assert(!vec[0]);
+    assert(!vec[1]);
+  }
+  // const Ref&
+  {
+    vec[0] = false;
+    vec[1] = true;
+    ref1 = static_cast<const Ref&>(ref2);
+    assert(vec[0]);
+    assert(vec[1]);
+  }
+  {
+    vec[0] = true;
+    vec[1] = false;
+    ref1 = static_cast<const Ref&>(ref2);
+    assert(!vec[0]);
+    assert(!vec[1]);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

libcxx/test/std/containers/sequences/vector.bool/reference/ctor_copy.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// reference(const reference&)
+
+#include <cassert>
+#include <vector>
+
+bool test() {
+  std::vector<bool> vec;
+  typedef std::vector<bool>::reference Ref;
+  vec.push_back(true);
+  Ref ref = vec[0];
+  Ref ref2 = ref;
+  assert(ref == ref2 && ref2);
+  ref.flip();
+  assert(ref == ref2 && !ref2);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

libcxx/test/std/containers/sequences/vector.bool/reference/flip.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// flip()
+
+#include <cassert>
+#include <vector>
+
+bool test() {
+  std::vector<bool> vec;
+  typedef std::vector<bool>::reference Ref;
+  vec.push_back(true);
+  vec.push_back(false);
+  Ref ref = vec[0];
+  assert(vec[0]);
+  assert(!vec[1]);
+  ref.flip();
+  assert(!vec[0]);
+  assert(!vec[1]);
+  ref.flip();
+  assert(vec[0]);
+  assert(!vec[1]);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

libcxx/test/std/containers/sequences/vector.bool/reference/operator_bool.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// operator bool()
+
+#include <cassert>
+#include <type_traits>
+#include <vector>
+
+bool test() {
+  std::vector<bool> vec;
+  typedef std::vector<bool>::reference Ref;
+  static_assert(std::is_convertible<Ref, bool>::value, "");
+
+  vec.push_back(true);
+  vec.push_back(false);
+  Ref true_ref = vec[0];
+  Ref false_ref = vec[1];
+  bool b = true_ref;
+  assert(b);
+  assert(true_ref);
+  assert(!false_ref);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}

libcxx/test/std/containers/sequences/vector.bool/reference/triviality.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <type_traits>
+#include <vector>
+
+#include "test_macros.h"
+
+using Ref = std::vector<bool>::reference;
+
+LIBCPP_STATIC_ASSERT(!std::is_trivially_constructible<Ref>::value, "");
+LIBCPP_STATIC_ASSERT(std::is_trivially_copy_constructible<Ref>::value, "");
+LIBCPP_STATIC_ASSERT(std::is_trivially_move_constructible<Ref>::value, "");
+LIBCPP_STATIC_ASSERT(!std::is_trivially_copy_assignable<Ref>::value, "");
+LIBCPP_STATIC_ASSERT(!std::is_trivially_move_assignable<Ref>::value, "");
+LIBCPP_STATIC_ASSERT(std::is_trivially_destructible<Ref>::value, "");