diff options
Diffstat (limited to 'test/std/utilities/function.objects/func.memfn')
6 files changed, 391 insertions, 0 deletions
diff --git a/test/std/utilities/function.objects/func.memfn/member_data.fail.cpp b/test/std/utilities/function.objects/func.memfn/member_data.fail.cpp new file mode 100644 index 000000000000..5e748c93b9e4 --- /dev/null +++ b/test/std/utilities/function.objects/func.memfn/member_data.fail.cpp @@ -0,0 +1,42 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. 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_)); +} diff --git a/test/std/utilities/function.objects/func.memfn/member_data.pass.cpp b/test/std/utilities/function.objects/func.memfn/member_data.pass.cpp new file mode 100644 index 000000000000..dff211c60573 --- /dev/null +++ b/test/std/utilities/function.objects/func.memfn/member_data.pass.cpp @@ -0,0 +1,43 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. 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)); + const F& cf = f; + assert(cf(ap) == f(ap)); + } +} + +int main() +{ + test(std::mem_fn(&A::data_)); +} diff --git a/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp b/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp new file mode 100644 index 000000000000..4096bd814421 --- /dev/null +++ b/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp @@ -0,0 +1,72 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. 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'); + const F& cf = f; + assert(cf(ap) == 'a'); + } +} + +template <class F> +void +test1(F f) +{ + { + A a; + assert(f(a, 1) == 'b'); + A* ap = &a; + assert(f(ap, 2) == 'b'); + const F& cf = f; + assert(cf(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'); + const F& cf = f; + assert(cf(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)); +} diff --git a/test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp b/test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp new file mode 100644 index 000000000000..be22443e9542 --- /dev/null +++ b/test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp @@ -0,0 +1,78 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. 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'); + const F& cf = f; + assert(cf(ap) == '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'); + const F& cf = f; + assert(cf(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'); + const A* cap = &a; + assert(f(cap, 2, 3.5) == 'c'); + const F& cf = f; + assert(cf(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)); +} diff --git a/test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp b/test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp new file mode 100644 index 000000000000..329ac16a86db --- /dev/null +++ b/test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp @@ -0,0 +1,78 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. 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'); + const F& cf = f; + assert(cf(ap) == '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'); + const F& cf = f; + assert(cf(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'); + const volatile A* cap = &a; + assert(f(cap, 2, 3.5) == 'c'); + const F& cf = f; + assert(cf(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)); +} diff --git a/test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp b/test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp new file mode 100644 index 000000000000..743ded9944aa --- /dev/null +++ b/test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp @@ -0,0 +1,78 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. 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'); + const F& cf = f; + assert(cf(ap) == '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'); + const F& cf = f; + assert(cf(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'); + volatile A* cap = &a; + assert(f(cap, 2, 3.5) == 'c'); + const F& cf = f; + assert(cf(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)); +} |