From 7ef8372129d03061107eac1a96ef5d947ea6716d Mon Sep 17 00:00:00 2001 From: Ichthyostega Date: Wed, 19 Sep 2007 03:55:45 +0200 Subject: [PATCH 1/2] equality and ordering of assets implemented --- src/proc/asset.cpp | 2 -- src/proc/asset.hpp | 9 +++++--- src/proc/asset/category.hpp | 2 +- tests/51asset.tests | 3 ++- .../proc/asset/orderingofassetstest.cpp | 21 ++++++++++++------- 5 files changed, 23 insertions(+), 14 deletions(-) diff --git a/src/proc/asset.cpp b/src/proc/asset.cpp index 460464a8e..8780ca518 100644 --- a/src/proc/asset.cpp +++ b/src/proc/asset.cpp @@ -27,8 +27,6 @@ #include -#include -#include using boost::format; using util::cStr; diff --git a/src/proc/asset.hpp b/src/proc/asset.hpp index a6e3b1ad8..c97af4844 100644 --- a/src/proc/asset.hpp +++ b/src/proc/asset.hpp @@ -273,19 +273,22 @@ namespace asset /** shorthand for refcounting Asset pointers */ typedef shared_ptr PAsset; - /** ordering of Assets based on Ident tuple */ + /** ordering of Asset smart ptrs based on Ident tuple. + * @todo currently supporting only smart_ptr. */ + inline bool operator== (const PAsset& a1, const PAsset& a2) { return a1 && a2 && ( 0==a1->ident.compare(a2->ident));} inline bool operator< (const PAsset& a1, const PAsset& a2) { return a1 && a2 && (-1==a1->ident.compare(a2->ident));} inline bool operator> (const PAsset& a1, const PAsset& a2) { return a2 < a1; } inline bool operator>= (const PAsset& a1, const PAsset& a2) { return !(a1 < a2); } inline bool operator<= (const PAsset& a1, const PAsset& a2) { return !(a1 > a2); } + inline bool operator!= (const PAsset& a1, const PAsset& a2) { return !(a1== a2); } /** ordering of Asset Ident tuples. * @note version is irrelevant */ inline int Asset::Ident::compare (const Asset::Ident& oi) const { int res; - if (1 != (res=category.compare (oi.category))) return res; - if (1 != (res=org.compare (oi.org))) return res; + if (0 != (res=category.compare (oi.category))) return res; + if (0 != (res=org.compare (oi.org))) return res; return name.compare (oi.name); } diff --git a/src/proc/asset/category.hpp b/src/proc/asset/category.hpp index 5a1bf905c..b51ef1919 100644 --- a/src/proc/asset/category.hpp +++ b/src/proc/asset/category.hpp @@ -94,7 +94,7 @@ namespace asset int compare (const Category& co) const { int res = int(kind_) - int(co.kind_); - if (1 != res) + if (0 != res) return res; else return path_.compare (co.path_); diff --git a/tests/51asset.tests b/tests/51asset.tests index 4c87542f4..0e6b6c009 100644 --- a/tests/51asset.tests +++ b/tests/51asset.tests @@ -20,5 +20,6 @@ return: 0 END -PLANNED "OrderingOfAssets_test" OrderingOfAssets_test < PM; + typedef shared_ptr PA; Asset::Ident key1("Au-1", Category(AUDIO), "ichthyo", 5); - PM mm1 = asset::Media::create(key1, "Name-1"); + PA mm1 = asset::Media::create(key1, "Name-1"); Asset::Ident key2("Au-1", Category(AUDIO), "ichthyo", 7); - PM mm2 = asset::Media::create(key2, "Name-2"); + PA mm2 = asset::Media::create(key2, "Name-2"); Asset::Ident key3("Au-2", Category(AUDIO), "ichthyo", 5); - PM mm3 = asset::Media::create(key3, "Name-3"); + PA mm3 = asset::Media::create(key3, "Name-3"); Asset::Ident key4("Au-2", Category(AUDIO), "stega", 5); - PM mm4 = asset::Media::create(key4, "Name-4"); + PA mm4 = asset::Media::create(key4, "Name-4"); Asset::Ident key5("Au-1", Category(VIDEO), "ichthyo", 5); - PM mm5 = asset::Media::create(key5, "Name-5"); + PA mm5 = asset::Media::create(key5, "Name-5"); // ordering of keys @@ -111,7 +119,6 @@ namespace asset ASSERT (mm2 < mm4); } - }; From dc97acde5eaf304f6f15c0046a4bfa2c21473372 Mon Sep 17 00:00:00 2001 From: Ichthyostega Date: Wed, 19 Sep 2007 05:05:25 +0200 Subject: [PATCH 2/2] added test covering Asset category tuple --- src/common/util.hpp | 14 +- tests/51asset.tests | 9 ++ .../proc/asset/assetcategorytest.cpp | 144 ++++++++++++++++++ .../proc/asset/orderingofassetstest.cpp | 20 +-- 4 files changed, 174 insertions(+), 13 deletions(-) create mode 100644 tests/components/proc/asset/assetcategorytest.cpp diff --git a/src/common/util.hpp b/src/common/util.hpp index 7b036e1be..82b29439e 100644 --- a/src/common/util.hpp +++ b/src/common/util.hpp @@ -34,26 +34,34 @@ namespace util { using std::string; + + template + inline int + sgn (NUM n) + { + return (n==0)? 0 :((n<0)? -1:+1 ); + } + /** a family of util functions providing a "no value whatsoever" test. Works on strings and all STL containers, includes NULL test for pointers */ template inline bool - isnil(const CONT& container) + isnil (const CONT& container) { return container.empty(); } template inline bool - isnil(const CONT* pContainer) + isnil (const CONT* pContainer) { return !pContainer || pContainer->empty(); } template <> inline bool - isnil(const char* pCStr) + isnil (const char* pCStr) { return !pCStr || 0 == std::strlen(pCStr); } diff --git a/tests/51asset.tests b/tests/51asset.tests index 0e6b6c009..9bc0186fd 100644 --- a/tests/51asset.tests +++ b/tests/51asset.tests @@ -2,6 +2,15 @@ TESTING "Component Test Suite: Asset Manager" ./test-components --group=asset +TEST "AssetCategory_test" AssetCategory_test < + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +* *****************************************************/ + + +#include "common/test/run.hpp" +#include "common/util.hpp" + +#include "proc/asset/category.hpp" + +#include +#include + +using boost::format; +using util::isnil; +using std::string; +using std::cout; + + +namespace asset + { + namespace test + { + + + + + /*********************************************************************** + * @test checking the properties of Asset Category structs. + * They are included in the Asset::Ident identification tuple + * of Assets and can be used to organize Assets into a tree + * like structure + */ + class AssetCategory_test : public Test + { + virtual void run(Arg arg) + { + createCategory(); + containmentQuery(); + ordering(); + } + + + + + void createCategory() + { + Category c1 (AUDIO); + Category c2 (VIDEO,"bin1"); + Category c3 (VIDEO,"bin1/subbin"); + Category c4 (EFFECT,"some_kind"); + + format fmt ("Category: %s"); + + cout << fmt % c1 << "\n"; + cout << fmt % c2 << "\n"; + cout << fmt % c3 << "\n"; + cout << fmt % c4 << "\n"; + } + + + void containmentQuery() + { + Category c1 (VIDEO); + Category c2 (VIDEO,"bin1"); + Category c3 (VIDEO,"bin1/subbin"); + Category c4 (EFFECT,"some_kind"); + + ASSERT ( c1.hasKind(VIDEO) ); + ASSERT (!c1.hasKind(AUDIO) ); + ASSERT ( c2.isWithin(c1) ); + ASSERT ( c3.isWithin(c2) ); + ASSERT ( c3.isWithin(c1) ); + ASSERT (!c1.isWithin(c2) ); + ASSERT (!c2.isWithin(c3) ); + ASSERT (!c1.isWithin(c3) ); + ASSERT (!c3.isWithin(c4) ); + ASSERT (!c4.isWithin(c3) ); + } + + + void ordering() + { + Category c1 (AUDIO); + Category c2 (VIDEO); + Category c3 (EFFECT); + Category c4 (CODEC); + Category c5 (STRUCT); + Category c6 (META); + + ASSERT (0 > c1.compare(c2)); + ASSERT (0 > c2.compare(c3)); + ASSERT (0 > c3.compare(c4)); + ASSERT (0 > c4.compare(c5)); + ASSERT (0 > c5.compare(c6)); + + ASSERT (0 ==c1.compare(c1)); + ASSERT (0 > c1.compare(c6)); + + Category c21 (VIDEO,"bin1"); + Category c22 (VIDEO,"bin2"); + Category c23 (VIDEO,"bin2/sub"); + + ASSERT (0 > c1.compare(c21)); + ASSERT (0 > c2.compare(c21)); + ASSERT (0 < c22.compare(c21)); + ASSERT (0 < c23.compare(c22)); + ASSERT (0 < c23.compare(c21)); + ASSERT ( 0==c22.compare(c22)); + + + ASSERT ( c2 == c2 ); + ASSERT ( c2 != c22 ); + ASSERT ( c2 != c3 ); + } + }; + + + /** Register this test class... */ + LAUNCHER (AssetCategory_test, "unit asset"); + + + + } // namespace test + +} // namespace asset diff --git a/tests/components/proc/asset/orderingofassetstest.cpp b/tests/components/proc/asset/orderingofassetstest.cpp index e456a356e..99381c9e6 100644 --- a/tests/components/proc/asset/orderingofassetstest.cpp +++ b/tests/components/proc/asset/orderingofassetstest.cpp @@ -84,17 +84,17 @@ namespace asset ASSERT (key4 != key5); ASSERT (key1 != key5); - ASSERT (-1 == key2.compare(key3)); - ASSERT (+1 == key3.compare(key2)); + ASSERT ( 0 > key2.compare(key3)); + ASSERT ( 0 < key3.compare(key2)); - ASSERT (-1 == key3.compare(key4)); - ASSERT (-1 == key4.compare(key5)); - ASSERT (-1 == key1.compare(key5)); - ASSERT (-1 == key2.compare(key5)); - ASSERT (-1 == key3.compare(key5)); - ASSERT (-1 == key1.compare(key3)); - ASSERT (-1 == key1.compare(key4)); - ASSERT (-1 == key2.compare(key4)); + ASSERT ( 0 > key3.compare(key4)); + ASSERT ( 0 > key4.compare(key5)); + ASSERT ( 0 > key1.compare(key5)); + ASSERT ( 0 > key2.compare(key5)); + ASSERT ( 0 > key3.compare(key5)); + ASSERT ( 0 > key1.compare(key3)); + ASSERT ( 0 > key1.compare(key4)); + ASSERT ( 0 > key2.compare(key4)); // ordering of Asset smart ptrs