Wiped out some non-ascii characters that snuck into the copyright.

llvm-svn: 103516

7 files changed, 7 insertions, 7 deletions

diff --git a/libcxx/test/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp b/libcxx/test/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp
index fd462640f83..49d39da4034 100644
--- a/libcxx/test/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp
+++ b/libcxx/test/utilities/memory/default.allocator/allocator.globals/eq.pass.cpp
@@ -1 +1 @@
-//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚ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));
}
\ No newline at end of file
+//===----------------------------------------------------------------------===//
//
//                     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));
}
\ No newline at end of file
diff --git a/libcxx/test/utilities/memory/default.allocator/allocator.members/address.pass.cpp b/libcxx/test/utilities/memory/default.allocator/allocator.members/address.pass.cpp
index a434c7e5b56..c14607f6cfb 100644
--- a/libcxx/test/utilities/memory/default.allocator/allocator.members/address.pass.cpp
+++ b/libcxx/test/utilities/memory/default.allocator/allocator.members/address.pass.cpp
@@ -1 +1 @@
-//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚ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>();
}
\ No newline at end of file
+//===----------------------------------------------------------------------===//
//
//                     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>();
}
\ No newline at end of file
diff --git a/libcxx/test/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp b/libcxx/test/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
index 9856770a5f0..161d3835b3f 100644
--- a/libcxx/test/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
+++ b/libcxx/test/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
@@ -1 +1 @@
-//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚ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);
}
\ No newline at end of file
+//===----------------------------------------------------------------------===//
//
//                     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);
}
\ No newline at end of file
diff --git a/libcxx/test/utilities/memory/default.allocator/allocator.members/construct.pass.cpp b/libcxx/test/utilities/memory/default.allocator/allocator.members/construct.pass.cpp
index 6718d10b1f6..bf6e20ab1f6 100644
--- a/libcxx/test/utilities/memory/default.allocator/allocator.members/construct.pass.cpp
+++ b/libcxx/test/utilities/memory/default.allocator/allocator.members/construct.pass.cpp
@@ -1 +1 @@
-//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚ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
    move_only(move_only&);
    move_only& operator=(move_only&);
#endif

public:

#ifdef _LIBCPP_MOVE
    move_only(move_only&&) {++move_only_constructed;}
    move_only& operator=(move_only&&) {}
#else
    operator std::__rv<move_only> () {return std::__rv<move_only>(*this);}
    move_only(std::__rv<move_only>) {++move_only_constructed;}
#endif

    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);
    }
}
\ No newline at end of file
+//===----------------------------------------------------------------------===//
//
//                     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
    move_only(move_only&);
    move_only& operator=(move_only&);
#endif

public:

#ifdef _LIBCPP_MOVE
    move_only(move_only&&) {++move_only_constructed;}
    move_only& operator=(move_only&&) {}
#else
    operator std::__rv<move_only> () {return std::__rv<move_only>(*this);}
    move_only(std::__rv<move_only>) {++move_only_constructed;}
#endif

    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);
    }
}
\ No newline at end of file
diff --git a/libcxx/test/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp b/libcxx/test/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp
index b6736ec3530..eb596f42f2c 100644
--- a/libcxx/test/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp
+++ b/libcxx/test/utilities/memory/default.allocator/allocator.members/max_size.pass.cpp
@@ -1 +1 @@
-//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚ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());
}
\ No newline at end of file
+//===----------------------------------------------------------------------===//
//
//                     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());
}
\ No newline at end of file
diff --git a/libcxx/test/utilities/memory/default.allocator/allocator_types.pass.cpp b/libcxx/test/utilities/memory/default.allocator/allocator_types.pass.cpp
index e3ac76514a7..7ee46ff06fc 100644
--- a/libcxx/test/utilities/memory/default.allocator/allocator_types.pass.cpp
+++ b/libcxx/test/utilities/memory/default.allocator/allocator_types.pass.cpp
@@ -1 +1 @@
-//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚ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;
}
\ No newline at end of file
+//===----------------------------------------------------------------------===//
//
//                     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;
}
\ No newline at end of file
diff --git a/libcxx/test/utilities/memory/default.allocator/allocator_void.pass.cpp b/libcxx/test/utilities/memory/default.allocator/allocator_void.pass.cpp
index 9d948fbb82d..79b0690f3a9 100644
--- a/libcxx/test/utilities/memory/default.allocator/allocator_void.pass.cpp
+++ b/libcxx/test/utilities/memory/default.allocator/allocator_void.pass.cpp
@@ -1 +1 @@
-//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚ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;
}
\ No newline at end of file
+//===----------------------------------------------------------------------===//
//
//                     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;
}
\ No newline at end of file