testsuite/json/jsontest_main.cpp

#include "jsontest.h"
#include <json/json.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);
}
Revision:	1.1
Committed:	Sun Oct 17 08:15:15 2010 UTC (13 years, 8 months ago) by sf-pippijn
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	initial import
#	User	Rev	Content
1	sf-pippijn	1.1	#include "jsontest.h"
2			#include <json/json.h>
3
4
5			/*
6			* TODO:
7			* - boolean value returns that they are integral. Should not be.
8			* - unsigned integer in integer range are not considered to be valid integer. Should check range.
9			*/
10
11
12			/*
13			* //////////////////////////////////////////////////////////////////
14			* //////////////////////////////////////////////////////////////////
15			* Json Library test cases
16			* //////////////////////////////////////////////////////////////////
17			* //////////////////////////////////////////////////////////////////
18			*/
19
20
21			struct ValueTest
22			: JsonTest::TestCase
23			{
24			Json::Value null_;
25			Json::Value emptyArray_;
26			Json::Value emptyObject_;
27			Json::Value integer_;
28			Json::Value unsignedInteger_;
29			Json::Value smallUnsignedInteger_;
30			Json::Value real_;
31			Json::Value array1_;
32			Json::Value object1_;
33			Json::Value emptyString_;
34			Json::Value string1_;
35			Json::Value string_;
36			Json::Value true_;
37			Json::Value false_;
38
39			ValueTest ()
40			: emptyArray_ (Json::arrayValue)
41			, emptyObject_ (Json::objectValue)
42			, integer_ (123456789)
43			, smallUnsignedInteger_ (Json::Value::UInt (Json::Value::maxInt))
44			, unsignedInteger_ (34567890u)
45			, real_ (1234.56789)
46			, emptyString_ ("")
47			, string1_ ("a")
48			, string_ ("sometext with space")
49			, true_ (true)
50			, false_ (false)
51			{
52			array1_.append (1234);
53			object1_["id"] = 1234;
54			}
55
56			struct IsCheck
57			{
58			/* / Initialize all checks to \c false by default. */
59			IsCheck ();
60
61			bool isObject_;
62			bool isArray_;
63			bool isBool_;
64			bool isDouble_;
65			bool isInt_;
66			bool isUInt_;
67			bool isIntegral_;
68			bool isNumeric_;
69			bool isString_;
70			bool isNull_;
71			};
72
73			void checkConstMemberCount (const Json::Value &value, unsigned int expectedCount);
74
75			void checkMemberCount (Json::Value &value, unsigned int expectedCount);
76
77			void checkIs (const Json::Value &value, const IsCheck &check);
78			};
79
80
81			JSONTEST_FIXTURE (ValueTest, size)
82			{
83			JSONTEST_ASSERT_PRED (checkMemberCount (emptyArray_, 0));
84			JSONTEST_ASSERT_PRED (checkMemberCount (emptyObject_, 0));
85			JSONTEST_ASSERT_PRED (checkMemberCount (array1_, 1));
86			JSONTEST_ASSERT_PRED (checkMemberCount (object1_, 1));
87			JSONTEST_ASSERT_PRED (checkMemberCount (null_, 0));
88			JSONTEST_ASSERT_PRED (checkMemberCount (integer_, 0));
89			JSONTEST_ASSERT_PRED (checkMemberCount (real_, 0));
90			JSONTEST_ASSERT_PRED (checkMemberCount (emptyString_, 0));
91			JSONTEST_ASSERT_PRED (checkMemberCount (string_, 0));
92			JSONTEST_ASSERT_PRED (checkMemberCount (true_, 0));
93			}
94
95
96			JSONTEST_FIXTURE (ValueTest, isObject)
97			{
98			IsCheck checks;
99
100			checks.isObject_ = true;
101			JSONTEST_ASSERT_PRED (checkIs (emptyObject_, checks));
102			JSONTEST_ASSERT_PRED (checkIs (object1_, checks));
103			}
104
105
106			JSONTEST_FIXTURE (ValueTest, isArray)
107			{
108			IsCheck checks;
109
110			checks.isArray_ = true;
111			JSONTEST_ASSERT_PRED (checkIs (emptyArray_, checks));
112			JSONTEST_ASSERT_PRED (checkIs (array1_, checks));
113			}
114
115
116			JSONTEST_FIXTURE (ValueTest, isNull)
117			{
118			IsCheck checks;
119
120			checks.isNull_ = true;
121			checks.isObject_ = true;
122			checks.isArray_ = true;
123			JSONTEST_ASSERT_PRED (checkIs (null_, checks));
124			}
125
126
127			JSONTEST_FIXTURE (ValueTest, isString)
128			{
129			IsCheck checks;
130
131			checks.isString_ = true;
132			JSONTEST_ASSERT_PRED (checkIs (emptyString_, checks));
133			JSONTEST_ASSERT_PRED (checkIs (string_, checks));
134			JSONTEST_ASSERT_PRED (checkIs (string1_, checks));
135			}
136
137
138			JSONTEST_FIXTURE (ValueTest, isBool)
139			{
140			IsCheck checks;
141
142			checks.isBool_ = true;
143			checks.isIntegral_ = true;
144			checks.isNumeric_ = true;
145			JSONTEST_ASSERT_PRED (checkIs (false_, checks));
146			JSONTEST_ASSERT_PRED (checkIs (true_, checks));
147			}
148
149
150			JSONTEST_FIXTURE (ValueTest, isDouble)
151			{
152			IsCheck checks;
153
154			checks.isDouble_ = true;
155			checks.isNumeric_ = true;
156			JSONTEST_ASSERT_PRED (checkIs (real_, checks));
157			}
158
159
160			JSONTEST_FIXTURE (ValueTest, isInt)
161			{
162			IsCheck checks;
163
164			checks.isInt_ = true;
165			checks.isNumeric_ = true;
166			checks.isIntegral_ = true;
167			JSONTEST_ASSERT_PRED (checkIs (integer_, checks));
168			}
169
170
171			JSONTEST_FIXTURE (ValueTest, isUInt)
172			{
173			IsCheck checks;
174
175			checks.isUInt_ = true;
176			checks.isNumeric_ = true;
177			checks.isIntegral_ = true;
178			JSONTEST_ASSERT_PRED (checkIs (unsignedInteger_, checks));
179			JSONTEST_ASSERT_PRED (checkIs (smallUnsignedInteger_, checks));
180			}
181
182
183			void
184			ValueTest::checkConstMemberCount (const Json::Value &value, unsigned int expectedCount)
185			{
186			unsigned int count = 0;
187			Json::Value::const_iterator itEnd = value.end ();
188
189			for (Json::Value::const_iterator it = value.begin (); it != itEnd; ++it)
190			++count;
191			JSONTEST_ASSERT_EQUAL (expectedCount, count) << "Json::Value::const_iterator";
192			}
193
194			void
195			ValueTest::checkMemberCount (Json::Value &value, unsigned int expectedCount)
196			{
197			JSONTEST_ASSERT_EQUAL (expectedCount, value.size ());
198
199			unsigned int count = 0;
200			Json::Value::iterator itEnd = value.end ();
201			for (Json::Value::iterator it = value.begin (); it != itEnd; ++it)
202			++count;
203			JSONTEST_ASSERT_EQUAL (expectedCount, count) << "Json::Value::iterator";
204
205			JSONTEST_ASSERT_PRED (checkConstMemberCount (value, expectedCount));
206			}
207
208			ValueTest::IsCheck::IsCheck ()
209			: isObject_ (false)
210			, isArray_ (false)
211			, isBool_ (false)
212			, isDouble_ (false)
213			, isInt_ (false)
214			, isUInt_ (false)
215			, isIntegral_ (false)
216			, isNumeric_ (false)
217			, isString_ (false)
218			, isNull_ (false)
219			{
220			}
221
222			void
223			ValueTest::checkIs (const Json::Value &value, const IsCheck &check)
224			{
225			JSONTEST_ASSERT_EQUAL (check.isObject_, value.isObject ());
226			JSONTEST_ASSERT_EQUAL (check.isArray_, value.isArray ());
227			JSONTEST_ASSERT_EQUAL (check.isBool_, value.isBool ());
228			JSONTEST_ASSERT_EQUAL (check.isDouble_, value.isDouble ());
229			JSONTEST_ASSERT_EQUAL (check.isInt_, value.isInt ());
230			JSONTEST_ASSERT_EQUAL (check.isUInt_, value.isUInt ());
231			JSONTEST_ASSERT_EQUAL (check.isIntegral_, value.isIntegral ());
232			JSONTEST_ASSERT_EQUAL (check.isNumeric_, value.isNumeric ());
233			JSONTEST_ASSERT_EQUAL (check.isString_, value.isString ());
234			JSONTEST_ASSERT_EQUAL (check.isNull_, value.isNull ());
235			}
236
237			int
238			main (int argc, const char *argv[])
239			{
240			JsonTest::Runner runner;
241
242			JSONTEST_REGISTER_FIXTURE (runner, ValueTest, size);
243			JSONTEST_REGISTER_FIXTURE (runner, ValueTest, isObject);
244			JSONTEST_REGISTER_FIXTURE (runner, ValueTest, isArray);
245			JSONTEST_REGISTER_FIXTURE (runner, ValueTest, isBool);
246			JSONTEST_REGISTER_FIXTURE (runner, ValueTest, isInt);
247			JSONTEST_REGISTER_FIXTURE (runner, ValueTest, isUInt);
248			JSONTEST_REGISTER_FIXTURE (runner, ValueTest, isDouble);
249			JSONTEST_REGISTER_FIXTURE (runner, ValueTest, isString);
250			JSONTEST_REGISTER_FIXTURE (runner, ValueTest, isNull);
251			return runner.runCommandLine (argc, argv);
252			}