[tracker/wip/miner-fs-refactor: 14/55] libtracker-miner, tests: implement multiple cases for indexing tree add/remove.

[Carlos Garnacho <carlosg src gnome org>]

commit 7a5680975ecc47346c54d06f0b124d846fc06988
Author: Aleksander Morgado <aleksander lanedo com>
Date:   Wed Aug 3 17:57:24 2011 +0200

    libtracker-miner, tests: implement multiple cases for indexing tree add/remove.

 .../libtracker-miner/tracker-indexing-tree-test.c  |  815 +++++++++++++++++++-
 1 files changed, 813 insertions(+), 2 deletions(-)
---
diff --git a/tests/libtracker-miner/tracker-indexing-tree-test.c b/tests/libtracker-miner/tracker-indexing-tree-test.c
index b390e2e..daa4b2f 100644
--- a/tests/libtracker-miner/tracker-indexing-tree-test.c
+++ b/tests/libtracker-miner/tracker-indexing-tree-test.c
@@ -75,7 +75,7 @@ typedef struct {
 	            fun, \
 	            test_common_context_teardown)
 
-void
+static void
 test_common_context_setup (TestCommonContext *fixture,
                            gconstpointer      data)
 {
@@ -99,7 +99,7 @@ test_common_context_setup (TestCommonContext *fixture,
 	fixture->tree = tracker_indexing_tree_new ();
 }
 
-void
+static void
 test_common_context_teardown (TestCommonContext *fixture,
                               gconstpointer      data)
 {
@@ -160,6 +160,789 @@ test_indexing_tree_002 (TestCommonContext *fixture,
 	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
 }
 
+/* If A is monitored (recursively):
+ *  -A, AA, AB, AAA, AAB, ABA and ABB are indexable
+ */
+static void
+test_indexing_tree_003 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is ignored and AA is ignored:
+ *  -A, AA, AB, AAA, AAB, ABA and ABB are not indexable
+ */
+static void
+test_indexing_tree_004 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is ignored and AA is monitored (not recursively):
+ *  -AA, AAA, AAB are indexable
+ *  -A, AAAA, AAAB, AB, ABA, ABB are not indexable
+ */
+static void
+test_indexing_tree_005 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is ignored and AA is monitored (recursively):
+ *  -AA, AAA, AAAA, AAAB, AAB are indexable
+ *  -A, AB, ABA, ABB are not indexable
+ */
+static void
+test_indexing_tree_006 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (not recursively) and AA is ignored:
+ *  -A and AB are indexable
+ *  -AA, AAA, AAAA, AAAB, AAB, ABA, ABB are not indexable
+ */
+static void
+test_indexing_tree_007 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (not recursively) and AA is monitored (not recursively):
+ *  -A, AA, AAA, AAB, AB are indexable
+ *  -AAAA, AAAB, ABA, ABB are not indexable
+ */
+static void
+test_indexing_tree_008 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (not recursively) and AA is monitored (recursively):
+ *  -A, AA, AAA, AAAA, AAAB, AAB, AB are indexable
+ *  -ABA, ABB are not indexable
+ */
+static void
+test_indexing_tree_009 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (recursively) and AA is ignored:
+ *  -A, AB, ABA, ABB are indexable
+ *  -AA, AAA, AAAA, AAAB, AAB are not indexable
+ */
+static void
+test_indexing_tree_010 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (recursively) and AA is monitored (not recursively):
+ *  -A, AA, AAA, AAB, AB, ABA, ABB are indexable
+ *  -AAAA, AAAB are not indexable
+ */
+static void
+test_indexing_tree_011 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (recursively) and AA is monitored (recursively):
+ *  -A, AA, AAA, AAAA, AAAB, AAB, AB, ABA, ABB are indexable
+ */
+static void
+test_indexing_tree_012 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is ignored and AA is ignored, then A is removed from tree
+ *  -A, AA, AAA, AAAA, AAAB, AAB, AB, ABA and ABB are not indexable
+ */
+static void
+test_indexing_tree_013 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_A]);
+
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is ignored and AA is ignored, then AA is removed from tree
+ *  -A, AA, AAA, AAAA, AAAB, AAB, AB, ABA and ABB are not indexable
+ */
+static void
+test_indexing_tree_014 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is ignored and AA is monitored (not recursively), then A is removed
+ * from tree.
+ *  -AA, AAA, AAB are indexable
+ *  -A, AAAA, AAAB, AB, ABA and ABB are not indexable
+ */
+static void
+test_indexing_tree_015 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_A]);
+
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is ignored and AA is monitored (not recursively), then AA is removed
+ * from tree.
+ *  -A, AA, AAA, AAAA, AAAB, AAB, AB, ABA and ABB are not indexable
+ */
+static void
+test_indexing_tree_016 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is ignored and AA is monitored (recursively), then A is removed from
+ * tree.
+ *  -AA, AAA, AAAA, AAAB, AAB are indexable
+ *  -A, AB, ABA and ABB are not indexable
+ */
+static void
+test_indexing_tree_017 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_A]);
+
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is ignored and AA is monitored (recursively), then AA is removed
+ * from tree.
+ *  -A, AA, AAA, AAAA, AAAB, AAB, AB, ABA and ABB are not indexable
+ */
+static void
+test_indexing_tree_018 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (not recursively) and AA is ignored, then A is removed
+ * from tree.
+ *  -A, AA, AAA, AAAA, AAAB, AAB, AB, ABA and ABB are not indexable
+ */
+static void
+test_indexing_tree_019 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_A]);
+
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (not recursively) and AA is ignored, then AA is removed
+ * from tree.
+ *  -A, AA, AB are indexable.
+ *  -AAA, AAAA, AAAB, AAB, ABA and ABB are not indexable
+ */
+static void
+test_indexing_tree_020 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (not recursively) and AA is monitored (not recursively),
+ *  then A is removed from tree.
+ *  -AA, AAA, AAB are indexable.
+ *  -A, AAAA, AAAB, AB, ABA and ABB are not indexable
+ */
+static void
+test_indexing_tree_021 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_A]);
+
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (not recursively) and AA is monitored (not recursively),
+ *  then AA is removed from tree.
+ *  -A, AA, AB are indexable.
+ *  -AAA, AAAA, AAAB, AAB, ABA and ABB are not indexable
+ */
+static void
+test_indexing_tree_022 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (not recursively) and AA is monitored (recursively),
+ *  then A is removed from tree.
+ *  -AA, AAA, AAAA, AAAB, AAB are indexable.
+ *  -A, AB, ABA and ABB are not indexable
+ */
+static void
+test_indexing_tree_023 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_A]);
+
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (not recursively) and AA is monitored (recursively),
+ *  then AA is removed from tree.
+ *  -A, AA, AB are indexable.
+ *  -AAA, AAAA, AAAB, AAB, ABA and ABB are not indexable
+ */
+static void
+test_indexing_tree_024 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (recursively) and AA is ignored, then A is removed
+ * from tree.
+ *  -A, AA, AAA, AAAA, AAAB, AAB, AB, ABA and ABB are not indexable
+ */
+static void
+test_indexing_tree_025 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_A]);
+
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (recursively) and AA is ignored, then AA is removed
+ * from tree.
+ *  -A, AA, AAA, AAAA, AAAB, AAB, AB, ABA and ABB are indexable
+ */
+static void
+test_indexing_tree_026 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_IGNORE);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (recursively) and AA is monitored (not recursively), then
+ *  A is removed from tree.
+ *  -AA, AAA, AAB are indexable
+ *  -A, AAAA, AAAB, AB, ABA and ABB are not indexable
+ */
+static void
+test_indexing_tree_027 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_A]);
+
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (recursively) and AA is monitored (not recursively), then
+ *  AA is removed from tree.
+ *  -A, AA, AAA, AAAA, AAAB, AAB, AB, ABA and ABB are indexable
+ */
+static void
+test_indexing_tree_028 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (recursively) and AA is monitored (recursively),
+ * then A is removed from tree.
+ *  -AA, AAA, AAAA, AAAB, AAB are indexable
+ *  -A, AB, ABA and ABB are not indexable
+ */
+static void
+test_indexing_tree_029 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_A]);
+
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_NOT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
+/* If A is monitored (recursively) and AA is monitored (recursively),
+ * then AA is removed from tree.
+ *  -A, AA, AAA, AAAA, AAAB, AAB, AB, ABA and ABB are indexable
+ */
+static void
+test_indexing_tree_030 (TestCommonContext *fixture,
+                        gconstpointer      data)
+{
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_A],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+	tracker_indexing_tree_add (fixture->tree,
+	                           fixture->test_dir[TEST_DIRECTORY_AA],
+	                           TRACKER_DIRECTORY_FLAG_MONITOR | TRACKER_DIRECTORY_FLAG_RECURSE);
+
+	tracker_indexing_tree_remove (fixture->tree,
+	                              fixture->test_dir[TEST_DIRECTORY_AA]);
+
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_A);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AAB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_AB);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+	ASSERT_INDEXABLE (fixture, TEST_DIRECTORY_ABA);
+}
+
 gint
 main (gint    argc,
       gchar **argv)
