1 template<typename T, class P>
2 struct TwoOptionTemplate {};
3
4 template<typename T>
5 struct TwoOptionTemplate<T, char> {
6 int member;
7 };
8
9
10 template<typename T>
11 struct TwoOptionTemplate<T, double> {
12 float member;
13 };
14
15 template<typename T>
16 struct TwoOptionTemplate<T, T> {
17 T** member;
18 };
19
20 TwoOptionTemplate<int, char> X0;
21 TwoOptionTemplate<int, float> X1;
22 TwoOptionTemplate<void *, wchar_t> X2;
23 TwoOptionTemplate<long, long> X3;
24 TwoOptionTemplate<float, float> X4;
25 TwoOptionTemplate<long, long> SingleSource;
26 TwoOptionTemplate<char, double> SecondDoubleSource;
27
28
29 template<int I, class C>
30 struct IntTemplateSpec {};
31
32 template<class C>
33 struct IntTemplateSpec<4, C> {
34 C member;
35 };
36
37 template<int I>
38 struct IntTemplateSpec<I, void *> {
39 int member;
40 static constexpr int val = I;
41 };
42
43 template<int I>
44 struct IntTemplateSpec<I, double> {
45 char member;
46 static constexpr int val = I;
47 };
48
49 IntTemplateSpec<4, wchar_t> Y0;
50 IntTemplateSpec<5, void *> Y1;
51 IntTemplateSpec<1, long> Y2;
52 IntTemplateSpec<3, int> Y3;
53 //template<int I> constexpr int IntTemplateSpec<I, double>::val;
54 IntTemplateSpec<42, double> NumberSource;
55 static_assert(NumberSource.val == 42);
56
57 namespace One {
58 namespace Two {
59 // Just an empty namespace to ensure we can deal with multiple namespace decls.
60 }
61 }
62
63
64 namespace One {
65 namespace Two {
66 namespace Three {
67
68 template<class T>
69 class Parent {};
70
71 } // namespace Three
72
73 } // namespace Two
74
75 template<typename T, typename X>
76 struct Child1: public Two::Three::Parent<unsigned> {
77 char member;
78 };
79
80 template<class T>
81 struct Child1<T, One::Two::Three::Parent<T>> {
82 T member;
83 };
84
85 } // namespace One
86
87 One::Child1<int, double> Z0Source;
88
89 // Test import of nested namespace specifiers
90 template<typename T>
91 struct Outer {
92 template<typename U> class Inner0;
93 };
94
95 template<typename X>
96 template<typename Y>
97 class Outer<X>::Inner0 {
98 public:
99 void f(X, Y);
100 template<typename Z> struct Inner1;
101 };
102
103 template<typename X>
104 template<typename Y>
f(X,Y)105 void Outer<X>::Inner0<Y>::f(X, Y) {}
106
107 template<typename X>
108 template<typename Y>
109 template<typename Z>
110 class Outer<X>::Inner0<Y>::Inner1 {
111 public:
112 void f(Y, Z);
113 };
114
115 template<typename X>
116 template<typename Y>
117 template<typename Z>
f(Y,Z)118 void Outer<X>::Inner0<Y>::Inner1<Z>::f(Y, Z) {}
119