Home | History | Annotate | Download | only in json
      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 "base/json/json_writer.h"
      6 
      7 #include "base/memory/ptr_util.h"
      8 #include "base/values.h"
      9 #include "build/build_config.h"
     10 #include "testing/gtest/include/gtest/gtest.h"
     11 
     12 namespace base {
     13 
     14 TEST(JSONWriterTest, BasicTypes) {
     15   std::string output_js;
     16 
     17   // Test null.
     18   EXPECT_TRUE(JSONWriter::Write(*Value::CreateNullValue(), &output_js));
     19   EXPECT_EQ("null", output_js);
     20 
     21   // Test empty dict.
     22   EXPECT_TRUE(JSONWriter::Write(DictionaryValue(), &output_js));
     23   EXPECT_EQ("{}", output_js);
     24 
     25   // Test empty list.
     26   EXPECT_TRUE(JSONWriter::Write(ListValue(), &output_js));
     27   EXPECT_EQ("[]", output_js);
     28 
     29   // Test integer values.
     30   EXPECT_TRUE(JSONWriter::Write(FundamentalValue(42), &output_js));
     31   EXPECT_EQ("42", output_js);
     32 
     33   // Test boolean values.
     34   EXPECT_TRUE(JSONWriter::Write(FundamentalValue(true), &output_js));
     35   EXPECT_EQ("true", output_js);
     36 
     37   // Test Real values should always have a decimal or an 'e'.
     38   EXPECT_TRUE(JSONWriter::Write(FundamentalValue(1.0), &output_js));
     39   EXPECT_EQ("1.0", output_js);
     40 
     41   // Test Real values in the the range (-1, 1) must have leading zeros
     42   EXPECT_TRUE(JSONWriter::Write(FundamentalValue(0.2), &output_js));
     43   EXPECT_EQ("0.2", output_js);
     44 
     45   // Test Real values in the the range (-1, 1) must have leading zeros
     46   EXPECT_TRUE(JSONWriter::Write(FundamentalValue(-0.8), &output_js));
     47   EXPECT_EQ("-0.8", output_js);
     48 
     49   // Test String values.
     50   EXPECT_TRUE(JSONWriter::Write(StringValue("foo"), &output_js));
     51   EXPECT_EQ("\"foo\"", output_js);
     52 }
     53 
     54 TEST(JSONWriterTest, NestedTypes) {
     55   std::string output_js;
     56 
     57   // Writer unittests like empty list/dict nesting,
     58   // list list nesting, etc.
     59   DictionaryValue root_dict;
     60   std::unique_ptr<ListValue> list(new ListValue());
     61   std::unique_ptr<DictionaryValue> inner_dict(new DictionaryValue());
     62   inner_dict->SetInteger("inner int", 10);
     63   list->Append(std::move(inner_dict));
     64   list->Append(WrapUnique(new ListValue()));
     65   list->AppendBoolean(true);
     66   root_dict.Set("list", std::move(list));
     67 
     68   // Test the pretty-printer.
     69   EXPECT_TRUE(JSONWriter::Write(root_dict, &output_js));
     70   EXPECT_EQ("{\"list\":[{\"inner int\":10},[],true]}", output_js);
     71   EXPECT_TRUE(JSONWriter::WriteWithOptions(
     72       root_dict, JSONWriter::OPTIONS_PRETTY_PRINT, &output_js));
     73 
     74   // The pretty-printer uses a different newline style on Windows than on
     75   // other platforms.
     76 #if defined(OS_WIN)
     77 #define JSON_NEWLINE "\r\n"
     78 #else
     79 #define JSON_NEWLINE "\n"
     80 #endif
     81   EXPECT_EQ("{" JSON_NEWLINE
     82             "   \"list\": [ {" JSON_NEWLINE
     83             "      \"inner int\": 10" JSON_NEWLINE
     84             "   }, [  ], true ]" JSON_NEWLINE
     85             "}" JSON_NEWLINE,
     86             output_js);
     87 #undef JSON_NEWLINE
     88 }
     89 
     90 TEST(JSONWriterTest, KeysWithPeriods) {
     91   std::string output_js;
     92 
     93   DictionaryValue period_dict;
     94   period_dict.SetIntegerWithoutPathExpansion("a.b", 3);
     95   period_dict.SetIntegerWithoutPathExpansion("c", 2);
     96   std::unique_ptr<DictionaryValue> period_dict2(new DictionaryValue());
     97   period_dict2->SetIntegerWithoutPathExpansion("g.h.i.j", 1);
     98   period_dict.SetWithoutPathExpansion("d.e.f", std::move(period_dict2));
     99   EXPECT_TRUE(JSONWriter::Write(period_dict, &output_js));
    100   EXPECT_EQ("{\"a.b\":3,\"c\":2,\"d.e.f\":{\"g.h.i.j\":1}}", output_js);
    101 
    102   DictionaryValue period_dict3;
    103   period_dict3.SetInteger("a.b", 2);
    104   period_dict3.SetIntegerWithoutPathExpansion("a.b", 1);
    105   EXPECT_TRUE(JSONWriter::Write(period_dict3, &output_js));
    106   EXPECT_EQ("{\"a\":{\"b\":2},\"a.b\":1}", output_js);
    107 }
    108 
    109 TEST(JSONWriterTest, BinaryValues) {
    110   std::string output_js;
    111 
    112   // Binary values should return errors unless suppressed via the
    113   // OPTIONS_OMIT_BINARY_VALUES flag.
    114   std::unique_ptr<Value> root(BinaryValue::CreateWithCopiedBuffer("asdf", 4));
    115   EXPECT_FALSE(JSONWriter::Write(*root, &output_js));
    116   EXPECT_TRUE(JSONWriter::WriteWithOptions(
    117       *root, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
    118   EXPECT_TRUE(output_js.empty());
    119 
    120   ListValue binary_list;
    121   binary_list.Append(BinaryValue::CreateWithCopiedBuffer("asdf", 4));
    122   binary_list.Append(WrapUnique(new FundamentalValue(5)));
    123   binary_list.Append(BinaryValue::CreateWithCopiedBuffer("asdf", 4));
    124   binary_list.Append(WrapUnique(new FundamentalValue(2)));
    125   binary_list.Append(BinaryValue::CreateWithCopiedBuffer("asdf", 4));
    126   EXPECT_FALSE(JSONWriter::Write(binary_list, &output_js));
    127   EXPECT_TRUE(JSONWriter::WriteWithOptions(
    128       binary_list, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
    129   EXPECT_EQ("[5,2]", output_js);
    130 
    131   DictionaryValue binary_dict;
    132   binary_dict.Set("a", BinaryValue::CreateWithCopiedBuffer("asdf", 4));
    133   binary_dict.SetInteger("b", 5);
    134   binary_dict.Set("c", BinaryValue::CreateWithCopiedBuffer("asdf", 4));
    135   binary_dict.SetInteger("d", 2);
    136   binary_dict.Set("e", BinaryValue::CreateWithCopiedBuffer("asdf", 4));
    137   EXPECT_FALSE(JSONWriter::Write(binary_dict, &output_js));
    138   EXPECT_TRUE(JSONWriter::WriteWithOptions(
    139       binary_dict, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
    140   EXPECT_EQ("{\"b\":5,\"d\":2}", output_js);
    141 }
    142 
    143 TEST(JSONWriterTest, DoublesAsInts) {
    144   std::string output_js;
    145 
    146   // Test allowing a double with no fractional part to be written as an integer.
    147   FundamentalValue double_value(1e10);
    148   EXPECT_TRUE(JSONWriter::WriteWithOptions(
    149       double_value, JSONWriter::OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION,
    150       &output_js));
    151   EXPECT_EQ("10000000000", output_js);
    152 }
    153 
    154 }  // namespace base
    155