Debian Codegraph @

unittests/unit/common/test_Factory.cpp

raw
1 /*
2 * Copyright (c) 2011-2022, The DART development contributors
3 * All rights reserved.
4 *
5 * The list of contributors can be found at:
6 * https://github.com/dartsim/dart/blob/master/LICENSE
7 *
8 * This file is provided under the following "BSD-style" License:
9 * Redistribution and use in source and binary forms, with or
10 * without modification, are permitted provided that the following
11 * conditions are met:
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * * Redistributions in binary form must reproduce the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer in the documentation and/or other materials provided
17 * with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
19 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
26 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
27 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
29 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #include <dart/common/Factory.hpp>
34 #include <gtest/gtest.h>
35
36 #include "TestHelpers.hpp"
37
38 using namespace dart;
39
40 enum ObjectTypeEnum
41 {
42 OT_None,
43 OT_Apple,
44 OT_Banana,
45 OT_Orange
46 };
47
48 enum class ObjectTypeEnumClass
49 {
50 None,
51 Apple,
52 Banana,
53 Orange
54 };
55
56 class Fruit
57 {
58 public:
59 using FactoryEnum = common::Factory<ObjectTypeEnum, Fruit>;
60 using FactoryEnumClass = common::Factory<ObjectTypeEnumClass, Fruit>;
61 using FactoryString = common::Factory<std::string, Fruit>;
62
63 using SingletonFactoryEnum = common::Singleton<FactoryEnum>;
64 using SingletonFactoryEnumClass = common::Singleton<FactoryEnumClass>;
65 using SingletonFactoryString = common::Singleton<FactoryString>;
66
67 template <typename Derived>
68 using RegistrarEnum = common::
69 FactoryRegistrar<ObjectTypeEnum, Fruit, Derived, std::shared_ptr<Fruit>>;
70 template <typename Derived>
71 using RegistrarEnumClass = common::FactoryRegistrar<
72 ObjectTypeEnumClass,
73 Fruit,
74 Derived,
75 std::shared_ptr<Fruit>>;
76 template <typename Derived>
77 using RegistrarString = common::
78 FactoryRegistrar<std::string, Fruit, Derived, std::shared_ptr<Fruit>>;
79
80 static FactoryEnum* getFactoryEnum()
81 {
82 return SingletonFactoryEnum::getSingletonPtr();
83 }
84
85 static FactoryEnumClass* getFactoryEnumClass()
86 {
87 return SingletonFactoryEnumClass::getSingletonPtr();
88 }
89
90 static FactoryString* getFactoryString()
91 {
92 return SingletonFactoryString::getSingletonPtr();
93 }
94
95 virtual ~Fruit() = default;
96
97 virtual std::string getName() const = 0;
98 };
99
100 class Apple : public Fruit
101 {
102 public:
103 std::string getName() const override
104 {
105 return "apple";
106 }
107
108 static RegistrarEnum<Apple> mRegistrarEnum;
109 static RegistrarEnumClass<Apple> mRegistrarEnumClass;
110 static RegistrarString<Apple> mRegistrarString;
111 };
112
113 Apple::RegistrarEnum<Apple> Apple::mRegistrarEnum{OT_Apple};
114 Apple::RegistrarEnumClass<Apple> Apple::mRegistrarEnumClass{
115 ObjectTypeEnumClass::Apple};
116 Apple::RegistrarString<Apple> Apple::mRegistrarString{"apple"};
117
118 class Banana : public Fruit
119 {
120 public:
121 std::string getName() const override
122 {
123 return "banana";
124 }
125
126 static RegistrarEnum<Banana> mRegistrarEnum;
127 static RegistrarEnumClass<Banana> mRegistrarEnumClass;
128 static RegistrarString<Banana> mRegistrarString;
129 };
130
131 Banana::RegistrarEnum<Banana> Banana::mRegistrarEnum{OT_Banana};
132 Banana::RegistrarEnumClass<Banana> Banana::mRegistrarEnumClass{
133 ObjectTypeEnumClass::Banana};
134 Banana::RegistrarString<Banana> Banana::mRegistrarString{"banana"};
135
136 class Orange : public Fruit
137 {
138 public:
139 std::string getName() const override
140 {
141 return "orange";
142 }
143
144 static RegistrarEnum<Orange> mRegistrarEnum;
145 static RegistrarEnumClass<Orange> mRegistrarEnumClass;
146 static RegistrarString<Orange> mRegistrarString;
147 };
148
149 Orange::RegistrarEnum<Orange> Orange::mRegistrarEnum{OT_Orange};
150 Orange::RegistrarEnumClass<Orange> Orange::mRegistrarEnumClass{
151 ObjectTypeEnumClass::Orange};
152 Orange::RegistrarString<Orange> Orange::mRegistrarString{"orange"};
153
154 class City
155 {
156 public:
157 using Factory
158 = common::Factory<std::string, City, std::shared_ptr<City>, int>;
159 using SingletonFactory = common::Singleton<Factory>;
160
161 template <typename Derived>
162 using Registrar = common::
163 FactoryRegistrar<std::string, City, Derived, std::shared_ptr<City>, int>;
164
165 static Factory* getFactory()
166 {
167 return SingletonFactory::getSingletonPtr();
168 }
169
170 City(int year) : mYear(year) {}
171
172 virtual ~City() = default;
173
174 virtual std::string getName() const = 0;
175
176 int getYear() const
177 {
178 return mYear;
179 }
180
181 protected:
182 int mYear;
183 };
184
185 class Atlanta : public City
186 {
187 public:
188 Atlanta(int year) : City(year) {}
189
190 std::string getName() const override
191 {
192 return "Atlanta";
193 }
194
195 static Registrar<Atlanta> mRegistrar;
196 };
197
198 City::Registrar<Atlanta> Atlanta::mRegistrar("Atlanta");
199
200 class Pittsburgh : public City
201 {
202 public:
203 Pittsburgh(int year) : City(year) {}
204
205 std::string getName() const override
206 {
207 return "Pittsburgh";
208 }
209
210 static Registrar<Pittsburgh> mRegistrar;
211 };
212
213 City::Registrar<Pittsburgh> Pittsburgh::mRegistrar("Pittsburgh");
214
215 class Seattle : public City
216 {
217 public:
218 Seattle(int year) : City(year) {}
219
220 std::string getName() const override
221 {
222 return "Seattle";
223 }
224
225 static Registrar<Seattle> mRegistrar;
226 };
227
228 City::Registrar<Seattle> Seattle::mRegistrar{"Seattle"};
229
230 //==============================================================================
231 TEST(Factory, Create)
232 {
233 //----------------------------------------------------------------------------
234 // enum class key type
235 //----------------------------------------------------------------------------
236 EXPECT_TRUE(!Fruit::getFactoryEnum()->create(OT_None));
237
238 EXPECT_TRUE(Fruit::getFactoryEnum()->canCreate(OT_Apple));
239 EXPECT_EQ(Fruit::getFactoryEnum()->create(OT_Apple)->getName(), "apple");
240
241 // Can't create an orange since it's unregistered.
242 Fruit::getFactoryEnum()->unregisterCreator(OT_Orange);
243 EXPECT_TRUE(!Fruit::getFactoryEnum()->canCreate(OT_Orange));
244
245 // Once it's registered back we can create an orange.
246 Fruit::getFactoryEnum()->registerCreator<Orange>(OT_Orange);
247 EXPECT_TRUE(Fruit::getFactoryEnum()->canCreate(OT_Orange));
248 EXPECT_EQ(Fruit::getFactoryEnum()->create(OT_Orange)->getName(), "orange");
249
250 Fruit::getFactoryEnum()->unregisterCreator(OT_Orange);
251 EXPECT_TRUE(!Fruit::getFactoryEnum()->canCreate(OT_Orange));
252
253 //----------------------------------------------------------------------------
254 // enum class key type
255 //----------------------------------------------------------------------------
256 EXPECT_TRUE(!Fruit::getFactoryEnumClass()->create(ObjectTypeEnumClass::None));
257
258 EXPECT_TRUE(
259 Fruit::getFactoryEnumClass()->canCreate(ObjectTypeEnumClass::Apple));
260 EXPECT_EQ(
261 Fruit::getFactoryEnumClass()
262 ->create(ObjectTypeEnumClass::Apple)
263 ->getName(),
264 "apple");
265
266 // Can't create an orange since it's unregistered.
267 Fruit::getFactoryEnumClass()->unregisterCreator(ObjectTypeEnumClass::Orange);
268 EXPECT_TRUE(
269 !Fruit::getFactoryEnumClass()->canCreate(ObjectTypeEnumClass::Orange));
270
271 // Once it's registered back we can create an orange.
272 Fruit::getFactoryEnumClass()->registerCreator<Orange>(
273 ObjectTypeEnumClass::Orange);
274 EXPECT_TRUE(
275 Fruit::getFactoryEnumClass()->canCreate(ObjectTypeEnumClass::Orange));
276 EXPECT_EQ(
277 Fruit::getFactoryEnumClass()
278 ->create(ObjectTypeEnumClass::Orange)
279 ->getName(),
280 "orange");
281
282 Fruit::getFactoryEnumClass()->unregisterCreator(ObjectTypeEnumClass::Orange);
283 EXPECT_TRUE(
284 !Fruit::getFactoryEnumClass()->canCreate(ObjectTypeEnumClass::Orange));
285
286 //----------------------------------------------------------------------------
287 // std::string key type
288 //----------------------------------------------------------------------------
289 EXPECT_TRUE(!Fruit::getFactoryString()->create("none"));
290
291 EXPECT_TRUE(Fruit::getFactoryString()->canCreate("apple"));
292 EXPECT_EQ(Fruit::getFactoryString()->create("apple")->getName(), "apple");
293
294 // Can't create an orange since it's unregistered.
295 Fruit::getFactoryString()->unregisterCreator("orange");
296 EXPECT_TRUE(!Fruit::getFactoryString()->canCreate("orange"));
297
298 // Once it's registered back we can create an orange.
299 Fruit::getFactoryString()->registerCreator<Orange>("orange");
300 EXPECT_TRUE(Fruit::getFactoryString()->canCreate("orange"));
301 EXPECT_EQ(Fruit::getFactoryString()->create("orange")->getName(), "orange");
302
303 Fruit::getFactoryString()->unregisterCreator("orange");
304 EXPECT_TRUE(!Fruit::getFactoryString()->canCreate("orange"));
305 }
306
307 //==============================================================================
308 static std::shared_ptr<Orange> createOrange()
309 {
310 return std::shared_ptr<Orange>(new Orange());
311 }
312
313 //==============================================================================
314 TEST(Factory, VariousCreatorFunctions)
315 {
316 using FruitFactory = common::Singleton<common::Factory<std::string, Fruit>>;
317
318 FruitFactory::getSingleton().unregisterAllCreators();
319
320 EXPECT_TRUE(!FruitFactory::getSingleton().canCreate("apple"));
321 EXPECT_TRUE(!FruitFactory::getSingleton().canCreate("banana"));
322 EXPECT_TRUE(!FruitFactory::getSingleton().canCreate("orange"));
323
324 // Default creator
325 FruitFactory::getSingleton().registerCreator<Apple>("apple");
326
327 // Lambda function
328 FruitFactory::getSingleton().registerCreator(
329 std::string("banana"), []() -> std::shared_ptr<Banana> {
330 return std::shared_ptr<Banana>(new Banana());
331 });
332
333 // Global static function
334 FruitFactory::getSingleton().registerCreator(
335 std::string("orange"), createOrange);
336 }
337
338 //==============================================================================
339 TEST(Factory, CreateWithArguments)
340 {
341 EXPECT_TRUE(City::getFactory()->canCreate("Atlanta"));
342 EXPECT_TRUE(City::getFactory()->canCreate("Pittsburgh"));
343 EXPECT_TRUE(City::getFactory()->canCreate("Seattle"));
344
345 auto atlanta = City::getFactory()->create("Atlanta", 2013);
346 auto pittsburgh = City::getFactory()->create("Pittsburgh", 2016);
347 auto seatle = City::getFactory()->create("Seattle", 2017);
348 EXPECT_TRUE(atlanta->getYear() == 2013);
349 EXPECT_TRUE(pittsburgh->getYear() == 2016);
350 EXPECT_TRUE(seatle->getYear() == 2017);
351 }