Rename gdata_parser to gdata_wapi_parser

chrome/browser/chromeos/gdata/gdata_wapi_parser_unittest.cc

 // Copyright (c) 2012 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 "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/path_service.h"
 #include "base/string16.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/chromeos/gdata/gdata_parser.h"
+#include "chrome/browser/chromeos/gdata/gdata_wapi_parser.h"
 #include "chrome/common/chrome_paths.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libxml/chromium/libxml_utils.h"
 
 using base::Value;
 using base::DictionaryValue;
 using base::ListValue;
 
 #define IF_EXPECT_EQ(arg1, arg2) \
   EXPECT_EQ(arg1, arg2); \
   if (arg1 == arg2)
 
 #define IF_EXPECT_TRUE(arg) \
   EXPECT_TRUE(arg); \
   if (arg)
 
 namespace gdata {
 
-class GDataParserTest : public testing::Test {
+class GDataWAPIParserTest : public testing::Test {
  protected:
   static Value* LoadJSONFile(const std::string& filename) {
     FilePath path;
     std::string error;
     // Test files for this unit test are located in
     // src/chrome/test/data/chromeos/gdata/*
     PathService::Get(chrome::DIR_TEST_DATA, &path);
     path = path.AppendASCII("chromeos")
         .AppendASCII("gdata")
         .AppendASCII(filename.c_str());
@@ skipping 28 matching lines @@
       if (reader.NodeName() == "entry") {
         entry.reset(DocumentEntry::CreateFromXml(&reader));
         break;
       }
     }
     return entry.release();
   }
 };
 
 // Test document feed parsing.
-TEST_F(GDataParserTest, DocumentFeedJsonParser) {
+TEST_F(GDataWAPIParserTest, DocumentFeedJsonParser) {
   std::string error;
   scoped_ptr<Value> document(LoadJSONFile("basic_feed.json"));
   ASSERT_TRUE(document.get());
   ASSERT_EQ(Value::TYPE_DICTIONARY, document->GetType());
   scoped_ptr<DocumentFeed> feed(DocumentFeed::ExtractAndParse(*document));
   ASSERT_TRUE(feed.get());
 
   base::Time update_time;
   ASSERT_TRUE(FeedEntry::GetTimeFromString("2011-12-14T01:03:21.151Z",
                                            &update_time));
@@ skipping 121 matching lines @@
   IF_EXPECT_TRUE(app_entry) {
     EXPECT_EQ(DocumentEntry::EXTERNAL_APP, app_entry->kind());
     EXPECT_TRUE(app_entry->is_hosted_document());
     EXPECT_TRUE(app_entry->is_external_document());
     EXPECT_FALSE(app_entry->is_google_document());
   }
 }
 
 
 // Test document feed parsing.
-TEST_F(GDataParserTest, DocumentEntryXmlParser) {
+TEST_F(GDataWAPIParserTest, DocumentEntryXmlParser) {
   scoped_ptr<DocumentEntry> entry(LoadDocumentEntryFromXml("entry.xml"));
   ASSERT_TRUE(entry.get());
 
   EXPECT_EQ(DocumentEntry::FILE, entry->kind());
   EXPECT_EQ("\"HhMOFgcNHSt7ImBr\"", entry->etag());
   EXPECT_EQ("file:xml_file_resouce_id", entry->resource_id());
   EXPECT_EQ("https://xml_file_id", entry->id());
   EXPECT_EQ(ASCIIToUTF16("Xml Entry File Title.tar"), entry->title());
   base::Time entry1_update_time;
   base::Time entry1_publish_time;
@@ skipping 67 matching lines @@
 
   // Check a file properties.
   EXPECT_EQ(DocumentEntry::FILE, entry->kind());
   EXPECT_EQ(ASCIIToUTF16("Xml Entry File Name.tar"), entry->filename());
   EXPECT_EQ(ASCIIToUTF16("Xml Entry Suggested File Name.tar"),
             entry->suggested_filename());
   EXPECT_EQ("e48f4d5c46a778de263e0e3f4b3d2a7d", entry->file_md5());
   EXPECT_EQ(26562560, entry->file_size());
 }
 
-TEST_F(GDataParserTest, AccountMetadataFeedParser) {
+TEST_F(GDataWAPIParserTest, AccountMetadataFeedParser) {
   scoped_ptr<Value> document(LoadJSONFile("account_metadata.json"));
   ASSERT_TRUE(document.get());
   ASSERT_EQ(Value::TYPE_DICTIONARY, document->GetType());
   DictionaryValue* entry_value = NULL;
   ASSERT_TRUE(reinterpret_cast<DictionaryValue*>(document.get())->GetDictionary(
       std::string("entry"), &entry_value));
   ASSERT_TRUE(entry_value);
 
   scoped_ptr<AccountMetadataFeed> feed(
       AccountMetadataFeed::CreateFrom(*document));
@@ skipping 49 matching lines @@
               second_app->GetProductUrl().spec());
     EXPECT_FALSE(second_app->supports_create());
     EXPECT_EQ(2U, second_app->primary_mimetypes().size());
     EXPECT_EQ(0U, second_app->secondary_mimetypes().size());
     EXPECT_EQ(1U, second_app->primary_extensions().size());
     EXPECT_EQ(0U, second_app->secondary_extensions().size());
   }
 }
 
 // Test file extension checking in DocumentEntry::HasDocumentExtension().
-TEST_F(GDataParserTest, DocumentEntryHasDocumentExtension) {
+TEST_F(GDataWAPIParserTest, DocumentEntryHasDocumentExtension) {
   EXPECT_TRUE(DocumentEntry::HasHostedDocumentExtension(
       FilePath(FILE_PATH_LITERAL("Test.gdoc"))));
   EXPECT_TRUE(DocumentEntry::HasHostedDocumentExtension(
       FilePath(FILE_PATH_LITERAL("Test.gsheet"))));
   EXPECT_TRUE(DocumentEntry::HasHostedDocumentExtension(
       FilePath(FILE_PATH_LITERAL("Test.gslides"))));
   EXPECT_TRUE(DocumentEntry::HasHostedDocumentExtension(
       FilePath(FILE_PATH_LITERAL("Test.gdraw"))));
   EXPECT_TRUE(DocumentEntry::HasHostedDocumentExtension(
       FilePath(FILE_PATH_LITERAL("Test.gtable"))));
   EXPECT_FALSE(DocumentEntry::HasHostedDocumentExtension(
       FilePath(FILE_PATH_LITERAL("Test.tar.gz"))));
   EXPECT_FALSE(DocumentEntry::HasHostedDocumentExtension(
       FilePath(FILE_PATH_LITERAL("Test.txt"))));
   EXPECT_FALSE(DocumentEntry::HasHostedDocumentExtension(
       FilePath(FILE_PATH_LITERAL("Test"))));
   EXPECT_FALSE(DocumentEntry::HasHostedDocumentExtension(
       FilePath(FILE_PATH_LITERAL(""))));
 }
 
 }  // namespace gdata