Blender V5.3
main_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include <ranges>
6
7#include "testing/testing.h"
8
9#include "BLI_array.hh"
10#include "BLI_listbase.hh"
11#include "BLI_path_utils.hh"
12#include "BLI_string.hh"
13
14#include "BKE_collection.hh"
15#include "BKE_gtest_base.hh"
16#include "BKE_idtype.hh"
17#include "BKE_lib_id.hh"
18#include "BKE_library.hh"
19#include "BKE_main.hh"
20#include "BKE_main_namemap.hh"
21
22#include "DNA_ID.h"
24#include "DNA_object_types.h"
25
26namespace blender::bke::tests {
27
29
31 public:
32 void SetUp() override
33 {
35 }
36
37 void TearDown() override
38 {
39 if (bmain) {
41 }
42 }
43
45};
46
48{
49 EXPECT_TRUE(bmain->libraries.is_empty());
50 EXPECT_TRUE(bmain->collections.is_empty());
51 EXPECT_TRUE(bmain->objects.is_empty());
52
53 /* Test also (default-constructed) empty iterator. */
54 MainAllIDsIterator empty_main_iter{};
55 EXPECT_EQ(empty_main_iter, empty_main_iter.end());
56 EXPECT_EQ(0, empty_main_iter.size());
57 EXPECT_EQ(empty_main_iter.begin(), empty_main_iter.end());
58
59 Library *lib = BKE_id_new<Library>(bmain, "Library");
60 Collection *coll = BKE_id_new<Collection>(bmain, "Collection");
61 Object *ob = BKE_id_new<Object>(bmain, "Object");
62 BKE_collection_object_add(bmain, coll, ob);
63 Object *ob_linked = BKE_id_new_in_lib<Object>(bmain, lib, "Object_linked");
64 BKE_collection_object_add(bmain, coll, ob_linked);
65
66 Array<ID *> expected_ids_dependency_first = {&lib->id, &ob->id, &ob_linked->id, &coll->id};
67 Array<ID *> expected_ids_user_first = {&coll->id, &ob->id, &ob_linked->id, &lib->id};
68
69 EXPECT_EQ(1, bmain->libraries.count());
70 EXPECT_EQ(1, bmain->collections.count());
71 EXPECT_EQ(2, bmain->objects.count());
72
73 MainAllIDsIterator main_iter{*bmain};
74 MainAllIDsIterator main_iter_user_first{*bmain, false};
75 MainAllIDsIterator main_iter_dependency_first{*bmain, true};
76 EXPECT_EQ(4, main_iter.size());
77 EXPECT_EQ(4, main_iter_dependency_first.size());
78 EXPECT_EQ(4, main_iter_user_first.size());
79
80 int i = 0;
81 for (ID &id_iter : main_iter) {
82 EXPECT_EQ(expected_ids_user_first[i], &id_iter);
83 i++;
84 }
85 EXPECT_EQ(4, i);
86 i = 0;
87 for (ID &id_iter : main_iter_user_first) {
88 EXPECT_EQ(expected_ids_user_first[i], &id_iter);
89 i++;
90 }
91 EXPECT_EQ(4, i);
92 i = 0;
93 for (ID &id_iter : main_iter_dependency_first) {
94 EXPECT_EQ(expected_ids_dependency_first[i], &id_iter);
95 i++;
96 }
97 EXPECT_EQ(4, i);
98
99 i = 4;
100 for (ID &id_iter : main_iter.begin() | std::views::reverse) {
101 i--;
102 EXPECT_EQ(expected_ids_user_first[i], &id_iter);
103 }
104 EXPECT_EQ(0, i);
105 i = 4;
106 for (ID &id_iter : main_iter_user_first.begin() | std::views::reverse) {
107 i--;
108 EXPECT_EQ(expected_ids_user_first[i], &id_iter);
109 }
110 EXPECT_EQ(0, i);
111 i = 4;
112 for (ID &id_iter : main_iter_dependency_first.begin() | std::views::reverse) {
113 i--;
114 EXPECT_EQ(expected_ids_dependency_first[i], &id_iter);
115 }
116 EXPECT_EQ(0, i);
117}
118
119class BMainMergeTest : public BMainTest {
120 public:
121 void SetUp() override
122 {
125 }
126
127 void TearDown() override
128 {
129 if (bmain_src) {
131 }
132 if (bmain_dst) {
134 }
135 }
136
139};
140
142{
143 EXPECT_TRUE(bmain_dst->libraries.is_empty());
144 EXPECT_TRUE(bmain_dst->collections.is_empty());
145 EXPECT_TRUE(bmain_dst->objects.is_empty());
146
147 EXPECT_TRUE(bmain_src->libraries.is_empty());
148 EXPECT_TRUE(bmain_src->collections.is_empty());
149 EXPECT_TRUE(bmain_src->objects.is_empty());
150
151 BKE_id_new(bmain_dst, ID_GR, "Coll_dst");
152 Collection *coll = BKE_id_new<Collection>(bmain_src, "Coll_src");
153 Object *ob = BKE_id_new<Object>(bmain_src, "Ob_src");
154 BKE_collection_object_add(bmain_src, coll, ob);
155
156 EXPECT_EQ(1, bmain_dst->collections.count());
157 EXPECT_EQ(0, bmain_dst->objects.count());
158 EXPECT_EQ(1, bmain_src->collections.count());
159 EXPECT_EQ(1, bmain_src->objects.count());
160
161 MainMergeReport reports = {};
162 BKE_main_merge(bmain_dst, &bmain_src, reports);
163
164 EXPECT_EQ(2, bmain_dst->collections.count());
165 EXPECT_EQ(1, bmain_dst->objects.count());
166 EXPECT_EQ(2, reports.num_merged_ids);
167 EXPECT_EQ(0, reports.num_unknown_ids);
168 EXPECT_EQ(0, reports.num_remapped_ids);
170 EXPECT_EQ(nullptr, bmain_src);
171
172 auto gen_main_new = [](Collection **r_coll, Object **r_ob) -> Main * {
173 Main *bmain_new = BKE_main_new();
174 *r_coll = BKE_id_new<Collection>(bmain_new, "Coll_src_2");
175 *r_ob = BKE_id_new<Object>(bmain_new, "Ob_src");
176 BKE_collection_object_add(bmain_new, *r_coll, *r_ob);
177
178 EXPECT_EQ(1, bmain_new->collections.count());
179 EXPECT_EQ(1, bmain_new->objects.count());
180
181 return bmain_new;
182 };
183
184 Collection *coll_2;
185 Object *ob_2;
186 bmain_src = gen_main_new(&coll_2, &ob_2);
187 reports = {};
188 BKE_main_merge(bmain_dst, &bmain_src, reports);
189
190 /* The second `Ob_src` object in `bmain_src` cannot be merged in `bmain_dst`, since its name
191 * would collide with the first object. */
192 EXPECT_EQ(3, bmain_dst->collections.count());
193 EXPECT_EQ(1, bmain_dst->objects.count());
194 EXPECT_EQ(1, reports.num_merged_ids);
195 EXPECT_EQ(0, reports.num_unknown_ids);
196 EXPECT_EQ(1, reports.num_remapped_ids);
198 EXPECT_EQ(nullptr, bmain_src);
199
200 /* `Coll_src_2` should have been remapped to using `Ob_src` in `bmain_dst`, instead of `Ob_src`
201 * in `bmain_src`. */
202 EXPECT_EQ(1, coll_2->gobject.count());
203 EXPECT_EQ(ob, coll_2->gobject.first()->ob);
204
205 Collection *coll_3;
206 Object *ob_3;
207 bmain_src = gen_main_new(&coll_3, &ob_3);
208 reports = {};
209 Set<ID *> force_merge_ids = {id_cast<ID *>(ob_3)};
210 BKE_main_merge(bmain_dst, &force_merge_ids, &bmain_src, reports);
211
212 /* The third `Ob_src` object in `bmain_src` is forced to be merged in `bmain_dst`, even though
213 * its name will collide with the first object. So it will be renamed. The third source
214 * collection however will not be merged. */
215 EXPECT_EQ(3, bmain_dst->collections.count());
216 EXPECT_EQ(2, bmain_dst->objects.count());
217 EXPECT_EQ(1, reports.num_merged_ids);
218 EXPECT_EQ(0, reports.num_unknown_ids);
219 EXPECT_EQ(1, reports.num_remapped_ids);
221 EXPECT_EQ(nullptr, bmain_src);
222
223 EXPECT_TRUE(BKE_id_is_in_main(bmain_dst, id_cast<ID *>(ob_3)));
224 EXPECT_EQ(std::string("Ob_src.001"), BKE_id_name(*id_cast<ID *>(ob_3)));
225
226 /* `Coll_src_2` should not have been modified here (Ob_3 is not instantiated at all in
227 * destination Main). */
228 EXPECT_EQ(1, coll_2->gobject.count());
229 EXPECT_EQ(ob, coll_2->gobject.first()->ob);
230}
231
233{
234#ifdef WIN32
235# define ABS_ROOT "C:" SEP_STR
236#else
237# define ABS_ROOT SEP_STR
238#endif
239 constexpr char DST_PATH[] = ABS_ROOT "tmp" SEP_STR "dst" SEP_STR "dst.blend";
240 constexpr char SRC_PATH[] = ABS_ROOT "tmp" SEP_STR "src" SEP_STR "src.blend";
241 constexpr char LIB_PATH[] = ABS_ROOT "tmp" SEP_STR "lib" SEP_STR "lib.blend";
242
243 constexpr char LIB_PATH_RELATIVE[] = "//lib" SEP_STR "lib.blend";
244 constexpr char LIB_PATH_RELATIVE_ABS_SRC[] = ABS_ROOT "tmp" SEP_STR "src" SEP_STR "lib" SEP_STR
245 "lib.blend";
246
247 EXPECT_TRUE(bmain_dst->libraries.is_empty());
248 EXPECT_TRUE(bmain_dst->collections.is_empty());
249 EXPECT_TRUE(bmain_dst->objects.is_empty());
250
251 EXPECT_TRUE(bmain_src->libraries.is_empty());
252 EXPECT_TRUE(bmain_src->collections.is_empty());
253 EXPECT_TRUE(bmain_src->objects.is_empty());
254
255 STRNCPY(bmain_dst->filepath, DST_PATH);
256 STRNCPY(bmain_src->filepath, SRC_PATH);
257
258 BKE_id_new<Collection>(bmain_dst, "Coll_dst");
259
260 Collection *coll_1 = BKE_id_new<Collection>(bmain_src, "Coll_src");
261 Library *lib_src_1 = BKE_id_new<Library>(bmain_src, LIB_PATH);
262 BKE_library_filepath_set(bmain_src, lib_src_1, LIB_PATH);
263 Object *ob_1 = BKE_id_new_in_lib<Object>(bmain_src, lib_src_1, "Ob_src");
264 BKE_collection_object_add(bmain_src, coll_1, ob_1);
265
266 EXPECT_EQ(1, bmain_dst->collections.count());
267 EXPECT_EQ(0, bmain_dst->objects.count());
268 EXPECT_EQ(0, bmain_dst->libraries.count());
269 EXPECT_EQ(1, bmain_src->collections.count());
270 EXPECT_EQ(1, bmain_src->objects.count());
271 EXPECT_EQ(1, bmain_src->libraries.count());
272
273 MainMergeReport reports = {};
274 BKE_main_merge(bmain_dst, &bmain_src, reports);
275
276 EXPECT_EQ(2, bmain_dst->collections.count());
277 EXPECT_EQ(1, bmain_dst->objects.count());
278 EXPECT_EQ(1, bmain_dst->libraries.count());
279 EXPECT_EQ(ob_1, bmain_dst->objects.first());
280 EXPECT_EQ(lib_src_1, bmain_dst->libraries.first());
281 EXPECT_EQ(ob_1->id.lib, lib_src_1);
282 EXPECT_EQ(3, reports.num_merged_ids);
283 EXPECT_EQ(0, reports.num_unknown_ids);
284 EXPECT_EQ(0, reports.num_remapped_ids);
286 EXPECT_EQ(nullptr, bmain_src);
287
288 /* Try another merge, with the same library path - second library should be skipped, destination
289 * merge should still have only one library ID. */
290 bmain_src = BKE_main_new();
291 STRNCPY(bmain_src->filepath, SRC_PATH);
292
293 Collection *coll_2 = BKE_id_new<Collection>(bmain_src, "Coll_src_2");
294 Library *lib_src_2 = BKE_id_new<Library>(bmain_src, LIB_PATH);
295 BKE_library_filepath_set(bmain_src, lib_src_2, LIB_PATH);
296 std::cout << lib_src_1->runtime->filepath_abs << "\n";
297 std::cout << lib_src_2->runtime->filepath_abs << "\n";
298 Object *ob_2 = BKE_id_new_in_lib<Object>(bmain_src, lib_src_2, "Ob_src_2");
299 BKE_collection_object_add(bmain_src, coll_2, ob_2);
300 Object *ob_2_2 = BKE_id_new_in_lib<Object>(bmain_src, lib_src_2, "Ob_src_2_2");
301 BKE_collection_object_add(bmain_src, coll_2, ob_2_2);
302
303 EXPECT_EQ(1, bmain_src->collections.count());
304 EXPECT_EQ(2, bmain_src->objects.count());
305 EXPECT_EQ(1, bmain_src->libraries.count());
306
307 reports = {};
308 BKE_main_merge(bmain_dst, &bmain_src, reports);
309
310 EXPECT_EQ(3, bmain_dst->collections.count());
311 EXPECT_EQ(3, bmain_dst->objects.count());
312 EXPECT_EQ(1, bmain_dst->libraries.count());
313 EXPECT_EQ(ob_1, bmain_dst->objects.first());
314 EXPECT_EQ(ob_2_2, bmain_dst->objects.last());
315 EXPECT_EQ(lib_src_1, bmain_dst->libraries.first());
316 EXPECT_EQ(ob_1->id.lib, lib_src_1);
317 EXPECT_EQ(ob_2->id.lib, lib_src_1);
318 EXPECT_EQ(ob_2_2->id.lib, lib_src_1);
319 EXPECT_EQ(3, reports.num_merged_ids);
320 EXPECT_EQ(0, reports.num_unknown_ids);
321 EXPECT_EQ(0, reports.num_remapped_ids);
323 EXPECT_EQ(nullptr, bmain_src);
324
325 /* Use a relative library path. Since this is a different library, even though the object re-use
326 * the same name, it should still be moved into `bmain_dst`. The library filepath should also be
327 * updated and become relative the path of bmain_dst too. */
328 bmain_src = BKE_main_new();
329 STRNCPY(bmain_src->filepath, SRC_PATH);
330
331 Collection *coll_3 = BKE_id_new<Collection>(bmain_src, "Coll_src_3");
332 Library *lib_src_3 = BKE_id_new<Library>(bmain_src, LIB_PATH_RELATIVE);
333 BKE_library_filepath_set(bmain_src, lib_src_3, LIB_PATH_RELATIVE);
334 Object *ob_3 = BKE_id_new_in_lib<Object>(bmain_src, lib_src_3, "Ob_src");
335 BKE_collection_object_add(bmain_src, coll_3, ob_3);
336
337 EXPECT_EQ(1, bmain_src->collections.count());
338 EXPECT_EQ(1, bmain_src->objects.count());
339 EXPECT_EQ(1, bmain_src->libraries.count());
340 EXPECT_TRUE(STREQ(lib_src_3->filepath, LIB_PATH_RELATIVE));
341 EXPECT_TRUE(STREQ(lib_src_3->runtime->filepath_abs, LIB_PATH_RELATIVE_ABS_SRC));
342
343 reports = {};
344 BKE_main_merge(bmain_dst, &bmain_src, reports);
345
346 EXPECT_EQ(4, bmain_dst->collections.count());
347 EXPECT_EQ(4, bmain_dst->objects.count());
348 EXPECT_EQ(2, bmain_dst->libraries.count());
349 EXPECT_EQ(ob_1, bmain_dst->objects.first());
350 EXPECT_EQ(ob_3, bmain_dst->objects.last());
351 EXPECT_EQ(lib_src_3, bmain_dst->libraries.first());
352 EXPECT_EQ(lib_src_1, bmain_dst->libraries.last());
353 EXPECT_EQ(ob_1->id.lib, lib_src_1);
354 EXPECT_EQ(ob_2->id.lib, lib_src_1);
355 EXPECT_EQ(ob_2_2->id.lib, lib_src_1);
356 EXPECT_EQ(ob_3->id.lib, lib_src_3);
357 EXPECT_FALSE(STREQ(lib_src_3->filepath, LIB_PATH_RELATIVE));
358 EXPECT_TRUE(STREQ(lib_src_3->runtime->filepath_abs, LIB_PATH_RELATIVE_ABS_SRC));
359 EXPECT_EQ(3, reports.num_merged_ids);
360 EXPECT_EQ(0, reports.num_unknown_ids);
361 EXPECT_EQ(0, reports.num_remapped_ids);
363 EXPECT_EQ(nullptr, bmain_src);
364
365 /* Try another merge, with the library path set to the path of the destination bmain. That source
366 * library should also be skipped, and the 'linked' object in source bmain should become a local
367 * object in destination bmain. */
368 bmain_src = BKE_main_new();
369 STRNCPY(bmain_src->filepath, SRC_PATH);
370
371 Library *lib_src_4 = BKE_id_new<Library>(bmain_src, DST_PATH);
372 BKE_library_filepath_set(bmain_src, lib_src_4, DST_PATH);
373 Collection *coll_4 = BKE_id_new_in_lib<Collection>(bmain_src, lib_src_4, "Coll_src");
374 Object *ob_4 = BKE_id_new_in_lib<Object>(bmain_src, lib_src_4, "Ob_src_4");
375 BKE_collection_object_add(bmain_src, coll_4, ob_4);
376
377 EXPECT_EQ(1, bmain_src->collections.count());
378 EXPECT_EQ(1, bmain_src->objects.count());
379 EXPECT_EQ(1, bmain_src->libraries.count());
380
381 reports = {};
382 BKE_main_merge(bmain_dst, &bmain_src, reports);
383
384 /* `bmain_dst` is unchanged, since both `coll_4` and `ob_4` were defined as linked from
385 * `bmain_dst`. */
386 EXPECT_EQ(4, bmain_dst->collections.count());
387 EXPECT_EQ(4, bmain_dst->objects.count());
388 EXPECT_EQ(2, bmain_dst->libraries.count());
389 EXPECT_EQ(lib_src_3, bmain_dst->libraries.first());
390 EXPECT_EQ(lib_src_1, bmain_dst->libraries.last());
391 EXPECT_EQ(ob_1->id.lib, lib_src_1);
392 EXPECT_EQ(ob_2->id.lib, lib_src_1);
393 EXPECT_EQ(ob_2_2->id.lib, lib_src_1);
394 EXPECT_EQ(ob_3->id.lib, lib_src_3);
395 EXPECT_EQ(0, reports.num_merged_ids);
396 EXPECT_EQ(1, reports.num_unknown_ids);
397 EXPECT_EQ(1, reports.num_remapped_ids);
399 EXPECT_EQ(nullptr, bmain_src);
400}
401
402TEST_F(BMainMergeTest, link_lib_packed)
403{
404 constexpr char LIB_PATH[] = ABS_ROOT "tmp" SEP_STR "lib" SEP_STR "lib.blend";
405 bool is_archive_lib_new = false;
406
407 auto create_packed_object = [&is_archive_lib_new](Main &bmain,
408 Library &owner_lib,
409 StringRefNull ob_name,
410 IDHash ob_deep_hash) -> Object * {
411 Object *ob_packed = BKE_id_new_in_lib<Object>(&bmain, &owner_lib, ob_name.c_str());
412 ob_packed->id.deep_hash = ob_deep_hash;
414 bmain, ob_packed->id, owner_lib, ob_packed->id.deep_hash, is_archive_lib_new);
415 BKE_main_namemap_remove_id(bmain, ob_packed->id);
416 ob_packed->id.lib = archive_lib;
417 ob_packed->id.flag |= ID_FLAG_LINKED_AND_PACKED;
418 BKE_main_namemap_get_unique_name(bmain, ob_packed->id, BKE_id_name(ob_packed->id));
419 return ob_packed;
420 };
421
422 /* Three packed IDs in source Main, two with same names, one with different name, leading to two
423 * different archive libraries. */
424 Library *lib_src = BKE_id_new<Library>(bmain_src, LIB_PATH);
425 BKE_library_filepath_set(bmain_src, lib_src, LIB_PATH);
426
427 Object *ob_src_linked = BKE_id_new_in_lib<Object>(bmain_src, lib_src, "Ob_linked");
428
429 Object *ob_src_packed = create_packed_object(*bmain_src, *lib_src, "Ob_packed", {1});
430 EXPECT_TRUE(is_archive_lib_new);
431 Object *ob_src_packed_same_name = create_packed_object(*bmain_src, *lib_src, "Ob_packed", {2});
432 EXPECT_TRUE(is_archive_lib_new);
433 Object *ob_src_packed_diff_name = create_packed_object(
434 *bmain_src, *lib_src, "Ob_packed_second_name", {3});
435 EXPECT_FALSE(is_archive_lib_new);
436
437 /* Two packed IDs in destination Main before the merge, with same names as the two first in
438 * source Main, one sharing the same deep_hash (so being identical data), the second with another
439 * deep hash. */
440 Library *lib_dst = BKE_id_new<Library>(bmain_dst, LIB_PATH);
441 BKE_library_filepath_set(bmain_dst, lib_dst, LIB_PATH);
442
443 Object *ob_dst_packed = create_packed_object(*bmain_dst, *lib_dst, "Ob_packed", {1});
444 EXPECT_TRUE(is_archive_lib_new);
445 Object *ob_dst_packed_same_name = create_packed_object(*bmain_dst, *lib_dst, "Ob_packed", {4});
446 EXPECT_TRUE(is_archive_lib_new);
447
448 MainMergeReport reports = {};
449 BKE_main_merge(bmain_dst, &bmain_src, reports);
450
451 /* Part of the packed IDs in `bmain_src` already existed in `bmain_dst`, so these are re-used.
452 * The others are moved over, which will also create a new archive library in `bmain_dst`. */
453 EXPECT_EQ(4, bmain_dst->libraries.count());
454 EXPECT_TRUE((static_cast<Library *>(BLI_findlink(&bmain_dst->libraries, 0))->flag &
456 EXPECT_EQ(static_cast<Library *>(BLI_findlink(&bmain_dst->libraries, 0)), lib_dst);
457 EXPECT_TRUE((static_cast<Library *>(BLI_findlink(&bmain_dst->libraries, 1))->flag &
459 EXPECT_EQ(static_cast<Library *>(BLI_findlink(&bmain_dst->libraries, 1))->archive_parent_library,
460 lib_dst);
461 EXPECT_TRUE((static_cast<Library *>(BLI_findlink(&bmain_dst->libraries, 2))->flag &
463 EXPECT_EQ(static_cast<Library *>(BLI_findlink(&bmain_dst->libraries, 2))->archive_parent_library,
464 lib_dst);
465 EXPECT_TRUE((static_cast<Library *>(BLI_findlink(&bmain_dst->libraries, 3))->flag &
467 EXPECT_EQ(static_cast<Library *>(BLI_findlink(&bmain_dst->libraries, 3))->archive_parent_library,
468 lib_dst);
469
470 EXPECT_EQ(5, bmain_dst->objects.count());
471 /* ob_src_packed is identical to ob_dst_packed (same deep hash), so it has been discarded. */
472 UNUSED_VARS(ob_src_packed);
473 EXPECT_EQ(ob_dst_packed, BLI_findlink(&bmain_dst->objects, 0));
474 EXPECT_TRUE(ID_IS_PACKED(&ob_dst_packed->id));
475 /* ob_src_packed_diff_name has no name collision with any other packed objects, so it is added to
476 * the first archive library in bmain_dst, and therefore is the second object. */
477 EXPECT_EQ(ob_src_packed_diff_name->id.lib, ob_dst_packed->id.lib);
478 EXPECT_EQ(ob_src_packed_diff_name, BLI_findlink(&bmain_dst->objects, 1));
479 EXPECT_TRUE(ID_IS_PACKED(&ob_src_packed_diff_name->id));
480 /* ob_dst_packed_same_name was the second packed ID in bmain_dst, requiring its own archive
481 * library, so it is now third. */
482 EXPECT_EQ(ob_dst_packed_same_name, BLI_findlink(&bmain_dst->objects, 2));
483 EXPECT_TRUE(ID_IS_PACKED(&ob_dst_packed_same_name->id));
484 /* ob_src_linked is added to the first, regular existing lib_dst library in bmain_dst, as it
485 * matches its original source library in bmain_src. Since it's the first ID for lib_dst in
486 * bmain_dst, it is added after all packed IDs belonging to the first two archive libraries
487 * pre-existing in bmain_dst. */
488 EXPECT_EQ(ob_src_linked->id.lib, static_cast<Library *>(BLI_findlink(&bmain_dst->libraries, 0)));
489 EXPECT_EQ(ob_src_linked, BLI_findlink(&bmain_dst->objects, 3));
490 EXPECT_FALSE(ID_IS_PACKED(&ob_src_linked->id));
491 /* ob_src_packed_same_name name conflicts with ob_dst_packed and ob_dst_packed_same_name names,
492 * so it is added in a new archive library by the merge operation. This makes it the last object,
493 * using the last library, in bmain_dst. */
494 EXPECT_EQ(ob_src_packed_same_name->id.lib,
495 static_cast<Library *>(BLI_findlink(&bmain_dst->libraries, 3)));
496 EXPECT_EQ(ob_src_packed_same_name, BLI_findlink(&bmain_dst->objects, 4));
497 EXPECT_TRUE(ID_IS_PACKED(&ob_src_packed_same_name->id));
498
499 EXPECT_EQ(nullptr, bmain_src);
500}
501
502} // namespace blender::bke::tests
ID and Library types, which are fundamental for SDNA.
#define ID_IS_PACKED(_id)
Definition DNA_ID.h:703
Object groups, one object can be in many groups at once.
Object is a sort of wrapper for general info.
#define UNUSED_VARS(...)
#define STREQ(a, b)
MainAllIDsIterator begin() const
Definition BKE_main.hh:901
MainAllIDsIterator end() const
Definition BKE_main.hh:909
int64_t size() const
Definition main.cc:1291
#define EXPECT_FALSE(result)
#define EXPECT_TRUE(result)
#define ABS_ROOT
Library * ensure_archive_library(Main &bmain, ID &id, Library &reference_library, const IDHash &id_deep_hash, bool &is_new)
Definition library.cc:542
TEST_F(AnimDataTest, BKE_fcurves_id_cb_test)
char * STRNCPY(char(&dst)[N], const char *src)
Main * BKE_main_new()
Definition main.cc:93
bool BKE_main_namemap_get_unique_name(Main &bmain, ID &id, char *r_name)
const char * BKE_id_name(const ID &id)
void BKE_main_namemap_remove_id(Main &bmain, ID &id)
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
bool BKE_collection_object_add(Main *bmain, Collection *collection, Object *ob)
void BKE_main_merge(Main *bmain_dst, Set< ID * > *force_merge_src_ids, Main **r_bmain_src, MainMergeReport &reports)
Definition main.cc:362
@ LIBRARY_FLAG_IS_ARCHIVE
bool BKE_id_is_in_main(Main *bmain, ID *id)
Definition lib_id.cc:2752
void BKE_main_free(Main *bmain)
Definition main.cc:202
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
void BKE_library_filepath_set(Main *bmain, Library *lib, const char *filepath)
Definition library.cc:249
void * BKE_id_new_in_lib(Main *bmain, std::optional< Library * > owner_library, short type, const char *name)
Definition lib_id.cc:1594
@ ID_FLAG_LINKED_AND_PACKED
Definition DNA_ID.h:806
void * BKE_id_new(Main *bmain, short type, const char *name)
Definition lib_id.cc:1612
ListBaseT< CollectionObject > gobject
struct Library * lib
Definition DNA_ID.h:421
short flag
Definition DNA_ID.h:439
IDHash deep_hash
Definition DNA_ID.h:475
struct Library * archive_parent_library
Definition DNA_ID.h:575
char filepath[1024]
Definition DNA_ID.h:562
bke::library::LibraryRuntime * runtime
Definition DNA_ID.h:591
uint16_t flag
Definition DNA_ID.h:565
ListBaseT< Collection > collections
Definition BKE_main.hh:406
ListBaseT< Object > objects
Definition BKE_main.hh:388
#define SEP_STR
Definition unit.cc:41