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
#	Content
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	}