@@ -172,6 +955,34 @@ main (gint    argc,
 
 	test_add ("/libtracker-miner/indexing-tree/001", test_indexing_tree_001);
 	test_add ("/libtracker-miner/indexing-tree/002", test_indexing_tree_002);
+	test_add ("/libtracker-miner/indexing-tree/003", test_indexing_tree_003);
+	test_add ("/libtracker-miner/indexing-tree/004", test_indexing_tree_004);
+	test_add ("/libtracker-miner/indexing-tree/005", test_indexing_tree_005);
+	test_add ("/libtracker-miner/indexing-tree/006", test_indexing_tree_006);
+	test_add ("/libtracker-miner/indexing-tree/007", test_indexing_tree_007);
+	test_add ("/libtracker-miner/indexing-tree/008", test_indexing_tree_008);
+	test_add ("/libtracker-miner/indexing-tree/009", test_indexing_tree_009);
+	test_add ("/libtracker-miner/indexing-tree/010", test_indexing_tree_010);
+	test_add ("/libtracker-miner/indexing-tree/011", test_indexing_tree_011);
+	test_add ("/libtracker-miner/indexing-tree/012", test_indexing_tree_012);
+	test_add ("/libtracker-miner/indexing-tree/013", test_indexing_tree_013);
+	test_add ("/libtracker-miner/indexing-tree/014", test_indexing_tree_014);
+	test_add ("/libtracker-miner/indexing-tree/015", test_indexing_tree_015);
+	test_add ("/libtracker-miner/indexing-tree/016", test_indexing_tree_016);
+	test_add ("/libtracker-miner/indexing-tree/017", test_indexing_tree_017);
+	test_add ("/libtracker-miner/indexing-tree/018", test_indexing_tree_018);
+	test_add ("/libtracker-miner/indexing-tree/019", test_indexing_tree_019);
+	test_add ("/libtracker-miner/indexing-tree/020", test_indexing_tree_020);
+	test_add ("/libtracker-miner/indexing-tree/021", test_indexing_tree_021);
+	test_add ("/libtracker-miner/indexing-tree/022", test_indexing_tree_022);
+	test_add ("/libtracker-miner/indexing-tree/023", test_indexing_tree_023);
+	test_add ("/libtracker-miner/indexing-tree/024", test_indexing_tree_024);
+	test_add ("/libtracker-miner/indexing-tree/025", test_indexing_tree_025);
+	test_add ("/libtracker-miner/indexing-tree/026", test_indexing_tree_026);
+	test_add ("/libtracker-miner/indexing-tree/027", test_indexing_tree_027);
+	test_add ("/libtracker-miner/indexing-tree/028", test_indexing_tree_028);
+	test_add ("/libtracker-miner/indexing-tree/029", test_indexing_tree_029);
+	test_add ("/libtracker-miner/indexing-tree/030", test_indexing_tree_030);
 
 	return g_test_run ();
 }