1 /*
2 * Copyright (c) Facebook, Inc. and its affiliates.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <thrift/lib/cpp2/gen/module_types_cpp.h>
18
19 #include <folly/portability/GTest.h>
20 #include <thrift/lib/cpp2/TypeClass.h>
21
22 using namespace apache::thrift;
23
24 // Fields without any unique-ness.
TEST(CopyUniqueTest,NoUnique)25 TEST(CopyUniqueTest, NoUnique) {
26 auto i = 42;
27 auto i_copy = detail::st::copy_field<type_class::integral>(i);
28 static_assert(std::is_same_v<decltype(i), decltype(i_copy)>);
29 EXPECT_EQ(i, i_copy);
30 EXPECT_NE(&i, &i_copy);
31
32 auto s = std::string("foo");
33 auto s_copy = detail::st::copy_field<type_class::string>(s);
34 static_assert(std::is_same_v<decltype(s), decltype(s_copy)>);
35 EXPECT_EQ(s, s_copy);
36 EXPECT_NE(&s, &s_copy);
37
38 auto v = std::vector<int>{1, 2, 3};
39 auto v_copy =
40 detail::st::copy_field<type_class::list<type_class::integral>>(v);
41 static_assert(std::is_same_v<decltype(v), std::vector<int>>);
42 EXPECT_EQ(v, v_copy);
43 EXPECT_NE(&v, &v_copy);
44 }
45
46 //
TEST(CopyUniqueTest,Unique)47 TEST(CopyUniqueTest, Unique) {
48 auto v = std::vector<std::unique_ptr<int>>{};
49 v.push_back(std::make_unique<int>(101));
50 v.push_back(std::make_unique<int>(202));
51 auto v_copy =
52 detail::st::copy_field<type_class::list<type_class::integral>>(v);
53 static_assert(std::is_same_v<decltype(v), decltype(v_copy)>);
54 auto v_iter = v.begin();
55 auto v_copy_iter = v_copy.begin();
56 for (; v_iter != v.end() && v_copy_iter != v_copy.end();
57 ++v_iter, ++v_copy_iter) {
58 EXPECT_EQ(**v_iter, **v_copy_iter);
59 EXPECT_NE(v_iter, v_copy_iter);
60 }
61 EXPECT_NE(&v, &v_copy);
62
63 auto s = std::set<std::unique_ptr<int>>{};
64 s.insert(std::make_unique<int>(101));
65 s.insert(std::make_unique<int>(202));
66 auto s_copy =
67 detail::st::copy_field<type_class::set<type_class::integral>>(s);
68 static_assert(std::is_same_v<decltype(s), decltype(s_copy)>);
69 auto s_iter = s.begin();
70 auto s_copy_iter = s_copy.begin();
71 for (; s_iter != s.end() && s_copy_iter != s_copy.end();
72 ++s_iter, ++s_copy_iter) {
73 EXPECT_EQ(**s_iter, **s_copy_iter);
74 EXPECT_NE(s_iter, s_copy_iter);
75 }
76 EXPECT_NE(&s, &s_copy);
77
78 auto m = std::map<int, std::unique_ptr<int>>{};
79 m.emplace(0, std::make_unique<int>(101));
80 m.emplace(1, std::make_unique<int>(202));
81 auto m_copy = detail::st::copy_field<
82 type_class::map<type_class::integral, type_class::integral>>(m);
83 static_assert(std::is_same_v<decltype(m), decltype(m_copy)>);
84 auto m_iter = m.begin();
85 auto m_copy_iter = m_copy.begin();
86 for (; m_iter != m.end() && m_copy_iter != m_copy.end();
87 ++m_iter, ++m_copy_iter) {
88 EXPECT_EQ(m_iter->first, m_copy_iter->first);
89 EXPECT_NE(&m_iter->first, &m_copy_iter->first);
90 EXPECT_EQ(*m_iter->second, *m_copy_iter->second);
91 EXPECT_NE(m_iter->second, m_copy_iter->second);
92 }
93 EXPECT_NE(&m, &m_copy);
94 }
95
96 // Field-level annotations such as `cpp.ref`, `cpp.ref_type = "unique"`.
TEST(CopyUniqueTest,UniqueRef)97 TEST(CopyUniqueTest, UniqueRef) {
98 auto pi = std::make_unique<int>(42);
99 auto pi_copy = detail::st::copy_field<type_class::integral>(pi);
100 static_assert(std::is_same_v<decltype(pi), decltype(pi_copy)>);
101 EXPECT_EQ(*pi, *pi_copy);
102 EXPECT_NE(pi, pi_copy);
103
104 auto ps = std::make_unique<std::string>("foo");
105 auto ps_copy = detail::st::copy_field<type_class::string>(ps);
106 static_assert(std::is_same_v<decltype(ps), decltype(ps_copy)>);
107 EXPECT_EQ(*ps, *ps_copy);
108 EXPECT_NE(ps, ps_copy);
109
110 auto pv = std::make_unique<std::vector<int>>(std::vector<int>{1, 2, 3});
111 auto pv_copy =
112 detail::st::copy_field<type_class::list<type_class::integral>>(pv);
113 static_assert(std::is_same_v<decltype(pv), decltype(pv_copy)>);
114 EXPECT_EQ(*pv, *pv_copy);
115 EXPECT_NE(pv, pv_copy);
116
117 auto pvp = std::make_unique<std::vector<std::unique_ptr<int>>>();
118 pvp->push_back(std::make_unique<int>(101));
119 pvp->push_back(std::make_unique<int>(202));
120 auto pvp_copy =
121 detail::st::copy_field<type_class::list<type_class::integral>>(pvp);
122 static_assert(std::is_same_v<decltype(pvp), decltype(pvp_copy)>);
123 auto pvp_iter = pvp->begin();
124 auto pvp_copy_iter = pvp_copy->begin();
125 for (; pvp_iter != pvp->end() && pvp_copy_iter != pvp_copy->end();
126 ++pvp_iter, ++pvp_copy_iter) {
127 EXPECT_EQ(**pvp_iter, **pvp_copy_iter);
128 EXPECT_NE(pvp_iter, pvp_copy_iter);
129 }
130 EXPECT_NE(&pvp, &pvp_copy);
131
132 auto psp = std::make_unique<std::set<std::unique_ptr<int>>>();
133 psp->insert(std::make_unique<int>(101));
134 psp->insert(std::make_unique<int>(202));
135 auto psp_copy =
136 detail::st::copy_field<type_class::set<type_class::integral>>(psp);
137 static_assert(std::is_same_v<decltype(psp), decltype(psp_copy)>);
138 auto psp_iter = psp->begin();
139 auto psp_copy_iter = psp_copy->begin();
140 for (; psp_iter != psp->end() && psp_copy_iter != psp_copy->end();
141 ++psp_iter, ++psp_copy_iter) {
142 EXPECT_EQ(**psp_iter, **psp_copy_iter);
143 EXPECT_NE(psp_iter, psp_copy_iter);
144 }
145 EXPECT_NE(&psp, &psp_copy);
146
147 auto pmp = std::make_unique<std::map<int, std::unique_ptr<int>>>();
148 pmp->emplace(0, std::make_unique<int>(101));
149 pmp->emplace(1, std::make_unique<int>(202));
150 auto pmp_copy = detail::st::copy_field<
151 type_class::map<type_class::integral, type_class::integral>>(pmp);
152 static_assert(std::is_same_v<decltype(pmp), decltype(pmp_copy)>);
153 auto pmp_iter = pmp->begin();
154 auto pmp_copy_iter = pmp_copy->begin();
155 for (; pmp_iter != pmp->end() && pmp_copy_iter != pmp_copy->end();
156 ++pmp_iter, ++pmp_copy_iter) {
157 EXPECT_EQ(pmp_iter->first, pmp_copy_iter->first);
158 EXPECT_NE(&pmp_iter->first, &pmp_copy_iter->first);
159 EXPECT_EQ(*pmp_iter->second, *pmp_copy_iter->second);
160 EXPECT_NE(pmp_iter->second, pmp_copy_iter->second);
161 }
162 EXPECT_NE(&pmp, &pmp_copy);
163 }
164