16 #include "testing/testing.h"
69 if (catalog_uptr->path == path) {
84 testing::Test::SetUpTestSuite();
91 testing::Test::TearDownTestSuite();
96 const std::string test_files_dir = blender::tests::flags_test_asset_dir();
97 if (test_files_dir.empty()) {
143 const std::string expected_path_str = expected_path.
str();
144 const size_t expected_parent_count =
std::count(
154 const std::vector<AssetCatalogPath> &expected_paths)
158 ASSERT_LT(i, expected_paths.size())
159 <<
"More catalogs in tree than expected; did not expect " << actual_item.
catalog_path();
171 const std::vector<AssetCatalogPath> &expected_paths)
175 ASSERT_LT(i, expected_paths.size())
176 <<
"More catalogs in tree root than expected; did not expect "
189 const std::vector<AssetCatalogPath> &expected_paths)
193 ASSERT_LT(i, expected_paths.size())
194 <<
"More catalogs in tree item than expected; did not expect "
206 const CatalogFilePath registered_asset_lib = target_dir +
"my_asset_library/";
207 const CatalogFilePath asset_lib_subdir = registered_asset_lib +
"subdir/";
217 &
U,
"Test", registered_asset_lib.c_str());
218 ASSERT_NE(
nullptr, asset_lib_pref);
221 if (should_top_level_cdf_exist) {
222 ASSERT_EQ(0,
BLI_copy(original_cdf_file.c_str(), cdf_toplevel.c_str()));
232 const CatalogFilePath blendfilename = asset_lib_subdir +
"some_file.blend";
239 EXPECT_TRUE(
BLI_exists(cdf_toplevel.c_str()));
241 const bool backup_exists =
BLI_exists(backup_filename.c_str());
242 EXPECT_EQ(should_top_level_cdf_exist, backup_exists)
243 <<
"Overwritten CDF should have been backed up.";
258 if (should_top_level_cdf_exist) {
259 EXPECT_NE(
nullptr, poses_ellie_catalog);
275 service.
load_from_disk(asset_library_root_ +
"/" +
"blender_assets.cats.txt");
282 ASSERT_EQ(
nullptr, cat_without_path);
286 ASSERT_NE(
nullptr, poses_ellie);
293 ASSERT_NE(
nullptr, poses_whitespace);
295 EXPECT_EQ(
"character/Ellie/poselib/white space", poses_whitespace->
path.
str());
300 ASSERT_NE(
nullptr, poses_ruzena);
307 ASSERT_NE(
nullptr, another_ruzena);
316 service.
load_from_disk(asset_library_root_ +
"/" +
"blender_assets.cats.txt");
319 ASSERT_NE(
nullptr, found_by_id);
321 <<
"Backslashes should be normalized when loading from disk.";
326 <<
"Catalog with backslashed path should be findable by the normalized path.";
329 <<
"Nothing should be found when searching for backslashes.";
335 service.
load_from_disk(asset_library_root_ +
"/" +
"blender_assets.cats.txt");
339 <<
"Adding a catalog at runtime should never mark it as 'first loaded'; "
340 "only loading from disk is allowed to do that.";
344 <<
"Adding a new catalog with an already-loaded path should not mark it as 'first loaded'";
353 <<
"The first-seen definition of a catalog should be returned";
361 tree.insert_item(*catalog_empty_path);
363 assert_expected_tree_items(&
tree, {});
370 tree.insert_item(*catalog);
371 assert_expected_tree_items(&
tree, {
"item"});
375 tree.insert_item(*catalog);
376 assert_expected_tree_items(&
tree, {
"item",
"item/child"});
378 std::vector<AssetCatalogPath> expected_paths;
382 "item/child/grandchild/grandgrandchild");
383 tree.insert_item(*catalog);
385 "item",
"item/child",
"item/child/grandchild",
"item/child/grandchild/grandgrandchild"};
386 assert_expected_tree_items(&
tree, expected_paths);
389 tree.insert_item(*catalog);
390 expected_paths = {
"item",
392 "item/child/grandchild",
393 "item/child/grandchild/grandgrandchild",
395 assert_expected_tree_items(&
tree, expected_paths);
402 tree.insert_item(*catalog);
403 assert_expected_tree_items(&
tree, {
"item",
"item/child"});
410 tree.insert_item(*catalog);
411 assert_expected_tree_items(&
tree, {
"white space"});
418 tree.insert_item(*catalog);
419 assert_expected_tree_items(&
tree, {
"item",
"item/white space"});
426 tree.insert_item(*catalog_unicode_path);
427 assert_expected_tree_items(&
tree, {
"Ružena"});
430 tree.insert_item(*catalog_unicode_path);
431 assert_expected_tree_items(&
tree, {
"Ružena",
"Ružena/Ružena"});
438 service.
load_from_disk(asset_library_root_ +
"/" +
"blender_assets.cats.txt");
442 std::vector<AssetCatalogPath> expected_paths{
445 "character/Ellie/backslashes",
446 "character/Ellie/poselib",
447 "character/Ellie/poselib/tailslash",
448 "character/Ellie/poselib/white space",
450 "character/Ružena/poselib",
451 "character/Ružena/poselib/face",
452 "character/Ružena/poselib/hand",
455 "path/without/simplename",
459 assert_expected_tree_items(
tree, expected_paths);
466 const std::vector<AssetCatalogPath> no_catalogs{};
468 assert_expected_tree_items(&
tree, no_catalogs);
469 assert_expected_tree_root_items(&
tree, no_catalogs);
472 tree.insert_item(*catalog);
474 assert_expected_tree_item_child_items(&item, no_catalogs);
479 service.
load_from_disk(asset_library_root_ +
"/" +
"blender_assets.cats.txt");
481 std::vector<AssetCatalogPath> expected_root_items{{
"character",
"path"}};
483 assert_expected_tree_root_items(
tree, expected_root_items);
486 std::vector<std::vector<AssetCatalogPath>> expected_root_child_items = {
488 {
"character/Ellie",
"character/Ružena"},
494 assert_expected_tree_item_child_items(&item, expected_root_child_items[i]);
509 EXPECT_NE(
nullptr, catalog);
512 EXPECT_NE(
nullptr, catalog);
517 EXPECT_NE(
nullptr, catalog);
553 const CatalogFilePath load_from_path = asset_library_root_ +
"/новый/" +
557 const CatalogFilePath save_to_path = use_temp_path() +
"новый.cats.txt";
559 ASSERT_NE(
nullptr, cdf) <<
"unable to load " << load_from_path;
566 const bUUID materials_uuid(
"a2151dff-dead-4f29-b6bc-b2c7d6cccdb4");
568 ASSERT_NE(
nullptr, cat);
582 EXPECT_FALSE(
BLI_exists(default_cdf_path.c_str()));
591 const CatalogFilePath original_cdf_file = asset_library_root_ +
"/blender_assets.cats.txt";
595 ASSERT_EQ(0,
BLI_copy(original_cdf_file.c_str(), cdf_filename.c_str()))
596 <<
"Unable to copy " << original_cdf_file <<
" to " << cdf_filename;
603 const CatalogFilePath blendfilename = top_level_dir +
"subdir/some_file.blend";
609 EXPECT_TRUE(
BLI_exists(cdf_filename.c_str()));
610 EXPECT_TRUE(
BLI_exists(backup_filename.c_str()))
611 <<
"Overwritten CDF should have been backed up.";
617 <<
"Expected to see the newly-created catalog.";
619 <<
"Expected to see the already-existing catalog.";
636 EXPECT_TRUE(
BLI_exists(expected_cdf_path.c_str()));
640 ASSERT_NE(
nullptr, cdf);
653 const CatalogFilePath original_cdf_file = asset_library_root_ +
"/blender_assets.cats.txt";
656 ASSERT_EQ(0,
BLI_copy(original_cdf_file.c_str(), writable_cdf_file.c_str()));
668 EXPECT_TRUE(
BLI_exists(writable_cdf_file.c_str()));
669 EXPECT_TRUE(
BLI_exists(backup_filename.c_str()))
670 <<
"Overwritten CDF should have been backed up.";
674 ASSERT_NE(
nullptr, cdf);
688 on_blendfile_save__from_memory_into_existing_asset_lib_without_top_level_cdf)
690 save_from_memory_into_existing_asset_lib(
true);
698 save_from_memory_into_existing_asset_lib(
false);
708 EXPECT_FALSE(
BLI_exists(temp_lib_root.c_str()));
711 ASSERT_NE(
nullptr, cat);
716 EXPECT_FALSE(
BLI_exists(temp_lib_root.c_str()));
720 EXPECT_TRUE(
BLI_is_dir(temp_lib_root.c_str()));
724 EXPECT_TRUE(
BLI_is_file(definition_file_path.c_str()));
731 ASSERT_NE(
nullptr, written_cat);
742 const CatalogFilePath default_catalog_path = asset_library_root_ +
"/" +
746 ASSERT_EQ(0,
BLI_copy(default_catalog_path.c_str(), writable_catalog_path.c_str()));
747 EXPECT_TRUE(
BLI_is_dir(temp_lib_root.c_str()));
748 EXPECT_TRUE(
BLI_is_file(writable_catalog_path.c_str()));
765 <<
"expected pre-existing catalogs to be kept in the file";
767 <<
"expecting newly added catalog to not yet be saved to " << temp_lib_root;
774 <<
"expected pre-existing catalogs to be kept in the file";
775 EXPECT_NE(
nullptr, reloaded_service.
find_catalog(new_catalog_id))
776 <<
"expecting newly added catalog to exist in the file";
793 "production/Spite Fright/Characters/Victora/Pose Library/Approved/Body Parts/Hands");
796 EXPECT_EQ(
"production/Spite Fright/Characters/Victora/Pose Library/Approved/Body Parts/Hands",
804 service.
load_from_disk(asset_library_root_ +
"/" +
"blender_assets.cats.txt");
813 std::vector<AssetCatalogPath> expected_paths{
816 "character/Ellie/backslashes",
817 "character/Ellie/poselib",
818 "character/Ellie/poselib/tailslash",
819 "character/Ellie/poselib/white space",
821 "character/Ružena/poselib",
822 "character/Ružena/poselib/face",
826 "path/without/simplename",
830 assert_expected_tree_items(
tree, expected_paths);
836 service.
load_from_disk(asset_library_root_ +
"/" +
"blender_assets.cats.txt");
850 service.
load_from_disk(asset_library_root_ +
"/" +
"blender_assets.cats.txt");
870 std::vector<AssetCatalogPath> expected_paths{
873 "character/Ellie/backslashes",
874 "character/Ellie/poselib",
875 "character/Ellie/poselib/tailslash",
876 "character/Ellie/poselib/white space",
880 "path/without/simplename",
884 assert_expected_tree_items(
tree, expected_paths);
923 <<
"The original (pre-rename) path should not be associated with a catalog any more.";
926 ASSERT_NE(
nullptr, renamed_cat);
927 ASSERT_EQ(orig_cat, renamed_cat) <<
"Changing the path should not reallocate the catalog.";
929 <<
"Changing the path should not change the catalog ID.";
932 <<
"Changing the path should change the path. Surprise.";
935 <<
"Changing the path should update children.";
937 <<
"Changing the path should update children.";
951 <<
"Changing the path should update the simplename.";
953 <<
"Changing the path should update the simplename of children.";
961 const std::string new_path =
962 "this/is/a/very/long/path/that/exceeds/the/simple-name/length/of/assets";
964 <<
"This test case should work with paths longer than AssetMetaData::catalog_simple_name";
970 <<
"The new simple name should fit in the asset metadata.";
971 EXPECT_EQ(
"...very-long-path-that-exceeds-the-simple-name-length-of-assets", new_simple_name)
972 <<
"Changing the path should update the simplename.";
973 EXPECT_EQ(
"...long-path-that-exceeds-the-simple-name-length-of-assets-face",
975 <<
"Changing the path should update the simplename of children.";
992 <<
"The original (pre-rename) path should not be associated with a catalog any more.";
995 ASSERT_NE(
nullptr, renamed_cat);
997 <<
"Changing the path should not change the catalog ID.";
1000 <<
"When creating a new catalog by renaming + adding a slash, the renamed catalog should be "
1001 "assigned the path passed to update_catalog_path()";
1005 ASSERT_NE(
nullptr, new_cat) <<
"Renaming to .../X/Y should cause .../X to exist as well.";
1011 EXPECT_EQ(
"character/Ružena/poses/general/hand",
1013 <<
"Changing the path should update children.";
1014 EXPECT_EQ(
"character/Ružena/poses/general/face",
1016 <<
"Changing the path should update children.";
1022 const CatalogFilePath original_cdf_file = asset_library_root_ +
"/blender_assets.cats.txt";
1023 const CatalogFilePath modified_cdf_file = asset_library_root_ +
"/modified_assets.cats.txt";
1024 const CatalogFilePath temp_cdf_file = cdf_dir +
"blender_assets.cats.txt";
1025 ASSERT_EQ(0,
BLI_copy(original_cdf_file.c_str(), temp_cdf_file.c_str()));
1033 ASSERT_EQ(0,
BLI_copy(modified_cdf_file.c_str(), temp_cdf_file.c_str()));
1062 const CatalogFilePath original_cdf_file = asset_library_root_ +
"/blender_assets.cats.txt";
1063 const CatalogFilePath modified_cdf_file = asset_library_root_ +
"/catalog_reload_test.cats.txt";
1064 const CatalogFilePath temp_cdf_file = cdf_dir +
"blender_assets.cats.txt";
1065 ASSERT_EQ(0,
BLI_copy(original_cdf_file.c_str(), temp_cdf_file.c_str()));
1081 ASSERT_EQ(0,
BLI_copy(modified_cdf_file.c_str(), temp_cdf_file.c_str()));
1103 EXPECT_NE(ellie_whitespace_after_reload, ellie_whitespace_before_reload);
1105 EXPECT_EQ(std::string(
"Hah simple name after all"),
1126 <<
"The catalogs whose path we changed should now be saved";
1128 <<
"Deleted catalogs should not be remembered after saving.";
1134 const CatalogFilePath original_cdf_file = asset_library_root_ +
"/blender_assets.cats.txt";
1135 const CatalogFilePath writable_cdf_file = cdf_dir +
"/blender_assets.cats.txt";
1136 ASSERT_EQ(0,
BLI_copy(original_cdf_file.c_str(), writable_cdf_file.c_str()));
1162 const bUUID cat2_uuid(
"22222222-b847-44d9-bdca-ff04db1c24f5");
1163 const bUUID cat4_uuid(
"11111111-b847-44d9-bdca-ff04db1c24f5");
1168 cat4_uuid,
"simple/path",
"different ID, same path");
1169 const AssetCatalog cat5(cat4_uuid,
"simple/path",
"same ID, same path");
1172 by_path.insert(&cat1);
1173 by_path.insert(&cat2);
1174 by_path.insert(&cat3);
1175 by_path.insert(&cat4);
1176 by_path.insert(&cat5);
1178 AssetCatalogOrderedSet::const_iterator set_iter = by_path.begin();
1184 ASSERT_EQ(4, by_path.size()) <<
"Expecting cat5 to not be stored in the set, as it duplicates "
1185 "an already-existing path + UUID";
1192 if (set_iter != by_path.end()) {
1194 FAIL() <<
"Did not expect more items in the set, had at least " << next_cat->
catalog_id <<
":"
1204 const bUUID first_seen_uuid(
"3d451c87-27d1-40fd-87fc-f4c9e829c848");
1205 const bUUID first_sorted_uuid(
"00000000-0000-0000-0000-000000000001");
1206 const bUUID last_sorted_uuid(
"ffffffff-ffff-ffff-ffff-ffffffffffff");
1208 AssetCatalog first_seen_cat(first_seen_uuid,
"simple/path/child",
"");
1209 const AssetCatalog first_sorted_cat(first_sorted_uuid,
"simple/path/child",
"");
1210 const AssetCatalog last_sorted_cat(last_sorted_uuid,
"simple/path/child",
"");
1221 by_path.insert(&first_seen_cat);
1222 by_path.insert(&first_sorted_cat);
1223 by_path.insert(&last_sorted_cat);
1225 AssetCatalogOrderedSet::const_iterator set_iter = by_path.begin();
1227 EXPECT_EQ(1, by_path.count(&first_seen_cat));
1228 EXPECT_EQ(1, by_path.count(&first_sorted_cat));
1229 EXPECT_EQ(1, by_path.count(&last_sorted_cat));
1230 ASSERT_EQ(3, by_path.size());
1232 EXPECT_EQ(first_seen_uuid, (*(set_iter++))->catalog_id);
1233 EXPECT_EQ(first_sorted_uuid, (*(set_iter++))->catalog_id);
1234 EXPECT_EQ(last_sorted_uuid, (*(set_iter++))->catalog_id);
1236 if (set_iter != by_path.end()) {
1238 FAIL() <<
"Did not expect more items in the set, had at least " << next_cat->
catalog_id <<
":"
1249 <<
"Missing parents should not be immediately created.";
1258 <<
"Empty path should never be valid, even when after missing catalogs";
1269 ASSERT_NE(
nullptr, cat_char) <<
"Missing parents should be created immediately after loading.";
1270 ASSERT_NE(
nullptr, cat_ellie) <<
"Missing parents should be created immediately after loading.";
1271 ASSERT_NE(
nullptr, cat_ruzena) <<
"Missing parents should be created immediately after loading.";
1274 <<
"Missing parents should be marked as having changes.";
1276 <<
"Missing parents should be marked as having changes.";
1278 <<
"Missing parents should be marked as having changes.";
1281 ASSERT_NE(
nullptr, cdf);
1282 EXPECT_TRUE(cdf->
contains(cat_char->
catalog_id)) <<
"Missing parents should be saved to a CDF.";
1283 EXPECT_TRUE(cdf->
contains(cat_ellie->
catalog_id)) <<
"Missing parents should be saved to a CDF.";
1285 <<
"Missing parents should be saved to a CDF.";
1308 <<
"Main catalog should be included in the filter.";
1310 <<
"Sub-catalog should be included in the filter.";
1312 <<
"Sub-catalog should be included in the filter.";
1316 <<
"Alias of main catalog should be included in the filter.";
1318 <<
"Alias of sub-catalog should be included in the filter.";
1321 EXPECT_FALSE(
filter.contains(
BLI_uuid_nil())) <<
"Nil catalog should not be included.";
1335 EXPECT_TRUE(
filter.contains(unknown_uuid));
1337 EXPECT_FALSE(
filter.contains(
BLI_uuid_nil())) <<
"Nil catalog should not be included.";
1354 EXPECT_NE(&empty,
copy.get());
1381 auto cat1 = std::make_unique<AssetCatalog>(
UUID_POSES_RUZENA,
"poses/Henrik",
"");
1384 cat3->flags.is_deleted =
true;
1394 EXPECT_NE(&catcoll,
copy.get());
1409 <<
"AssetCatalogs should be actual copies.";
1413 <<
"AssetCatalogs should be actual copies.";
1427 auto cat1 = std::make_unique<AssetCatalog>(
UUID_POSES_RUZENA,
"poses/Henrik",
"");
1430 cat3->flags.is_deleted =
true;
1441 cdf->
file_path =
"path/to/somewhere.cats.txt";
1455 <<
"AssetCatalog pointers should have been remapped to the copy.";
1459 <<
"Deleted AssetCatalog pointers should have been remapped to the copy.";
1472 <<
"Undo steps should be created explicitly, and not after creating any catalog.";
1477 <<
"Undo should be possible after creating an undo snapshot.";
1482 <<
"Undoing the only stored step should make it impossible to undo further.";
1483 EXPECT_TRUE(service.
is_redo_possbile()) <<
"Undoing a step should make redo possible.";
1485 <<
"Undone catalog should not exist after undo.";
1487 <<
"First catalog should still exist after undo.";
1489 <<
"The CDF should also not contain the undone catalog.";
1494 <<
"Undoing and then redoing a step should make it possible to undo again.";
1496 <<
"Undoing and then redoing a step should make redo impossible.";
1498 <<
"Redone catalog should exist after redo.";
1500 <<
"First catalog should still exist after redo.";
1502 <<
"The CDF should contain the redone catalog.";
1523 <<
"After storing an undo snapshot, the redo buffer should be empty.";
1525 <<
"After storing an undo snapshot, undoing should be possible";
1529 "POSES_ELLIE WHITESPACE");
void BKE_tempdir_init(const char *userdir)
struct bUserAssetLibrary * BKE_preferences_asset_library_add(struct UserDef *userdef, const char *name, const char *path) ATTR_NONNULL(1)
void BKE_preferences_asset_library_remove(struct UserDef *userdef, struct bUserAssetLibrary *library) ATTR_NONNULL()
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
File and directory operations.
int BLI_exists(const char *path) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
bool BLI_file_touch(const char *file) ATTR_NONNULL()
bool BLI_is_file(const char *path) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
int BLI_delete(const char *file, bool dir, bool recursive) ATTR_NONNULL()
size_t BLI_file_size(const char *path) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
bool BLI_is_dir(const char *path) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
bool BLI_dir_create_recursive(const char *dir) ATTR_NONNULL()
int BLI_copy(const char *file, const char *to) ATTR_NONNULL()
void BLI_path_slash_native(char *path) ATTR_NONNULL()
bool BLI_uuid_is_nil(bUUID uuid)
bUUID BLI_uuid_generate_random(void)
const Value & lookup(const Key &key) const
void add_new(const Key &key, const Value &value)
bool contains(const Key &key) const
OwningAssetCatalogMap deleted_catalogs_
std::unique_ptr< AssetCatalogCollection > deep_copy() const
OwningAssetCatalogMap catalogs_
std::unique_ptr< AssetCatalogDefinitionFile > catalog_definition_file_
void add_new(AssetCatalog *catalog)
bool contains(CatalogID catalog_id) const
Map< CatalogID, AssetCatalog * > catalogs_
bool write_to_disk() const
CatalogFilePath file_path
const std::string & str() const
StringRefNull name() const
static const char SEPARATOR
void create_missing_catalogs()
AssetCatalog * create_catalog(const AssetCatalogPath &catalog_path)
void delete_catalog_by_id_soft(CatalogID catalog_id)
bool write_to_disk(const CatalogFilePath &blend_file_path)
AssetCatalog * find_catalog_by_path(const AssetCatalogPath &path) const
void update_catalog_path(CatalogID catalog_id, const AssetCatalogPath &new_catalog_path)
void tag_has_unsaved_changes(AssetCatalog *edited_catalog)
AssetCatalogDefinitionFile * get_catalog_definition_file()
AssetCatalogFilter create_catalog_filter(CatalogID active_catalog_id) const
bool is_redo_possbile() const
AssetCatalog * find_catalog(CatalogID catalog_id) const
void prune_catalogs_by_id(CatalogID catalog_id)
bool is_undo_possbile() const
AssetCatalogTree * get_catalog_tree()
void prune_catalogs_by_path(const AssetCatalogPath &path)
OwningAssetCatalogMap & get_deleted_catalogs()
static const CatalogFilePath DEFAULT_CATALOG_FILENAME
OwningAssetCatalogMap & get_catalogs()
StringRefNull get_name() const
AssetCatalogPath catalog_path() const
int count_parents() const
void foreach_child(const ItemIterFn callback)
struct blender::bke::AssetCatalog::Flags flags
static std::unique_ptr< AssetCatalog > from_path(const AssetCatalogPath &path)
CatalogFilePath asset_library_root_
static void TearDownTestSuite()
void assert_expected_tree_items(AssetCatalogTree *tree, const std::vector< AssetCatalogPath > &expected_paths)
CatalogFilePath temp_library_path_
CatalogFilePath use_temp_path()
void assert_expected_item(const AssetCatalogPath &expected_path, const AssetCatalogTreeItem &actual_item)
static void SetUpTestSuite()
void assert_expected_tree_item_child_items(AssetCatalogTreeItem *parent_item, const std::vector< AssetCatalogPath > &expected_paths)
CatalogFilePath create_temp_path()
void save_from_memory_into_existing_asset_lib(const bool should_top_level_cdf_exist)
void assert_expected_tree_root_items(AssetCatalogTree *tree, const std::vector< AssetCatalogPath > &expected_paths)
AssetCatalogDefinitionFile * allocate_catalog_definition_file()
OwningAssetCatalogMap & get_catalogs()
OwningAssetCatalogMap & get_deleted_catalogs()
AssetCatalogDefinitionFile * get_catalog_definition_file()
Map< CatalogID, AssetCatalog * > get_catalogs()
AssetCatalogDefinitionFile * get_catalog_definition_file()
TestableAssetCatalogService(const CatalogFilePath &asset_library_root)
int64_t count_catalogs_with_path(const CatalogFilePath &path)
TestableAssetCatalogService()=default
void create_missing_catalogs()
OwningAssetCatalogMap & get_deleted_catalogs()
void delete_catalog_by_id_soft(CatalogID catalog_id)
DO_INLINE void filter(lfVector *V, fmatrix3x3 *S)
void * BKE_tempdir_session
const bUUID UUID_ID_WITHOUT_PATH("e34dd2c5-5d2e-4668-9794-1db5de2a4f71")
const bUUID UUID_POSES_ELLIE("df60e1f6-2259-475b-93d9-69a1b4a8db78")
TEST_F(BKE_armature_find_selected_bones_test, some_bones_selected)
const bUUID UUID_WITHOUT_SIMPLENAME("d7916a31-6ca9-4909-955f-182ca2b81fa3")
const bUUID UUID_ANOTHER_RUZENA("00000000-d9fa-4b91-b704-e6af1f1339ef")
const bUUID UUID_POSES_RUZENA_HAND("81811c31-1a88-4bd7-bb34-c6fc2607a12e")
const bUUID UUID_POSES_ELLIE_BACKSLASHES("a51e17ae-34fc-47d5-ba0f-64c2c9b771f7")
const bUUID UUID_AGENT_47("c5744ba5-43f5-4f73-8e52-010ad4a61b34")
const bUUID UUID_POSES_ELLIE_WHITESPACE("b06132f6-5687-4751-a6dd-392740eb3c46")
const bUUID UUID_POSES_RUZENA_FACE("82162c1f-06cc-4d91-a9bf-4f72c104e348")
const bUUID UUID_POSES_ELLIE_TRAILING_SLASH("3376b94b-a28d-4d05-86c1-bf30b937130d")
const bUUID UUID_POSES_RUZENA("79a4f887-ab60-4bd4-94da-d572e27d6aed")
std::string CatalogFilePath
std::set< const AssetCatalog *, AssetCatalogLessThan > AssetCatalogOrderedSet
static void copy(bNodeTree *dest_ntree, bNode *dest_node, const bNode *src_node)
Universally Unique Identifier according to RFC4122.