Clang format slam.

net/http/http_auth_handler_negotiate_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 "net/http/http_auth_handler_negotiate.h"
 
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 14 matching lines @@
 typedef net::test::MockGSSAPILibrary MockAuthLibrary;
 #endif
 
 namespace net {
 
 class HttpAuthHandlerNegotiateTest : public PlatformTest {
  public:
   virtual void SetUp() {
     auth_library_ = new MockAuthLibrary();
     resolver_.reset(new MockHostResolver());
-    resolver_->rules()->AddIPLiteralRule("alias", "10.0.0.2",
-                                           "canonical.example.com");
+    resolver_->rules()->AddIPLiteralRule(
+        "alias", "10.0.0.2", "canonical.example.com");
 
     url_security_manager_.reset(new MockAllowURLSecurityManager());
     factory_.reset(new HttpAuthHandlerNegotiate::Factory());
     factory_->set_url_security_manager(url_security_manager_.get());
     factory_->set_library(auth_library_);
     factory_->set_host_resolver(resolver_.get());
   }
 
   void SetupMocks(MockAuthLibrary* mock_library) {
 #if defined(OS_WIN)
@@ skipping 44 matching lines @@
         "\x2C\xE3\xEA\x64\xEF\x91\xA5\x4E\x94\xE1\xDC\x56\x3A\xAF\xD5\xBC"
         "\xC9\xD3\x9B\x6B\x1F\xBE\x40\xE5\x40\xFF\x5E\x21\xEA\xCE\xFC\xD5"
         "\xB0\xE5\xBA\x10\x94\xAE\x16\x54\xFC\xEB\xAB\xF1\xD4\x20\x31\xCC"
         "\x26\xFE\xBE\xFE\x22\xB6\x9B\x1A\xE5\x55\x2C\x93\xB7\x3B\xD6\x4C"
         "\x35\x35\xC1\x59\x61\xD4\x1F\x2E\x4C\xE1\x72\x8F\x71\x4B\x0C\x39"
         "\x80\x79\xFA\xCD\xEA\x71\x1B\xAE\x35\x41\xED\xF9\x65\x0C\x59\xF8"
         "\xE1\x27\xDA\xD6\xD1\x20\x32\xCD\xBF\xD1\xEF\xE2\xED\xAD\x5D\xA7"
         "\x69\xE3\x55\xF9\x30\xD3\xD4\x08\xC8\xCA\x62\xF8\x64\xEC\x9B\x92"
         "\x1A\xF1\x03\x2E\xCC\xDC\xEB\x17\xDE\x09\xAC\xA9\x58\x86";
     test::GssContextMockImpl context1(
-        "localhost",                         // Source name
-        "example.com",                       // Target name
-        23,                                  // Lifetime
-        *CHROME_GSS_SPNEGO_MECH_OID_DESC,    // Mechanism
-        0,                                   // Context flags
-        1,                                   // Locally initiated
-        0);                                  // Open
+        "localhost",                       // Source name
+        "example.com",                     // Target name
+        23,                                // Lifetime
+        *CHROME_GSS_SPNEGO_MECH_OID_DESC,  // Mechanism
+        0,                                 // Context flags
+        1,                                 // Locally initiated
+        0);                                // Open
     test::GssContextMockImpl context2(
-        "localhost",                         // Source name
-        "example.com",                       // Target name
-        23,                                  // Lifetime
-        *CHROME_GSS_SPNEGO_MECH_OID_DESC,    // Mechanism
-        0,                                   // Context flags
-        1,                                   // Locally initiated
-        1);                                  // Open
+        "localhost",                       // Source name
+        "example.com",                     // Target name
+        23,                                // Lifetime
+        *CHROME_GSS_SPNEGO_MECH_OID_DESC,  // Mechanism
+        0,                                 // Context flags
+        1,                                 // Locally initiated
+        1);                                // Open
     test::MockGSSAPILibrary::SecurityContextQuery queries[] = {
-    test::MockGSSAPILibrary::SecurityContextQuery(
-        "Negotiate",                    // Package name
-        GSS_S_CONTINUE_NEEDED,          // Major response code
-        0,                              // Minor response code
-        context1,                       // Context
-        NULL,                           // Expected input token
-        kAuthResponse),                 // Output token
-    test::MockGSSAPILibrary::SecurityContextQuery(
-        "Negotiate",                    // Package name
-        GSS_S_COMPLETE,                 // Major response code
-        0,                              // Minor response code
-        context2,                       // Context
-        kAuthResponse,                  // Expected input token
-        kAuthResponse)                  // Output token
+        test::MockGSSAPILibrary::SecurityContextQuery(
+            "Negotiate",            // Package name
+            GSS_S_CONTINUE_NEEDED,  // Major response code
+            0,                      // Minor response code
+            context1,               // Context
+            NULL,                   // Expected input token
+            kAuthResponse),         // Output token
+        test::MockGSSAPILibrary::SecurityContextQuery(
+            "Negotiate",     // Package name
+            GSS_S_COMPLETE,  // Major response code
+            0,               // Minor response code
+            context2,        // Context
+            kAuthResponse,   // Expected input token
+            kAuthResponse)   // Output token
     };
 
     for (size_t i = 0; i < arraysize(queries); ++i) {
       mock_library->ExpectSecurityContext(queries[i].expected_package,
                                           queries[i].response_code,
                                           queries[i].minor_response_code,
                                           queries[i].context_info,
                                           queries[i].expected_input_token,
                                           queries[i].output_token);
     }
 #endif  // defined(OS_POSIX)
   }
 
 #if defined(OS_POSIX)
   void SetupErrorMocks(MockAuthLibrary* mock_library,
                        int major_status,
                        int minor_status) {
-    const gss_OID_desc kDefaultMech = { 0, NULL };
-    test::GssContextMockImpl context(
-        "localhost",                    // Source name
-        "example.com",                  // Target name
-        0,                              // Lifetime
-        kDefaultMech,                   // Mechanism
-        0,                              // Context flags
-        1,                              // Locally initiated
-        0);                             // Open
+    const gss_OID_desc kDefaultMech = {0, NULL};
+    test::GssContextMockImpl context("localhost",    // Source name
+                                     "example.com",  // Target name
+                                     0,              // Lifetime
+                                     kDefaultMech,   // Mechanism
+                                     0,              // Context flags
+                                     1,              // Locally initiated
+                                     0);             // Open
     test::MockGSSAPILibrary::SecurityContextQuery query(
-        "Negotiate",                    // Package name
-        major_status,                   // Major response code
-        minor_status,                   // Minor response code
-        context,                        // Context
-        NULL,                           // Expected input token
-        NULL);                          // Output token
+        "Negotiate",   // Package name
+        major_status,  // Major response code
+        minor_status,  // Minor response code
+        context,       // Context
+        NULL,          // Expected input token
+        NULL);         // Output token
 
     mock_library->ExpectSecurityContext(query.expected_package,
                                         query.response_code,
                                         query.minor_response_code,
                                         query.context_info,
                                         query.expected_input_token,
                                         query.output_token);
   }
 
 #endif  // defined(OS_POSIX)
 
