Merged cptspiff's code-reshuffle branch.

Squashed commit due to build breakage during code-reshuffle history.

Conflicts:
	xbmc/Util.cpp
	xbmc/cdrip/CDDARipper.cpp
	xbmc/filesystem/Directory.cpp
	xbmc/filesystem/File.cpp

1 files changed, 244 insertions, 0 deletions

diff --git a/lib/jsoncpp/src/test_lib_json/main.cpp b/lib/jsoncpp/src/test_lib_json/main.cpp
new file mode 100644
index 0000000000..b80776d630
--- /dev/null
+++ b/lib/jsoncpp/src/test_lib_json/main.cpp
@@ -0,0 +1,244 @@
+#include <json/json.h>
+#include "jsontest.h"
+
+
+// TODO:
+// - boolean value returns that they are integral. Should not be.
+// - unsigned integer in integer range are not considered to be valid integer. Should check range.
+
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// Json Library test cases
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+
+struct ValueTest : JsonTest::TestCase
+{
+   Json::Value null_;
+   Json::Value emptyArray_;
+   Json::Value emptyObject_;
+   Json::Value integer_;
+   Json::Value unsignedInteger_;
+   Json::Value smallUnsignedInteger_;
+   Json::Value real_;
+   Json::Value array1_;
+   Json::Value object1_;
+   Json::Value emptyString_;
+   Json::Value string1_;
+   Json::Value string_;
+   Json::Value true_;
+   Json::Value false_;
+
+   ValueTest()
+      : emptyArray_( Json::arrayValue )
+      , emptyObject_( Json::objectValue )
+      , integer_( 123456789 )
+      , smallUnsignedInteger_( Json::Value::UInt( Json::Value::maxInt ) )
+      , unsignedInteger_( 34567890u )
+      , real_( 1234.56789 )
+      , emptyString_( "" )
+      , string1_( "a" )
+      , string_( "sometext with space" )
+      , true_( true )
+      , false_( false )
+   {
+      array1_.append( 1234 );
+      object1_["id"] = 1234;
+   }
+
+   struct IsCheck
+   {
+      /// Initialize all checks to \c false by default.
+      IsCheck();
+
+      bool isObject_;
+      bool isArray_;
+      bool isBool_;
+      bool isDouble_;
+      bool isInt_;
+      bool isUInt_;
+      bool isIntegral_;
+      bool isNumeric_;
+      bool isString_;
+      bool isNull_;
+   };
+
+   void checkConstMemberCount( const Json::Value &value, unsigned int expectedCount );
+
+   void checkMemberCount( Json::Value &value, unsigned int expectedCount );
+
+   void checkIs( const Json::Value &value, const IsCheck &check );
+};
+
+
+JSONTEST_FIXTURE( ValueTest, size )
+{
+   JSONTEST_ASSERT_PRED( checkMemberCount(emptyArray_, 0) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(emptyObject_, 0) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(array1_, 1) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(object1_, 1) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(null_, 0) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(integer_, 0) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(real_, 0) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(emptyString_, 0) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(string_, 0) );
+   JSONTEST_ASSERT_PRED( checkMemberCount(true_, 0) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, isObject )
+{
+   IsCheck checks;
+   checks.isObject_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( emptyObject_, checks ) );
+   JSONTEST_ASSERT_PRED( checkIs( object1_, checks ) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, isArray )
+{
+   IsCheck checks;
+   checks.isArray_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( emptyArray_, checks ) );
+   JSONTEST_ASSERT_PRED( checkIs( array1_, checks ) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, isNull )
+{
+   IsCheck checks;
+   checks.isNull_ = true;
+   checks.isObject_ = true;
+   checks.isArray_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( null_, checks ) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, isString )
+{
+   IsCheck checks;
+   checks.isString_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( emptyString_, checks ) );
+   JSONTEST_ASSERT_PRED( checkIs( string_, checks ) );
+   JSONTEST_ASSERT_PRED( checkIs( string1_, checks ) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, isBool )
+{
+   IsCheck checks;
+   checks.isBool_ = true;
+   checks.isIntegral_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( false_, checks ) );
+   JSONTEST_ASSERT_PRED( checkIs( true_, checks ) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, isDouble )
+{
+   IsCheck checks;
+   checks.isDouble_ = true;
+   checks.isNumeric_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( real_, checks ) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, isInt )
+{
+   IsCheck checks;
+   checks.isInt_ = true;
+   checks.isNumeric_ = true;
+   checks.isIntegral_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( integer_, checks ) );
+}
+
+
+JSONTEST_FIXTURE( ValueTest, isUInt )
+{
+   IsCheck checks;
+   checks.isUInt_ = true;
+   checks.isNumeric_ = true;
+   checks.isIntegral_ = true;
+   JSONTEST_ASSERT_PRED( checkIs( unsignedInteger_, checks ) );
+   JSONTEST_ASSERT_PRED( checkIs( smallUnsignedInteger_, checks ) );
+}
+
+
+void
+ValueTest::checkConstMemberCount( const Json::Value &value, unsigned int expectedCount )
+{
+   unsigned int count = 0;
+   Json::Value::const_iterator itEnd = value.end();
+   for ( Json::Value::const_iterator it = value.begin(); it != itEnd; ++it )
+   {
+      ++count;
+   }
+   JSONTEST_ASSERT_EQUAL( expectedCount, count ) << "Json::Value::const_iterator";
+}
+
+void
+ValueTest::checkMemberCount( Json::Value &value, unsigned int expectedCount )
+{
+   JSONTEST_ASSERT_EQUAL( expectedCount, value.size() );
+
+   unsigned int count = 0;
+   Json::Value::iterator itEnd = value.end();
+   for ( Json::Value::iterator it = value.begin(); it != itEnd; ++it )
+   {
+      ++count;
+   }
+   JSONTEST_ASSERT_EQUAL( expectedCount, count ) << "Json::Value::iterator";
+
+   JSONTEST_ASSERT_PRED( checkConstMemberCount(value, expectedCount) );
+}
+
+
+ValueTest::IsCheck::IsCheck()
+   : isObject_( false )
+   , isArray_( false )
+   , isBool_( false )
+   , isDouble_( false )
+   , isInt_( false )
+   , isUInt_( false )
+   , isIntegral_( false )
+   , isNumeric_( false )
+   , isString_( false )
+   , isNull_( false )
+{
+}
+
+
+void 
+ValueTest::checkIs( const Json::Value &value, const IsCheck &check )
+{
+   JSONTEST_ASSERT_EQUAL( check.isObject_, value.isObject() );
+   JSONTEST_ASSERT_EQUAL( check.isArray_, value.isArray() );
+   JSONTEST_ASSERT_EQUAL( check.isBool_, value.isBool() );
+   JSONTEST_ASSERT_EQUAL( check.isDouble_, value.isDouble() );
+   JSONTEST_ASSERT_EQUAL( check.isInt_, value.isInt() );
+   JSONTEST_ASSERT_EQUAL( check.isUInt_, value.isUInt() );
+   JSONTEST_ASSERT_EQUAL( check.isIntegral_, value.isIntegral() );
+   JSONTEST_ASSERT_EQUAL( check.isNumeric_, value.isNumeric() );
+   JSONTEST_ASSERT_EQUAL( check.isString_, value.isString() );
+   JSONTEST_ASSERT_EQUAL( check.isNull_, value.isNull() );
+}
+
+
+
+int main( int argc, const char *argv[] )
+{
+   JsonTest::Runner runner;
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, size );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isObject );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isArray );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isBool );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isInt );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isUInt );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isDouble );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isString );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isNull );
+   return runner.runCommandLine( argc, argv );
+}