test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // <vector>
  11
  12 // void push_back(value_type&& x);
  13
  14 #include <vector>
  15 #include <cassert>
  16 #include <cstddef>
  17 #include "MoveOnly.h"
  18 #include "test_allocator.h"
  19 #include "min_allocator.h"
  20 #include "asan_testing.h"
  21
  22 int main()
  23 {
  24 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
  25     {
  26         std::vector<MoveOnly> c;
  27         c.push_back(MoveOnly(0));
  28         assert(c.size() == 1);
  29         assert(is_contiguous_container_asan_correct(c));
  30         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
  31             assert(c[j] == MoveOnly(j));
  32         c.push_back(MoveOnly(1));
  33         assert(c.size() == 2);
  34         assert(is_contiguous_container_asan_correct(c));
  35         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
  36             assert(c[j] == MoveOnly(j));
  37         c.push_back(MoveOnly(2));
  38         assert(c.size() == 3);
  39         assert(is_contiguous_container_asan_correct(c));
  40         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
  41             assert(c[j] == MoveOnly(j));
  42         c.push_back(MoveOnly(3));
  43         assert(c.size() == 4);
  44         assert(is_contiguous_container_asan_correct(c));
  45         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
  46             assert(c[j] == MoveOnly(j));
  47         c.push_back(MoveOnly(4));
  48         assert(c.size() == 5);
  49         assert(is_contiguous_container_asan_correct(c));
  50         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
  51             assert(c[j] == MoveOnly(j));
  52     }
  53     {
  54         // libc++ needs 15 because it grows by 2x (1 + 2 + 4 + 8).
  55         // Use 17 for implementations that dynamically allocate a container proxy
  56         // and grow by 1.5x (1 for proxy + 1 + 2 + 3 + 4 + 6).
  57         std::vector<MoveOnly, limited_allocator<MoveOnly, 17> > c;
  58         c.push_back(MoveOnly(0));
  59         assert(c.size() == 1);
  60         assert(is_contiguous_container_asan_correct(c));
  61         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
  62             assert(c[j] == MoveOnly(j));
  63         c.push_back(MoveOnly(1));
  64         assert(c.size() == 2);
  65         assert(is_contiguous_container_asan_correct(c));
  66         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
  67             assert(c[j] == MoveOnly(j));
  68         c.push_back(MoveOnly(2));
  69         assert(c.size() == 3);
  70         assert(is_contiguous_container_asan_correct(c));
  71         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
  72             assert(c[j] == MoveOnly(j));
  73         c.push_back(MoveOnly(3));
  74         assert(c.size() == 4);
  75         assert(is_contiguous_container_asan_correct(c));
  76         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
  77             assert(c[j] == MoveOnly(j));
  78         c.push_back(MoveOnly(4));
  79         assert(c.size() == 5);
  80         assert(is_contiguous_container_asan_correct(c));
  81         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
  82             assert(c[j] == MoveOnly(j));
  83     }
  84 #if TEST_STD_VER >= 11
  85     {
  86         std::vector<MoveOnly, min_allocator<MoveOnly>> c;
  87         c.push_back(MoveOnly(0));
  88         assert(c.size() == 1);
  89         assert(is_contiguous_container_asan_correct(c));
  90         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
  91             assert(c[j] == MoveOnly(j));
  92         c.push_back(MoveOnly(1));
  93         assert(c.size() == 2);
  94         assert(is_contiguous_container_asan_correct(c));
  95         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
  96             assert(c[j] == MoveOnly(j));
  97         c.push_back(MoveOnly(2));
  98         assert(c.size() == 3);
  99         assert(is_contiguous_container_asan_correct(c));
 100         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
 101             assert(c[j] == MoveOnly(j));
 102         c.push_back(MoveOnly(3));
 103         assert(c.size() == 4);
 104         assert(is_contiguous_container_asan_correct(c));
 105         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
 106             assert(c[j] == MoveOnly(j));
 107         c.push_back(MoveOnly(4));
 108         assert(c.size() == 5);
 109         assert(is_contiguous_container_asan_correct(c));
 110         for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
 111             assert(c[j] == MoveOnly(j));
 112     }
 113 #endif
 114 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 115 }