-  int CreateHandler(bool disable_cname_lookup, bool use_port,
-                     bool synchronous_resolve_mode,
-                     const std::string& url_string,
-                     scoped_ptr<HttpAuthHandlerNegotiate>* handler) {
+  int CreateHandler(bool disable_cname_lookup,
+                    bool use_port,
+                    bool synchronous_resolve_mode,
+                    const std::string& url_string,
+                    scoped_ptr<HttpAuthHandlerNegotiate>* handler) {
     factory_->set_disable_cname_lookup(disable_cname_lookup);
     factory_->set_use_port(use_port);
     resolver_->set_synchronous_mode(synchronous_resolve_mode);
     GURL gurl(url_string);
 
     // Note: This is a little tricky because CreateAuthHandlerFromString
     // expects a scoped_ptr<HttpAuthHandler>* rather than a
     // scoped_ptr<HttpAuthHandlerNegotiate>*. This needs to do the cast
     // after creating the handler, and make sure that generic_handler
     // no longer holds on to the HttpAuthHandlerNegotiate object.
@@ skipping 20 matching lines @@
   // |auth_library_| is passed to |factory_|, which assumes ownership of it.
   MockAuthLibrary* auth_library_;
   scoped_ptr<MockHostResolver> resolver_;
   scoped_ptr<URLSecurityManager> url_security_manager_;
   scoped_ptr<HttpAuthHandlerNegotiate::Factory> factory_;
 };
 
 TEST_F(HttpAuthHandlerNegotiateTest, DisableCname) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
-  EXPECT_EQ(OK, CreateHandler(
-      true, false, true, "http://alias:500", &auth_handler));
+  EXPECT_EQ(
+      OK, CreateHandler(true, false, true, "http://alias:500", &auth_handler));
 
   ASSERT_TRUE(auth_handler.get() != NULL);
   TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
-  EXPECT_EQ(OK, auth_handler->GenerateAuthToken(NULL, &request_info,
-                                                callback.callback(), &token));
+  EXPECT_EQ(OK,
+            auth_handler->GenerateAuthToken(
+                NULL, &request_info, callback.callback(), &token));
 #if defined(OS_WIN)
   EXPECT_EQ("HTTP/alias", auth_handler->spn());
 #elif defined(OS_POSIX)
   EXPECT_EQ("HTTP@alias", auth_handler->spn());
 #endif
 }
 
 TEST_F(HttpAuthHandlerNegotiateTest, DisableCnameStandardPort) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
