← Back to branch summary

~c-e-pidcott/maus/devel

« back to all changes in this revision

Viewing changes to third_party/JsonCpp_0.5.0/src/test_lib_json/main.cpp

  • Committer: Christopher Tunnell
  • Date: 2010-10-22 23:28:44 UTC
  • Revision ID: c.tunnell1@physics.ox.ac.uk-20101022232844-o8bl6n26kk03deuw
remove jsoncpp (so it's now downloaded instead)

Show diffs side-by-side

added added

removed removed

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