Remove deprecated wstring Get(As)String() methods from Value, etc.

base/json/json_reader_unittest.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "base/json/json_reader.h"
 #include "base/scoped_ptr.h"
+#include "base/string_piece.h"
+#include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 
 namespace base {
 
 TEST(JSONReaderTest, Reading) {
   // some whitespace checking
   scoped_ptr<Value> root;
   root.reset(JSONReader().JsonToValue("   null   ", false, false));
   ASSERT_TRUE(root.get());
@@ skipping 143 matching lines @@
   // Invalid number formats
   root.reset(JSONReader().JsonToValue("4.3.1", false, false));
   ASSERT_FALSE(root.get());
   root.reset(JSONReader().JsonToValue("4e3.1", false, false));
   ASSERT_FALSE(root.get());
 
   // Test string parser
   root.reset(JSONReader().JsonToValue("\"hello world\"", false, false));
   ASSERT_TRUE(root.get());
   ASSERT_TRUE(root->IsType(Value::TYPE_STRING));
-  std::wstring str_val;
+  std::string str_val;
   ASSERT_TRUE(root->GetAsString(&str_val));
-  ASSERT_EQ(L"hello world", str_val);
+  ASSERT_EQ("hello world", str_val);
 
   // Empty string
   root.reset(JSONReader().JsonToValue("\"\"", false, false));
   ASSERT_TRUE(root.get());
   ASSERT_TRUE(root->IsType(Value::TYPE_STRING));
   str_val.clear();
   ASSERT_TRUE(root->GetAsString(&str_val));
-  ASSERT_EQ(L"", str_val);
+  ASSERT_EQ("", str_val);
 
   // Test basic string escapes
   root.reset(JSONReader().JsonToValue("\" \\\"\\\\\\/\\b\\f\\n\\r\\t\\v\"",
                                       false, false));
   ASSERT_TRUE(root.get());
   ASSERT_TRUE(root->IsType(Value::TYPE_STRING));
   str_val.clear();
   ASSERT_TRUE(root->GetAsString(&str_val));
-  ASSERT_EQ(L" \"\\/\b\f\n\r\t\v", str_val);
+  ASSERT_EQ(" \"\\/\b\f\n\r\t\v", str_val);
 
   // Test hex and unicode escapes including the null character.
   root.reset(JSONReader().JsonToValue("\"\\x41\\x00\\u1234\"", false,
                                       false));
   ASSERT_TRUE(root.get());
   ASSERT_TRUE(root->IsType(Value::TYPE_STRING));
   str_val.clear();
   ASSERT_TRUE(root->GetAsString(&str_val));
-  ASSERT_EQ(std::wstring(L"A\0\x1234", 3), str_val);
+  ASSERT_EQ(std::wstring(L"A\0\x1234", 3), UTF8ToWide(str_val));
 
   // Test invalid strings
   root.reset(JSONReader().JsonToValue("\"no closing quote", false, false));
   ASSERT_FALSE(root.get());
   root.reset(JSONReader().JsonToValue("\"\\z invalid escape char\"", false,
                                       false));
   ASSERT_FALSE(root.get());
   root.reset(JSONReader().JsonToValue("\"\\xAQ invalid hex code\"", false,
                                       false));
   ASSERT_FALSE(root.get());
@@ skipping 91 matching lines @@
   ASSERT_TRUE(root.get());
   ASSERT_TRUE(root->IsType(Value::TYPE_DICTIONARY));
   DictionaryValue* dict_val = static_cast<DictionaryValue*>(root.get());
   real_val = 0.0;
   ASSERT_TRUE(dict_val->GetReal("number", &real_val));
   ASSERT_DOUBLE_EQ(9.87654321, real_val);
   Value* null_val = NULL;
   ASSERT_TRUE(dict_val->Get("null", &null_val));
   ASSERT_TRUE(null_val->IsType(Value::TYPE_NULL));
   str_val.clear();
-  ASSERT_TRUE(dict_val->GetString(L"S", &str_val));
-  ASSERT_EQ(L"str", str_val);
+  ASSERT_TRUE(dict_val->GetString("S", &str_val));
+  ASSERT_EQ("str", str_val);
 
   root2.reset(JSONReader::Read(
       "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\", }", true));
   ASSERT_TRUE(root2.get());
   EXPECT_TRUE(root->Equals(root2.get()));
 
   // Test newline equivalence.
   root2.reset(JSONReader::Read(
       "{\n"
       "  \"number\":9.87654321,\n"
@@ skipping 114 matching lines @@
   list = static_cast<ListValue*>(root.get());
   ASSERT_EQ(5001U, list->GetSize());
 
   // Test utf8 encoded input
   root.reset(JSONReader().JsonToValue("\"\xe7\xbd\x91\xe9\xa1\xb5\"",
                                       false, false));
   ASSERT_TRUE(root.get());
   ASSERT_TRUE(root->IsType(Value::TYPE_STRING));
   str_val.clear();
   ASSERT_TRUE(root->GetAsString(&str_val));
-  ASSERT_EQ(L"\x7f51\x9875", str_val);
+  ASSERT_EQ(L"\x7f51\x9875", UTF8ToWide(str_val));
 
   // Test invalid utf8 encoded input
   root.reset(JSONReader().JsonToValue("\"345\xb0\xa1\xb0\xa2\"",
                                       false, false));
   ASSERT_FALSE(root.get());
   root.reset(JSONReader().JsonToValue("\"123\xc0\x81\"",
                                       false, false));
   ASSERT_FALSE(root.get());
 
   // Test invalid root objects.
@@ skipping 97 matching lines @@
 
   root.reset(JSONReader::ReadAndReturnError("[\"xxx\\q\"]", false,
                                             &error_code, &error_message));
   EXPECT_FALSE(root.get());
   EXPECT_EQ(JSONReader::FormatErrorMessage(1, 7, JSONReader::kInvalidEscape),
             error_message);
   EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code);
 }
 
 }  // namespace base