1 //===----------------------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 // type_traits
11
12 // is_convertible
13
14 #include <type_traits>
15
16 template <class T, class U>
test_is_convertible()17 void test_is_convertible()
18 {
19 static_assert((std::is_convertible<T, U>::value), "");
20 static_assert((std::is_convertible<const T, U>::value), "");
21 static_assert((std::is_convertible<T, const U>::value), "");
22 static_assert((std::is_convertible<const T, const U>::value), "");
23 }
24
25 template <class T, class U>
test_is_not_convertible()26 void test_is_not_convertible()
27 {
28 static_assert((!std::is_convertible<T, U>::value), "");
29 static_assert((!std::is_convertible<const T, U>::value), "");
30 static_assert((!std::is_convertible<T, const U>::value), "");
31 static_assert((!std::is_convertible<const T, const U>::value), "");
32 }
33
34 typedef void Function();
35 typedef char Array[1];
36
37 class NonCopyable {
38 NonCopyable(NonCopyable&);
39 };
40
41 class MoveOnly {
42 MoveOnly(const MoveOnly &);
43 MoveOnly& operator =(const MoveOnly&);
44 public:
45 MoveOnly(MoveOnly&& x);
46 };
47
main()48 int main()
49 {
50 // void
51 test_is_convertible<void,void> ();
52 test_is_not_convertible<void,Function> ();
53 test_is_not_convertible<void,Function&> ();
54 test_is_not_convertible<void,Function*> ();
55 test_is_not_convertible<void,Array> ();
56 test_is_not_convertible<void,Array&> ();
57 test_is_not_convertible<void,char> ();
58 test_is_not_convertible<void,char&> ();
59 test_is_not_convertible<void,char*> ();
60
61 // Function
62 test_is_not_convertible<Function, void> ();
63 test_is_not_convertible<Function, Function> ();
64 test_is_convertible<Function, Function&> ();
65 test_is_convertible<Function, Function*> ();
66 test_is_not_convertible<Function, Array> ();
67 test_is_not_convertible<Function, Array&> ();
68 test_is_not_convertible<Function, char> ();
69 test_is_not_convertible<Function, char&> ();
70 test_is_not_convertible<Function, char*> ();
71
72 // Function&
73 test_is_not_convertible<Function&, void> ();
74 test_is_not_convertible<Function&, Function> ();
75 test_is_convertible<Function&, Function&> ();
76
77 test_is_convertible<Function&, Function*> ();
78 test_is_not_convertible<Function&, Array> ();
79 test_is_not_convertible<Function&, Array&> ();
80 test_is_not_convertible<Function&, char> ();
81 test_is_not_convertible<Function&, char&> ();
82 test_is_not_convertible<Function&, char*> ();
83
84 // Function*
85 test_is_not_convertible<Function*, void> ();
86 test_is_not_convertible<Function*, Function> ();
87 test_is_not_convertible<Function*, Function&> ();
88 test_is_convertible<Function*, Function*> ();
89
90 test_is_not_convertible<Function*, Array> ();
91 test_is_not_convertible<Function*, Array&> ();
92 test_is_not_convertible<Function*, char> ();
93 test_is_not_convertible<Function*, char&> ();
94 test_is_not_convertible<Function*, char*> ();
95
96 // Array
97 test_is_not_convertible<Array, void> ();
98 test_is_not_convertible<Array, Function> ();
99 test_is_not_convertible<Array, Function&> ();
100 test_is_not_convertible<Array, Function*> ();
101 test_is_not_convertible<Array, Array> ();
102
103 static_assert((!std::is_convertible<Array, Array&>::value), "");
104 static_assert(( std::is_convertible<Array, const Array&>::value), "");
105 static_assert((!std::is_convertible<const Array, Array&>::value), "");
106 static_assert(( std::is_convertible<const Array, const Array&>::value), "");
107
108 test_is_not_convertible<Array, char> ();
109 test_is_not_convertible<Array, char&> ();
110
111 static_assert(( std::is_convertible<Array, char*>::value), "");
112 static_assert(( std::is_convertible<Array, const char*>::value), "");
113 static_assert((!std::is_convertible<const Array, char*>::value), "");
114 static_assert(( std::is_convertible<const Array, const char*>::value), "");
115
116 // Array&
117 test_is_not_convertible<Array&, void> ();
118 test_is_not_convertible<Array&, Function> ();
119 test_is_not_convertible<Array&, Function&> ();
120 test_is_not_convertible<Array&, Function*> ();
121 test_is_not_convertible<Array&, Array> ();
122
123 static_assert(( std::is_convertible<Array&, Array&>::value), "");
124 static_assert(( std::is_convertible<Array&, const Array&>::value), "");
125 static_assert((!std::is_convertible<const Array&, Array&>::value), "");
126 static_assert(( std::is_convertible<const Array&, const Array&>::value), "");
127
128 test_is_not_convertible<Array&, char> ();
129 test_is_not_convertible<Array&, char&> ();
130
131 static_assert(( std::is_convertible<Array&, char*>::value), "");
132 static_assert(( std::is_convertible<Array&, const char*>::value), "");
133 static_assert((!std::is_convertible<const Array&, char*>::value), "");
134 static_assert(( std::is_convertible<const Array&, const char*>::value), "");
135
136 // char
137 test_is_not_convertible<char, void> ();
138 test_is_not_convertible<char, Function> ();
139 test_is_not_convertible<char, Function&> ();
140 test_is_not_convertible<char, Function*> ();
141 test_is_not_convertible<char, Array> ();
142 test_is_not_convertible<char, Array&> ();
143
144 test_is_convertible<char, char> ();
145
146 static_assert((!std::is_convertible<char, char&>::value), "");
147 static_assert(( std::is_convertible<char, const char&>::value), "");
148 static_assert((!std::is_convertible<const char, char&>::value), "");
149 static_assert(( std::is_convertible<const char, const char&>::value), "");
150
151 test_is_not_convertible<char, char*> ();
152
153 // char&
154 test_is_not_convertible<char&, void> ();
155 test_is_not_convertible<char&, Function> ();
156 test_is_not_convertible<char&, Function&> ();
157 test_is_not_convertible<char&, Function*> ();
158 test_is_not_convertible<char&, Array> ();
159 test_is_not_convertible<char&, Array&> ();
160
161 test_is_convertible<char&, char> ();
162
163 static_assert(( std::is_convertible<char&, char&>::value), "");
164 static_assert(( std::is_convertible<char&, const char&>::value), "");
165 static_assert((!std::is_convertible<const char&, char&>::value), "");
166 static_assert(( std::is_convertible<const char&, const char&>::value), "");
167
168 test_is_not_convertible<char&, char*> ();
169
170 // char*
171 test_is_not_convertible<char*, void> ();
172 test_is_not_convertible<char*, Function> ();
173 test_is_not_convertible<char*, Function&> ();
174 test_is_not_convertible<char*, Function*> ();
175 test_is_not_convertible<char*, Array> ();
176 test_is_not_convertible<char*, Array&> ();
177
178 test_is_not_convertible<char*, char> ();
179 test_is_not_convertible<char*, char&> ();
180
181 static_assert(( std::is_convertible<char*, char*>::value), "");
182 static_assert(( std::is_convertible<char*, const char*>::value), "");
183 static_assert((!std::is_convertible<const char*, char*>::value), "");
184 static_assert(( std::is_convertible<const char*, const char*>::value), "");
185
186 // NonCopyable
187 static_assert(( std::is_convertible<NonCopyable&, NonCopyable&>::value), "");
188 static_assert(( std::is_convertible<NonCopyable&, const NonCopyable&>::value), "");
189 static_assert(( std::is_convertible<NonCopyable&, const volatile NonCopyable&>::value), "");
190 static_assert(( std::is_convertible<NonCopyable&, volatile NonCopyable&>::value), "");
191 static_assert(( std::is_convertible<const NonCopyable&, const NonCopyable&>::value), "");
192 static_assert(( std::is_convertible<const NonCopyable&, const volatile NonCopyable&>::value), "");
193 static_assert(( std::is_convertible<volatile NonCopyable&, const volatile NonCopyable&>::value), "");
194 static_assert(( std::is_convertible<const volatile NonCopyable&, const volatile NonCopyable&>::value), "");
195 static_assert((!std::is_convertible<const NonCopyable&, NonCopyable&>::value), "");
196
197 // MoveOnly
198 static_assert(( std::is_convertible<MoveOnly, MoveOnly>::value), "");
199 static_assert((!std::is_convertible<const MoveOnly, MoveOnly>::value), "");
200 }
201