| // -*- C++ -*- |
| /*************************************************************************** |
| * |
| * 20.meta.unary.cat.cpp - test exercising meta.unary.cat |
| * |
| * $Id$ |
| * |
| *************************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed |
| * with this work for additional information regarding copyright |
| * ownership. The ASF licenses this file to you under the Apache |
| * License, Version 2.0 (the "License"); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * permissions and limitations under the License. |
| * |
| * Copyright 1999-2008 Rogue Wave Software, Inc. |
| * |
| **************************************************************************/ |
| |
| #include <rw_driver.h> |
| #include <rw/_defs.h> |
| |
| // compile out all test code if extensions disabled |
| #ifndef _RWSTD_NO_EXT_CXX_0X |
| |
| #include <type_traits> |
| |
| #include <stddef.h> |
| |
| /**************************************************************************/ |
| |
| static void |
| test_trait (int line, |
| const char* trait_name, const char* type_name, |
| size_t count, bool value) |
| { |
| // verify that the expected trait is actually working |
| |
| if (rw_assert (value != false, 0, line, |
| "%s<%s>::value was %b, expected true", |
| trait_name, type_name, value)) |
| { |
| |
| // [meta.unary.cat p3] for any given type T, exactly one of the |
| // primary type categories has a value member that evaluates to |
| // true |
| |
| rw_assert (count == 1, 0, line, |
| "%s evaluated true for %zu traits, expected 1", |
| type_name, count); |
| } |
| } |
| |
| #define _TEST(Trait,Type) \ |
| test_trait(__LINE__, #Trait, #Type, \ |
| std::is_void<Type>::value \ |
| + std::is_integral<Type>::value \ |
| + std::is_floating_point<Type>::value \ |
| + std::is_array<Type>::value \ |
| + std::is_pointer<Type>::value \ |
| + std::is_lvalue_reference<Type>::value \ |
| + std::is_rvalue_reference<Type>::value \ |
| + std::is_member_object_pointer<Type>::value \ |
| + std::is_member_function_pointer<Type>::value \ |
| + std::is_enum<Type>::value \ |
| + std::is_union<Type>::value \ |
| + std::is_class<Type>::value \ |
| + std::is_function<Type>::value, \ |
| Trait<Type>::value) |
| |
| #if 0 |
| |
| #define TEST(Trait,Type) \ |
| _TEST(Trait, Type); \ |
| _TEST(Trait, std::add_const<Type>::type); \ |
| _TEST(Trait, std::add_volatile<Type>::type); \ |
| _TEST(Trait, std::add_cv<Type>::type) |
| |
| #else |
| |
| #define TEST(Trait,Type) \ |
| _TEST(Trait, Type) |
| |
| #endif |
| |
| /**************************************************************************/ |
| |
| class class_t { |
| int i_; float f_; |
| }; |
| |
| struct struct_t { |
| int i_; float f_; |
| }; |
| |
| union union_t { |
| int i_; float f_; |
| }; |
| |
| enum enum_t { |
| E_a, E_b, E_c |
| }; |
| |
| /**************************************************************************/ |
| |
| static void test_is_void () |
| { |
| TEST(std::is_void, void); |
| } |
| |
| static void test_is_integral () |
| { |
| TEST(std::is_integral, bool); |
| TEST(std::is_integral, char); |
| |
| #ifndef _RWSTD_NO_WCHAR_T |
| TEST(std::is_integral, wchar_t); |
| #endif // _RWSTD_NO_WCHAR_T |
| |
| TEST(std::is_integral, signed char); |
| TEST(std::is_integral, unsigned char); |
| |
| TEST(std::is_integral, signed short); |
| TEST(std::is_integral, unsigned short); |
| |
| TEST(std::is_integral, signed int); |
| TEST(std::is_integral, unsigned int); |
| |
| TEST(std::is_integral, signed long); |
| TEST(std::is_integral, unsigned long); |
| |
| #ifndef _RWSTD_NO_LONG_LONG |
| TEST(std::is_integral, signed long long); |
| TEST(std::is_integral, unsigned long long); |
| #endif // _RWSTD_NO_LONG_LONG |
| } |
| |
| static void test_is_floating_point () |
| { |
| TEST(std::is_floating_point, float); |
| TEST(std::is_floating_point, double); |
| TEST(std::is_floating_point, long double); |
| } |
| |
| static void test_is_array () |
| { |
| TEST(std::is_array, char []); |
| TEST(std::is_array, char [10]); |
| TEST(std::is_array, char [][10]); |
| TEST(std::is_array, char [10][10]); |
| } |
| |
| static void test_is_pointer () |
| { |
| TEST(std::is_pointer, char* const); |
| TEST(std::is_pointer, char const*); |
| TEST(std::is_pointer, const char*); |
| |
| TEST(std::is_pointer, char*); |
| TEST(std::is_pointer, char (*)[]); |
| TEST(std::is_pointer, char (*)()); |
| } |
| |
| static void test_is_lvalue_reference () |
| { |
| TEST(std::is_lvalue_reference, char&); // reference |
| |
| TEST(std::is_lvalue_reference, void (&)()); // function reference |
| TEST(std::is_lvalue_reference, void (&)(int)); // function reference |
| |
| #ifdef _ILL_FORMED |
| TEST(std::is_lvalue_reference, long (&)[]); // array reference |
| TEST(std::is_lvalue_reference, long (&)[][10]); // array reference |
| #endif |
| |
| TEST(std::is_lvalue_reference, long (&)[10]); // array reference |
| TEST(std::is_lvalue_reference, long (&)[10][10]); // array reference |
| } |
| |
| static void test_is_rvalue_reference () |
| { |
| #ifndef _RWSTD_NO_RVALUE_REFERENCES |
| TEST(std::is_rvalue_reference, char&&); |
| #else |
| rw_warn (0, 0, __LINE__, |
| "test_is_rvalue_reference() disabled because " |
| "_RWSTD_NO_RVALUE_REFERENCES is defined"); |
| #endif // _RWSTD_NO_RVALUE_REFERENCES |
| } |
| |
| static void test_is_member_object_pointer () |
| { |
| TEST (std::is_member_object_pointer, long (class_t::*)); |
| TEST (std::is_member_object_pointer, long (struct_t::*)); |
| TEST (std::is_member_object_pointer, long (union_t::*)); |
| } |
| |
| static void test_is_member_function_pointer () |
| { |
| // arity 0 |
| TEST (std::is_member_function_pointer, long (class_t:: *)()); |
| TEST (std::is_member_function_pointer, long (struct_t::*)()); |
| TEST (std::is_member_function_pointer, long (union_t:: *)()); |
| |
| // arity 1 |
| TEST (std::is_member_function_pointer, long (class_t:: *)(int)); |
| TEST (std::is_member_function_pointer, long (struct_t::*)(int)); |
| TEST (std::is_member_function_pointer, long (union_t:: *)(int)); |
| |
| // arity 2 |
| TEST (std::is_member_function_pointer, |
| long (class_t:: *)(int, char)); |
| TEST (std::is_member_function_pointer, |
| long (struct_t::*)(int, char)); |
| TEST (std::is_member_function_pointer, |
| long (union_t:: *)(int, char)); |
| |
| // arity 12 |
| TEST (std::is_member_function_pointer, |
| long (class_t:: *)(char, short, int, long, float, double, |
| char, short, int, long, float, double)); |
| TEST (std::is_member_function_pointer, |
| long (struct_t::*)(char, short, int, long, float, double, |
| char, short, int, long, float, double)); |
| TEST (std::is_member_function_pointer, |
| long (union_t:: *)(char, short, int, long, float, double, |
| char, short, int, long, float, double)); |
| } |
| |
| static void test_is_enum () |
| { |
| TEST (std::is_enum, enum_t); |
| } |
| |
| static void test_is_union () |
| { |
| #if !defined (_RWSTD_TT_IS_CLASS) && !defined (_RWSTD_TT_IS_UNION) |
| |
| rw_warn (0, 0, __LINE__, |
| "test_is_union() disabled because neither of " |
| "_RWSTD_TT_IS_CLASS or _RWSTD_TT_IS_UNION is " |
| "defined"); |
| |
| #else |
| TEST (std::is_union, union_t); |
| #endif |
| } |
| |
| static void test_is_class () |
| { |
| TEST (std::is_class, class_t); |
| TEST (std::is_class, struct_t); |
| } |
| |
| static void test_is_function () |
| { |
| TEST (std::is_function, void ()); |
| TEST (std::is_function, long (int)); |
| TEST (std::is_function, long (int, char)); |
| TEST (std::is_function, long (int, char)); |
| } |
| |
| |
| /**************************************************************************/ |
| |
| static int run_test (int, char*[]) |
| { |
| test_is_void (); |
| test_is_integral (); |
| test_is_floating_point (); |
| test_is_array (); |
| test_is_pointer (); |
| test_is_lvalue_reference (); |
| test_is_rvalue_reference (); |
| test_is_member_object_pointer (); |
| test_is_member_function_pointer (); |
| test_is_enum (); |
| test_is_union (); |
| test_is_class (); |
| test_is_function (); |
| |
| return 0; |
| } |
| |
| /**************************************************************************/ |
| |
| #else // _RWSTD_NO_EXT_CXX_0X |
| |
| /**************************************************************************/ |
| |
| static int run_test (int, char*[]) |
| { |
| rw_warn (0, 0, __LINE__, |
| "test disabled because _RWSTD_NO_EXT_CXX_0X is defined"); |
| return 0; |
| } |
| |
| #endif // !_RWSTD_NO_EXT_CXX_0X |
| |
| /**************************************************************************/ |
| |
| int main (int argc, char *argv[]) |
| { |
| return rw_test (argc, argv, __FILE__, |
| "meta.unary.cat", |
| 0 /* no comment */, |
| run_test, |
| 0); |
| } |
| |