-  EXPECT_EQ(OK, CreateHandler(
-      true, true, true, "http://alias:80", &auth_handler));
+  EXPECT_EQ(OK,
+            CreateHandler(true, true, true, "http://alias:80", &auth_handler));
   ASSERT_TRUE(auth_handler.get() != NULL);
   TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
-  EXPECT_EQ(OK, auth_handler->GenerateAuthToken(NULL, &request_info,
-                                                callback.callback(), &token));
+  EXPECT_EQ(OK,
+            auth_handler->GenerateAuthToken(
+                NULL, &request_info, callback.callback(), &token));
 #if defined(OS_WIN)
   EXPECT_EQ("HTTP/alias", auth_handler->spn());
 #elif defined(OS_POSIX)
   EXPECT_EQ("HTTP@alias", auth_handler->spn());
 #endif
 }
 
 TEST_F(HttpAuthHandlerNegotiateTest, DisableCnameNonstandardPort) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
-  EXPECT_EQ(OK, CreateHandler(
-      true, true, true, "http://alias:500", &auth_handler));
+  EXPECT_EQ(OK,
+            CreateHandler(true, true, true, "http://alias:500", &auth_handler));
   ASSERT_TRUE(auth_handler.get() != NULL);
   TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
-  EXPECT_EQ(OK, auth_handler->GenerateAuthToken(NULL, &request_info,
-                                                callback.callback(), &token));
+  EXPECT_EQ(OK,
+            auth_handler->GenerateAuthToken(
+                NULL, &request_info, callback.callback(), &token));
 #if defined(OS_WIN)
   EXPECT_EQ("HTTP/alias:500", auth_handler->spn());
 #elif defined(OS_POSIX)
   EXPECT_EQ("HTTP@alias:500", auth_handler->spn());
 #endif
 }
 
 TEST_F(HttpAuthHandlerNegotiateTest, CnameSync) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
-  EXPECT_EQ(OK, CreateHandler(
-      false, false, true, "http://alias:500", &auth_handler));
+  EXPECT_EQ(
+      OK, CreateHandler(false, false, true, "http://alias:500", &auth_handler));
   ASSERT_TRUE(auth_handler.get() != NULL);
   TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
-  EXPECT_EQ(OK, auth_handler->GenerateAuthToken(NULL, &request_info,
-                                                callback.callback(), &token));
+  EXPECT_EQ(OK,
+            auth_handler->GenerateAuthToken(
+                NULL, &request_info, callback.callback(), &token));
 #if defined(OS_WIN)
   EXPECT_EQ("HTTP/canonical.example.com", auth_handler->spn());
 #elif defined(OS_POSIX)
   EXPECT_EQ("HTTP@canonical.example.com", auth_handler->spn());
 #endif
 }
 
 TEST_F(HttpAuthHandlerNegotiateTest, CnameAsync) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
-  EXPECT_EQ(OK, CreateHandler(
-      false, false, false, "http://alias:500", &auth_handler));
+  EXPECT_EQ(
+      OK,
+      CreateHandler(false, false, false, "http://alias:500", &auth_handler));
   ASSERT_TRUE(auth_handler.get() != NULL);
   TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
