diff --git a/tests/components/proc/mobject/mobject-ref-test.cpp b/tests/components/proc/mobject/mobject-ref-test.cpp
index fad045ab4..f851b4b06 100644
--- a/tests/components/proc/mobject/mobject-ref-test.cpp
+++ b/tests/components/proc/mobject/mobject-ref-test.cpp
@@ -84,7 +84,7 @@ namespace test    {
           ASSERT (2 == pClip2.use_count());
           
           
-#if 0 /////////////////////////////////////////////////////////////////////////////////////////TODO lots of things unimplemented.....!!!!!
+#if false  //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET 384  !!!!!!!!!
           // Prepare an (test)Index
           typedef shared_ptr<PlacementIndex> PIdx;
           PIdx index (PlacementIndex::create());
@@ -136,7 +136,7 @@ namespace test    {
       void
       checkBuildMObjectRef (REF refObj, void* placementAdr)
         {
-#if 0 /////////////////////////////////////////////////////////////////////////////////////////TODO lots of things unimplemented.....!!!!!
+#if false  //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET 384  !!!!!!!!!
           MORef<Clip> rMO;
           ASSERT (!rMO);                    // still empty (not bound)
           cout << rMO             << endl;
@@ -177,7 +177,7 @@ namespace test    {
       void
       checkLifecylce (PMObj const& p1, PMObj const& p2)
         {
-#if 0 /////////////////////////////////////////////////////////////////////////////////////////TODO lots of things unimplemented.....!!!!!
+#if false  //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET 384  !!!!!!!!!
           ASSERT (2 == p1.use_count());
           ASSERT (2 == p2.use_count());
           
@@ -215,7 +215,7 @@ namespace test    {
       void
       checkTypeHandling (LumieraUid luid)
         {
-#if 0 /////////////////////////////////////////////////////////////////////////////////////////TODO lots of things unimplemented.....!!!!!
+#if false  //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET 384  !!!!!!!!!
           MObjectRef rMObj;
           MORef<Clip> rClip;
           MORef<TestSubMO1> rSub1;
diff --git a/tests/components/proc/mobject/placement-scope-test.cpp b/tests/components/proc/mobject/placement-scope-test.cpp
index c5bccb2c4..87ba1a1bf 100644
--- a/tests/components/proc/mobject/placement-scope-test.cpp
+++ b/tests/components/proc/mobject/placement-scope-test.cpp
@@ -73,6 +73,7 @@ namespace test    {
           PPIdx index = build_testScopes();
           
           UNIMPLEMENTED ("function test of placement scope interface");
+#if false  //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET 384  !!!!!!!!!
           verifyLookup (index);
           verifyNavigation (index);
         }
@@ -84,6 +85,7 @@ namespace test    {
       getContents(PPIdx index)
         {
           return index->query<DummyMO>(index->getRoot());
+#endif     //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET 384  !!!!!!!!!
         }
       
       /** @test for each Placement in our test "session",
@@ -92,6 +94,7 @@ namespace test    {
       void
       verifyLookup (PPIdx ref_index)
         {
+#if false  //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET 384  !!!!!!!!!
           for (_Iter elm = getContents(ref_index); elm; ++elm)
             {
               ASSERT (elm->isValid());
@@ -109,6 +112,7 @@ namespace test    {
               
               ASSERT (isSameObject (scope1,scope2));
             }
+#endif     //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET 384  !!!!!!!!!
         }
       
       
@@ -116,6 +120,7 @@ namespace test    {
       void
       verifyNavigation (PPIdx ref_index)
         {
+#if false  //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET 384  !!!!!!!!!
           for (_Iter elm = getContents(ref_index); elm; ++elm)
             {
               Scope const& scope = Scope::containing(*elm);
@@ -138,6 +143,7 @@ namespace test    {
                     ASSERT (topsTop == parentsScope);
                     ASSERT (isSameObject (topsTop, parentsScope.getTop()));
             }     }
+#endif     //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET 384  !!!!!!!!!
         }
       
     };
diff --git a/tests/components/proc/mobject/query-focus-test.cpp b/tests/components/proc/mobject/query-focus-test.cpp
index d1e621c2d..589dec521 100644
--- a/tests/components/proc/mobject/query-focus-test.cpp
+++ b/tests/components/proc/mobject/query-focus-test.cpp
@@ -70,6 +70,7 @@ namespace test    {
           
           QueryFocus theFocus;
           theFocus.reset();
+#ifdef false  ////////////////////////////////////////////////////////////////////////////////TICKET 384
           ASSERT (Scope(root) == Scope(theFocus));
           
           checkNavigation (theFocus);
@@ -80,6 +81,7 @@ namespace test    {
           QueryFocus currentFocus;
           ASSERT (scopePosition == Scope(currentFocus));
           ASSERT (currentFocus == theFocus);
+#endif          
         }
       
       
@@ -91,6 +93,7 @@ namespace test    {
           focus.reset();
           ASSERT (Scope(focus).isRoot());
           
+#ifdef false  ////////////////////////////////////////////////////////////////////////////////TICKET 384
           PMO& someObj = focus.query<TestSubMO1>();
                          // by construction of the test fixture,
                          // we know this object is root -> ps2 -> ps3
@@ -107,6 +110,7 @@ namespace test    {
           ASSERT (someObj != Scope(focus));
           ASSERT (path.contains (focus.currentPath()));
           ASSERT (focus.currentPath().getParent().isRoot());
+#endif
         }
       
       
@@ -114,6 +118,7 @@ namespace test    {
       void
       manipulate_subFocus()
         {
+#ifdef false  ////////////////////////////////////////////////////////////////////////////////TICKET 384
           QueryFocus original;
           uint num_refs = original.ref_count();
           ASSERT (num_refs > 1);
@@ -152,6 +157,7 @@ namespace test    {
           ASSERT (       1 == subF.ref_count());
           ASSERT (num_refs == original.ref_count());
          // when subF goes out of scope now, auto-pop will happen...
+#endif
         }
           
     };
diff --git a/tests/components/proc/mobject/scope-path-test.cpp b/tests/components/proc/mobject/scope-path-test.cpp
index 343104089..9adcfb03d 100644
--- a/tests/components/proc/mobject/scope-path-test.cpp
+++ b/tests/components/proc/mobject/scope-path-test.cpp
@@ -24,6 +24,7 @@
 #include "lib/test/run.hpp"
 #include "lib/test/test-helper.hpp"
 #include "proc/mobject/session/test-scopes.hpp"
+#include "proc/mobject/session/scope-path.hpp"
 //#include "lib/lumitime.hpp"
 //#include "proc/mobject/placement-ref.hpp"
 //#include "proc/mobject/placement-index.hpp"
@@ -64,6 +65,7 @@ namespace test    {
         {
           // Prepare an (test)Index backing the PlacementRefs
           PPIdx index = build_testScopes();
+#if false     ////////////////////////////////////////////////////////////////////////////////TICKET 384
           PMO& startPlacement = *(index->query<TestSubMO1>(index->getRoot()));
           ASSERT (startPlacement);
           
@@ -73,6 +75,7 @@ namespace test    {
           check_Identity_and_Copy (startPlacement);
           navigate (testPath, index);
           clear (testPath, index);
+#endif
         }
       
       
@@ -80,6 +83,7 @@ namespace test    {
       buildPath (PMO& startPla)
         {
           Scope startScope (startPla);
+#if false     ////////////////////////////////////////////////////////////////////////////////TICKET 384
           ScopePath path (startScope);
           ASSERT (path);
           ASSERT (path.contains (startScope));
@@ -88,12 +92,14 @@ namespace test    {
           
           ScopePath path2 (startScope);
           ScopePath path3 (path2);
+#endif
         }
       
       
       void
       checkRelations (ScopePath path1, PMO& refPla)
         {
+#if false     ////////////////////////////////////////////////////////////////////////////////TICKET 384
           ASSERT (path1.contains (refPla));
           
           Scope refScope (refPla);
@@ -119,12 +125,14 @@ namespace test    {
           ASSERT (path2 == commonPrefix(path2,path1));
           ASSERT (path1 != commonPrefix(path1,path2));
           ASSERT (path1 != commonPrefix(path2,path1));
+#endif        ////////////////////////////////////////////////////////////////////////////////TICKET 384
         }
       
       
       void
       invalidPath (ScopePath refPath, PMO& refPla)
         {
+#if false     ////////////////////////////////////////////////////////////////////////////////TICKET 384
           ASSERT (refPath);
           ASSERT (!ScopePath::INVALID);
           
@@ -160,12 +168,14 @@ namespace test    {
           ASSERT (refPath);
           
         //ScopePath::INVALID.navigate(root);  // doesn't compile
+#endif        ////////////////////////////////////////////////////////////////////////////////TICKET 384
         }
       
       
       void
       check_Identity_and_Copy (PMO& refPla)
         {
+#if false     ////////////////////////////////////////////////////////////////////////////////TICKET 384
           Scope startScope (startPla);
           ScopePath path1 (startScope);
           ScopePath path2 (startScope);
@@ -196,6 +206,7 @@ namespace test    {
           ASSERT (path1 != path2);
           ASSERT (path2 != path3);
           ASSERT (path1 != path3);
+#endif        ////////////////////////////////////////////////////////////////////////////////TICKET 384
         }
       
       
@@ -211,6 +222,7 @@ namespace test    {
       void
       navigate (const ScopePath refPath, PPIdx index)
         {
+#if false     ////////////////////////////////////////////////////////////////////////////////TICKET 384
           ScopePath path (refPath);
           ASSERT (path == refPath);
           
@@ -268,12 +280,14 @@ namespace test    {
           ASSERT (other.getTop() == separatePlacement);
           ScopePath rootPrefix = commonPrefix (path,refPath);
           ASSERT (rootPrefix.endsAt (root));
+#endif        ////////////////////////////////////////////////////////////////////////////////TICKET 384
         }
       
       
       void
       clear (ScopePath& testPath, PPIdx index)
         {
+#if false     ////////////////////////////////////////////////////////////////////////////////TICKET 384
           ASSERT (path);
           PMO rootNode = index->getRoot();
           ASSERT (path.getLeaf() != rootNode);
@@ -281,6 +295,7 @@ namespace test    {
           path.clear();
           ASSERT (path);
           ASSERT (path.getLeaf() == rootNode);
+#endif        ////////////////////////////////////////////////////////////////////////////////TICKET 384
         }
           
     };
diff --git a/tests/components/proc/mobject/session/contents-query-test.cpp b/tests/components/proc/mobject/session/contents-query-test.cpp
index a62cf9802..e8619c217 100644
--- a/tests/components/proc/mobject/session/contents-query-test.cpp
+++ b/tests/components/proc/mobject/session/contents-query-test.cpp
@@ -81,9 +81,11 @@ namespace test    {
       void
       discover (Query<MO> const& query)
         {
+#if false  //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET 384  !!!!!!!!!
           Query<MO>::iterator elm = query();
           while (elm)
             cout << *elm++ << endl;
+#endif ////////////////////////////////////////////////////////////////////////////////////////TODO lots of things unimplemented.....!!!!!
         }
           
     };