ichthyo/LUMIERA.clone
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

disable the tests not ready yet (see Ticket 384)

Browse source
This commit is contained in:
Fischlurch 2009-10-29 21:59:25 +01:00
parent d2721378d5
commit ee611224b6
5 changed files with 33 additions and 4 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
tests/components/proc/mobject/mobject-ref-test.cpp
View file

@ -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;

6
tests/components/proc/mobject/placement-scope-test.cpp
View file

@ -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 !!!!!!!!!
}
};

6
tests/components/proc/mobject/query-focus-test.cpp
View file

@ -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
}
};

15
tests/components/proc/mobject/scope-path-test.cpp
View file

@ -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
}
};

2
tests/components/proc/mobject/session/contents-query-test.cpp
View file

@ -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.....!!!!!
}
};