rAc: use libaddressinput to validate international addresses.

third_party/libaddressinput/chromium/cpp/test/retriever_test.cc

 // Copyright (C) 2013 Google Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 37 matching lines @@
                  const std::string& checksum,
                  const std::string& timestamp) {
   return data + "\n" + "checksum=" + checksum + "\n" + "timestamp=" + timestamp;
 }
 
 }  // namespace
 
 // Tests for Retriever object.
 class RetrieverTest : public testing::Test {
  protected:
-  RetrieverTest()
-      : storage_(NULL),
-        retriever_(),
-        success_(false),
-        key_(),
-        data_() {
+  RetrieverTest() : success_(false) {
     ResetRetriever(FakeDownloader::kFakeDataUrl);
   }
 
   virtual ~RetrieverTest() {}
 
   scoped_ptr<Retriever::Callback> BuildCallback() {
     return ::i18n::addressinput::BuildCallback(
         this, &RetrieverTest::OnDataReady);
   }
 
   void ResetRetriever(const std::string& url) {
-    storage_ = new FakeStorage;
-    retriever_.reset(
-        new Retriever(url,
-                      scoped_ptr<Downloader>(new FakeDownloader),
-                      scoped_ptr<Storage>(storage_)));
+    retriever_.reset(new Retriever(
+        url, scoped_ptr<Downloader>(new FakeDownloader), &storage_));
   }
 
   std::string GetUrlForKey(const std::string& key) {
     return retriever_->GetUrlForKey(key);
   }
 
   std::string GetKeyForUrl(const std::string& url) {
     return retriever_->GetKeyForUrl(url);
   }
 
-  Storage* storage_;  // Owned by |retriever_|.
+  FakeStorage storage_;
   scoped_ptr<Retriever> retriever_;
   bool success_;
   std::string key_;
   std::string data_;
 
  private:
   void OnDataReady(bool success,
                    const std::string& key,
                    const std::string& data) {
     success_ = success;
@@ skipping 40 matching lines @@
   // Downloader implementation.
   virtual void Download(const std::string& url,
                         scoped_ptr<Callback> downloaded) {
     (*downloaded)(false, url, make_scoped_ptr(new std::string("garbage")));
   }
 };
 
 TEST_F(RetrieverTest, FaultyDownloader) {
   Retriever bad_retriever(FakeDownloader::kFakeDataUrl,
                           scoped_ptr<Downloader>(new FaultyDownloader),
-                          scoped_ptr<Storage>(new FakeStorage));
+                          &storage_);
   bad_retriever.Retrieve(kKey, BuildCallback());
 
   EXPECT_FALSE(success_);
   EXPECT_EQ(kKey, key_);
   EXPECT_TRUE(data_.empty());
 }
 
 TEST_F(RetrieverTest, FaultyDownloaderFallback) {
   Retriever bad_retriever(FakeDownloader::kFakeDataUrl,
                           scoped_ptr<Downloader>(new FaultyDownloader),
-                          scoped_ptr<Storage>(new FakeStorage));
+                          &storage_);
   const char kFallbackDataKey[] = "data/US";
   bad_retriever.Retrieve(kFallbackDataKey, BuildCallback());
 
   EXPECT_TRUE(success_);
   EXPECT_EQ(kFallbackDataKey, key_);
   EXPECT_FALSE(data_.empty());
   EXPECT_NE(kEmptyData, data_);
 }
 
 TEST_F(RetrieverTest, NoChecksumAndTimestampWillRedownload) {
-  storage_->Put(kKey, kEmptyData);
+  storage_.Put(kKey, kEmptyData);
   retriever_->Retrieve(kKey, BuildCallback());
   EXPECT_TRUE(success_);
   EXPECT_EQ(kKey, key_);
   EXPECT_FALSE(data_.empty());
   EXPECT_NE(kEmptyData, data_);
 }
 
 TEST_F(RetrieverTest, ChecksumAndTimestampWillNotRedownload) {
-  storage_->Put(kKey,
-                Wrap(kEmptyData, kEmptyDataChecksum, TimeToString(time(NULL))));
+  storage_.Put(kKey,
+               Wrap(kEmptyData, kEmptyDataChecksum, TimeToString(time(NULL))));
   retriever_->Retrieve(kKey, BuildCallback());
   EXPECT_TRUE(success_);
   EXPECT_EQ(kKey, key_);
   EXPECT_EQ(kEmptyData, data_);
 }
 
 TEST_F(RetrieverTest, OldTimestampWillRedownload) {
-  storage_->Put(kKey, Wrap(kEmptyData, kEmptyDataChecksum, "0"));
+  storage_.Put(kKey, Wrap(kEmptyData, kEmptyDataChecksum, "0"));
   retriever_->Retrieve(kKey, BuildCallback());
   EXPECT_TRUE(success_);
   EXPECT_EQ(kKey, key_);
   EXPECT_FALSE(data_.empty());
   EXPECT_NE(kEmptyData, data_);
 }
 
 TEST_F(RetrieverTest, OldTimestampOkIfDownloadFails) {
-  storage_ = new FakeStorage;
   Retriever bad_retriever(FakeDownloader::kFakeDataUrl,
                           scoped_ptr<Downloader>(new FaultyDownloader),
-                          scoped_ptr<Storage>(storage_));
-  storage_->Put(kKey, Wrap(kEmptyData, kEmptyDataChecksum, "0"));
+                          &storage_);
+  storage_.Put(kKey, Wrap(kEmptyData, kEmptyDataChecksum, "0"));
   bad_retriever.Retrieve(kKey, BuildCallback());
   EXPECT_TRUE(success_);
   EXPECT_EQ(kKey, key_);
   EXPECT_EQ(kEmptyData, data_);
 }
 
 TEST_F(RetrieverTest, WrongChecksumWillRedownload) {
   static const char kNonEmptyData[] = "{\"non-empty\": \"data\"}";
-  storage_->Put(
+  storage_.Put(
       kKey,
       Wrap(kNonEmptyData, kEmptyDataChecksum, TimeToString(time(NULL))));
   retriever_->Retrieve(kKey, BuildCallback());
   EXPECT_TRUE(success_);
   EXPECT_EQ(kKey, key_);
   EXPECT_FALSE(data_.empty());
   EXPECT_NE(kNonEmptyData, data_);
 }
 
 // The downloader that doesn't get back to you.
 class HangingDownloader : public Downloader {
  public:
   HangingDownloader() {}
   virtual ~HangingDownloader() {}
 
   // Downloader implementation.
   virtual void Download(const std::string& url,
                         scoped_ptr<Callback> downloaded) {}
 };
 
 TEST_F(RetrieverTest, RequestsDontStack) {
   Retriever slow_retriever(FakeDownloader::kFakeDataUrl,
                            scoped_ptr<Downloader>(new HangingDownloader),
-                           scoped_ptr<Storage>(new FakeStorage));
+                           &storage_);
 
   slow_retriever.Retrieve(kKey, BuildCallback());
   EXPECT_FALSE(success_);
   EXPECT_TRUE(key_.empty());
 
   EXPECT_NO_FATAL_FAILURE(slow_retriever.Retrieve(kKey, BuildCallback()));
 }
 
 TEST_F(RetrieverTest, GetUrlForKey) {
   ResetRetriever("test:///");
@@ skipping 16 matching lines @@
 
 TEST_F(RetrieverTest, NullCallbackNoCrash) {
   ASSERT_NO_FATAL_FAILURE(
       retriever_->Retrieve(kKey, scoped_ptr<Retriever::Callback>()));
   ASSERT_NO_FATAL_FAILURE(
       retriever_->Retrieve(kKey, scoped_ptr<Retriever::Callback>()));
 }
 
 }  // namespace addressinput
 }  // namespace i18n