Implement the NTLM authentication scheme by porting...

net/http/http_auth_cache_unittest.cc

 // Copyright (c) 2008 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/string_util.h"
 #include "net/http/http_auth_cache.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 class MockAuthHandler : public HttpAuthHandler {
  public:
   MockAuthHandler(const char* scheme, const std::string& realm,
                   HttpAuth::Target target) {
     // Can't use initializer list since these are members of the base class.
     scheme_ = scheme;
     realm_ = realm;
     score_ = 1;
     target_ = target;
+    properties_ = 0;
   }
-  
-  virtual std::string GenerateCredentials(const std::wstring&,
+
+ virtual std::string GenerateCredentials(const std::wstring&,
                                           const std::wstring&,
                                           const HttpRequestInfo*,
                                           const ProxyInfo*) {
     return "mock-credentials";  // Unused.
   }
 
  protected:
   virtual bool Init(std::string::const_iterator, std::string::const_iterator) {
     return false;  // Unused.
   }
 };
 
-} // namespace
+}  // namespace
 
 // Test adding and looking-up cache entries (both by realm and by path).
 TEST(HttpAuthCacheTest, Basic) {
   GURL origin("http://www.google.com");
   HttpAuthCache cache;
   HttpAuthCache::Entry* entry;
-  
+
   // Add cache entries for 3 realms: "Realm1", "Realm2", "Realm3"
 
   scoped_refptr<HttpAuthHandler> realm1_handler =
       new MockAuthHandler("basic", "Realm1", HttpAuth::AUTH_SERVER);
   cache.Add(origin, realm1_handler, L"realm1-user", L"realm1-password",
       "/foo/bar/index.html");
 
   scoped_refptr<HttpAuthHandler> realm2_handler =
       new MockAuthHandler("basic", "Realm2", HttpAuth::AUTH_SERVER);
   cache.Add(origin, realm2_handler, L"realm2-user", L"realm2-password",
@@ skipping 17 matching lines @@
   EXPECT_TRUE(entry->handler() == realm3_handler.get());
   EXPECT_EQ(L"realm3-user", entry->username());
   EXPECT_EQ(L"realm3-password", entry->password());
 
   // Valid lookup by realm.
   entry = cache.LookupByRealm(origin, "Realm2");
   EXPECT_FALSE(NULL == entry);
   EXPECT_TRUE(entry->handler() == realm2_handler.get());
   EXPECT_EQ(L"realm2-user", entry->username());
   EXPECT_EQ(L"realm2-password", entry->password());
-  
+
   // Check that subpaths are recognized.
   HttpAuthCache::Entry* realm2Entry = cache.LookupByRealm(origin, "Realm2");
   EXPECT_FALSE(NULL == realm2Entry);
   // Positive tests:
   entry = cache.LookupByPath(origin, "/foo2/index.html");
   EXPECT_TRUE(realm2Entry == entry);
   entry = cache.LookupByPath(origin, "/foo2/foobar.html");
   EXPECT_TRUE(realm2Entry == entry);
   entry = cache.LookupByPath(origin, "/foo2/bar/index.html");
   EXPECT_TRUE(realm2Entry == entry);
@@ skipping 60 matching lines @@
   HttpAuthCache::Entry* orig_entry = cache.Add(
       origin, handler, L"user1", L"password1", "/x/y/z/");
   cache.Add(origin, handler, L"user2", L"password2", "/z/y/x/");
   cache.Add(origin, handler, L"user3", L"password3", "/z/y");
 
   HttpAuthCache::Entry* entry = cache.LookupByRealm(origin, "MyRealm");
 
   EXPECT_TRUE(entry == orig_entry);
   EXPECT_EQ(L"user3", entry->username());
   EXPECT_EQ(L"password3", entry->password());
-  
+
   EXPECT_EQ(2U, entry->paths_.size());
   EXPECT_EQ("/z/", entry->paths_.front());
   EXPECT_EQ("/x/y/z/", entry->paths_.back());
 }
 
 TEST(HttpAuthCacheTest, Remove) {
   GURL origin("http://foobar2.com");
 
   scoped_refptr<HttpAuthHandler> realm1_handler =
       new MockAuthHandler("basic", "Realm1", HttpAuth::AUTH_SERVER);
 
   scoped_refptr<HttpAuthHandler> realm2_handler =
       new MockAuthHandler("basic", "Realm2", HttpAuth::AUTH_SERVER);
 
   scoped_refptr<HttpAuthHandler> realm3_handler =
       new MockAuthHandler("basic", "Realm3", HttpAuth::AUTH_SERVER);
 
   HttpAuthCache cache;
   cache.Add(origin, realm1_handler, L"alice", L"123", "/");
   cache.Add(origin, realm2_handler, L"bob", L"princess", "/");
   cache.Add(origin, realm3_handler, L"admin", L"password", "/");
-  
+
   // Fails, because there is no realm "Realm4".
   EXPECT_FALSE(cache.Remove(origin, "Realm4", L"alice", L"123"));
 
   // Fails because the origin is wrong.
   EXPECT_FALSE(cache.Remove(
       GURL("http://foobar2.com:100"), "Realm1", L"alice", L"123"));
 
   // Fails because the username is wrong.
   EXPECT_FALSE(cache.Remove(origin, "Realm1", L"alice2", L"123"));
 
@@ skipping 66 matching lines @@
 // full this causes FIFO eviction of the first three entries.
 TEST_F(HttpAuthCacheEvictionTest, RealmEntryEviction) {
   for (int i = 0; i < kMaxRealms; ++i)
     AddRealm(i);
 
   for (int i = 0; i < kMaxRealms; ++i)
     CheckRealmExistence(i, true);
 
   for (int i = 0; i < 3; ++i)
     AddRealm(i + kMaxRealms);
-  
+
   for (int i = 0; i < 3; ++i)
     CheckRealmExistence(i, false);
 
   for (int i = 0; i < kMaxRealms; ++i)
     CheckRealmExistence(i + 3, true);
 }
 
 // Add the maximum number of paths to a single realm entry. Each of these
 // paths should be retrievable. Next add 3 more paths -- since the cache is
 // full this causes FIFO eviction of the first three paths.
@@ skipping 10 matching lines @@
   for (int i = 0; i < 3; ++i)
     CheckPathExistence(0, i, false);
 
   for (int i = 0; i < kMaxPaths; ++i)
     CheckPathExistence(0, i + 3, true);
 
   for (int i = 0; i < kMaxRealms; ++i)
     CheckRealmExistence(i, true);
 }
 
-} // namespace net
+}  // namespace net