libcxx/test/std/containers/sequences/vector.bool/move.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // UNSUPPORTED: c++98, c++03
  10
  11 // <vector>
  12
  13 // vector(vector&& c);
  14
  15 #include <vector>
  16 #include <cassert>
  17 #include "test_macros.h"
  18 #include "test_allocator.h"
  19 #include "min_allocator.h"
  20
  21 int main(int, char**)
  22 {
  23     {
  24         std::vector<bool, test_allocator<bool> > l(test_allocator<bool>(5));
  25         std::vector<bool, test_allocator<bool> > lo(test_allocator<bool>(5));
  26         for (int i = 1; i <= 3; ++i)
  27         {
  28             l.push_back(true);
  29             lo.push_back(true);
  30         }
  31         std::vector<bool, test_allocator<bool> > l2 = std::move(l);
  32         assert(l2 == lo);
  33         assert(l.empty());
  34         assert(l2.get_allocator() == lo.get_allocator());
  35     }
  36     {
  37         std::vector<bool, other_allocator<bool> > l(other_allocator<bool>(5));
  38         std::vector<bool, other_allocator<bool> > lo(other_allocator<bool>(5));
  39         for (int i = 1; i <= 3; ++i)
  40         {
  41             l.push_back(true);
  42             lo.push_back(true);
  43         }
  44         std::vector<bool, other_allocator<bool> > l2 = std::move(l);
  45         assert(l2 == lo);
  46         assert(l.empty());
  47         assert(l2.get_allocator() == lo.get_allocator());
  48     }
  49     {
  50         std::vector<bool, min_allocator<bool> > l(min_allocator<bool>{});
  51         std::vector<bool, min_allocator<bool> > lo(min_allocator<bool>{});
  52         for (int i = 1; i <= 3; ++i)
  53         {
  54             l.push_back(true);
  55             lo.push_back(true);
  56         }
  57         std::vector<bool, min_allocator<bool> > l2 = std::move(l);
  58         assert(l2 == lo);
  59         assert(l.empty());
  60         assert(l2.get_allocator() == lo.get_allocator());
  61     }
  62     {
  63       test_alloc_base::clear();
  64       using Vect = std::vector<bool, test_allocator<bool> >;
  65       using AllocT = Vect::allocator_type;
  66       Vect v(test_allocator<bool>(42, 101));
  67       assert(test_alloc_base::count == 1);
  68       {
  69         const AllocT& a = v.get_allocator();
  70         assert(test_alloc_base::count == 2);
  71         assert(a.get_data() == 42);
  72         assert(a.get_id() == 101);
  73       }
  74       assert(test_alloc_base::count == 1);
  75       test_alloc_base::clear_ctor_counters();
  76
  77       Vect v2 = std::move(v);
  78       assert(test_alloc_base::count == 2);
  79       assert(test_alloc_base::copied == 0);
  80       assert(test_alloc_base::moved == 1);
  81       {
  82         const AllocT& a = v.get_allocator();
  83         assert(a.get_id() == test_alloc_base::moved_value);
  84         assert(a.get_data() == test_alloc_base::moved_value);
  85       }
  86       {
  87         const AllocT& a = v2.get_allocator();
  88         assert(a.get_id() == 101);
  89         assert(a.get_data() == 42);
  90       }
  91     }
  92
  93   return 0;
  94 }