Fixing whitespace problems

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@111767 91177308-0d34-0410-b5e6-96231b3b80d8

test/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp

@@ -1 +1,31 @@
-//===----------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// allocator:
+
+// template <class T1, class T2>
+//   bool
+//   operator==(const allocator<T1>&, const allocator<T2>&) throw();
+//
+// template <class T1, class T2>
+//   bool
+//   operator!=(const allocator<T1>&, const allocator<T2>&) throw();
+
+#include <memory>
+#include <cassert>
+
+int main()
+{
+    std::allocator<int> a1;
+    std::allocator<int> a2;
+    assert(a1 == a2);
+    assert(!(a1 != a2));
+}

test/utilities/memory/default.allocator/allocator.members/address.pass.cpp

@@ -1 +1,39 @@
-//===----------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// allocator:
+// pointer address(reference x) const;
+// const_pointer address(const_reference x) const;
+
+#include <memory>
+#include <cassert>
+
+template <class T>
+void test_address()
+{
+    T* tp = new T();
+    const T* ctp = tp;
+    const std::allocator<T> a;
+    assert(a.address(*tp) == tp);
+    assert(a.address(*ctp) == tp);
+    delete tp;
+}
+
+struct A
+{
+    void operator&() const {}
+};
+
+int main()
+{
+    test_address<int>();
+    test_address<A>();
+}

test/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp

@@ -1 +1,63 @@
-//===----------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// allocator:
+// pointer allocate(size_type n, allocator<void>::const_pointer hint=0);
+
+#include <memory>
+#include <new>
+#include <cstdlib>
+#include <cassert>
+
+int new_called = 0;
+
+void* operator new(std::size_t s) throw(std::bad_alloc)
+{
+    ++new_called;
+    assert(s == 3 * sizeof(int));
+    return std::malloc(s);
+}
+
+void  operator delete(void* p) throw()
+{
+    --new_called;
+    std::free(p);
+}
+
+int A_constructed = 0;
+
+struct A
+{
+    int data;
+    A() {++A_constructed;}
+    A(const A&) {++A_constructed;}
+    ~A() {--A_constructed;}
+};
+
+int main()
+{
+    std::allocator<A> a;
+    assert(new_called == 0);
+    assert(A_constructed == 0);
+    A* ap = a.allocate(3);
+    assert(new_called == 1);
+    assert(A_constructed == 0);
+    a.deallocate(ap, 3);
+    assert(new_called == 0);
+    assert(A_constructed == 0);
+
+    A* ap2 = a.allocate(3, (const void*)5);
+    assert(new_called == 1);
+    assert(A_constructed == 0);
+    a.deallocate(ap2, 3);
+    assert(new_called == 0);
+    assert(A_constructed == 0);
+}

test/utilities/memory/default.allocator/allocator.members/construct.pass.cpp

@@ -1 +1,153 @@
-//===----------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// allocator:
+// template <class... Args> void construct(pointer p, Args&&... args);
+
+#include <memory>
+#include <new>
+#include <cstdlib>
+#include <cassert>
+
+int new_called = 0;
+
+void* operator new(std::size_t s) throw(std::bad_alloc)
+{
+    ++new_called;
+    assert(s == 3 * sizeof(int));
+    return std::malloc(s);
+}
+
+void  operator delete(void* p) throw()
+{
+    --new_called;
+    std::free(p);
+}
+
+int A_constructed = 0;
+
+struct A
+{
+    int data;
+    A() {++A_constructed;}
+
+    A(const A&) {++A_constructed;}
+
+    explicit A(int) {++A_constructed;}
+    A(int, int*) {++A_constructed;}
+
+    ~A() {--A_constructed;}
+};
+
+int move_only_constructed = 0;
+
+class move_only
+{
+    int data;
+#ifdef _LIBCPP_MOVE
+    move_only(const move_only&);
+    move_only& operator=(const move_only&);
+#else  // _LIBCPP_MOVE
+    move_only(move_only&);
+    move_only& operator=(move_only&);
+#endif  // _LIBCPP_MOVE
+
+public:
+
+#ifdef _LIBCPP_MOVE
+    move_only(move_only&&) {++move_only_constructed;}
+    move_only& operator=(move_only&&) {}
+#else  // _LIBCPP_MOVE
+    operator std::__rv<move_only> () {return std::__rv<move_only>(*this);}
+    move_only(std::__rv<move_only>) {++move_only_constructed;}
+#endif  // _LIBCPP_MOVE
+
+    move_only() {++move_only_constructed;}
+    ~move_only() {--move_only_constructed;}
+};
+
+int main()
+{
+    {
+    std::allocator<A> a;
+    assert(new_called == 0);
+    assert(A_constructed == 0);
+
+    A* ap = a.allocate(3);
+    assert(new_called == 1);
+    assert(A_constructed == 0);
+
+    a.construct(ap);
+    assert(new_called == 1);
+    assert(A_constructed == 1);
+
+    a.destroy(ap);
+    assert(new_called == 1);
+    assert(A_constructed == 0);
+
+    a.construct(ap, A());
+    assert(new_called == 1);
+    assert(A_constructed == 1);
+
+    a.destroy(ap);
+    assert(new_called == 1);
+    assert(A_constructed == 0);
+
+    a.construct(ap, 5);
+    assert(new_called == 1);
+    assert(A_constructed == 1);
+
+    a.destroy(ap);
+    assert(new_called == 1);
+    assert(A_constructed == 0);
+
+    a.construct(ap, 5, (int*)0);
+    assert(new_called == 1);
+    assert(A_constructed == 1);
+
+    a.destroy(ap);
+    assert(new_called == 1);
+    assert(A_constructed == 0);
+
+    a.deallocate(ap, 3);
+    assert(new_called == 0);
+    assert(A_constructed == 0);
+    }
+    {
+    std::allocator<move_only> a;
+    assert(new_called == 0);
+    assert(move_only_constructed == 0);
+
+    move_only* ap = a.allocate(3);
+    assert(new_called == 1);
+    assert(move_only_constructed == 0);
+
+    a.construct(ap);
+    assert(new_called == 1);
+    assert(move_only_constructed == 1);
+
+    a.destroy(ap);
+    assert(new_called == 1);
+    assert(move_only_constructed == 0);
+
+    a.construct(ap, move_only());
+    assert(new_called == 1);
+    assert(move_only_constructed == 1);
+
+    a.destroy(ap);
+    assert(new_called == 1);
+    assert(move_only_constructed == 0);
+
+    a.deallocate(ap, 3);
+    assert(new_called == 0);
+    assert(move_only_constructed == 0);
+    }
+}

