chrome/browser/safe_json_parser_browsertest.cc

   1 // Copyright 2014 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 "base/bind.h"
   6 #include "base/json/json_reader.h"
   7 #include "base/json/json_writer.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/values.h"
  10 #include "chrome/test/base/in_process_browser_test.h"
  11 #include "components/safe_json/safe_json_parser.h"
  12 #include "content/public/test/test_browser_thread_bundle.h"
  13 #include "content/public/test/test_utils.h"
  14
  15 namespace {
  16
  17 using safe_json::SafeJsonParser;
  18
  19 std::string MaybeToJson(const base::Value* value) {
  20   if (!value)
  21     return "(null)";
  22
  23   std::string json;
  24   if (!base::JSONWriter::Write(*value, &json))
  25     return "(invalid value)";
  26
  27   return json;
  28 }
  29
  30 }  // namespace
  31
  32 class SafeJsonParserTest : public InProcessBrowserTest {
  33  protected:
  34   void TestParse(const std::string& json) {
  35     SCOPED_TRACE(json);
  36     DCHECK(!message_loop_runner_);
  37     message_loop_runner_ = new content::MessageLoopRunner;
  38
  39     std::string error;
  40     scoped_ptr<base::Value> value = base::JSONReader::ReadAndReturnError(
  41         json, base::JSON_PARSE_RFC, nullptr, &error);
  42
  43     SafeJsonParser::SuccessCallback success_callback;
  44     SafeJsonParser::ErrorCallback error_callback;
  45     if (value) {
  46       success_callback =
  47           base::Bind(&SafeJsonParserTest::ExpectValue, base::Unretained(this),
  48                      base::Passed(&value));
  49       error_callback = base::Bind(&SafeJsonParserTest::FailWithError,
  50                                   base::Unretained(this));
  51     } else {
  52       success_callback = base::Bind(&SafeJsonParserTest::FailWithValue,
  53                                     base::Unretained(this));
  54       error_callback = base::Bind(&SafeJsonParserTest::ExpectError,
  55                                   base::Unretained(this), error);
  56     }
  57     SafeJsonParser::Parse(json, success_callback, error_callback);
  58
  59     message_loop_runner_->Run();
  60     message_loop_runner_ = nullptr;
  61   }
  62
  63  private:
  64   void ExpectValue(scoped_ptr<base::Value> expected_value,
  65                    scoped_ptr<base::Value> actual_value) {
  66     EXPECT_TRUE(base::Value::Equals(actual_value.get(), expected_value.get()))
  67         << "Expected: " << MaybeToJson(expected_value.get())
  68         << " Actual: " << MaybeToJson(actual_value.get());
  69     message_loop_runner_->Quit();
  70   }
  71
  72   void ExpectError(const std::string& expected_error,
  73                    const std::string& actual_error) {
  74     EXPECT_EQ(expected_error, actual_error);
  75     message_loop_runner_->Quit();
  76   }
  77
  78   void FailWithValue(scoped_ptr<base::Value> value) {
  79     ADD_FAILURE() << MaybeToJson(value.get());
  80     message_loop_runner_->Quit();
  81   }
  82
  83   void FailWithError(const std::string& error) {
  84     ADD_FAILURE() << error;
  85     message_loop_runner_->Quit();
  86   }
  87
  88   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
  89 };
  90
  91 IN_PROC_BROWSER_TEST_F(SafeJsonParserTest, Parse) {
  92   TestParse("{}");
  93   TestParse("choke");
  94   TestParse("{\"awesome\": true}");
  95   TestParse("\"laser\"");
  96   TestParse("false");
  97   TestParse("null");
  98   TestParse("3.14");
  99   TestParse("[");
 100   TestParse("\"");
 101   TestParse(std::string());
 102   TestParse("☃");
 103   TestParse("\"☃\"");
 104   TestParse("\"\\ufdd0\"");
 105   TestParse("\"\\ufffe\"");
 106   TestParse("\"\\ud83f\\udffe\"");
 107 }