1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/common/json_schema/json_schema_validator_unittest_base.h" 6 7 #include <cfloat> 8 #include <cmath> 9 #include <limits> 10 11 #include "base/file_util.h" 12 #include "base/json/json_file_value_serializer.h" 13 #include "base/logging.h" 14 #include "base/memory/scoped_ptr.h" 15 #include "base/path_service.h" 16 #include "base/strings/stringprintf.h" 17 #include "base/values.h" 18 #include "chrome/common/chrome_paths.h" 19 #include "chrome/common/json_schema/json_schema_constants.h" 20 #include "chrome/common/json_schema/json_schema_validator.h" 21 22 namespace schema = json_schema_constants; 23 24 namespace { 25 26 #define TEST_SOURCE base::StringPrintf("%s:%i", __FILE__, __LINE__) 27 28 base::Value* LoadValue(const std::string& filename) { 29 base::FilePath path; 30 PathService::Get(chrome::DIR_TEST_DATA, &path); 31 path = path.AppendASCII("json_schema_validator").AppendASCII(filename); 32 EXPECT_TRUE(base::PathExists(path)); 33 34 std::string error_message; 35 JSONFileValueSerializer serializer(path); 36 base::Value* result = serializer.Deserialize(NULL, &error_message); 37 if (!result) 38 ADD_FAILURE() << "Could not parse JSON: " << error_message; 39 return result; 40 } 41 42 base::Value* LoadValue(const std::string& filename, base::Value::Type type) { 43 scoped_ptr<base::Value> result(LoadValue(filename)); 44 if (!result.get()) 45 return NULL; 46 if (!result->IsType(type)) { 47 ADD_FAILURE() << "Expected type " << type << ", got: " << result->GetType(); 48 return NULL; 49 } 50 return result.release(); 51 } 52 53 base::ListValue* LoadList(const std::string& filename) { 54 return static_cast<base::ListValue*>( 55 LoadValue(filename, base::Value::TYPE_LIST)); 56 } 57 58 base::DictionaryValue* LoadDictionary(const std::string& filename) { 59 return static_cast<base::DictionaryValue*>( 60 LoadValue(filename, base::Value::TYPE_DICTIONARY)); 61 } 62 63 } // namespace 64 65 66 JSONSchemaValidatorTestBase::JSONSchemaValidatorTestBase( 67 JSONSchemaValidatorTestBase::ValidatorType type) 68 : type_(type) { 69 } 70 71 void JSONSchemaValidatorTestBase::RunTests() { 72 TestComplex(); 73 TestStringPattern(); 74 TestEnum(); 75 TestChoices(); 76 TestExtends(); 77 TestObject(); 78 TestTypeReference(); 79 TestArrayTuple(); 80 TestArrayNonTuple(); 81 TestString(); 82 TestNumber(); 83 TestTypeClassifier(); 84 TestTypes(); 85 } 86 87 void JSONSchemaValidatorTestBase::TestComplex() { 88 scoped_ptr<base::DictionaryValue> schema( 89 LoadDictionary("complex_schema.json")); 90 scoped_ptr<base::ListValue> instance(LoadList("complex_instance.json")); 91 92 ASSERT_TRUE(schema.get()); 93 ASSERT_TRUE(instance.get()); 94 95 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 96 instance->Remove(instance->GetSize() - 1, NULL); 97 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 98 instance->Append(new base::DictionaryValue()); 99 ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "1", 100 JSONSchemaValidator::FormatErrorMessage( 101 JSONSchemaValidator::kInvalidType, 102 schema::kNumber, 103 schema::kObject)); 104 instance->Remove(instance->GetSize() - 1, NULL); 105 106 base::DictionaryValue* item = NULL; 107 ASSERT_TRUE(instance->GetDictionary(0, &item)); 108 item->SetString("url", "xxxxxxxxxxx"); 109 110 ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, 111 "0.url", 112 JSONSchemaValidator::FormatErrorMessage( 113 JSONSchemaValidator::kStringMaxLength, "10")); 114 } 115 116 void JSONSchemaValidatorTestBase::TestStringPattern() { 117 // Regex patterns not supported in CPP validator. 118 if (type_ == CPP) 119 return; 120 121 scoped_ptr<base::DictionaryValue> schema(new base::DictionaryValue()); 122 schema->SetString(schema::kType, schema::kString); 123 schema->SetString(schema::kPattern, "foo+"); 124 125 ExpectValid(TEST_SOURCE, 126 scoped_ptr<base::Value>(new base::StringValue("foo")).get(), 127 schema.get(), NULL); 128 ExpectValid(TEST_SOURCE, 129 scoped_ptr<base::Value>(new base::StringValue("foooooo")).get(), 130 schema.get(), NULL); 131 ExpectNotValid(TEST_SOURCE, 132 scoped_ptr<base::Value>(new base::StringValue("bar")).get(), 133 schema.get(), 134 NULL, 135 std::string(), 136 JSONSchemaValidator::FormatErrorMessage( 137 JSONSchemaValidator::kStringPattern, "foo+")); 138 } 139 140 void JSONSchemaValidatorTestBase::TestEnum() { 141 scoped_ptr<base::DictionaryValue> schema(LoadDictionary("enum_schema.json")); 142 143 ExpectValid(TEST_SOURCE, 144 scoped_ptr<base::Value>(new base::StringValue("foo")).get(), 145 schema.get(), NULL); 146 ExpectValid(TEST_SOURCE, 147 scoped_ptr<base::Value>(new base::FundamentalValue(42)).get(), 148 schema.get(), NULL); 149 ExpectValid(TEST_SOURCE, 150 scoped_ptr<base::Value>(new base::FundamentalValue(false)).get(), 151 schema.get(), NULL); 152 153 ExpectNotValid(TEST_SOURCE, 154 scoped_ptr<base::Value>(new base::StringValue("42")).get(), 155 schema.get(), 156 NULL, 157 std::string(), 158 JSONSchemaValidator::kInvalidEnum); 159 ExpectNotValid(TEST_SOURCE, 160 scoped_ptr<base::Value>(base::Value::CreateNullValue()).get(), 161 schema.get(), 162 NULL, 163 std::string(), 164 JSONSchemaValidator::kInvalidEnum); 165 } 166 167 void JSONSchemaValidatorTestBase::TestChoices() { 168 scoped_ptr<base::DictionaryValue> schema( 169 LoadDictionary("choices_schema.json")); 170 171 ExpectValid(TEST_SOURCE, 172 scoped_ptr<base::Value>(base::Value::CreateNullValue()).get(), 173 schema.get(), NULL); 174 ExpectValid(TEST_SOURCE, 175 scoped_ptr<base::Value>(new base::FundamentalValue(42)).get(), 176 schema.get(), NULL); 177 178 scoped_ptr<base::DictionaryValue> instance(new base::DictionaryValue()); 179 instance->SetString("foo", "bar"); 180 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 181 182 ExpectNotValid(TEST_SOURCE, 183 scoped_ptr<base::Value>(new base::StringValue("foo")).get(), 184 schema.get(), 185 NULL, 186 std::string(), 187 JSONSchemaValidator::kInvalidChoice); 188 ExpectNotValid(TEST_SOURCE, 189 scoped_ptr<base::Value>(new base::ListValue()).get(), 190 schema.get(), 191 NULL, 192 std::string(), 193 JSONSchemaValidator::kInvalidChoice); 194 195 instance->SetInteger("foo", 42); 196 ExpectNotValid(TEST_SOURCE, 197 instance.get(), 198 schema.get(), 199 NULL, 200 std::string(), 201 JSONSchemaValidator::kInvalidChoice); 202 } 203 204 void JSONSchemaValidatorTestBase::TestExtends() { 205 // TODO(aa): JS only 206 } 207 208 void JSONSchemaValidatorTestBase::TestObject() { 209 scoped_ptr<base::DictionaryValue> schema(new base::DictionaryValue()); 210 schema->SetString(schema::kType, schema::kObject); 211 schema->SetString("properties.foo.type", schema::kString); 212 schema->SetString("properties.bar.type", schema::kInteger); 213 214 scoped_ptr<base::DictionaryValue> instance(new base::DictionaryValue()); 215 instance->SetString("foo", "foo"); 216 instance->SetInteger("bar", 42); 217 218 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 219 220 instance->SetBoolean("extra", true); 221 ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, 222 "extra", JSONSchemaValidator::kUnexpectedProperty); 223 224 instance->Remove("extra", NULL); 225 instance->Remove("bar", NULL); 226 ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "bar", 227 JSONSchemaValidator::kObjectPropertyIsRequired); 228 229 instance->SetString("bar", "42"); 230 ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "bar", 231 JSONSchemaValidator::FormatErrorMessage( 232 JSONSchemaValidator::kInvalidType, 233 schema::kInteger, 234 schema::kString)); 235 236 base::DictionaryValue* additional_properties = new base::DictionaryValue(); 237 additional_properties->SetString(schema::kType, schema::kAny); 238 schema->Set(schema::kAdditionalProperties, additional_properties); 239 240 instance->SetInteger("bar", 42); 241 instance->SetBoolean("extra", true); 242 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 243 244 instance->SetString("extra", "foo"); 245 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 246 247 additional_properties->SetString(schema::kType, schema::kBoolean); 248 instance->SetBoolean("extra", true); 249 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 250 251 instance->SetString("extra", "foo"); 252 ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, 253 "extra", JSONSchemaValidator::FormatErrorMessage( 254 JSONSchemaValidator::kInvalidType, 255 schema::kBoolean, 256 schema::kString)); 257 258 base::DictionaryValue* properties = NULL; 259 base::DictionaryValue* bar_property = NULL; 260 ASSERT_TRUE(schema->GetDictionary(schema::kProperties, &properties)); 261 ASSERT_TRUE(properties->GetDictionary("bar", &bar_property)); 262 263 bar_property->SetBoolean(schema::kOptional, true); 264 instance->Remove("extra", NULL); 265 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 266 instance->Remove("bar", NULL); 267 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 268 instance->Set("bar", base::Value::CreateNullValue()); 269 ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, 270 "bar", JSONSchemaValidator::FormatErrorMessage( 271 JSONSchemaValidator::kInvalidType, 272 schema::kInteger, 273 schema::kNull)); 274 instance->SetString("bar", "42"); 275 ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, 276 "bar", JSONSchemaValidator::FormatErrorMessage( 277 JSONSchemaValidator::kInvalidType, 278 schema::kInteger, 279 schema::kString)); 280 } 281 282 void JSONSchemaValidatorTestBase::TestTypeReference() { 283 scoped_ptr<base::ListValue> types(LoadList("reference_types.json")); 284 ASSERT_TRUE(types.get()); 285 286 scoped_ptr<base::DictionaryValue> schema(new base::DictionaryValue()); 287 schema->SetString(schema::kType, schema::kObject); 288 schema->SetString("properties.foo.type", schema::kString); 289 schema->SetString("properties.bar.$ref", "Max10Int"); 290 schema->SetString("properties.baz.$ref", "MinLengthString"); 291 292 scoped_ptr<base::DictionaryValue> schema_inline(new base::DictionaryValue()); 293 schema_inline->SetString(schema::kType, schema::kObject); 294 schema_inline->SetString("properties.foo.type", schema::kString); 295 schema_inline->SetString("properties.bar.id", "NegativeInt"); 296 schema_inline->SetString("properties.bar.type", schema::kInteger); 297 schema_inline->SetInteger("properties.bar.maximum", 0); 298 schema_inline->SetString("properties.baz.$ref", "NegativeInt"); 299 300 scoped_ptr<base::DictionaryValue> instance(new base::DictionaryValue()); 301 instance->SetString("foo", "foo"); 302 instance->SetInteger("bar", 4); 303 instance->SetString("baz", "ab"); 304 305 scoped_ptr<base::DictionaryValue> instance_inline( 306 new base::DictionaryValue()); 307 instance_inline->SetString("foo", "foo"); 308 instance_inline->SetInteger("bar", -4); 309 instance_inline->SetInteger("baz", -2); 310 311 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), types.get()); 312 ExpectValid(TEST_SOURCE, instance_inline.get(), schema_inline.get(), NULL); 313 314 // Validation failure, but successful schema reference. 315 instance->SetString("baz", "a"); 316 ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), types.get(), 317 "baz", JSONSchemaValidator::FormatErrorMessage( 318 JSONSchemaValidator::kStringMinLength, "2")); 319 320 instance_inline->SetInteger("bar", 20); 321 ExpectNotValid(TEST_SOURCE, instance_inline.get(), schema_inline.get(), NULL, 322 "bar", JSONSchemaValidator::FormatErrorMessage( 323 JSONSchemaValidator::kNumberMaximum, "0")); 324 325 // Remove MinLengthString type. 326 types->Remove(types->GetSize() - 1, NULL); 327 instance->SetString("baz", "ab"); 328 ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), types.get(), 329 "bar", JSONSchemaValidator::FormatErrorMessage( 330 JSONSchemaValidator::kUnknownTypeReference, 331 "Max10Int")); 332 333 // Remove internal type "NegativeInt". 334 schema_inline->Remove("properties.bar", NULL); 335 instance_inline->Remove("bar", NULL); 336 ExpectNotValid(TEST_SOURCE, instance_inline.get(), schema_inline.get(), NULL, 337 "baz", JSONSchemaValidator::FormatErrorMessage( 338 JSONSchemaValidator::kUnknownTypeReference, 339 "NegativeInt")); 340 } 341 342 void JSONSchemaValidatorTestBase::TestArrayTuple() { 343 scoped_ptr<base::DictionaryValue> schema( 344 LoadDictionary("array_tuple_schema.json")); 345 ASSERT_TRUE(schema.get()); 346 347 scoped_ptr<base::ListValue> instance(new base::ListValue()); 348 instance->Append(new base::StringValue("42")); 349 instance->Append(new base::FundamentalValue(42)); 350 351 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 352 353 instance->Append(new base::StringValue("anything")); 354 ExpectNotValid(TEST_SOURCE, 355 instance.get(), 356 schema.get(), 357 NULL, 358 std::string(), 359 JSONSchemaValidator::FormatErrorMessage( 360 JSONSchemaValidator::kArrayMaxItems, "2")); 361 362 instance->Remove(1, NULL); 363 instance->Remove(1, NULL); 364 ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "1", 365 JSONSchemaValidator::kArrayItemRequired); 366 367 instance->Set(0, new base::FundamentalValue(42)); 368 instance->Append(new base::FundamentalValue(42)); 369 ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "0", 370 JSONSchemaValidator::FormatErrorMessage( 371 JSONSchemaValidator::kInvalidType, 372 schema::kString, 373 schema::kInteger)); 374 375 base::DictionaryValue* additional_properties = new base::DictionaryValue(); 376 additional_properties->SetString(schema::kType, schema::kAny); 377 schema->Set(schema::kAdditionalProperties, additional_properties); 378 instance->Set(0, new base::StringValue("42")); 379 instance->Append(new base::StringValue("anything")); 380 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 381 instance->Set(2, new base::ListValue()); 382 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 383 384 additional_properties->SetString(schema::kType, schema::kBoolean); 385 ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "2", 386 JSONSchemaValidator::FormatErrorMessage( 387 JSONSchemaValidator::kInvalidType, 388 schema::kBoolean, 389 schema::kArray)); 390 instance->Set(2, new base::FundamentalValue(false)); 391 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 392 393 base::ListValue* items_schema = NULL; 394 base::DictionaryValue* item0_schema = NULL; 395 ASSERT_TRUE(schema->GetList(schema::kItems, &items_schema)); 396 ASSERT_TRUE(items_schema->GetDictionary(0, &item0_schema)); 397 item0_schema->SetBoolean(schema::kOptional, true); 398 instance->Remove(2, NULL); 399 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 400 // TODO(aa): I think this is inconsistent with the handling of NULL+optional 401 // for objects. 402 instance->Set(0, base::Value::CreateNullValue()); 403 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 404 instance->Set(0, new base::FundamentalValue(42)); 405 ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "0", 406 JSONSchemaValidator::FormatErrorMessage( 407 JSONSchemaValidator::kInvalidType, 408 schema::kString, 409 schema::kInteger)); 410 } 411 412 void JSONSchemaValidatorTestBase::TestArrayNonTuple() { 413 scoped_ptr<base::DictionaryValue> schema(new base::DictionaryValue()); 414 schema->SetString(schema::kType, schema::kArray); 415 schema->SetString("items.type", schema::kString); 416 schema->SetInteger(schema::kMinItems, 2); 417 schema->SetInteger(schema::kMaxItems, 3); 418 419 scoped_ptr<base::ListValue> instance(new base::ListValue()); 420 instance->Append(new base::StringValue("x")); 421 instance->Append(new base::StringValue("x")); 422 423 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 424 instance->Append(new base::StringValue("x")); 425 ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL); 426 427 instance->Append(new base::StringValue("x")); 428 ExpectNotValid(TEST_SOURCE, 429 instance.get(), 430 schema.get(), 431 NULL, 432 std::string(), 433 JSONSchemaValidator::FormatErrorMessage( 434 JSONSchemaValidator::kArrayMaxItems, "3")); 435 instance->Remove(1, NULL); 436 instance->Remove(1, NULL); 437 instance->Remove(1, NULL); 438 ExpectNotValid(TEST_SOURCE, 439 instance.get(), 440 schema.get(), 441 NULL, 442 std::string(), 443 JSONSchemaValidator::FormatErrorMessage( 444 JSONSchemaValidator::kArrayMinItems, "2")); 445 446 instance->Remove(1, NULL); 447 instance->Append(new base::FundamentalValue(42)); 448 ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "1", 449 JSONSchemaValidator::FormatErrorMessage( 450 JSONSchemaValidator::kInvalidType, 451 schema::kString, 452 schema::kInteger)); 453 } 454 455 void JSONSchemaValidatorTestBase::TestString() { 456 scoped_ptr<base::DictionaryValue> schema(new base::DictionaryValue()); 457 schema->SetString(schema::kType, schema::kString); 458 schema->SetInteger(schema::kMinLength, 1); 459 schema->SetInteger(schema::kMaxLength, 10); 460 461 ExpectValid(TEST_SOURCE, 462 scoped_ptr<base::Value>(new base::StringValue("x")).get(), 463 schema.get(), NULL); 464 ExpectValid(TEST_SOURCE, 465 scoped_ptr<base::Value>( 466 new base::StringValue("xxxxxxxxxx")).get(), 467 schema.get(), NULL); 468 469 ExpectNotValid( 470 TEST_SOURCE, 471 scoped_ptr<base::Value>(new base::StringValue(std::string())).get(), 472 schema.get(), 473 NULL, 474 std::string(), 475 JSONSchemaValidator::FormatErrorMessage( 476 JSONSchemaValidator::kStringMinLength, "1")); 477 ExpectNotValid( 478 TEST_SOURCE, 479 scoped_ptr<base::Value>(new base::StringValue("xxxxxxxxxxx")).get(), 480 schema.get(), 481 NULL, 482 std::string(), 483 JSONSchemaValidator::FormatErrorMessage( 484 JSONSchemaValidator::kStringMaxLength, "10")); 485 } 486 487 void JSONSchemaValidatorTestBase::TestNumber() { 488 scoped_ptr<base::DictionaryValue> schema(new base::DictionaryValue()); 489 schema->SetString(schema::kType, schema::kNumber); 490 schema->SetInteger(schema::kMinimum, 1); 491 schema->SetInteger(schema::kMaximum, 100); 492 schema->SetInteger("maxDecimal", 2); 493 494 ExpectValid(TEST_SOURCE, 495 scoped_ptr<base::Value>(new base::FundamentalValue(1)).get(), 496 schema.get(), NULL); 497 ExpectValid(TEST_SOURCE, 498 scoped_ptr<base::Value>(new base::FundamentalValue(50)).get(), 499 schema.get(), NULL); 500 ExpectValid(TEST_SOURCE, 501 scoped_ptr<base::Value>(new base::FundamentalValue(100)).get(), 502 schema.get(), NULL); 503 ExpectValid(TEST_SOURCE, 504 scoped_ptr<base::Value>(new base::FundamentalValue(88.88)).get(), 505 schema.get(), NULL); 506 507 ExpectNotValid(TEST_SOURCE, 508 scoped_ptr<base::Value>(new base::FundamentalValue(0.5)).get(), 509 schema.get(), 510 NULL, 511 std::string(), 512 JSONSchemaValidator::FormatErrorMessage( 513 JSONSchemaValidator::kNumberMinimum, "1")); 514 ExpectNotValid( 515 TEST_SOURCE, 516 scoped_ptr<base::Value>(new base::FundamentalValue(100.1)).get(), 517 schema.get(), 518 NULL, 519 std::string(), 520 JSONSchemaValidator::FormatErrorMessage( 521 JSONSchemaValidator::kNumberMaximum, "100")); 522 } 523 524 void JSONSchemaValidatorTestBase::TestTypeClassifier() { 525 EXPECT_EQ(std::string(schema::kBoolean), 526 JSONSchemaValidator::GetJSONSchemaType( 527 scoped_ptr<base::Value>( 528 new base::FundamentalValue(true)).get())); 529 EXPECT_EQ(std::string(schema::kBoolean), 530 JSONSchemaValidator::GetJSONSchemaType( 531 scoped_ptr<base::Value>( 532 new base::FundamentalValue(false)).get())); 533 534 // It doesn't matter whether the C++ type is 'integer' or 'real'. If the 535 // number is integral and within the representable range of integers in 536 // double, it's classified as 'integer'. 537 EXPECT_EQ(std::string(schema::kInteger), 538 JSONSchemaValidator::GetJSONSchemaType( 539 scoped_ptr<base::Value>(new base::FundamentalValue(42)).get())); 540 EXPECT_EQ(std::string(schema::kInteger), 541 JSONSchemaValidator::GetJSONSchemaType( 542 scoped_ptr<base::Value>(new base::FundamentalValue(0)).get())); 543 EXPECT_EQ(std::string(schema::kInteger), 544 JSONSchemaValidator::GetJSONSchemaType( 545 scoped_ptr<base::Value>(new base::FundamentalValue(42)).get())); 546 EXPECT_EQ(std::string(schema::kInteger), 547 JSONSchemaValidator::GetJSONSchemaType(scoped_ptr<base::Value>( 548 new base::FundamentalValue(pow(2.0, DBL_MANT_DIG))).get())); 549 EXPECT_EQ(std::string(schema::kInteger), 550 JSONSchemaValidator::GetJSONSchemaType(scoped_ptr<base::Value>( 551 new base::FundamentalValue(pow(-2.0, DBL_MANT_DIG))).get())); 552 553 // "number" is only used for non-integral numbers, or numbers beyond what 554 // double can accurately represent. 555 EXPECT_EQ(std::string(schema::kNumber), 556 JSONSchemaValidator::GetJSONSchemaType( 557 scoped_ptr<base::Value>( 558 new base::FundamentalValue(88.8)).get())); 559 EXPECT_EQ(std::string(schema::kNumber), 560 JSONSchemaValidator::GetJSONSchemaType(scoped_ptr<base::Value>( 561 new base::FundamentalValue(pow(2.0, DBL_MANT_DIG) * 2)).get())); 562 EXPECT_EQ(std::string(schema::kNumber), 563 JSONSchemaValidator::GetJSONSchemaType(scoped_ptr<base::Value>( 564 new base::FundamentalValue( 565 pow(-2.0, DBL_MANT_DIG) * 2)).get())); 566 567 EXPECT_EQ(std::string(schema::kString), 568 JSONSchemaValidator::GetJSONSchemaType( 569 scoped_ptr<base::Value>(new base::StringValue("foo")).get())); 570 EXPECT_EQ(std::string(schema::kArray), 571 JSONSchemaValidator::GetJSONSchemaType( 572 scoped_ptr<base::Value>(new base::ListValue()).get())); 573 EXPECT_EQ(std::string(schema::kObject), 574 JSONSchemaValidator::GetJSONSchemaType( 575 scoped_ptr<base::Value>(new base::DictionaryValue()).get())); 576 EXPECT_EQ(std::string(schema::kNull), 577 JSONSchemaValidator::GetJSONSchemaType( 578 scoped_ptr<base::Value>(base::Value::CreateNullValue()).get())); 579 } 580 581 void JSONSchemaValidatorTestBase::TestTypes() { 582 scoped_ptr<base::DictionaryValue> schema(new base::DictionaryValue()); 583 584 // valid 585 schema->SetString(schema::kType, schema::kObject); 586 ExpectValid(TEST_SOURCE, 587 scoped_ptr<base::Value>(new base::DictionaryValue()).get(), 588 schema.get(), NULL); 589 590 schema->SetString(schema::kType, schema::kArray); 591 ExpectValid(TEST_SOURCE, scoped_ptr<base::Value>(new base::ListValue()).get(), 592 schema.get(), NULL); 593 594 schema->SetString(schema::kType, schema::kString); 595 ExpectValid(TEST_SOURCE, 596 scoped_ptr<base::Value>(new base::StringValue("foobar")).get(), 597 schema.get(), NULL); 598 599 schema->SetString(schema::kType, schema::kNumber); 600 ExpectValid(TEST_SOURCE, 601 scoped_ptr<base::Value>(new base::FundamentalValue(88.8)).get(), 602 schema.get(), NULL); 603 ExpectValid(TEST_SOURCE, 604 scoped_ptr<base::Value>(new base::FundamentalValue(42)).get(), 605 schema.get(), NULL); 606 ExpectValid(TEST_SOURCE, 607 scoped_ptr<base::Value>(new base::FundamentalValue(42)).get(), 608 schema.get(), NULL); 609 ExpectValid(TEST_SOURCE, 610 scoped_ptr<base::Value>(new base::FundamentalValue(0)).get(), 611 schema.get(), NULL); 612 613 schema->SetString(schema::kType, schema::kInteger); 614 ExpectValid(TEST_SOURCE, 615 scoped_ptr<base::Value>(new base::FundamentalValue(42)).get(), 616 schema.get(), NULL); 617 ExpectValid(TEST_SOURCE, 618 scoped_ptr<base::Value>(new base::FundamentalValue(42)).get(), 619 schema.get(), NULL); 620 ExpectValid(TEST_SOURCE, 621 scoped_ptr<base::Value>(new base::FundamentalValue(0)).get(), 622 schema.get(), NULL); 623 ExpectValid(TEST_SOURCE, 624 scoped_ptr<base::Value>( 625 new base::FundamentalValue(pow(2.0, DBL_MANT_DIG))).get(), 626 schema.get(), NULL); 627 ExpectValid(TEST_SOURCE, 628 scoped_ptr<base::Value>( 629 new base::FundamentalValue(pow(-2.0, DBL_MANT_DIG))).get(), 630 schema.get(), NULL); 631 632 schema->SetString(schema::kType, schema::kBoolean); 633 ExpectValid(TEST_SOURCE, 634 scoped_ptr<base::Value>(new base::FundamentalValue(false)).get(), 635 schema.get(), NULL); 636 ExpectValid(TEST_SOURCE, 637 scoped_ptr<base::Value>(new base::FundamentalValue(true)).get(), 638 schema.get(), NULL); 639 640 schema->SetString(schema::kType, schema::kNull); 641 ExpectValid(TEST_SOURCE, 642 scoped_ptr<base::Value>(base::Value::CreateNullValue()).get(), 643 schema.get(), NULL); 644 645 // not valid 646 schema->SetString(schema::kType, schema::kObject); 647 ExpectNotValid( 648 TEST_SOURCE, 649 scoped_ptr<base::Value>(new base::ListValue()).get(), 650 schema.get(), 651 NULL, 652 std::string(), 653 JSONSchemaValidator::FormatErrorMessage( 654 JSONSchemaValidator::kInvalidType, schema::kObject, schema::kArray)); 655 656 schema->SetString(schema::kType, schema::kObject); 657 ExpectNotValid( 658 TEST_SOURCE, 659 scoped_ptr<base::Value>(base::Value::CreateNullValue()).get(), 660 schema.get(), 661 NULL, 662 std::string(), 663 JSONSchemaValidator::FormatErrorMessage( 664 JSONSchemaValidator::kInvalidType, schema::kObject, schema::kNull)); 665 666 schema->SetString(schema::kType, schema::kArray); 667 ExpectNotValid( 668 TEST_SOURCE, 669 scoped_ptr<base::Value>(new base::FundamentalValue(42)).get(), 670 schema.get(), 671 NULL, 672 std::string(), 673 JSONSchemaValidator::FormatErrorMessage( 674 JSONSchemaValidator::kInvalidType, schema::kArray, schema::kInteger)); 675 676 schema->SetString(schema::kType, schema::kString); 677 ExpectNotValid( 678 TEST_SOURCE, 679 scoped_ptr<base::Value>(new base::FundamentalValue(42)).get(), 680 schema.get(), 681 NULL, 682 std::string(), 683 JSONSchemaValidator::FormatErrorMessage(JSONSchemaValidator::kInvalidType, 684 schema::kString, 685 schema::kInteger)); 686 687 schema->SetString(schema::kType, schema::kNumber); 688 ExpectNotValid( 689 TEST_SOURCE, 690 scoped_ptr<base::Value>(new base::StringValue("42")).get(), 691 schema.get(), 692 NULL, 693 std::string(), 694 JSONSchemaValidator::FormatErrorMessage( 695 JSONSchemaValidator::kInvalidType, schema::kNumber, schema::kString)); 696 697 schema->SetString(schema::kType, schema::kInteger); 698 ExpectNotValid( 699 TEST_SOURCE, 700 scoped_ptr<base::Value>(new base::FundamentalValue(88.8)).get(), 701 schema.get(), 702 NULL, 703 std::string(), 704 JSONSchemaValidator::kInvalidTypeIntegerNumber); 705 706 schema->SetString(schema::kType, schema::kBoolean); 707 ExpectNotValid( 708 TEST_SOURCE, 709 scoped_ptr<base::Value>(new base::FundamentalValue(1)).get(), 710 schema.get(), 711 NULL, 712 std::string(), 713 JSONSchemaValidator::FormatErrorMessage(JSONSchemaValidator::kInvalidType, 714 schema::kBoolean, 715 schema::kInteger)); 716 717 schema->SetString(schema::kType, schema::kNull); 718 ExpectNotValid( 719 TEST_SOURCE, 720 scoped_ptr<base::Value>(new base::FundamentalValue(false)).get(), 721 schema.get(), 722 NULL, 723 std::string(), 724 JSONSchemaValidator::FormatErrorMessage( 725 JSONSchemaValidator::kInvalidType, schema::kNull, schema::kBoolean)); 726 } 727
