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