test/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp

@@ -1 +1,27 @@
-//===----------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// allocator:
+// size_type max_size() const throw();
+
+#include <memory>
+#include <limits>
+#include <cstddef>
+#include <cassert>
+
+int new_called = 0;
+
+int main()
+{
+    const std::allocator<int> a;
+    std::size_t M = a.max_size() * sizeof(int);
+    assert(M > 0xFFFF && M <= std::numeric_limits<std::size_t>::max());
+}

test/utilities/memory/default.allocator/allocator_types.pass.cpp

@@ -1 +1,49 @@
-//===----------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// check nested types:
+
+// template <class T>
+// class allocator
+// {
+// public:
+//     typedef size_t                                size_type;
+//     typedef ptrdiff_t                             difference_type;
+//     typedef T*                                    pointer;
+//     typedef const T*                              const_pointer;
+//     typedef typename add_lvalue_reference<T>::type       reference;
+//     typedef typename add_lvalue_reference<const T>::type const_reference;
+//     typedef T                                     value_type;
+//
+//     template <class U> struct rebind {typedef allocator<U> other;};
+// ...
+// };
+
+#include <memory>
+#include <type_traits>
+#include <cstddef>
+
+int main()
+{
+    static_assert((std::is_same<std::allocator<char>::size_type, std::size_t>::value), "");
+    static_assert((std::is_same<std::allocator<char>::difference_type, std::ptrdiff_t>::value), "");
+    static_assert((std::is_same<std::allocator<char>::pointer, char*>::value), "");
+    static_assert((std::is_same<std::allocator<char>::const_pointer, const char*>::value), "");
+    static_assert((std::is_same<std::allocator<char>::value_type, char>::value), "");
+    static_assert((std::is_same<std::allocator<char>::reference, char&>::value), "");
+    static_assert((std::is_same<std::allocator<char>::const_reference, const char&>::value), "");
+    static_assert((std::is_same<std::allocator<char>::rebind<int>::other,
+                                std::allocator<int> >::value), "");
+    std::allocator<char> a;
+    std::allocator<char> a2 = a;
+    a2 = a;
+    std::allocator<int> a3 = a2;
+}

test/utilities/memory/default.allocator/allocator_void.pass.cpp

@@ -1 +1,36 @@
-//===----------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// template <>
+// class allocator<void>
+// {
+// public:
+//     typedef void*                                 pointer;
+//     typedef const void*                           const_pointer;
+//     typedef void                                  value_type;
+//
+//     template <class _Up> struct rebind {typedef allocator<_Up> other;};
+// };
+
+#include <memory>
+#include <type_traits>
+
+int main()
+{
+    static_assert((std::is_same<std::allocator<void>::pointer, void*>::value), "");
+    static_assert((std::is_same<std::allocator<void>::const_pointer, const void*>::value), "");
+    static_assert((std::is_same<std::allocator<void>::value_type, void>::value), "");
+    static_assert((std::is_same<std::allocator<void>::rebind<int>::other,
+                                std::allocator<int> >::value), "");
+    std::allocator<void> a;
+    std::allocator<void> a2 = a;
+    a2 = a;
+}