ASSERT_TRUE that the HttpAuthHandlerNegotiate::Factory creates non-NULL handlers.

net/http/http_auth_handler_negotiate_unittest.cc

 // 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 "net/http/http_auth_handler_negotiate.h"
 
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_request_info.h"
 #if defined(OS_WIN)
 #include "net/http/mock_sspi_library_win.h"
 #elif defined(OS_POSIX)
 #include "net/http/mock_gssapi_library_posix.h"
 #endif
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 typedef net::SSPILibrary SecureServicesLibrary;
 typedef net::MockSSPILibrary MockSecureServicesLibrary;
 #elif defined(OS_POSIX)
 typedef net::GSSAPILibrary SecureServicesLibrary;
 typedef net::test::MockGSSAPILibrary MockSecureServicesLibrary;
 #endif
 
 
 namespace net {
 
-// TODO(cbentzel): Remove the OS_WIN condition once Negotiate is supported
-// on all platforms.
 namespace {
 
 void SetupTransactions(MockSecureServicesLibrary* mock_library) {
 #if defined(OS_POSIX)
   // Copied from an actual transaction!
   const char kAuthResponse[] =
       "\x60\x82\x02\xCA\x06\x09\x2A\x86\x48\x86\xF7\x12\x01\x02\x02\x01"
       "\x00\x6E\x82\x02\xB9\x30\x82\x02\xB5\xA0\x03\x02\x01\x05\xA1\x03"
       "\x02\x01\x0E\xA2\x07\x03\x05\x00\x00\x00\x00\x00\xA3\x82\x01\xC1"
       "\x61\x82\x01\xBD\x30\x82\x01\xB9\xA0\x03\x02\x01\x05\xA1\x16\x1B"
@@ skipping 115 matching lines @@
 }
 
 }  // namespace
 
 TEST(HttpAuthHandlerNegotiateTest, DisableCname) {
   MockSecureServicesLibrary mock_library;
   SetupTransactions(&mock_library);
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   CreateHandler(true, false, true, "http://alias:500",
                 &mock_library, &auth_handler);
+  ASSERT_TRUE(auth_handler.get() != NULL);
   TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
   std::wstring username = L"foo";
   std::wstring password = L"bar";
   EXPECT_EQ(OK, auth_handler->GenerateAuthToken(&username, &password,
                                                 &request_info,
                                                 &callback, &token));
   EXPECT_EQ(L"HTTP/alias", auth_handler->spn());
 }
 
 TEST(HttpAuthHandlerNegotiateTest, DisableCnameStandardPort) {
   MockSecureServicesLibrary mock_library;
   SetupTransactions(&mock_library);
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   CreateHandler(true, true, true,
                 "http://alias:80", &mock_library, &auth_handler);
+  ASSERT_TRUE(auth_handler.get() != NULL);
   TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
   std::wstring username = L"foo";
   std::wstring password = L"bar";
   EXPECT_EQ(OK, auth_handler->GenerateAuthToken(&username, &password,
                                                 &request_info,
                                                 &callback, &token));
   EXPECT_EQ(L"HTTP/alias", auth_handler->spn());
 }
 
 TEST(HttpAuthHandlerNegotiateTest, DisableCnameNonstandardPort) {
   MockSecureServicesLibrary mock_library;
   SetupTransactions(&mock_library);
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   CreateHandler(true, true, true,
                 "http://alias:500", &mock_library, &auth_handler);
+  ASSERT_TRUE(auth_handler.get() != NULL);
   TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
   std::wstring username = L"foo";
   std::wstring password = L"bar";
   EXPECT_EQ(OK, auth_handler->GenerateAuthToken(&username, &password,
                                                 &request_info,
                                                 &callback, &token));
   EXPECT_EQ(L"HTTP/alias:500", auth_handler->spn());
 }
 
 TEST(HttpAuthHandlerNegotiateTest, CnameSync) {
   MockSecureServicesLibrary mock_library;
   SetupTransactions(&mock_library);
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   CreateHandler(false, false, true,
                 "http://alias:500", &mock_library, &auth_handler);
+  ASSERT_TRUE(auth_handler.get() != NULL);
   TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
   std::wstring username = L"foo";
   std::wstring password = L"bar";
   EXPECT_EQ(OK, auth_handler->GenerateAuthToken(&username, &password,
                                                 &request_info,
                                                 &callback, &token));
   EXPECT_EQ(L"HTTP/canonical.example.com", auth_handler->spn());
 }
 
 TEST(HttpAuthHandlerNegotiateTest, CnameAsync) {
   MockSecureServicesLibrary mock_library;
   SetupTransactions(&mock_library);
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   CreateHandler(false, false, false,
                 "http://alias:500", &mock_library, &auth_handler);
+  ASSERT_TRUE(auth_handler.get() != NULL);
   TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
   std::wstring username = L"foo";
   std::wstring password = L"bar";
   EXPECT_EQ(ERR_IO_PENDING, auth_handler->GenerateAuthToken(
       &username, &password, &request_info, &callback, &token));
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_EQ(L"HTTP/canonical.example.com", auth_handler->spn());
 }
 
 }  // namespace net