diff options
| author | Howard Hinnant <hhinnant@apple.com> | 2010-05-11 19:42:16 +0000 |
|---|---|---|
| committer | Howard Hinnant <hhinnant@apple.com> | 2010-05-11 19:42:16 +0000 |
| commit | 3e519524c118651123eecf60c2bbc5d65ad9bac3 (patch) | |
| tree | b2dd4168cfe448920a602cd7d2e40f95da187153 /libcxx/test/utilities/function.objects | |
| parent | 9132c59d43b6c590c9bb33496eebf9f192d6857a (diff) | |
| download | bcm5719-llvm-3e519524c118651123eecf60c2bbc5d65ad9bac3.tar.gz bcm5719-llvm-3e519524c118651123eecf60c2bbc5d65ad9bac3.zip | |
libcxx initial import
llvm-svn: 103490
Diffstat (limited to 'libcxx/test/utilities/function.objects')
110 files changed, 400 insertions, 0 deletions
diff --git a/libcxx/test/utilities/function.objects/arithmetic.operations/divides.pass.cpp b/libcxx/test/utilities/function.objects/arithmetic.operations/divides.pass.cpp new file mode 100644 index 00000000000..1b05252d9cb --- /dev/null +++ b/libcxx/test/utilities/function.objects/arithmetic.operations/divides.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// divides
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::divides<int> F;
const F f = F();
static_assert((std::is_base_of<std::binary_function<int, int, int>, F>::value), "");
assert(f(36, 4) == 9);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/arithmetic.operations/minus.pass.cpp b/libcxx/test/utilities/function.objects/arithmetic.operations/minus.pass.cpp new file mode 100644 index 00000000000..0667c9b39a0 --- /dev/null +++ b/libcxx/test/utilities/function.objects/arithmetic.operations/minus.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// minus
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::minus<int> F;
const F f = F();
static_assert((std::is_base_of<std::binary_function<int, int, int>, F>::value), "");
assert(f(3, 2) == 1);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/arithmetic.operations/modulus.pass.cpp b/libcxx/test/utilities/function.objects/arithmetic.operations/modulus.pass.cpp new file mode 100644 index 00000000000..4d8b4158ae0 --- /dev/null +++ b/libcxx/test/utilities/function.objects/arithmetic.operations/modulus.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// modulus
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::modulus<int> F;
const F f = F();
static_assert((std::is_base_of<std::binary_function<int, int, int>, F>::value), "");
assert(f(36, 8) == 4);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp b/libcxx/test/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp new file mode 100644 index 00000000000..4a92ef3bd18 --- /dev/null +++ b/libcxx/test/utilities/function.objects/arithmetic.operations/multiplies.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// multiplies
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::multiplies<int> F;
const F f = F();
static_assert((std::is_base_of<std::binary_function<int, int, int>, F>::value), "");
assert(f(3, 2) == 6);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/arithmetic.operations/negate.pass.cpp b/libcxx/test/utilities/function.objects/arithmetic.operations/negate.pass.cpp new file mode 100644 index 00000000000..832e5b07659 --- /dev/null +++ b/libcxx/test/utilities/function.objects/arithmetic.operations/negate.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// negate
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::negate<int> F;
const F f = F();
static_assert((std::is_base_of<std::unary_function<int, int>, F>::value), "");
assert(f(36) == -36);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/arithmetic.operations/plus.pass.cpp b/libcxx/test/utilities/function.objects/arithmetic.operations/plus.pass.cpp new file mode 100644 index 00000000000..6a6e07eb4a1 --- /dev/null +++ b/libcxx/test/utilities/function.objects/arithmetic.operations/plus.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// plus
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::plus<int> F;
const F f = F();
static_assert((std::is_base_of<std::binary_function<int, int, int>, F>::value), "");
assert(f(3, 2) == 5);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/base/nothing_to_do.pass.cpp b/libcxx/test/utilities/function.objects/base/nothing_to_do.pass.cpp new file mode 100644 index 00000000000..92348261209 --- /dev/null +++ b/libcxx/test/utilities/function.objects/base/nothing_to_do.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp new file mode 100644 index 00000000000..e93043efec3 --- /dev/null +++ b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<CopyConstructible Fn, CopyConstructible... Types>
// unspecified bind(Fn, Types...);
// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
// unspecified bind(Fn, Types...);
#include <functional>
#include <cassert>
template <class R, class F>
void
test(F f, R expected)
{
assert(f() == expected);
}
template <class R, class F>
void
test_const(const F& f, R expected)
{
assert(f() == expected);
}
int f() {return 1;}
struct A_int_0
{
int operator()() {return 4;}
int operator()() const {return 5;}
};
int main()
{
test(std::bind(f), 1);
test(std::bind(&f), 1);
test(std::bind(A_int_0()), 4);
test_const(std::bind(A_int_0()), 5);
test(std::bind<int>(f), 1);
test(std::bind<int>(&f), 1);
test(std::bind<int>(A_int_0()), 4);
test_const(std::bind<int>(A_int_0()), 5);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp new file mode 100644 index 00000000000..8f87a0d98f7 --- /dev/null +++ b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<CopyConstructible Fn, CopyConstructible... Types>
// unspecified bind(Fn, Types...);
// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
// unspecified bind(Fn, Types...);
#include <stdio.h>
#include <functional>
#include <cassert>
int count = 0;
// 1 arg, return void
void f_void_1(int i)
{
count += i;
}
struct A_void_1
{
void operator()(int i)
{
count += i;
}
void mem1() {++count;}
void mem2() const {count += 2;}
};
void
test_void_1()
{
using namespace std::placeholders;
int save_count = count;
// function
{
int i = 2;
std::bind(f_void_1, _1)(i);
assert(count == save_count + 2);
save_count = count;
}
{
int i = 2;
std::bind(f_void_1, i)();
assert(count == save_count + 2);
save_count = count;
}
// function pointer
{
void (*fp)(int) = f_void_1;
int i = 3;
std::bind(fp, _1)(i);
assert(count == save_count+3);
save_count = count;
}
{
void (*fp)(int) = f_void_1;
int i = 3;
std::bind(fp, i)();
assert(count == save_count+3);
save_count = count;
}
// functor
{
A_void_1 a0;
int i = 4;
std::bind(a0, _1)(i);
assert(count == save_count+4);
save_count = count;
}
{
A_void_1 a0;
int i = 4;
std::bind(a0, i)();
assert(count == save_count+4);
save_count = count;
}
// member function pointer
{
void (A_void_1::*fp)() = &A_void_1::mem1;
A_void_1 a;
std::bind(fp, _1)(a);
assert(count == save_count+1);
save_count = count;
A_void_1* ap = &a;
std::bind(fp, _1)(ap);
assert(count == save_count+1);
save_count = count;
}
{
void (A_void_1::*fp)() = &A_void_1::mem1;
A_void_1 a;
std::bind(fp, a)();
assert(count == save_count+1);
save_count = count;
A_void_1* ap = &a;
std::bind(fp, ap)();
assert(count == save_count+1);
save_count = count;
}
// const member function pointer
{
void (A_void_1::*fp)() const = &A_void_1::mem2;
A_void_1 a;
std::bind(fp, _1)(a);
assert(count == save_count+2);
save_count = count;
A_void_1* ap = &a;
std::bind(fp, _1)(ap);
assert(count == save_count+2);
save_count = count;
}
{
void (A_void_1::*fp)() const = &A_void_1::mem2;
A_void_1 a;
std::bind(fp, a)();
assert(count == save_count+2);
save_count = count;
A_void_1* ap = &a;
std::bind(fp, ap)();
assert(count == save_count+2);
save_count = count;
}
}
// 1 arg, return int
int f_int_1(int i)
{
return i + 1;
}
struct A_int_1
{
A_int_1() : data_(5) {}
int operator()(int i)
{
return i - 1;
}
int mem1() {return 3;}
int mem2() const {return 4;}
int data_;
};
void
test_int_1()
{
using namespace std::placeholders;
// function
{
int i = 2;
assert(std::bind(f_int_1, _1)(i) == 3);
assert(std::bind(f_int_1, i)() == 3);
}
// function pointer
{
int (*fp)(int) = f_int_1;
int i = 3;
assert(std::bind(fp, _1)(i) == 4);
assert(std::bind(fp, i)() == 4);
}
// functor
{
int i = 4;
assert(std::bind(A_int_1(), _1)(i) == 3);
assert(std::bind(A_int_1(), i)() == 3);
}
// member function pointer
{
A_int_1 a;
assert(std::bind(&A_int_1::mem1, _1)(a) == 3);
assert(std::bind(&A_int_1::mem1, a)() == 3);
A_int_1* ap = &a;
assert(std::bind(&A_int_1::mem1, _1)(ap) == 3);
assert(std::bind(&A_int_1::mem1, ap)() == 3);
}
// const member function pointer
{
A_int_1 a;
assert(std::bind(&A_int_1::mem2, _1)(A_int_1()) == 4);
assert(std::bind(&A_int_1::mem2, A_int_1())() == 4);
A_int_1* ap = &a;
assert(std::bind(&A_int_1::mem2, _1)(ap) == 4);
assert(std::bind(&A_int_1::mem2, ap)() == 4);
}
// member data pointer
{
A_int_1 a;
assert(std::bind(&A_int_1::data_, _1)(a) == 5);
assert(std::bind(&A_int_1::data_, a)() == 5);
A_int_1* ap = &a;
assert(std::bind(&A_int_1::data_, _1)(a) == 5);
std::bind(&A_int_1::data_, _1)(a) = 6;
assert(std::bind(&A_int_1::data_, _1)(a) == 6);
assert(std::bind(&A_int_1::data_, _1)(ap) == 6);
std::bind(&A_int_1::data_, _1)(ap) = 7;
assert(std::bind(&A_int_1::data_, _1)(ap) == 7);
}
}
// 2 arg, return void
void f_void_2(int i, int j)
{
count += i+j;
}
struct A_void_2
{
void operator()(int i, int j)
{
count += i+j;
}
void mem1(int i) {count += i;}
void mem2(int i) const {count += i;}
};
void
test_void_2()
{
using namespace std::placeholders;
int save_count = count;
// function
{
int i = 2;
int j = 3;
std::bind(f_void_2, _1, _2)(i, j);
assert(count == save_count+5);
save_count = count;
std::bind(f_void_2, i, _1)(j);
assert(count == save_count+5);
save_count = count;
std::bind(f_void_2, i, j)();
assert(count == save_count+5);
save_count = count;
}
// member function pointer
{
int j = 3;
std::bind(&A_void_2::mem1, _1, _2)(A_void_2(), j);
assert(count == save_count+3);
save_count = count;
std::bind(&A_void_2::mem1, _2, _1)(j, A_void_2());
assert(count == save_count+3);
save_count = count;
}
}
int main()
{
test_void_1();
test_int_1();
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp new file mode 100644 index 00000000000..1340a0cc89f --- /dev/null +++ b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<CopyConstructible Fn, CopyConstructible... Types>
// unspecified bind(Fn, Types...);
// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
// unspecified bind(Fn, Types...);
#include <stdio.h>
#include <functional>
#include <cassert>
int count = 0;
// 1 arg, return void
void f_void_1(int i)
{
count += i;
}
struct A_void_1
{
void operator()(int i)
{
count += i;
}
void mem1() {++count;}
void mem2() const {count += 2;}
};
void
test_void_1()
{
using namespace std::placeholders;
int save_count = count;
// function
{
std::bind(f_void_1, _1)(2);
assert(count == save_count + 2);
save_count = count;
}
{
std::bind(f_void_1, 2)();
assert(count == save_count + 2);
save_count = count;
}
// function pointer
{
void (*fp)(int) = f_void_1;
std::bind(fp, _1)(3);
assert(count == save_count+3);
save_count = count;
}
{
void (*fp)(int) = f_void_1;
std::bind(fp, 3)();
assert(count == save_count+3);
save_count = count;
}
// functor
{
A_void_1 a0;
std::bind(a0, _1)(4);
assert(count == save_count+4);
save_count = count;
}
{
A_void_1 a0;
std::bind(a0, 4)();
assert(count == save_count+4);
save_count = count;
}
// member function pointer
{
void (A_void_1::*fp)() = &A_void_1::mem1;
std::bind(fp, _1)(A_void_1());
assert(count == save_count+1);
save_count = count;
A_void_1 a;
std::bind(fp, _1)(&a);
assert(count == save_count+1);
save_count = count;
}
{
void (A_void_1::*fp)() = &A_void_1::mem1;
std::bind(fp, A_void_1())();
assert(count == save_count+1);
save_count = count;
A_void_1 a;
std::bind(fp, &a)();
assert(count == save_count+1);
save_count = count;
}
// const member function pointer
{
void (A_void_1::*fp)() const = &A_void_1::mem2;
std::bind(fp, _1)(A_void_1());
assert(count == save_count+2);
save_count = count;
A_void_1 a;
std::bind(fp, _1)(&a);
assert(count == save_count+2);
save_count = count;
}
{
void (A_void_1::*fp)() const = &A_void_1::mem2;
std::bind(fp, A_void_1())();
assert(count == save_count+2);
save_count = count;
A_void_1 a;
std::bind(fp, &a)();
assert(count == save_count+2);
save_count = count;
}
}
// 1 arg, return int
int f_int_1(int i)
{
return i + 1;
}
struct A_int_1
{
A_int_1() : data_(5) {}
int operator()(int i)
{
return i - 1;
}
int mem1() {return 3;}
int mem2() const {return 4;}
int data_;
};
void
test_int_1()
{
using namespace std::placeholders;
// function
{
assert(std::bind(f_int_1, _1)(2) == 3);
assert(std::bind(f_int_1, 2)() == 3);
}
// function pointer
{
int (*fp)(int) = f_int_1;
assert(std::bind(fp, _1)(3) == 4);
assert(std::bind(fp, 3)() == 4);
}
// functor
{
assert(std::bind(A_int_1(), _1)(4) == 3);
assert(std::bind(A_int_1(), 4)() == 3);
}
// member function pointer
{
assert(std::bind(&A_int_1::mem1, _1)(A_int_1()) == 3);
assert(std::bind(&A_int_1::mem1, A_int_1())() == 3);
A_int_1 a;
assert(std::bind(&A_int_1::mem1, _1)(&a) == 3);
assert(std::bind(&A_int_1::mem1, &a)() == 3);
}
// const member function pointer
{
assert(std::bind(&A_int_1::mem2, _1)(A_int_1()) == 4);
assert(std::bind(&A_int_1::mem2, A_int_1())() == 4);
A_int_1 a;
assert(std::bind(&A_int_1::mem2, _1)(&a) == 4);
assert(std::bind(&A_int_1::mem2, &a)() == 4);
}
// member data pointer
{
assert(std::bind(&A_int_1::data_, _1)(A_int_1()) == 5);
assert(std::bind(&A_int_1::data_, A_int_1())() == 5);
A_int_1 a;
assert(std::bind(&A_int_1::data_, _1)(a) == 5);
std::bind(&A_int_1::data_, _1)(a) = 6;
assert(std::bind(&A_int_1::data_, _1)(a) == 6);
assert(std::bind(&A_int_1::data_, _1)(&a) == 6);
std::bind(&A_int_1::data_, _1)(&a) = 7;
assert(std::bind(&A_int_1::data_, _1)(&a) == 7);
}
}
// 2 arg, return void
void f_void_2(int i, int j)
{
count += i+j;
}
struct A_void_2
{
void operator()(int i, int j)
{
count += i+j;
}
void mem1(int i) {count += i;}
void mem2(int i) const {count += i;}
};
void
test_void_2()
{
using namespace std::placeholders;
int save_count = count;
// function
{
std::bind(f_void_2, _1, _2)(2, 3);
assert(count == save_count+5);
save_count = count;
std::bind(f_void_2, 2, _1)(3);
assert(count == save_count+5);
save_count = count;
std::bind(f_void_2, 2, 3)();
assert(count == save_count+5);
save_count = count;
}
// member function pointer
{
std::bind(&A_void_2::mem1, _1, _2)(A_void_2(), 3);
assert(count == save_count+3);
save_count = count;
std::bind(&A_void_2::mem1, _2, _1)(3, A_void_2());
assert(count == save_count+3);
save_count = count;
}
}
int main()
{
test_void_1();
test_int_1();
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp new file mode 100644 index 00000000000..0eb0c0690e8 --- /dev/null +++ b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<CopyConstructible Fn, CopyConstructible... Types>
// unspecified bind(Fn, Types...);
// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
// unspecified bind(Fn, Types...);
#include <functional>
#include <cassert>
int count = 0;
template <class F>
void
test(F f)
{
int save_count = count;
f();
assert(count == save_count + 1);
}
template <class F>
void
test_const(const F& f)
{
int save_count = count;
f();
assert(count == save_count + 2);
}
void f() {++count;}
struct A_int_0
{
void operator()() {++count;}
void operator()() const {count += 2;}
};
int main()
{
test(std::bind(f));
test(std::bind(&f));
test(std::bind(A_int_0()));
test_const(std::bind(A_int_0()));
test(std::bind<void>(f));
test(std::bind<void>(&f));
test(std::bind<void>(A_int_0()));
test_const(std::bind<void>(A_int_0()));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp new file mode 100644 index 00000000000..341cf2748f8 --- /dev/null +++ b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.isbind/is_bind_expression.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<class T> struct is_bind_expression
#include <functional>
template <bool Expected, class T>
void
test(const T&)
{
static_assert(std::is_bind_expression<T>::value == Expected, "");
}
struct C {};
int main()
{
test<true>(std::bind(C()));
test<true>(std::bind(C(), std::placeholders::_2));
test<true>(std::bind<int>(C()));
test<false>(1);
test<false>(std::placeholders::_2);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp new file mode 100644 index 00000000000..eebe80b8ab5 --- /dev/null +++ b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.isbind/is_placeholder.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// struct is_placeholder
#include <functional>
template <int Expected, class T>
void
test(const T&)
{
static_assert(std::is_placeholder<T>::value == Expected, "");
}
struct C {};
int main()
{
test<1>(std::placeholders::_1);
test<2>(std::placeholders::_2);
test<3>(std::placeholders::_3);
test<4>(std::placeholders::_4);
test<5>(std::placeholders::_5);
test<6>(std::placeholders::_6);
test<7>(std::placeholders::_7);
test<8>(std::placeholders::_8);
test<9>(std::placeholders::_9);
test<10>(std::placeholders::_10);
test<0>(4);
test<0>(5.5);
test<0>('a');
test<0>(C());
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp new file mode 100644 index 00000000000..5b54c24120a --- /dev/null +++ b/libcxx/test/utilities/function.objects/bind/func.bind/func.bind.place/placeholders.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// placeholders
#include <functional>
template <class T>
void
test(const T& t)
{
T t2;
T t3 = t;
}
int main()
{
test(std::placeholders::_1);
test(std::placeholders::_2);
test(std::placeholders::_3);
test(std::placeholders::_4);
test(std::placeholders::_5);
test(std::placeholders::_6);
test(std::placeholders::_7);
test(std::placeholders::_8);
test(std::placeholders::_9);
test(std::placeholders::_10);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/bind/func.bind/nothing_to_do.pass.cpp b/libcxx/test/utilities/function.objects/bind/func.bind/nothing_to_do.pass.cpp new file mode 100644 index 00000000000..92348261209 --- /dev/null +++ b/libcxx/test/utilities/function.objects/bind/func.bind/nothing_to_do.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/bind/nothing_to_do.pass.cpp b/libcxx/test/utilities/function.objects/bind/nothing_to_do.pass.cpp new file mode 100644 index 00000000000..92348261209 --- /dev/null +++ b/libcxx/test/utilities/function.objects/bind/nothing_to_do.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/bitwise.operations/bit_and.pass.cpp b/libcxx/test/utilities/function.objects/bitwise.operations/bit_and.pass.cpp new file mode 100644 index 00000000000..6addf35e7d5 --- /dev/null +++ b/libcxx/test/utilities/function.objects/bitwise.operations/bit_and.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// bit_and
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::bit_and<int> F;
const F f = F();
static_assert((std::is_base_of<std::binary_function<int, int, int>, F>::value), "");
assert(f(0xEA95, 0xEA95) == 0xEA95);
assert(f(0xEA95, 0x58D3) == 0x4891);
assert(f(0x58D3, 0xEA95) == 0x4891);
assert(f(0x58D3, 0) == 0);
assert(f(0xFFFF, 0x58D3) == 0x58D3);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/bitwise.operations/bit_or.pass.cpp b/libcxx/test/utilities/function.objects/bitwise.operations/bit_or.pass.cpp new file mode 100644 index 00000000000..ef546841bd7 --- /dev/null +++ b/libcxx/test/utilities/function.objects/bitwise.operations/bit_or.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// bit_or
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::bit_or<int> F;
const F f = F();
static_assert((std::is_base_of<std::binary_function<int, int, int>, F>::value), "");
assert(f(0xEA95, 0xEA95) == 0xEA95);
assert(f(0xEA95, 0x58D3) == 0xFAD7);
assert(f(0x58D3, 0xEA95) == 0xFAD7);
assert(f(0x58D3, 0) == 0x58D3);
assert(f(0xFFFF, 0x58D3) == 0xFFFF);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp b/libcxx/test/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp new file mode 100644 index 00000000000..139763d8816 --- /dev/null +++ b/libcxx/test/utilities/function.objects/bitwise.operations/bit_xor.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// bit_xor
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::bit_xor<int> F;
const F f = F();
static_assert((std::is_base_of<std::binary_function<int, int, int>, F>::value), "");
assert(f(0xEA95, 0xEA95) == 0);
assert(f(0xEA95, 0x58D3) == 0xB246);
assert(f(0x58D3, 0xEA95) == 0xB246);
assert(f(0x58D3, 0) == 0x58D3);
assert(f(0xFFFF, 0x58D3) == 0xA72C);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/comparisons/equal_to.pass.cpp b/libcxx/test/utilities/function.objects/comparisons/equal_to.pass.cpp new file mode 100644 index 00000000000..55796f8276a --- /dev/null +++ b/libcxx/test/utilities/function.objects/comparisons/equal_to.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// equal_to
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::equal_to<int> F;
const F f = F();
static_assert((std::is_base_of<std::binary_function<int, int, bool>, F>::value), "");
assert(f(36, 36));
assert(!f(36, 6));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/comparisons/greater.pass.cpp b/libcxx/test/utilities/function.objects/comparisons/greater.pass.cpp new file mode 100644 index 00000000000..ee36c538cf1 --- /dev/null +++ b/libcxx/test/utilities/function.objects/comparisons/greater.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// greater
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::greater<int> F;
const F f = F();
static_assert((std::is_base_of<std::binary_function<int, int, bool>, F>::value), "");
assert(!f(36, 36));
assert(f(36, 6));
assert(!f(6, 36));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/comparisons/greater_equal.pass.cpp b/libcxx/test/utilities/function.objects/comparisons/greater_equal.pass.cpp new file mode 100644 index 00000000000..a6d114c675b --- /dev/null +++ b/libcxx/test/utilities/function.objects/comparisons/greater_equal.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// greater_equal
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::greater_equal<int> F;
const F f = F();
static_assert((std::is_base_of<std::binary_function<int, int, bool>, F>::value), "");
assert(f(36, 36));
assert(f(36, 6));
assert(!f(6, 36));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/comparisons/less.pass.cpp b/libcxx/test/utilities/function.objects/comparisons/less.pass.cpp new file mode 100644 index 00000000000..6a40ba0491f --- /dev/null +++ b/libcxx/test/utilities/function.objects/comparisons/less.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// less
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::less<int> F;
const F f = F();
static_assert((std::is_base_of<std::binary_function<int, int, bool>, F>::value), "");
assert(!f(36, 36));
assert(!f(36, 6));
assert(f(6, 36));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/comparisons/less_equal.pass.cpp b/libcxx/test/utilities/function.objects/comparisons/less_equal.pass.cpp new file mode 100644 index 00000000000..84976701724 --- /dev/null +++ b/libcxx/test/utilities/function.objects/comparisons/less_equal.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// less_equal
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::less_equal<int> F;
const F f = F();
static_assert((std::is_base_of<std::binary_function<int, int, bool>, F>::value), "");
assert(f(36, 36));
assert(!f(36, 6));
assert(f(6, 36));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/comparisons/not_equal_to.pass.cpp b/libcxx/test/utilities/function.objects/comparisons/not_equal_to.pass.cpp new file mode 100644 index 00000000000..fb99ee56b3a --- /dev/null +++ b/libcxx/test/utilities/function.objects/comparisons/not_equal_to.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// not_equal_to
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::not_equal_to<int> F;
const F f = F();
static_assert((std::is_base_of<std::binary_function<int, int, bool>, F>::value), "");
assert(!f(36, 36));
assert(f(36, 6));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.def/nothing_to_do.pass.cpp b/libcxx/test/utilities/function.objects/func.def/nothing_to_do.pass.cpp new file mode 100644 index 00000000000..92348261209 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.def/nothing_to_do.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.memfn/member_data.fail.cpp b/libcxx/test/utilities/function.objects/func.memfn/member_data.fail.cpp new file mode 100644 index 00000000000..4cc6644809d --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.memfn/member_data.fail.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<Returnable R, class T> unspecified mem_fn(R T::* pm);
#include <functional>
#include <cassert>
struct A
{
double data_;
};
template <class F>
void
test(F f)
{
{
A a;
f(a) = 5;
assert(a.data_ == 5);
A* ap = &a;
f(ap) = 6;
assert(a.data_ == 6);
const A* cap = ap;
assert(f(cap) == f(ap));
f(cap) = 7;
}
}
int main()
{
test(std::mem_fn(&A::data_));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.memfn/member_data.pass.cpp b/libcxx/test/utilities/function.objects/func.memfn/member_data.pass.cpp new file mode 100644 index 00000000000..303097e936e --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.memfn/member_data.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<Returnable R, class T> unspecified mem_fn(R T::* pm);
#include <functional>
#include <cassert>
struct A
{
double data_;
};
template <class F>
void
test(F f)
{
{
A a;
f(a) = 5;
assert(a.data_ == 5);
A* ap = &a;
f(ap) = 6;
assert(a.data_ == 6);
const A* cap = ap;
assert(f(cap) == f(ap));
}
}
int main()
{
test(std::mem_fn(&A::data_));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.memfn/member_function.pass.cpp b/libcxx/test/utilities/function.objects/func.memfn/member_function.pass.cpp new file mode 100644 index 00000000000..774a507a4a4 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.memfn/member_function.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<Returnable R, class T, CopyConstructible... Args>
// unspecified mem_fn(R (T::* pm)(Args...));
#include <functional>
#include <cassert>
struct A
{
char test0() {return 'a';}
char test1(int) {return 'b';}
char test2(int, double) {return 'c';}
};
template <class F>
void
test0(F f)
{
{
A a;
assert(f(a) == 'a');
A* ap = &a;
assert(f(ap) == 'a');
}
}
template <class F>
void
test1(F f)
{
{
A a;
assert(f(a, 1) == 'b');
A* ap = &a;
assert(f(ap, 2) == 'b');
}
}
template <class F>
void
test2(F f)
{
{
A a;
assert(f(a, 1, 2) == 'c');
A* ap = &a;
assert(f(ap, 2, 3.5) == 'c');
}
}
int main()
{
test0(std::mem_fn(&A::test0));
test1(std::mem_fn(&A::test1));
test2(std::mem_fn(&A::test2));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.memfn/member_function_const.pass.cpp b/libcxx/test/utilities/function.objects/func.memfn/member_function_const.pass.cpp new file mode 100644 index 00000000000..b8b24d9c182 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.memfn/member_function_const.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<Returnable R, class T, CopyConstructible... Args>
// unspecified mem_fn(R (T::* pm)(Args...) const);
#include <functional>
#include <cassert>
struct A
{
char test0() const {return 'a';}
char test1(int) const {return 'b';}
char test2(int, double) const {return 'c';}
};
template <class F>
void
test0(F f)
{
{
A a;
assert(f(a) == 'a');
A* ap = &a;
assert(f(ap) == 'a');
const A* cap = &a;
assert(f(cap) == 'a');
}
}
template <class F>
void
test1(F f)
{
{
A a;
assert(f(a, 1) == 'b');
A* ap = &a;
assert(f(ap, 2) == 'b');
const A* cap = &a;
assert(f(cap, 2) == 'b');
}
}
template <class F>
void
test2(F f)
{
{
A a;
assert(f(a, 1, 2) == 'c');
A* ap = &a;
assert(f(ap, 2, 3.5) == 'c');
const A* cap = &a;
assert(f(cap, 2, 3.5) == 'c');
}
}
int main()
{
test0(std::mem_fn(&A::test0));
test1(std::mem_fn(&A::test1));
test2(std::mem_fn(&A::test2));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp b/libcxx/test/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp new file mode 100644 index 00000000000..9523f537bda --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<Returnable R, class T, CopyConstructible... Args>
// unspecified mem_fn(R (T::* pm)(Args...) const volatile);
#include <functional>
#include <cassert>
struct A
{
char test0() const volatile {return 'a';}
char test1(int) const volatile {return 'b';}
char test2(int, double) const volatile {return 'c';}
};
template <class F>
void
test0(F f)
{
{
A a;
assert(f(a) == 'a');
A* ap = &a;
assert(f(ap) == 'a');
const volatile A* cap = &a;
assert(f(cap) == 'a');
}
}
template <class F>
void
test1(F f)
{
{
A a;
assert(f(a, 1) == 'b');
A* ap = &a;
assert(f(ap, 2) == 'b');
const volatile A* cap = &a;
assert(f(cap, 2) == 'b');
}
}
template <class F>
void
test2(F f)
{
{
A a;
assert(f(a, 1, 2) == 'c');
A* ap = &a;
assert(f(ap, 2, 3.5) == 'c');
const volatile A* cap = &a;
assert(f(cap, 2, 3.5) == 'c');
}
}
int main()
{
test0(std::mem_fn(&A::test0));
test1(std::mem_fn(&A::test1));
test2(std::mem_fn(&A::test2));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp b/libcxx/test/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp new file mode 100644 index 00000000000..bf028b3cf13 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<Returnable R, class T, CopyConstructible... Args>
// unspecified mem_fn(R (T::* pm)(Args...) volatile);
#include <functional>
#include <cassert>
struct A
{
char test0() volatile {return 'a';}
char test1(int) volatile {return 'b';}
char test2(int, double) volatile {return 'c';}
};
template <class F>
void
test0(F f)
{
{
A a;
assert(f(a) == 'a');
A* ap = &a;
assert(f(ap) == 'a');
volatile A* cap = &a;
assert(f(cap) == 'a');
}
}
template <class F>
void
test1(F f)
{
{
A a;
assert(f(a, 1) == 'b');
A* ap = &a;
assert(f(ap, 2) == 'b');
volatile A* cap = &a;
assert(f(cap, 2) == 'b');
}
}
template <class F>
void
test2(F f)
{
{
A a;
assert(f(a, 1, 2) == 'c');
A* ap = &a;
assert(f(ap, 2, 3.5) == 'c');
volatile A* cap = &a;
assert(f(cap, 2, 3.5) == 'c');
}
}
int main()
{
test0(std::mem_fn(&A::test0));
test1(std::mem_fn(&A::test1));
test2(std::mem_fn(&A::test2));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.require/binary_function.pass.cpp b/libcxx/test/utilities/function.objects/func.require/binary_function.pass.cpp new file mode 100644 index 00000000000..e03dfe2c71e --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.require/binary_function.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// binary_function
#include <functional>
#include <type_traits>
int main()
{
typedef std::binary_function<int, short, bool> bf;
static_assert((std::is_same<bf::first_argument_type, int>::value), "");
static_assert((std::is_same<bf::second_argument_type, short>::value), "");
static_assert((std::is_same<bf::result_type, bool>::value), "");
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.require/unary_function.pass.cpp b/libcxx/test/utilities/function.objects/func.require/unary_function.pass.cpp new file mode 100644 index 00000000000..b5c944cffb2 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.require/unary_function.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// unary_function
#include <functional>
#include <type_traits>
int main()
{
typedef std::unary_function<int, bool> uf;
static_assert((std::is_same<uf::argument_type, int>::value), "");
static_assert((std::is_same<uf::result_type, bool>::value), "");
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.badcall/bad_function_call.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.badcall/bad_function_call.pass.cpp new file mode 100644 index 00000000000..22af67ebf10 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.badcall/bad_function_call.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// Class bad_function_call
// class bad_function_call
// : public exception
// {
// public:
// // 20.7.16.1.1, constructor:
// bad_function_call();
// };
#include <functional>
#include <type_traits>
int main()
{
static_assert((std::is_base_of<std::exception, std::bad_function_call>::value), "");
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.badcall/func.wrap.badcall.const/bad_function_call_ctor.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.badcall/func.wrap.badcall.const/bad_function_call_ctor.pass.cpp new file mode 100644 index 00000000000..682399afacb --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.badcall/func.wrap.badcall.const/bad_function_call_ctor.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// Class bad_function_call
// bad_function_call();
#include <functional>
#include <type_traits>
int main()
{
std::bad_function_call ex;
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp new file mode 100644 index 00000000000..b21c5522d66 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// template <MoveConstructible R, MoveConstructible ... ArgTypes>
// void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&);
#include <functional>
#include <new>
#include <cstdlib>
#include <cassert>
int new_called = 0;
void* operator new(std::size_t s) throw(std::bad_alloc)
{
++new_called;
return std::malloc(s);
}
void operator delete(void* p) throw()
{
--new_called;
std::free(p);
}
class A
{
int data_[10];
public:
static int count;
explicit A(int j)
{
++count;
data_[0] = j;
}
A(const A& a)
{
++count;
for (int i = 0; i < 10; ++i)
data_[i] = a.data_[i];
}
~A() {--count;}
int operator()(int i) const
{
for (int j = 0; j < 10; ++j)
i += data_[j];
return i;
}
int id() const {return data_[0];}
};
int A::count = 0;
int g(int) {return 0;}
int h(int) {return 1;}
int main()
{
assert(new_called == 0);
{
std::function<int(int)> f1 = A(1);
std::function<int(int)> f2 = A(2);
assert(A::count == 2);
assert(new_called == 2);
assert(f1.target<A>()->id() == 1);
assert(f2.target<A>()->id() == 2);
swap(f1, f2);
assert(A::count == 2);
assert(new_called == 2);
assert(f1.target<A>()->id() == 2);
assert(f2.target<A>()->id() == 1);
}
assert(A::count == 0);
assert(new_called == 0);
{
std::function<int(int)> f1 = A(1);
std::function<int(int)> f2 = g;
assert(A::count == 1);
assert(new_called == 1);
assert(f1.target<A>()->id() == 1);
assert(*f2.target<int(*)(int)>() == g);
swap(f1, f2);
assert(A::count == 1);
assert(new_called == 1);
assert(*f1.target<int(*)(int)>() == g);
assert(f2.target<A>()->id() == 1);
}
assert(A::count == 0);
assert(new_called == 0);
{
std::function<int(int)> f1 = g;
std::function<int(int)> f2 = A(1);
assert(A::count == 1);
assert(new_called == 1);
assert(*f1.target<int(*)(int)>() == g);
assert(f2.target<A>()->id() == 1);
swap(f1, f2);
assert(A::count == 1);
assert(new_called == 1);
assert(f1.target<A>()->id() == 1);
assert(*f2.target<int(*)(int)>() == g);
}
assert(A::count == 0);
assert(new_called == 0);
{
std::function<int(int)> f1 = g;
std::function<int(int)> f2 = h;
assert(A::count == 0);
assert(new_called == 0);
assert(*f1.target<int(*)(int)>() == g);
assert(*f2.target<int(*)(int)>() == h);
swap(f1, f2);
assert(A::count == 0);
assert(new_called == 0);
assert(*f1.target<int(*)(int)>() == h);
assert(*f2.target<int(*)(int)>() == g);
}
assert(A::count == 0);
assert(new_called == 0);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.cpp new file mode 100644 index 00000000000..6ecb531243f --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// explicit operator bool() const
#include <functional>
#include <cassert>
int g(int) {return 0;}
int main()
{
{
std::function<int(int)> f;
assert(!f);
f = g;
assert(f);
}
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp new file mode 100644 index 00000000000..1cce025809b --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// function(nullptr_t);
#include <functional>
#include <new>
#include <cstdlib>
#include <cassert>
int new_called = 0;
void* operator new(std::size_t s) throw(std::bad_alloc)
{
++new_called;
return std::malloc(s);
}
void operator delete(void* p) throw()
{
--new_called;
std::free(p);
}
class A
{
int data_[10];
public:
static int count;
A()
{
++count;
for (int i = 0; i < 10; ++i)
data_[i] = i;
}
A(const A&) {++count;}
~A() {--count;}
int operator()(int i) const
{
for (int j = 0; j < 10; ++j)
i += data_[j];
return i;
}
int foo(int) const {return 1;}
};
int A::count = 0;
int g(int) {return 0;}
int main()
{
assert(new_called == 0);
{
std::function<int(int)> f = A();
assert(A::count == 1);
assert(new_called == 1);
assert(f.target<A>());
assert(f.target<int(*)(int)>() == 0);
}
assert(A::count == 0);
assert(new_called == 0);
{
std::function<int(int)> f = g;
assert(new_called == 0);
assert(f.target<int(*)(int)>());
assert(f.target<A>() == 0);
}
assert(new_called == 0);
{
std::function<int(int)> f = (int (*)(int))0;
assert(!f);
assert(new_called == 0);
assert(f.target<int(*)(int)>() == 0);
assert(f.target<A>() == 0);
}
{
std::function<int(const A*, int)> f = &A::foo;
assert(f);
assert(new_called == 0);
assert(f.target<int (A::*)(int) const>() != 0);
}
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp new file mode 100644 index 00000000000..9b090f3e5b9 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// template<class F>
// requires CopyConstructible<F> && Callable<F, ArgTypes..>
// && Convertible<Callable<F, ArgTypes...>::result_type
// operator=(F f);
#include <functional>
#include <new>
#include <cstdlib>
#include <cassert>
int new_called = 0;
void* operator new(std::size_t s) throw(std::bad_alloc)
{
++new_called;
return std::malloc(s);
}
void operator delete(void* p) throw()
{
--new_called;
std::free(p);
}
class A
{
int data_[10];
public:
static int count;
A()
{
++count;
for (int i = 0; i < 10; ++i)
data_[i] = i;
}
A(const A&) {++count;}
~A() {--count;}
int operator()(int i) const
{
for (int j = 0; j < 10; ++j)
i += data_[j];
return i;
}
int foo(int) const {return 1;}
};
int A::count = 0;
int g(int) {return 0;}
int main()
{
assert(new_called == 0);
{
std::function<int(int)> f;
f = A();
assert(A::count == 1);
assert(new_called == 1);
assert(f.target<A>());
assert(f.target<int(*)(int)>() == 0);
}
assert(A::count == 0);
assert(new_called == 0);
{
std::function<int(int)> f;
f = g;
assert(new_called == 0);
assert(f.target<int(*)(int)>());
assert(f.target<A>() == 0);
}
assert(new_called == 0);
{
std::function<int(int)> f;
f = (int (*)(int))0;
assert(!f);
assert(new_called == 0);
assert(f.target<int(*)(int)>() == 0);
assert(f.target<A>() == 0);
}
{
std::function<int(const A*, int)> f;
f = &A::foo;
assert(f);
assert(new_called == 0);
assert(f.target<int (A::*)(int) const>() != 0);
}
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp new file mode 100644 index 00000000000..bf2b3318650 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp @@ -0,0 +1,22 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <functional> + +// class function<R(ArgTypes...)> + +// template<class A> function(allocator_arg_t, const A&); + +#include <functional> +#include <cassert> + +int main() +{ +#error template<class A> function(allocator_arg_t, const A&); not implemented +} diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp new file mode 100644 index 00000000000..e3a1e7b2b90 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp @@ -0,0 +1,22 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <functional> + +// class function<R(ArgTypes...)> + +// template<class F, class A> function(allocator_arg_t, const A&, F); + +#include <functional> +#include <cassert> + +int main() +{ +#error template<class F, class A> function(allocator_arg_t, const A&, F); not implemented +} diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp new file mode 100644 index 00000000000..3b55eb8df10 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp @@ -0,0 +1,22 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <functional> + +// class function<R(ArgTypes...)> + +// template<class A> function(allocator_arg_t, const A&, const function&); + +#include <functional> +#include <cassert> + +int main() +{ +#error template<class A> function(allocator_arg_t, const A&, const function&); not implemented +} diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp new file mode 100644 index 00000000000..28edd858f82 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp @@ -0,0 +1,22 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <functional> + +// class function<R(ArgTypes...)> + +// template<class A> function(allocator_arg_t, const A&, nullptr_t); + +#include <functional> +#include <cassert> + +int main() +{ +#error template<class A> function(allocator_arg_t, const A&, nullptr_t); not implemented +} diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp new file mode 100644 index 00000000000..2facbf7b59d --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp @@ -0,0 +1,22 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <functional> + +// class function<R(ArgTypes...)> + +// template<class A> function(allocator_arg_t, const A&, function&&); + +#include <functional> +#include <cassert> + +int main() +{ +#error template<class A> function(allocator_arg_t, const A&, function&&); not implemented +} diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy.pass.cpp new file mode 100644 index 00000000000..78dcc58d84c --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// function(const function& f);
#include <functional>
#include <new>
#include <cstdlib>
#include <cassert>
int new_called = 0;
void* operator new(std::size_t s) throw(std::bad_alloc)
{
++new_called;
return std::malloc(s);
}
void operator delete(void* p) throw()
{
--new_called;
std::free(p);
}
class A
{
int data_[10];
public:
static int count;
A()
{
++count;
for (int i = 0; i < 10; ++i)
data_[i] = i;
}
A(const A&) {++count;}
~A() {--count;}
int operator()(int i) const
{
for (int j = 0; j < 10; ++j)
i += data_[j];
return i;
}
};
int A::count = 0;
int g(int) {return 0;}
int main()
{
assert(new_called == 0);
{
std::function<int(int)> f = A();
assert(A::count == 1);
assert(new_called == 1);
assert(f.target<A>());
assert(f.target<int(*)(int)>() == 0);
std::function<int(int)> f2 = f;
assert(A::count == 2);
assert(new_called == 2);
assert(f2.target<A>());
assert(f2.target<int(*)(int)>() == 0);
}
assert(A::count == 0);
assert(new_called == 0);
{
std::function<int(int)> f = g;
assert(new_called == 0);
assert(f.target<int(*)(int)>());
assert(f.target<A>() == 0);
std::function<int(int)> f2 = f;
assert(new_called == 0);
assert(f2.target<int(*)(int)>());
assert(f2.target<A>() == 0);
}
assert(new_called == 0);
{
std::function<int(int)> f;
assert(new_called == 0);
assert(f.target<int(*)(int)>() == 0);
assert(f.target<A>() == 0);
std::function<int(int)> f2 = f;
assert(new_called == 0);
assert(f2.target<int(*)(int)>() == 0);
assert(f2.target<A>() == 0);
}
#ifdef _LIBCPP_MOVE
assert(new_called == 0);
{
std::function<int(int)> f = A();
assert(A::count == 1);
assert(new_called == 1);
assert(f.target<A>());
assert(f.target<int(*)(int)>() == 0);
std::function<int(int)> f2 = _STD::move(f);
assert(A::count == 1);
assert(new_called == 1);
assert(f2.target<A>());
assert(f2.target<int(*)(int)>() == 0);
assert(f.target<A>() == 0);
assert(f.target<int(*)(int)>() == 0);
}
#endif
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp new file mode 100644 index 00000000000..2b168064e9f --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// function& operator=(const function& f);
#include <functional>
#include <new>
#include <cstdlib>
#include <cassert>
int new_called = 0;
void* operator new(std::size_t s) throw(std::bad_alloc)
{
++new_called;
return std::malloc(s);
}
void operator delete(void* p) throw()
{
--new_called;
std::free(p);
}
class A
{
int data_[10];
public:
static int count;
A()
{
++count;
for (int i = 0; i < 10; ++i)
data_[i] = i;
}
A(const A&) {++count;}
~A() {--count;}
int operator()(int i) const
{
for (int j = 0; j < 10; ++j)
i += data_[j];
return i;
}
};
int A::count = 0;
int g(int) {return 0;}
int main()
{
assert(new_called == 0);
{
std::function<int(int)> f = A();
assert(A::count == 1);
assert(new_called == 1);
assert(f.target<A>());
assert(f.target<int(*)(int)>() == 0);
std::function<int(int)> f2;
f2 = f;
assert(A::count == 2);
assert(new_called == 2);
assert(f2.target<A>());
assert(f2.target<int(*)(int)>() == 0);
}
assert(A::count == 0);
assert(new_called == 0);
{
std::function<int(int)> f = g;
assert(new_called == 0);
assert(f.target<int(*)(int)>());
assert(f.target<A>() == 0);
std::function<int(int)> f2;
f2 = f;
assert(new_called == 0);
assert(f2.target<int(*)(int)>());
assert(f2.target<A>() == 0);
}
assert(new_called == 0);
{
std::function<int(int)> f;
assert(new_called == 0);
assert(f.target<int(*)(int)>() == 0);
assert(f.target<A>() == 0);
std::function<int(int)> f2;
f2 = f;
assert(new_called == 0);
assert(f2.target<int(*)(int)>() == 0);
assert(f2.target<A>() == 0);
}
#ifdef _LIBCPP_MOVE
assert(new_called == 0);
{
std::function<int(int)> f = A();
assert(A::count == 1);
assert(new_called == 1);
assert(f.target<A>());
assert(f.target<int(*)(int)>() == 0);
std::function<int(int)> f2;
f2 = _STD::move(f);
assert(A::count == 1);
assert(new_called == 1);
assert(f2.target<A>());
assert(f2.target<int(*)(int)>() == 0);
assert(f.target<A>() == 0);
assert(f.target<int(*)(int)>() == 0);
}
#endif
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/default.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/default.pass.cpp new file mode 100644 index 00000000000..b63544fc1d7 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/default.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// explicit function();
#include <functional>
#include <cassert>
int main()
{
std::function<int(int)> f;
assert(!f);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t.pass.cpp new file mode 100644 index 00000000000..e493ccfdb72 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// function(nullptr_t);
#include <functional>
#include <cassert>
int main()
{
std::function<int(int)> f(nullptr);
assert(!f);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp new file mode 100644 index 00000000000..4361d4a4a50 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// function& operator=(nullptr_t);
#include <functional>
#include <new>
#include <cstdlib>
#include <cassert>
int new_called = 0;
void* operator new(std::size_t s) throw(std::bad_alloc)
{
++new_called;
return std::malloc(s);
}
void operator delete(void* p) throw()
{
--new_called;
std::free(p);
}
class A
{
int data_[10];
public:
static int count;
A()
{
++count;
for (int i = 0; i < 10; ++i)
data_[i] = i;
}
A(const A&) {++count;}
~A() {--count;}
int operator()(int i) const
{
for (int j = 0; j < 10; ++j)
i += data_[j];
return i;
}
};
int A::count = 0;
int g(int) {return 0;}
int main()
{
assert(new_called == 0);
{
std::function<int(int)> f = A();
assert(A::count == 1);
assert(new_called == 1);
assert(f.target<A>());
f = nullptr;
assert(A::count == 0);
assert(new_called == 0);
assert(f.target<A>() == 0);
}
{
std::function<int(int)> f = g;
assert(new_called == 0);
assert(f.target<int(*)(int)>());
assert(f.target<A>() == 0);
f = nullptr;
assert(new_called == 0);
assert(f.target<int(*)(int)>() == 0);
}
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp new file mode 100644 index 00000000000..e3626ef3c95 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.fail.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// R operator()(ArgTypes... args) const
#include <functional>
#include <cassert>
// member data pointer: cv qualifiers should transfer from argument to return type
struct A_int_1
{
A_int_1() : data_(5) {}
int data_;
};
void
test_int_1()
{
// member data pointer
{
int A_int_1::*fp = &A_int_1::data_;
A_int_1 a;
std::function<int& (const A_int_1*)> r2(fp);
const A_int_1* ap = &a;
assert(r2(ap) == 6);
r2(ap) = 7;
assert(r2(ap) == 7);
}
}
int main()
{
test_int_1();
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp new file mode 100644 index 00000000000..4babee7af17 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// R operator()(ArgTypes... args) const
#include <functional>
#include <cassert>
int count = 0;
// 1 arg, return void
void f_void_1(int i)
{
count += i;
}
struct A_void_1
{
void operator()(int i)
{
count += i;
}
void mem1() {++count;}
void mem2() const {++count;}
};
void
test_void_1()
{
int save_count = count;
// function
{
std::function<void (int)> r1(f_void_1);
int i = 2;
r1(i);
assert(count == save_count+2);
save_count = count;
}
// function pointer
{
void (*fp)(int) = f_void_1;
std::function<void (int)> r1(fp);
int i = 3;
r1(i);
assert(count == save_count+3);
save_count = count;
}
// functor
{
A_void_1 a0;
std::function<void (int)> r1(a0);
int i = 4;
r1(i);
assert(count == save_count+4);
save_count = count;
}
// member function pointer
{
void (A_void_1::*fp)() = &A_void_1::mem1;
std::function<void (A_void_1)> r1(fp);
A_void_1 a;
r1(a);
assert(count == save_count+1);
save_count = count;
A_void_1* ap = &a;
std::function<void (A_void_1*)> r2 = fp;
r2(ap);
assert(count == save_count+1);
save_count = count;
}
// const member function pointer
{
void (A_void_1::*fp)() const = &A_void_1::mem2;
std::function<void (A_void_1)> r1(fp);
A_void_1 a;
r1(a);
assert(count == save_count+1);
save_count = count;
std::function<void (A_void_1*)> r2(fp);
A_void_1* ap = &a;
r2(ap);
assert(count == save_count+1);
save_count = count;
}
}
// 1 arg, return int
int f_int_1(int i)
{
return i + 1;
}
struct A_int_1
{
A_int_1() : data_(5) {}
int operator()(int i)
{
return i - 1;
}
int mem1() {return 3;}
int mem2() const {return 4;}
int data_;
};
void
test_int_1()
{
// function
{
std::function<int (int)> r1(f_int_1);
int i = 2;
assert(r1(i) == 3);
}
// function pointer
{
int (*fp)(int) = f_int_1;
std::function<int (int)> r1(fp);
int i = 3;
assert(r1(i) == 4);
}
// functor
{
A_int_1 a0;
std::function<int (int)> r1(a0);
int i = 4;
assert(r1(i) == 3);
}
// member function pointer
{
int (A_int_1::*fp)() = &A_int_1::mem1;
std::function<int (A_int_1)> r1(fp);
A_int_1 a;
assert(r1(a) == 3);
std::function<int (A_int_1*)> r2(fp);
A_int_1* ap = &a;
assert(r2(ap) == 3);
}
// const member function pointer
{
int (A_int_1::*fp)() const = &A_int_1::mem2;
std::function<int (A_int_1)> r1(fp);
A_int_1 a;
assert(r1(a) == 4);
std::function<int (A_int_1*)> r2(fp);
A_int_1* ap = &a;
assert(r2(ap) == 4);
}
// member data pointer
{
int A_int_1::*fp = &A_int_1::data_;
std::function<int& (A_int_1&)> r1(fp);
A_int_1 a;
assert(r1(a) == 5);
r1(a) = 6;
assert(r1(a) == 6);
std::function<int& (A_int_1*)> r2(fp);
A_int_1* ap = &a;
assert(r2(ap) == 6);
r2(ap) = 7;
assert(r2(ap) == 7);
}
}
// 2 arg, return void
void f_void_2(int i, int j)
{
count += i+j;
}
struct A_void_2
{
void operator()(int i, int j)
{
count += i+j;
}
void mem1(int i) {count += i;}
void mem2(int i) const {count += i;}
};
void
test_void_2()
{
int save_count = count;
// function
{
std::function<void (int, int)> r1(f_void_2);
int i = 2;
int j = 3;
r1(i, j);
assert(count == save_count+5);
save_count = count;
}
// function pointer
{
void (*fp)(int, int) = f_void_2;
std::function<void (int, int)> r1(fp);
int i = 3;
int j = 4;
r1(i, j);
assert(count == save_count+7);
save_count = count;
}
// functor
{
A_void_2 a0;
std::function<void (int, int)> r1(a0);
int i = 4;
int j = 5;
r1(i, j);
assert(count == save_count+9);
save_count = count;
}
// member function pointer
{
void (A_void_2::*fp)(int) = &A_void_2::mem1;
std::function<void (A_void_2, int)> r1(fp);
A_void_2 a;
int i = 3;
r1(a, i);
assert(count == save_count+3);
save_count = count;
std::function<void (A_void_2*, int)> r2(fp);
A_void_2* ap = &a;
r2(ap, i);
assert(count == save_count+3);
save_count = count;
}
// const member function pointer
{
void (A_void_2::*fp)(int) const = &A_void_2::mem2;
std::function<void (A_void_2, int)> r1(fp);
A_void_2 a;
int i = 4;
r1(a, i);
assert(count == save_count+4);
save_count = count;
std::function<void (A_void_2*, int)> r2(fp);
A_void_2* ap = &a;
r2(ap, i);
assert(count == save_count+4);
save_count = count;
}
}
// 2 arg, return int
int f_int_2(int i, int j)
{
return i+j;
}
struct A_int_2
{
int operator()(int i, int j)
{
return i+j;
}
int mem1(int i) {return i+1;}
int mem2(int i) const {return i+2;}
};
void
testint_2()
{
// function
{
std::function<int (int, int)> r1(f_int_2);
int i = 2;
int j = 3;
assert(r1(i, j) == i+j);
}
// function pointer
{
int (*fp)(int, int) = f_int_2;
std::function<int (int, int)> r1(fp);
int i = 3;
int j = 4;
assert(r1(i, j) == i+j);
}
// functor
{
A_int_2 a0;
std::function<int (int, int)> r1(a0);
int i = 4;
int j = 5;
assert(r1(i, j) == i+j);
}
// member function pointer
{
int(A_int_2::*fp)(int) = &A_int_2::mem1;
std::function<int (A_int_2, int)> r1(fp);
A_int_2 a;
int i = 3;
assert(r1(a, i) == i+1);
std::function<int (A_int_2*, int)> r2(fp);
A_int_2* ap = &a;
assert(r2(ap, i) == i+1);
}
// const member function pointer
{
int (A_int_2::*fp)(int) const = &A_int_2::mem2;
std::function<int (A_int_2, int)> r1(fp);
A_int_2 a;
int i = 4;
assert(r1(a, i) == i+2);
std::function<int (A_int_2*, int)> r2(fp);
A_int_2* ap = &a;
assert(r2(ap, i) == i+2);
}
}
int main()
{
test_void_1();
test_int_1();
test_void_2();
testint_2();
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_int_0.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_int_0.pass.cpp new file mode 100644 index 00000000000..6bab12a9c79 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_int_0.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// R operator()(ArgTypes... args) const
#include <functional>
#include <cassert>
// 0 args, return int
int count = 0;
int f_int_0()
{
return 3;
}
struct A_int_0
{
int operator()() {return 4;}
};
void
test_int_0()
{
// function
{
std::function<int ()> r1(f_int_0);
assert(r1() == 3);
}
// function pointer
{
int (*fp)() = f_int_0;
std::function<int ()> r1(fp);
assert(r1() == 3);
}
// functor
{
A_int_0 a0;
std::function<int ()> r1(a0);
assert(r1() == 4);
}
}
int main()
{
test_int_0();
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_void_0.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_void_0.pass.cpp new file mode 100644 index 00000000000..5df26064f1e --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_void_0.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// R operator()(ArgTypes... args) const
#include <functional>
#include <new>
#include <cstdlib>
#include <cassert>
// 0 args, return void
int count = 0;
void f_void_0()
{
++count;
}
struct A_void_0
{
void operator()() {++count;}
};
void
test_void_0()
{
int save_count = count;
// function
{
std::function<void ()> r1(f_void_0);
r1();
assert(count == save_count+1);
save_count = count;
}
// function pointer
{
void (*fp)() = f_void_0;
std::function<void ()> r1(fp);
r1();
assert(count == save_count+1);
save_count = count;
}
// functor
{
A_void_0 a0;
std::function<void ()> r1(a0);
r1();
assert(count == save_count+1);
save_count = count;
}
}
int main()
{
test_void_0();
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp new file mode 100644 index 00000000000..bbb84aae410 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp @@ -0,0 +1,22 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <functional> + +// class function<R(ArgTypes...)> + +// template<class F, class A> void assign(F&&, const A&); + +#include <functional> +#include <cassert> + +int main() +{ +#error template<class F, class A> void assign(F&&, const A&); not implemented +} diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp new file mode 100644 index 00000000000..1e19ee2aa8b --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// void swap(function& other);
#include <functional>
#include <new>
#include <cstdlib>
#include <cassert>
int new_called = 0;
void* operator new(std::size_t s) throw(std::bad_alloc)
{
++new_called;
return std::malloc(s);
}
void operator delete(void* p) throw()
{
--new_called;
std::free(p);
}
class A
{
int data_[10];
public:
static int count;
explicit A(int j)
{
++count;
data_[0] = j;
}
A(const A& a)
{
++count;
for (int i = 0; i < 10; ++i)
data_[i] = a.data_[i];
}
~A() {--count;}
int operator()(int i) const
{
for (int j = 0; j < 10; ++j)
i += data_[j];
return i;
}
int id() const {return data_[0];}
};
int A::count = 0;
int g(int) {return 0;}
int h(int) {return 1;}
int main()
{
assert(new_called == 0);
{
std::function<int(int)> f1 = A(1);
std::function<int(int)> f2 = A(2);
assert(A::count == 2);
assert(new_called == 2);
assert(f1.target<A>()->id() == 1);
assert(f2.target<A>()->id() == 2);
f1.swap(f2);
assert(A::count == 2);
assert(new_called == 2);
assert(f1.target<A>()->id() == 2);
assert(f2.target<A>()->id() == 1);
}
assert(A::count == 0);
assert(new_called == 0);
{
std::function<int(int)> f1 = A(1);
std::function<int(int)> f2 = g;
assert(A::count == 1);
assert(new_called == 1);
assert(f1.target<A>()->id() == 1);
assert(*f2.target<int(*)(int)>() == g);
f1.swap(f2);
assert(A::count == 1);
assert(new_called == 1);
assert(*f1.target<int(*)(int)>() == g);
assert(f2.target<A>()->id() == 1);
}
assert(A::count == 0);
assert(new_called == 0);
{
std::function<int(int)> f1 = g;
std::function<int(int)> f2 = A(1);
assert(A::count == 1);
assert(new_called == 1);
assert(*f1.target<int(*)(int)>() == g);
assert(f2.target<A>()->id() == 1);
f1.swap(f2);
assert(A::count == 1);
assert(new_called == 1);
assert(f1.target<A>()->id() == 1);
assert(*f2.target<int(*)(int)>() == g);
}
assert(A::count == 0);
assert(new_called == 0);
{
std::function<int(int)> f1 = g;
std::function<int(int)> f2 = h;
assert(A::count == 0);
assert(new_called == 0);
assert(*f1.target<int(*)(int)>() == g);
assert(*f2.target<int(*)(int)>() == h);
f1.swap(f2);
assert(A::count == 0);
assert(new_called == 0);
assert(*f1.target<int(*)(int)>() == h);
assert(*f2.target<int(*)(int)>() == g);
}
assert(A::count == 0);
assert(new_called == 0);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp new file mode 100644 index 00000000000..8a2ae86b7ba --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// template <MoveConstructible R, MoveConstructible ... ArgTypes>
// bool operator==(const function<R(ArgTypes...)>&, nullptr_t);
//
// template <MoveConstructible R, MoveConstructible ... ArgTypes>
// bool operator==(nullptr_t, const function<R(ArgTypes...)>&);
//
// template <MoveConstructible R, MoveConstructible ... ArgTypes>
// bool operator!=(const function<R(ArgTypes...)>&, nullptr_t);
//
// template <MoveConstructible R, MoveConstructible ... ArgTypes>
// bool operator!=(nullptr_t, const function<R(ArgTypes...)>&);
#include <functional>
#include <cassert>
int g(int) {return 0;}
int main()
{
{
std::function<int(int)> f;
assert(f == nullptr);
assert(nullptr == f);
f = g;
assert(f != nullptr);
assert(nullptr != f);
}
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target.pass.cpp new file mode 100644 index 00000000000..53fa50ba87e --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// template<typename T>
// requires Callable<T, ArgTypes...> && Convertible<Callable<T, ArgTypes...>::result_type, R>
// T*
// target();
// template<typename T>
// requires Callable<T, ArgTypes...> && Convertible<Callable<T, ArgTypes...>::result_type, R>
// const T*
// target() const;
#include <functional>
#include <new>
#include <cstdlib>
#include <cassert>
class A
{
int data_[10];
public:
static int count;
A()
{
++count;
for (int i = 0; i < 10; ++i)
data_[i] = i;
}
A(const A&) {++count;}
~A() {--count;}
int operator()(int i) const
{
for (int j = 0; j < 10; ++j)
i += data_[j];
return i;
}
int foo(int) const {return 1;}
};
int A::count = 0;
int g(int) {return 0;}
int main()
{
{
std::function<int(int)> f = A();
assert(A::count == 1);
assert(f.target<A>());
assert(f.target<int(*)(int)>() == 0);
}
assert(A::count == 0);
{
std::function<int(int)> f = g;
assert(A::count == 0);
assert(f.target<int(*)(int)>());
assert(f.target<A>() == 0);
}
assert(A::count == 0);
{
const std::function<int(int)> f = A();
assert(A::count == 1);
assert(f.target<A>());
assert(f.target<int(*)(int)>() == 0);
}
assert(A::count == 0);
{
const std::function<int(int)> f = g;
assert(A::count == 0);
assert(f.target<int(*)(int)>());
assert(f.target<A>() == 0);
}
assert(A::count == 0);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target_type.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target_type.pass.cpp new file mode 100644 index 00000000000..08abfadc360 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target_type.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// class function<R(ArgTypes...)>
// const std::type_info& target_type() const;
#include <functional>
#include <typeinfo>
#include <cassert>
class A
{
int data_[10];
public:
static int count;
A()
{
++count;
for (int i = 0; i < 10; ++i)
data_[i] = i;
}
A(const A&) {++count;}
~A() {--count;}
int operator()(int i) const
{
for (int j = 0; j < 10; ++j)
i += data_[j];
return i;
}
int foo(int) const {return 1;}
};
int A::count = 0;
int g(int) {return 0;}
int main()
{
{
std::function<int(int)> f = A();
assert(f.target_type() == typeid(A));
}
{
std::function<int(int)> f;
assert(f.target_type() == typeid(void));
}
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp new file mode 100644 index 00000000000..17a8794bd5c --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<Returnable R, CopyConstructible... ArgTypes>
// class function<R(ArgTypes...)>
// : public unary_function<T1, R> // iff sizeof...(ArgTypes) == 1 and
// // ArgTypes contains T1
// : public binary_function<T1, T2, R> // iff sizeof...(ArgTypes) == 2 and
// // ArgTypes contains T1 and T2
// {
// public:
// typedef R result_type;
// ...
// };
#include <functional>
#include <type_traits>
int main()
{
static_assert((!std::is_base_of<std::unary_function <int, int>,
std::function<int()> >::value), "");
static_assert((!std::is_base_of<std::binary_function<int, int, int>,
std::function<int()> >::value), "");
static_assert(( std::is_same< std::function<int()>::result_type,
int>::value), "");
static_assert(( std::is_base_of<std::unary_function <int, double>,
std::function<double(int)> >::value), "");
static_assert((!std::is_base_of<std::binary_function<int, int, double>,
std::function<double(int)> >::value), "");
static_assert(( std::is_same< std::function<double(int)>::result_type,
double>::value), "");
static_assert((!std::is_base_of<std::unary_function <int, double>,
std::function<double(int, char)> >::value), "");
static_assert(( std::is_base_of<std::binary_function<int, char, double>,
std::function<double(int, char)> >::value), "");
static_assert(( std::is_same< std::function<double(int, char)>::result_type,
double>::value), "");
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/func.wrap/nothing_to_do.pass.cpp b/libcxx/test/utilities/function.objects/func.wrap/nothing_to_do.pass.cpp new file mode 100644 index 00000000000..92348261209 --- /dev/null +++ b/libcxx/test/utilities/function.objects/func.wrap/nothing_to_do.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/function.pointer.adaptors/pointer_to_binary_function.pass.cpp b/libcxx/test/utilities/function.objects/function.pointer.adaptors/pointer_to_binary_function.pass.cpp new file mode 100644 index 00000000000..f3f2c0a7297 --- /dev/null +++ b/libcxx/test/utilities/function.objects/function.pointer.adaptors/pointer_to_binary_function.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// pointer_to_binary_function
#include <functional>
#include <type_traits>
#include <cassert>
double binary_f(int i, short j) {return i - j + .75;}
int main()
{
typedef std::pointer_to_binary_function<int, short, double> F;
static_assert((std::is_base_of<std::binary_function<int, short, double>, F>::value), "");
const F f(binary_f);
assert(f(36, 27) == 9.75);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/function.pointer.adaptors/pointer_to_unary_function.pass.cpp b/libcxx/test/utilities/function.objects/function.pointer.adaptors/pointer_to_unary_function.pass.cpp new file mode 100644 index 00000000000..70a9cebc973 --- /dev/null +++ b/libcxx/test/utilities/function.objects/function.pointer.adaptors/pointer_to_unary_function.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// pointer_to_unary_function
#include <functional>
#include <type_traits>
#include <cassert>
double unary_f(int i) {return 0.5 - i;}
int main()
{
typedef std::pointer_to_unary_function<int, double> F;
static_assert((std::is_base_of<std::unary_function<int, double>, F>::value), "");
const F f(unary_f);
assert(f(36) == -35.5);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/function.pointer.adaptors/ptr_fun1.pass.cpp b/libcxx/test/utilities/function.objects/function.pointer.adaptors/ptr_fun1.pass.cpp new file mode 100644 index 00000000000..4f377ef17ea --- /dev/null +++ b/libcxx/test/utilities/function.objects/function.pointer.adaptors/ptr_fun1.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template <CopyConstructible Arg, Returnable Result>
// pointer_to_unary_function<Arg, Result>
// ptr_fun(Result (*f)(Arg));
#include <functional>
#include <type_traits>
#include <cassert>
double unary_f(int i) {return 0.5 - i;}
int main()
{
assert(std::ptr_fun(unary_f)(36) == -35.5);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/function.pointer.adaptors/ptr_fun2.pass.cpp b/libcxx/test/utilities/function.objects/function.pointer.adaptors/ptr_fun2.pass.cpp new file mode 100644 index 00000000000..93c6376efba --- /dev/null +++ b/libcxx/test/utilities/function.objects/function.pointer.adaptors/ptr_fun2.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template <CopyConstructible Arg1, CopyConstructible Arg2, Returnable Result>
// pointer_to_binary_function<Arg1,Arg2,Result>
// ptr_fun(Result (*f)(Arg1, Arg2));
#include <functional>
#include <type_traits>
#include <cassert>
double binary_f(int i, short j) {return i - j + .75;}
int main()
{
assert(std::ptr_fun(binary_f)(36, 27) == 9.75);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/logical.operations/logical_and.pass.cpp b/libcxx/test/utilities/function.objects/logical.operations/logical_and.pass.cpp new file mode 100644 index 00000000000..e193c90a6b9 --- /dev/null +++ b/libcxx/test/utilities/function.objects/logical.operations/logical_and.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// logical_and
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::logical_and<int> F;
const F f = F();
static_assert((std::is_base_of<std::binary_function<int, int, bool>, F>::value), "");
assert(f(36, 36));
assert(!f(36, 0));
assert(!f(0, 36));
assert(!f(0, 0));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/logical.operations/logical_not.pass.cpp b/libcxx/test/utilities/function.objects/logical.operations/logical_not.pass.cpp new file mode 100644 index 00000000000..16bb419b5ed --- /dev/null +++ b/libcxx/test/utilities/function.objects/logical.operations/logical_not.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// logical_not
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::logical_not<int> F;
const F f = F();
static_assert((std::is_base_of<std::unary_function<int, bool>, F>::value), "");
assert(!f(36));
assert(f(0));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/logical.operations/logical_or.pass.cpp b/libcxx/test/utilities/function.objects/logical.operations/logical_or.pass.cpp new file mode 100644 index 00000000000..0f2518acf94 --- /dev/null +++ b/libcxx/test/utilities/function.objects/logical.operations/logical_or.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// logical_or
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::logical_or<int> F;
const F f = F();
static_assert((std::is_base_of<std::binary_function<int, int, bool>, F>::value), "");
assert(f(36, 36));
assert(f(36, 0));
assert(f(0, 36));
assert(!f(0, 0));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun.pass.cpp b/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun.pass.cpp new file mode 100644 index 00000000000..b206b0001d2 --- /dev/null +++ b/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<cReturnable S, ClassType T>
// const_mem_fun_t<S,T>
// mem_fun(S (T::*f)() const);
#include <functional>
#include <cassert>
struct A
{
char a1() {return 5;}
short a2(int i) {return short(i+1);}
int a3() const {return 1;}
double a4(unsigned i) const {return i-1;}
};
int main()
{
const A a = A();
assert(std::mem_fun(&A::a3)(&a) == 1);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun1.pass.cpp b/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun1.pass.cpp new file mode 100644 index 00000000000..c2d6407cf6a --- /dev/null +++ b/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun1.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<Returnable S, ClassType T, CopyConstructible A>
// const_mem_fun1_t<S,T,A>
// mem_fun(S (T::*f)(A) const);
#include <functional>
#include <cassert>
struct A
{
char a1() {return 5;}
short a2(int i) {return short(i+1);}
int a3() const {return 1;}
double a4(unsigned i) const {return i-1;}
};
int main()
{
const A a = A();
assert(std::mem_fun(&A::a4)(&a, 6) == 5);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun1_ref_t.pass.cpp b/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun1_ref_t.pass.cpp new file mode 100644 index 00000000000..933842e2884 --- /dev/null +++ b/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun1_ref_t.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// const_mem_fun1_ref_t
#include <functional>
#include <type_traits>
#include <cassert>
struct A
{
char a1() {return 5;}
short a2(int i) {return short(i+1);}
int a3() const {return 1;}
double a4(unsigned i) const {return i-1;}
};
int main()
{
typedef std::const_mem_fun1_ref_t<double, A, unsigned> F;
static_assert((std::is_base_of<std::binary_function<A, unsigned, double>, F>::value), "");
const F f(&A::a4);
const A a = A();
assert(f(a, 6) == 5);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun1_t.pass.cpp b/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun1_t.pass.cpp new file mode 100644 index 00000000000..8071810984a --- /dev/null +++ b/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun1_t.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// const_mem_fun1_t
#include <functional>
#include <type_traits>
#include <cassert>
struct A
{
char a1() {return 5;}
short a2(int i) {return short(i+1);}
int a3() const {return 1;}
double a4(unsigned i) const {return i-1;}
};
int main()
{
typedef std::const_mem_fun1_t<double, A, unsigned> F;
static_assert((std::is_base_of<std::binary_function<const A*, unsigned, double>, F>::value), "");
const F f(&A::a4);
const A a = A();
assert(f(&a, 6) == 5);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun_ref.pass.cpp b/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun_ref.pass.cpp new file mode 100644 index 00000000000..d8c3dbb019e --- /dev/null +++ b/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun_ref.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<Returnable S, ClassType T>
// const_mem_fun_ref_t<S,T>
// mem_fun_ref(S (T::*f)() const);
#include <functional>
#include <cassert>
struct A
{
char a1() {return 5;}
short a2(int i) {return short(i+1);}
int a3() const {return 1;}
double a4(unsigned i) const {return i-1;}
};
int main()
{
const A a = A();
assert(std::mem_fun_ref(&A::a3)(a) == 1);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun_ref1.pass.cpp b/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun_ref1.pass.cpp new file mode 100644 index 00000000000..5cba2c9b0fe --- /dev/null +++ b/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun_ref1.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<Returnable S, ClassType T, CopyConstructible A>
// const_mem_fun1_ref_t<S,T,A>
// mem_fun_ref(S (T::*f)(A) const);
#include <functional>
#include <cassert>
struct A
{
char a1() {return 5;}
short a2(int i) {return short(i+1);}
int a3() const {return 1;}
double a4(unsigned i) const {return i-1;}
};
int main()
{
const A a = A();
assert(std::mem_fun_ref(&A::a4)(a, 6) == 5);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun_ref_t.pass.cpp b/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun_ref_t.pass.cpp new file mode 100644 index 00000000000..f28a36af9f1 --- /dev/null +++ b/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun_ref_t.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// const_mem_fun_ref_t
#include <functional>
#include <type_traits>
#include <cassert>
struct A
{
char a1() {return 5;}
short a2(int i) {return short(i+1);}
int a3() const {return 1;}
double a4(unsigned i) const {return i-1;}
};
int main()
{
typedef std::const_mem_fun_ref_t<int, A> F;
static_assert((std::is_base_of<std::unary_function<A, int>, F>::value), "");
const F f(&A::a3);
const A a = A();
assert(f(a) == 1);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun_t.pass.cpp b/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun_t.pass.cpp new file mode 100644 index 00000000000..fdcd440c064 --- /dev/null +++ b/libcxx/test/utilities/function.objects/member.pointer.adaptors/const_mem_fun_t.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// const_mem_fun_t
#include <functional>
#include <type_traits>
#include <cassert>
struct A
{
char a1() {return 5;}
short a2(int i) {return short(i+1);}
int a3() const {return 1;}
double a4(unsigned i) const {return i-1;}
};
int main()
{
typedef std::const_mem_fun_t<int, A> F;
static_assert((std::is_base_of<std::unary_function<const A*, int>, F>::value), "");
const F f(&A::a3);
const A a = A();
assert(f(&a) == 1);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun.pass.cpp b/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun.pass.cpp new file mode 100644 index 00000000000..0ea08e8d84b --- /dev/null +++ b/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<Returnable S, ClassType T>
// mem_fun_t<S,T>
// mem_fun(S (T::*f)());
#include <functional>
#include <cassert>
struct A
{
char a1() {return 5;}
short a2(int i) {return short(i+1);}
int a3() const {return 1;}
double a4(unsigned i) const {return i-1;}
};
int main()
{
A a;
assert(std::mem_fun(&A::a1)(&a) == 5);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun1.pass.cpp b/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun1.pass.cpp new file mode 100644 index 00000000000..e47fb6cc6ca --- /dev/null +++ b/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun1.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<Returnable S, ClassType T, CopyConstructible A>
// mem_fun1_t<S,T,A>
// mem_fun(S (T::*f)(A));
#include <functional>
#include <cassert>
struct A
{
char a1() {return 5;}
short a2(int i) {return short(i+1);}
int a3() const {return 1;}
double a4(unsigned i) const {return i-1;}
};
int main()
{
A a;
assert(std::mem_fun(&A::a2)(&a, 5) == 6);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun1_ref_t.pass.cpp b/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun1_ref_t.pass.cpp new file mode 100644 index 00000000000..adc00597cbe --- /dev/null +++ b/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun1_ref_t.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// mem_fun1_ref_t
#include <functional>
#include <type_traits>
#include <cassert>
struct A
{
char a1() {return 5;}
short a2(int i) {return short(i+1);}
int a3() const {return 1;}
double a4(unsigned i) const {return i-1;}
};
int main()
{
typedef std::mem_fun1_ref_t<short, A, int> F;
static_assert((std::is_base_of<std::binary_function<A, int, short>, F>::value), "");
const F f(&A::a2);
A a;
assert(f(a, 5) == 6);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun1_t.pass.cpp b/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun1_t.pass.cpp new file mode 100644 index 00000000000..ab29d9a67f8 --- /dev/null +++ b/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun1_t.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// mem_fun1_t
#include <functional>
#include <type_traits>
#include <cassert>
struct A
{
char a1() {return 5;}
short a2(int i) {return short(i+1);}
int a3() const {return 1;}
double a4(unsigned i) const {return i-1;}
};
int main()
{
typedef std::mem_fun1_t<short, A, int> F;
static_assert((std::is_base_of<std::binary_function<A*, int, short>, F>::value), "");
const F f(&A::a2);
A a;
assert(f(&a, 5) == 6);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun_ref.pass.cpp b/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun_ref.pass.cpp new file mode 100644 index 00000000000..8d79e7ac768 --- /dev/null +++ b/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun_ref.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<Returnable S, ClassType T>
// mem_fun_ref_t<S,T>
// mem_fun_ref(S (T::*f)());
#include <functional>
#include <cassert>
struct A
{
char a1() {return 5;}
short a2(int i) {return short(i+1);}
int a3() const {return 1;}
double a4(unsigned i) const {return i-1;}
};
int main()
{
A a;
assert(std::mem_fun_ref(&A::a1)(a) == 5);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun_ref1.pass.cpp b/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun_ref1.pass.cpp new file mode 100644 index 00000000000..bbc64a14ba7 --- /dev/null +++ b/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun_ref1.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// template<Returnable S, ClassType T, CopyConstructible A>
// mem_fun1_ref_t<S,T,A>
// mem_fun_ref(S (T::*f)(A));
#include <functional>
#include <cassert>
struct A
{
char a1() {return 5;}
short a2(int i) {return short(i+1);}
int a3() const {return 1;}
double a4(unsigned i) const {return i-1;}
};
int main()
{
A a;
assert(std::mem_fun_ref(&A::a2)(a, 5) == 6);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun_ref_t.pass.cpp b/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun_ref_t.pass.cpp new file mode 100644 index 00000000000..9a9e9dd718c --- /dev/null +++ b/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun_ref_t.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// mem_fun_ref_t
#include <functional>
#include <type_traits>
#include <cassert>
struct A
{
char a1() {return 5;}
short a2(int i) {return short(i+1);}
int a3() const {return 1;}
double a4(unsigned i) const {return i-1;}
};
int main()
{
typedef std::mem_fun_ref_t<char, A> F;
static_assert((std::is_base_of<std::unary_function<A, char>, F>::value), "");
const F f(&A::a1);
A a;
assert(f(a) == 5);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun_t.pass.cpp b/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun_t.pass.cpp new file mode 100644 index 00000000000..5db73e169dc --- /dev/null +++ b/libcxx/test/utilities/function.objects/member.pointer.adaptors/mem_fun_t.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// mem_fun_t
#include <functional>
#include <type_traits>
#include <cassert>
struct A
{
char a1() {return 5;}
short a2(int i) {return short(i+1);}
int a3() const {return 1;}
double a4(unsigned i) const {return i-1;}
};
int main()
{
typedef std::mem_fun_t<char, A> F;
static_assert((std::is_base_of<std::unary_function<A*, char>, F>::value), "");
const F f(&A::a1);
A a;
assert(f(&a) == 5);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/negators/binary_negate.pass.cpp b/libcxx/test/utilities/function.objects/negators/binary_negate.pass.cpp new file mode 100644 index 00000000000..25f79144899 --- /dev/null +++ b/libcxx/test/utilities/function.objects/negators/binary_negate.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// binary_negate
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::binary_negate<std::logical_and<int> > F;
const F f = F(std::logical_and<int>());
static_assert((std::is_base_of<std::binary_function<int, int, bool>, F>::value), "");
assert(!f(36, 36));
assert( f(36, 0));
assert( f(0, 36));
assert( f(0, 0));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/negators/not1.pass.cpp b/libcxx/test/utilities/function.objects/negators/not1.pass.cpp new file mode 100644 index 00000000000..03bb7a7c9ec --- /dev/null +++ b/libcxx/test/utilities/function.objects/negators/not1.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// not1
#include <functional>
#include <cassert>
int main()
{
typedef std::logical_not<int> F;
assert(std::not1(F())(36));
assert(!std::not1(F())(0));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/negators/not2.pass.cpp b/libcxx/test/utilities/function.objects/negators/not2.pass.cpp new file mode 100644 index 00000000000..1f32fb1004b --- /dev/null +++ b/libcxx/test/utilities/function.objects/negators/not2.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// not2
#include <functional>
#include <cassert>
int main()
{
typedef std::logical_and<int> F;
assert(!std::not2(F())(36, 36));
assert( std::not2(F())(36, 0));
assert( std::not2(F())(0, 36));
assert( std::not2(F())(0, 0));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/negators/unary_negate.pass.cpp b/libcxx/test/utilities/function.objects/negators/unary_negate.pass.cpp new file mode 100644 index 00000000000..55696b8619e --- /dev/null +++ b/libcxx/test/utilities/function.objects/negators/unary_negate.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// unary_negate
#include <functional>
#include <type_traits>
#include <cassert>
int main()
{
typedef std::unary_negate<std::logical_not<int> > F;
const F f = F(std::logical_not<int>());
static_assert((std::is_base_of<std::unary_function<int, bool>, F>::value), "");
assert(f(36));
assert(!f(0));
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/binary.pass.cpp b/libcxx/test/utilities/function.objects/refwrap/binary.pass.cpp new file mode 100644 index 00000000000..3dfae3e73db --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/binary.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// check for deriving from binary_function
#include <functional>
#include <type_traits>
class functor1
: public std::unary_function<int, char>
{
};
class functor2
: public std::binary_function<char, int, double>
{
};
class functor3
: public std::unary_function<int, int>,
public std::binary_function<char, int, double>
{
public:
typedef float result_type;
};
class functor4
: public std::unary_function<int, int>,
public std::binary_function<char, int, double>
{
public:
};
struct C
{
typedef int argument_type;
typedef int result_type;
};
int main()
{
static_assert((!std::is_base_of<std::binary_function<int, char, int>,
std::reference_wrapper<functor1> >::value), "");
static_assert((std::is_base_of<std::binary_function<char, int, double>,
std::reference_wrapper<functor2> >::value), "");
static_assert((std::is_base_of<std::binary_function<char, int, double>,
std::reference_wrapper<functor3> >::value), "");
static_assert((std::is_base_of<std::binary_function<char, int, double>,
std::reference_wrapper<functor4> >::value), "");
static_assert((!std::is_base_of<std::binary_function<int, int, int>,
std::reference_wrapper<C> >::value), "");
static_assert((!std::is_base_of<std::binary_function<int, int, float>,
std::reference_wrapper<float ()> >::value), "");
static_assert((!std::is_base_of<std::binary_function<int, int, float>,
std::reference_wrapper<float (int)> >::value), "");
static_assert((std::is_base_of<std::binary_function<int, int, float>,
std::reference_wrapper<float (int, int)> >::value), "");
static_assert((!std::is_base_of<std::binary_function<int, int, float>,
std::reference_wrapper<float(*)()> >::value), "");
static_assert((!std::is_base_of<std::binary_function<int, int, float>,
std::reference_wrapper<float(*)(int)> >::value), "");
static_assert((std::is_base_of<std::binary_function<int, int, float>,
std::reference_wrapper<float(*)(int, int)> >::value), "");
static_assert((!std::is_base_of<std::binary_function<C*, int, float>,
std::reference_wrapper<float(C::*)()> >::value), "");
static_assert((std::is_base_of<std::binary_function<C*, int, float>,
std::reference_wrapper<float(C::*)(int)> >::value), "");
static_assert((std::is_base_of<std::binary_function<const volatile C*, int, float>,
std::reference_wrapper<float(C::*)(int) const volatile> >::value), "");
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp b/libcxx/test/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp new file mode 100644 index 00000000000..c7bb7a0c7b5 --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// operator T& () const;
#include <functional>
#include <cassert>
class functor1
: public std::unary_function<int, char>
{
};
template <class T>
void
test(T& t)
{
std::reference_wrapper<T> r(t);
T& r2 = r;
assert(&r2 == &t);
}
void f() {}
int main()
{
void (*fp)() = f;
test(fp);
test(f);
functor1 f1;
test(f1);
int i = 0;
test(i);
const int j = 0;
test(j);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp b/libcxx/test/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp new file mode 100644 index 00000000000..c49105778bc --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// reference_wrapper& operator=(const reference_wrapper<T>& x);
#include <functional>
#include <cassert>
class functor1
: public std::unary_function<int, char>
{
};
template <class T>
void
test(T& t)
{
std::reference_wrapper<T> r(t);
T t2 = t;
std::reference_wrapper<T> r2(t2);
r2 = r;
assert(&r2.get() == &t);
}
void f() {}
void g() {}
void
test_function()
{
std::reference_wrapper<void ()> r(f);
std::reference_wrapper<void ()> r2(g);
r2 = r;
assert(&r2.get() == &f);
}
int main()
{
void (*fp)() = f;
test(fp);
test_function();
functor1 f1;
test(f1);
int i = 0;
test(i);
const int j = 0;
test(j);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp b/libcxx/test/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp new file mode 100644 index 00000000000..a866a41201e --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// reference_wrapper(const reference_wrapper<T>& x);
#include <functional>
#include <cassert>
class functor1
: public std::unary_function<int, char>
{
};
template <class T>
void
test(T& t)
{
std::reference_wrapper<T> r(t);
std::reference_wrapper<T> r2 = r;
assert(&r2.get() == &t);
}
void f() {}
int main()
{
void (*fp)() = f;
test(fp);
test(f);
functor1 f1;
test(f1);
int i = 0;
test(i);
const int j = 0;
test(j);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/refwrap.const/type_ctor.fail.cpp b/libcxx/test/utilities/function.objects/refwrap/refwrap.const/type_ctor.fail.cpp new file mode 100644 index 00000000000..633725b5e61 --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/refwrap.const/type_ctor.fail.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// reference_wrapper(T&&) = delete;
#include <functional>
#include <cassert>
int main()
{
std::reference_wrapper<const int> r(3);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp b/libcxx/test/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp new file mode 100644 index 00000000000..5f141400679 --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// reference_wrapper(T& t);
#include <functional>
#include <cassert>
class functor1
: public std::unary_function<int, char>
{
};
template <class T>
void
test(T& t)
{
std::reference_wrapper<T> r(t);
assert(&r.get() == &t);
}
void f() {}
int main()
{
void (*fp)() = f;
test(fp);
test(f);
functor1 f1;
test(f1);
int i = 0;
test(i);
const int j = 0;
test(j);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/refwrap.helpers/cref_1.pass.cpp b/libcxx/test/utilities/function.objects/refwrap/refwrap.helpers/cref_1.pass.cpp new file mode 100644 index 00000000000..7264e4fc3fb --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/refwrap.helpers/cref_1.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// template <ObjectType T> reference_wrapper<const T> cref(const T& t);
#include <functional>
#include <cassert>
int main()
{
int i = 0;
std::reference_wrapper<const int> r = std::cref(i);
assert(&r.get() == &i);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp b/libcxx/test/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp new file mode 100644 index 00000000000..db712ceba33 --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/refwrap.helpers/cref_2.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// template <ObjectType T> reference_wrapper<const T> cref(reference_wrapper<T> t);
#include <functional>
#include <cassert>
int main()
{
const int i = 0;
std::reference_wrapper<const int> r1 = std::cref(i);
std::reference_wrapper<const int> r2 = std::cref(r1);
assert(&r2.get() == &i);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/refwrap.helpers/ref_1.fail.cpp b/libcxx/test/utilities/function.objects/refwrap/refwrap.helpers/ref_1.fail.cpp new file mode 100644 index 00000000000..934a9a8dac0 --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/refwrap.helpers/ref_1.fail.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// template <ObjectType T> reference_wrapper<T> ref(T& t);
// Don't allow binding to a temp
#include <functional>
struct A {};
const A source() {return A();}
int main()
{
std::reference_wrapper<const A> r = std::ref(source());
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/refwrap.helpers/ref_1.pass.cpp b/libcxx/test/utilities/function.objects/refwrap/refwrap.helpers/ref_1.pass.cpp new file mode 100644 index 00000000000..684b1b358a0 --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/refwrap.helpers/ref_1.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// template <ObjectType T> reference_wrapper<T> ref(T& t);
#include <functional>
#include <cassert>
int main()
{
int i = 0;
std::reference_wrapper<int> r = std::ref(i);
assert(&r.get() == &i);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp b/libcxx/test/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp new file mode 100644 index 00000000000..e8221665bc5 --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/refwrap.helpers/ref_2.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// template <ObjectType T> reference_wrapper<T> ref(reference_wrapper<T>t);
#include <functional>
#include <cassert>
int main()
{
int i = 0;
std::reference_wrapper<int> r1 = std::ref(i);
std::reference_wrapper<int> r2 = std::ref(r1);
assert(&r2.get() == &i);
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/refwrap.invoke/invoke.fail.cpp b/libcxx/test/utilities/function.objects/refwrap/refwrap.invoke/invoke.fail.cpp new file mode 100644 index 00000000000..99a7fe2ddc3 --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/refwrap.invoke/invoke.fail.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// template <class... ArgTypes>
// requires Callable<T, ArgTypes&&...>
// Callable<T, ArgTypes&&...>::result_type
// operator()(ArgTypes&&... args) const;
#include <functional>
#include <cassert>
// member data pointer: cv qualifiers should transfer from argument to return type
struct A_int_1
{
A_int_1() : data_(5) {}
int data_;
};
void
test_int_1()
{
// member data pointer
{
int A_int_1::*fp = &A_int_1::data_;
std::reference_wrapper<int A_int_1::*> r1(fp);
A_int_1 a;
assert(r1(a) == 5);
r1(a) = 6;
assert(r1(a) == 6);
const A_int_1* ap = &a;
assert(r1(ap) == 6);
r1(ap) = 7;
assert(r1(ap) == 7);
}
}
int main()
{
test_int_1();
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/refwrap.invoke/invoke.pass.cpp b/libcxx/test/utilities/function.objects/refwrap/refwrap.invoke/invoke.pass.cpp new file mode 100644 index 00000000000..79a90b20357 --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/refwrap.invoke/invoke.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// template <class... ArgTypes>
// requires Callable<T, ArgTypes&&...>
// Callable<T, ArgTypes&&...>::result_type
// operator()(ArgTypes&&... args) const;
#include <functional>
#include <cassert>
int count = 0;
// 1 arg, return void
void f_void_1(int i)
{
count += i;
}
struct A_void_1
{
void operator()(int i)
{
count += i;
}
void mem1() {++count;}
void mem2() const {++count;}
};
void
test_void_1()
{
int save_count = count;
// function
{
std::reference_wrapper<void (int)> r1(f_void_1);
int i = 2;
r1(i);
assert(count == save_count+2);
save_count = count;
}
// function pointer
{
void (*fp)(int) = f_void_1;
std::reference_wrapper<void (*)(int)> r1(fp);
int i = 3;
r1(i);
assert(count == save_count+3);
save_count = count;
}
// functor
{
A_void_1 a0;
std::reference_wrapper<A_void_1> r1(a0);
int i = 4;
r1(i);
assert(count == save_count+4);
save_count = count;
}
// member function pointer
{
void (A_void_1::*fp)() = &A_void_1::mem1;
std::reference_wrapper<void (A_void_1::*)()> r1(fp);
A_void_1 a;
r1(a);
assert(count == save_count+1);
save_count = count;
A_void_1* ap = &a;
r1(ap);
assert(count == save_count+1);
save_count = count;
}
// const member function pointer
{
void (A_void_1::*fp)() const = &A_void_1::mem2;
std::reference_wrapper<void (A_void_1::*)() const> r1(fp);
A_void_1 a;
r1(a);
assert(count == save_count+1);
save_count = count;
A_void_1* ap = &a;
r1(ap);
assert(count == save_count+1);
save_count = count;
}
}
// 1 arg, return int
int f_int_1(int i)
{
return i + 1;
}
struct A_int_1
{
A_int_1() : data_(5) {}
int operator()(int i)
{
return i - 1;
}
int mem1() {return 3;}
int mem2() const {return 4;}
int data_;
};
void
test_int_1()
{
// function
{
std::reference_wrapper<int (int)> r1(f_int_1);
int i = 2;
assert(r1(i) == 3);
}
// function pointer
{
int (*fp)(int) = f_int_1;
std::reference_wrapper<int (*)(int)> r1(fp);
int i = 3;
assert(r1(i) == 4);
}
// functor
{
A_int_1 a0;
std::reference_wrapper<A_int_1> r1(a0);
int i = 4;
assert(r1(i) == 3);
}
// member function pointer
{
int (A_int_1::*fp)() = &A_int_1::mem1;
std::reference_wrapper<int (A_int_1::*)()> r1(fp);
A_int_1 a;
assert(r1(a) == 3);
A_int_1* ap = &a;
assert(r1(ap) == 3);
}
// const member function pointer
{
int (A_int_1::*fp)() const = &A_int_1::mem2;
std::reference_wrapper<int (A_int_1::*)() const> r1(fp);
A_int_1 a;
assert(r1(a) == 4);
A_int_1* ap = &a;
assert(r1(ap) == 4);
}
// member data pointer
{
int A_int_1::*fp = &A_int_1::data_;
std::reference_wrapper<int A_int_1::*> r1(fp);
A_int_1 a;
assert(r1(a) == 5);
r1(a) = 6;
assert(r1(a) == 6);
A_int_1* ap = &a;
assert(r1(ap) == 6);
r1(ap) = 7;
assert(r1(ap) == 7);
}
}
// 2 arg, return void
void f_void_2(int i, int j)
{
count += i+j;
}
struct A_void_2
{
void operator()(int i, int j)
{
count += i+j;
}
void mem1(int i) {count += i;}
void mem2(int i) const {count += i;}
};
void
test_void_2()
{
int save_count = count;
// function
{
std::reference_wrapper<void (int, int)> r1(f_void_2);
int i = 2;
int j = 3;
r1(i, j);
assert(count == save_count+5);
save_count = count;
}
// function pointer
{
void (*fp)(int, int) = f_void_2;
std::reference_wrapper<void (*)(int, int)> r1(fp);
int i = 3;
int j = 4;
r1(i, j);
assert(count == save_count+7);
save_count = count;
}
// functor
{
A_void_2 a0;
std::reference_wrapper<A_void_2> r1(a0);
int i = 4;
int j = 5;
r1(i, j);
assert(count == save_count+9);
save_count = count;
}
// member function pointer
{
void (A_void_2::*fp)(int) = &A_void_2::mem1;
std::reference_wrapper<void (A_void_2::*)(int)> r1(fp);
A_void_2 a;
int i = 3;
r1(a, i);
assert(count == save_count+3);
save_count = count;
A_void_2* ap = &a;
r1(ap, i);
assert(count == save_count+3);
save_count = count;
}
// const member function pointer
{
void (A_void_2::*fp)(int) const = &A_void_2::mem2;
std::reference_wrapper<void (A_void_2::*)(int) const> r1(fp);
A_void_2 a;
int i = 4;
r1(a, i);
assert(count == save_count+4);
save_count = count;
A_void_2* ap = &a;
r1(ap, i);
assert(count == save_count+4);
save_count = count;
}
}
// 2 arg, return int
int f_int_2(int i, int j)
{
return i+j;
}
struct A_int_2
{
int operator()(int i, int j)
{
return i+j;
}
int mem1(int i) {return i+1;}
int mem2(int i) const {return i+2;}
};
void
testint_2()
{
// function
{
std::reference_wrapper<int (int, int)> r1(f_int_2);
int i = 2;
int j = 3;
assert(r1(i, j) == i+j);
}
// function pointer
{
int (*fp)(int, int) = f_int_2;
std::reference_wrapper<int (*)(int, int)> r1(fp);
int i = 3;
int j = 4;
assert(r1(i, j) == i+j);
}
// functor
{
A_int_2 a0;
std::reference_wrapper<A_int_2> r1(a0);
int i = 4;
int j = 5;
assert(r1(i, j) == i+j);
}
// member function pointer
{
int(A_int_2::*fp)(int) = &A_int_2::mem1;
std::reference_wrapper<int (A_int_2::*)(int)> r1(fp);
A_int_2 a;
int i = 3;
assert(r1(a, i) == i+1);
A_int_2* ap = &a;
assert(r1(ap, i) == i+1);
}
// const member function pointer
{
int (A_int_2::*fp)(int) const = &A_int_2::mem2;
std::reference_wrapper<int (A_int_2::*)(int) const> r1(fp);
A_int_2 a;
int i = 4;
assert(r1(a, i) == i+2);
A_int_2* ap = &a;
assert(r1(ap, i) == i+2);
}
}
int main()
{
test_void_1();
test_int_1();
test_void_2();
testint_2();
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/refwrap.invoke/invoke_int_0.pass.cpp b/libcxx/test/utilities/function.objects/refwrap/refwrap.invoke/invoke_int_0.pass.cpp new file mode 100644 index 00000000000..283177b9a35 --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/refwrap.invoke/invoke_int_0.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// template <class... ArgTypes>
// requires Callable<T, ArgTypes&&...>
// Callable<T, ArgTypes&&...>::result_type
// operator()(ArgTypes&&... args) const;
#include <functional>
#include <cassert>
// 0 args, return int
int count = 0;
int f_int_0()
{
return 3;
}
struct A_int_0
{
int operator()() {return 4;}
};
void
test_int_0()
{
// function
{
std::reference_wrapper<int ()> r1(f_int_0);
assert(r1() == 3);
}
// function pointer
{
int (*fp)() = f_int_0;
std::reference_wrapper<int (*)()> r1(fp);
assert(r1() == 3);
}
// functor
{
A_int_0 a0;
std::reference_wrapper<A_int_0> r1(a0);
assert(r1() == 4);
}
}
// 1 arg, return void
void f_void_1(int i)
{
count += i;
}
struct A_void_1
{
void operator()(int i)
{
count += i;
}
};
int main()
{
test_int_0();
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/refwrap.invoke/invoke_void_0.pass.cpp b/libcxx/test/utilities/function.objects/refwrap/refwrap.invoke/invoke_void_0.pass.cpp new file mode 100644 index 00000000000..649c5c0bbf0 --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/refwrap.invoke/invoke_void_0.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// template <class... ArgTypes>
// requires Callable<T, ArgTypes&&...>
// Callable<T, ArgTypes&&...>::result_type
// operator()(ArgTypes&&... args) const;
#include <functional>
#include <cassert>
// 0 args, return void
int count = 0;
void f_void_0()
{
++count;
}
struct A_void_0
{
void operator()() {++count;}
};
void
test_void_0()
{
int save_count = count;
// function
{
std::reference_wrapper<void ()> r1(f_void_0);
r1();
assert(count == save_count+1);
save_count = count;
}
// function pointer
{
void (*fp)() = f_void_0;
std::reference_wrapper<void (*)()> r1(fp);
r1();
assert(count == save_count+1);
save_count = count;
}
// functor
{
A_void_0 a0;
std::reference_wrapper<A_void_0> r1(a0);
r1();
assert(count == save_count+1);
save_count = count;
}
}
int main()
{
test_void_0();
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/type.pass.cpp b/libcxx/test/utilities/function.objects/refwrap/type.pass.cpp new file mode 100644 index 00000000000..a151625bcca --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/type.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// check for member typedef type
#include <functional>
#include <type_traits>
class C {};
int main()
{
static_assert((std::is_same<std::reference_wrapper<C>::type,
C>::value), "");
static_assert((std::is_same<std::reference_wrapper<void ()>::type,
void ()>::value), "");
static_assert((std::is_same<std::reference_wrapper<int* (double*)>::type,
int* (double*)>::value), "");
static_assert((std::is_same<std::reference_wrapper<void(*)()>::type,
void(*)()>::value), "");
static_assert((std::is_same<std::reference_wrapper<int*(*)(double*)>::type,
int*(*)(double*)>::value), "");
static_assert((std::is_same<std::reference_wrapper<int*(C::*)(double*)>::type,
int*(C::*)(double*)>::value), "");
static_assert((std::is_same<std::reference_wrapper<int (C::*)(double*) const volatile>::type,
int (C::*)(double*) const volatile>::value), "");
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/unary.pass.cpp b/libcxx/test/utilities/function.objects/refwrap/unary.pass.cpp new file mode 100644 index 00000000000..c572920853a --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/unary.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// check for deriving from unary_function
#include <functional>
#include <type_traits>
class functor1
: public std::unary_function<int, char>
{
};
class functor2
: public std::binary_function<char, int, double>
{
};
class functor3
: public std::unary_function<int, int>,
public std::binary_function<char, int, double>
{
public:
typedef float result_type;
};
class functor4
: public std::unary_function<int, int>,
public std::binary_function<char, int, double>
{
public:
};
struct C
{
typedef int argument_type;
typedef int result_type;
};
int main()
{
static_assert((std::is_base_of<std::unary_function<int, char>,
std::reference_wrapper<functor1> >::value), "");
static_assert((!std::is_base_of<std::unary_function<char, int>,
std::reference_wrapper<functor2> >::value), "");
static_assert((std::is_base_of<std::unary_function<int, int>,
std::reference_wrapper<functor3> >::value), "");
static_assert((std::is_base_of<std::unary_function<int, int>,
std::reference_wrapper<functor4> >::value), "");
static_assert((!std::is_base_of<std::unary_function<int, int>,
std::reference_wrapper<C> >::value), "");
static_assert((!std::is_base_of<std::unary_function<int, float>,
std::reference_wrapper<float(*)()> >::value), "");
static_assert((std::is_base_of<std::unary_function<int, float>,
std::reference_wrapper<float (int)> >::value), "");
static_assert((!std::is_base_of<std::unary_function<int, float>,
std::reference_wrapper<float (int, int)> >::value), "");
static_assert((std::is_base_of<std::unary_function<int, float>,
std::reference_wrapper<float(*)(int)> >::value), "");
static_assert((!std::is_base_of<std::unary_function<int, float>,
std::reference_wrapper<float(*)(int, int)> >::value), "");
static_assert((std::is_base_of<std::unary_function<C*, float>,
std::reference_wrapper<float(C::*)()> >::value), "");
static_assert((std::is_base_of<std::unary_function<const volatile C*, float>,
std::reference_wrapper<float(C::*)() const volatile> >::value), "");
static_assert((!std::is_base_of<std::unary_function<C*, float>,
std::reference_wrapper<float(C::*)(int)> >::value), "");
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/refwrap/weak_result.pass.cpp b/libcxx/test/utilities/function.objects/refwrap/weak_result.pass.cpp new file mode 100644 index 00000000000..f0935fd396b --- /dev/null +++ b/libcxx/test/utilities/function.objects/refwrap/weak_result.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
// reference_wrapper
// has weak result type
#include <functional>
#include <type_traits>
class functor1
: public std::unary_function<int, char>
{
};
class functor2
: public std::binary_function<char, int, double>
{
};
class functor3
: public std::unary_function<char, int>,
public std::binary_function<char, int, double>
{
public:
typedef float result_type;
};
class functor4
: public std::unary_function<char, int>,
public std::binary_function<char, int, double>
{
public:
};
class C {};
template <class T>
struct has_result_type
{
private:
struct two {char _; char __;};
template <class U> static two test(...);
template <class U> static char test(typename U::result_type* = 0);
public:
static const bool value = sizeof(test<T>(0)) == 1;
};
int main()
{
static_assert((std::is_same<std::reference_wrapper<functor1>::result_type,
char>::value), "");
static_assert((std::is_same<std::reference_wrapper<functor2>::result_type,
double>::value), "");
static_assert((std::is_same<std::reference_wrapper<functor3>::result_type,
float>::value), "");
static_assert((std::is_same<std::reference_wrapper<void()>::result_type,
void>::value), "");
static_assert((std::is_same<std::reference_wrapper<int*(double*)>::result_type,
int*>::value), "");
static_assert((std::is_same<std::reference_wrapper<void(*)()>::result_type,
void>::value), "");
static_assert((std::is_same<std::reference_wrapper<int*(*)(double*)>::result_type,
int*>::value), "");
static_assert((std::is_same<std::reference_wrapper<int*(C::*)(double*)>::result_type,
int*>::value), "");
static_assert((std::is_same<std::reference_wrapper<int (C::*)(double*) const volatile>::result_type,
int>::value), "");
static_assert((std::is_same<std::reference_wrapper<C()>::result_type,
C>::value), "");
static_assert(has_result_type<std::reference_wrapper<functor3> >::value, "");
static_assert(!has_result_type<std::reference_wrapper<functor4> >::value, "");
static_assert(!has_result_type<std::reference_wrapper<C> >::value, "");
}
\ No newline at end of file diff --git a/libcxx/test/utilities/function.objects/unord.hash/floating.pass.cpp b/libcxx/test/utilities/function.objects/unord.hash/floating.pass.cpp new file mode 100644 index 00000000000..003ba198c64 --- /dev/null +++ b/libcxx/test/utilities/function.objects/unord.hash/floating.pass.cpp @@ -0,0 +1,68 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <functional> + +// template <class T> +// struct hash +// : public unary_function<T, size_t> +// { +// size_t operator()(T val) const; +// }; + +// Not very portable + +#include <functional> +#include <cassert> +#include <type_traits> +#include <limits> +#include <cmath> + +template <class T> +void +test() +{ + static_assert((std::is_base_of<std::unary_function<T, std::size_t>, + std::hash<T> >::value), ""); + std::hash<T> h; + std::size_t t0 = h(0.); + std::size_t tn0 = h(-0.); + std::size_t tp1 = h(0.1); + std::size_t t1 = h(1); + std::size_t tn1 = h(-1); + std::size_t pinf = h(INFINITY); + std::size_t ninf = h(-INFINITY); + assert(t0 == tn0); + assert(t0 != tp1); + assert(t0 != t1); + assert(t0 != tn1); + assert(t0 != pinf); + assert(t0 != ninf); + + assert(tp1 != t1); + assert(tp1 != tn1); + assert(tp1 != pinf); + assert(tp1 != ninf); + + assert(t1 != tn1); + assert(t1 != pinf); + assert(t1 != ninf); + + assert(tn1 != pinf); + assert(tn1 != ninf); + + assert(pinf != ninf); +} + +int main() +{ + test<float>(); + test<double>(); + test<long double>(); +} diff --git a/libcxx/test/utilities/function.objects/unord.hash/integral.pass.cpp b/libcxx/test/utilities/function.objects/unord.hash/integral.pass.cpp new file mode 100644 index 00000000000..1e6c0d559de --- /dev/null +++ b/libcxx/test/utilities/function.objects/unord.hash/integral.pass.cpp @@ -0,0 +1,57 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <functional> + +// template <class T> +// struct hash +// : public unary_function<T, size_t> +// { +// size_t operator()(T val) const; +// }; + +// Not very portable + +#include <functional> +#include <cassert> +#include <type_traits> +#include <limits> + +template <class T> +void +test() +{ + static_assert((std::is_base_of<std::unary_function<T, std::size_t>, + std::hash<T> >::value), ""); + std::hash<T> h; + for (int i = 0; i <= 5; ++i) + { + T t(i); + assert(h(t) == t); + } +} + +int main() +{ + test<bool>(); + test<char>(); + test<signed char>(); + test<unsigned char>(); + test<char16_t>(); + test<char32_t>(); + test<wchar_t>(); + test<short>(); + test<unsigned short>(); + test<int>(); + test<unsigned int>(); + test<long>(); + test<unsigned long>(); + test<long long>(); + test<unsigned long long>(); +} diff --git a/libcxx/test/utilities/function.objects/unord.hash/pointer.pass.cpp b/libcxx/test/utilities/function.objects/unord.hash/pointer.pass.cpp new file mode 100644 index 00000000000..1a66b5b8cd4 --- /dev/null +++ b/libcxx/test/utilities/function.objects/unord.hash/pointer.pass.cpp @@ -0,0 +1,42 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <functional> + +// template <class T> +// struct hash +// : public unary_function<T, size_t> +// { +// size_t operator()(T val) const; +// }; + +// Not very portable + +#include <functional> +#include <cassert> +#include <type_traits> +#include <limits> + +template <class T> +void +test() +{ + static_assert((std::is_base_of<std::unary_function<T, std::size_t>, + std::hash<T> >::value), ""); + std::hash<T> h; + typedef typename std::remove_pointer<T>::type type; + type i; + type j; + assert(h(&i) != h(&j)); +} + +int main() +{ + test<int*>(); +} diff --git a/libcxx/test/utilities/function.objects/version.pass.cpp b/libcxx/test/utilities/function.objects/version.pass.cpp new file mode 100644 index 00000000000..5b53d1884e9 --- /dev/null +++ b/libcxx/test/utilities/function.objects/version.pass.cpp @@ -0,0 +1 @@ +//===----------------------------------------------------------------------===//
//
// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <functional>
#include <functional>
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
int main()
{
}
\ No newline at end of file |