-  EXPECT_EQ(ERR_IO_PENDING, auth_handler->GenerateAuthToken(
-      NULL, &request_info, callback.callback(), &token));
+  EXPECT_EQ(ERR_IO_PENDING,
+            auth_handler->GenerateAuthToken(
+                NULL, &request_info, callback.callback(), &token));
   EXPECT_EQ(OK, callback.WaitForResult());
 #if defined(OS_WIN)
   EXPECT_EQ("HTTP/canonical.example.com", auth_handler->spn());
 #elif defined(OS_POSIX)
   EXPECT_EQ("HTTP@canonical.example.com", auth_handler->spn());
 #endif
 }
 
 #if defined(OS_POSIX)
 
 // This test is only for GSSAPI, as we can't use explicit credentials with
 // that library.
 TEST_F(HttpAuthHandlerNegotiateTest, ServerNotInKerberosDatabase) {
   SetupErrorMocks(AuthLibrary(), GSS_S_FAILURE, 0x96C73A07);  // No server
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
-  EXPECT_EQ(OK, CreateHandler(
-      false, false, false, "http://alias:500", &auth_handler));
+  EXPECT_EQ(
+      OK,
+      CreateHandler(false, false, false, "http://alias:500", &auth_handler));
   ASSERT_TRUE(auth_handler.get() != NULL);
   TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
-  EXPECT_EQ(ERR_IO_PENDING, auth_handler->GenerateAuthToken(
-      NULL, &request_info, callback.callback(), &token));
+  EXPECT_EQ(ERR_IO_PENDING,
+            auth_handler->GenerateAuthToken(
+                NULL, &request_info, callback.callback(), &token));
   EXPECT_EQ(ERR_MISSING_AUTH_CREDENTIALS, callback.WaitForResult());
 }
 
 // This test is only for GSSAPI, as we can't use explicit credentials with
 // that library.
 TEST_F(HttpAuthHandlerNegotiateTest, NoKerberosCredentials) {
   SetupErrorMocks(AuthLibrary(), GSS_S_FAILURE, 0x96C73AC3);  // No credentials
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
-  EXPECT_EQ(OK, CreateHandler(
-      false, false, false, "http://alias:500", &auth_handler));
+  EXPECT_EQ(
+      OK,
+      CreateHandler(false, false, false, "http://alias:500", &auth_handler));
   ASSERT_TRUE(auth_handler.get() != NULL);
   TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
-  EXPECT_EQ(ERR_IO_PENDING, auth_handler->GenerateAuthToken(
-      NULL, &request_info, callback.callback(), &token));
+  EXPECT_EQ(ERR_IO_PENDING,
+            auth_handler->GenerateAuthToken(
+                NULL, &request_info, callback.callback(), &token));
   EXPECT_EQ(ERR_MISSING_AUTH_CREDENTIALS, callback.WaitForResult());
 }
 
 #if defined(DLOPEN_KERBEROS)
 TEST_F(HttpAuthHandlerNegotiateTest, MissingGSSAPI) {
   scoped_ptr<HostResolver> host_resolver(new MockHostResolver());
   MockAllowURLSecurityManager url_security_manager;
   scoped_ptr<HttpAuthHandlerNegotiate::Factory> negotiate_factory(
       new HttpAuthHandlerNegotiate::Factory());
   negotiate_factory->set_host_resolver(host_resolver.get());
   negotiate_factory->set_url_security_manager(&url_security_manager);
   negotiate_factory->set_library(
       new GSSAPISharedLibrary("/this/library/does/not/exist"));
 
   GURL gurl("http://www.example.com");
   scoped_ptr<HttpAuthHandler> generic_handler;
-  int rv = negotiate_factory->CreateAuthHandlerFromString(
-      "Negotiate",
-      HttpAuth::AUTH_SERVER,
-      gurl,
-      BoundNetLog(),
-      &generic_handler);
+  int rv = negotiate_factory->CreateAuthHandlerFromString("Negotiate",
+                                                          HttpAuth::AUTH_SERVER,
+                                                          gurl,
+                                                          BoundNetLog(),
+                                                          &generic_handler);
   EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, rv);
   EXPECT_TRUE(generic_handler.get() == NULL);
 }
 #endif  // defined(DLOPEN_KERBEROS)
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace net