Undisable half of new ftp unit tests in url_request_unittest.cc.

net/url_request/url_request_unittest.cc

 // Copyright (c) 2006-2009 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/url_request/url_request_unittest.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 11 matching lines @@
 #include "base/process_util.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_module.h"
 #include "net/base/net_util.h"
 #include "net/base/upload_data.h"
 #include "net/disk_cache/disk_cache.h"
+#include "net/ftp/ftp_network_layer.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_response_headers.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/ssl_test_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_job.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using base::Time;
 
 namespace {
 
-class URLRequestHttpCacheContext : public URLRequestContext {
+class URLRequestTestContext : public URLRequestContext {

[wtc, 2009/07/30 22:16:32]

I found that there is a TestURLRequestContext class defined
in url_request_unittest.h.  The two class names are very
similar.  It would be nice to rename URLRequestTestContext
to be more different, or change it back to
URLRequestHttpCacheContext.

  public:
-  URLRequestHttpCacheContext() {
+  URLRequestTestContext() {
     host_resolver_ = net::CreateSystemHostResolver();
     proxy_service_ = net::ProxyService::CreateNull();
+    ftp_transaction_factory_ = new net::FtpNetworkLayer(host_resolver_);
     http_transaction_factory_ =
         new net::HttpCache(
           net::HttpNetworkLayer::CreateFactory(host_resolver_, proxy_service_),
           disk_cache::CreateInMemoryCacheBackend(0));
     // In-memory cookie store.
     cookie_store_ = new net::CookieMonster();
   }
 
-  virtual ~URLRequestHttpCacheContext() {
+  virtual ~URLRequestTestContext() {
     delete cookie_store_;
+    delete ftp_transaction_factory_;
     delete http_transaction_factory_;
     delete proxy_service_;
   }
 };
 
 class TestURLRequest : public URLRequest {
  public:
   TestURLRequest(const GURL& url, Delegate* delegate)
       : URLRequest(url, delegate) {
-    set_context(new URLRequestHttpCacheContext());
+    set_context(new URLRequestTestContext());
   }
 };
 
 StringPiece TestNetResourceProvider(int key) {
   return "header";
 }
 
 // Do a case-insensitive search through |haystack| for |needle|.
 bool ContainsString(const std::string& haystack, const char* needle) {
   std::string::const_iterator it =
@@ skipping 366 matching lines @@
   // we won't actually get a received reponse here because we've never run the
   // message loop
   EXPECT_FALSE(d.received_data_before_response());
   EXPECT_EQ(0, d.bytes_received());
 }
 
 TEST_F(URLRequestTest, CancelTest5) {
   scoped_refptr<HTTPTestServer> server =
       HTTPTestServer::CreateServer(L"", NULL);
   ASSERT_TRUE(NULL != server.get());
-  scoped_refptr<URLRequestContext> context = new URLRequestHttpCacheContext();
+  scoped_refptr<URLRequestContext> context = new URLRequestTestContext();
 
   // populate cache
   {
     TestDelegate d;
     URLRequest r(server->TestServerPage("cachetime"), &d);
     r.set_context(context);
     r.Start();
     MessageLoop::current()->Run();
     EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
   }
@@ skipping 32 matching lines @@
     ptr += 10;
     if (idx % 100 == 0) {
       ptr--;
       *ptr++ = marker;
       if (++marker > 'z')
         marker = 'a';
     }
   }
   uploadBytes[kMsgSize] = '\0';
 
-  scoped_refptr<URLRequestContext> context =
-      new URLRequestHttpCacheContext();
+  scoped_refptr<URLRequestContext> context = new URLRequestTestContext();
 
   for (int i = 0; i < kIterations; ++i) {
     TestDelegate d;
     URLRequest r(server->TestServerPage("echo"), &d);
     r.set_context(context);
     r.set_method("POST");
 
     r.AppendBytesToUpload(uploadBytes, kMsgSize);
 
     r.Start();
@@ skipping 612 matching lines @@
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status());
   }
 }
 
 TEST_F(URLRequestTest, VaryHeader) {
   scoped_refptr<HTTPTestServer> server =
       HTTPTestServer::CreateServer(L"net/data/url_request_unittest", NULL);
   ASSERT_TRUE(NULL != server.get());
 
-  scoped_refptr<URLRequestContext> context = new URLRequestHttpCacheContext();
+  scoped_refptr<URLRequestContext> context = new URLRequestTestContext();
 
   Time response_time;
 
   // populate the cache
   {
     TestDelegate d;
     URLRequest req(server->TestServerPage("echoheader?foo"), &d);
     req.set_context(context);
     req.SetExtraRequestHeaders("foo:1");
     req.Start();
@@ skipping 25 matching lines @@
     req.set_context(context);
     req.SetExtraRequestHeaders("foo:2");
     req.Start();
     MessageLoop::current()->Run();
 
     EXPECT_FALSE(req.response_time() == response_time);
   }
 }
 
 TEST_F(URLRequestTest, BasicAuth) {
-  scoped_refptr<URLRequestContext> context = new URLRequestHttpCacheContext();
+  scoped_refptr<URLRequestContext> context = new URLRequestTestContext();
   scoped_refptr<HTTPTestServer> server =
       HTTPTestServer::CreateServer(L"", NULL);
   ASSERT_TRUE(NULL != server.get());
 
   Time response_time;
 
   // populate the cache
   {
     TestDelegate d;
     d.set_username(L"user");
@@ skipping 43 matching lines @@
   scoped_refptr<HTTPTestServer> server =
       HTTPTestServer::CreateServer(L"", NULL);
   ASSERT_TRUE(NULL != server.get());
 
   GURL url_requiring_auth =
       server->TestServerPage("auth-basic?set-cookie-if-challenged");
 
   // Request a page that will give a 401 containing a Set-Cookie header.
   // Verify that when the transaction is restarted, it includes the new cookie.
   {
-    scoped_refptr<URLRequestContext> context = new URLRequestHttpCacheContext();
+    scoped_refptr<URLRequestContext> context = new URLRequestTestContext();
     TestDelegate d;
     d.set_username(L"user");
     d.set_password(L"secret");
 
     URLRequest r(url_requiring_auth, &d);
     r.set_context(context);
     r.Start();
 
     MessageLoop::current()->Run();
 
     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
 
     // Make sure we sent the cookie in the restarted transaction.
     EXPECT_TRUE(d.data_received().find("Cookie: got_challenged=true")
         != std::string::npos);
   }
 
   // Same test as above, except this time the restart is initiated earlier
   // (without user intervention since identity is embedded in the URL).
   {
-    scoped_refptr<URLRequestContext> context = new URLRequestHttpCacheContext();
+    scoped_refptr<URLRequestContext> context = new URLRequestTestContext();
     TestDelegate d;
 
     GURL::Replacements replacements;
     std::string username("user2");
     std::string password("secret");
     replacements.SetUsernameStr(username);
     replacements.SetPasswordStr(password);
     GURL url_with_identity = url_requiring_auth.ReplaceComponents(replacements);
 
     URLRequest r(url_with_identity, &d);
@@ skipping 514 matching lines @@
 
   // Check the interceptor got called as expected
   EXPECT_TRUE(interceptor.did_cancel_then_restart_main_);
   EXPECT_FALSE(interceptor.did_intercept_final_);
 
   // Check we see a canceled request
   EXPECT_FALSE(req.status().is_success());
   EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status());
 }
 
-// FTP tests appear to be hanging some of the time
-#if 1  // !defined(OS_WIN)
-  #define MAYBE_FTPGetTestAnonymous   DISABLED_FTPGetTestAnonymous
-  #define MAYBE_FTPGetTest            DISABLED_FTPGetTest
-  #define MAYBE_FTPCheckWrongUser     DISABLED_FTPCheckWrongUser
-  #define MAYBE_FTPCheckWrongPassword DISABLED_FTPCheckWrongPassword
-#else
-  #define MAYBE_FTPGetTestAnonymous   FTPGetTestAnonymous
-  #define MAYBE_FTPGetTest            FTPGetTest
-  #define MAYBE_FTPCheckWrongUser     FTPCheckWrongUser
-  #define MAYBE_FTPCheckWrongPassword FTPCheckWrongPassword
-#endif
-
-TEST_F(URLRequestTest, MAYBE_FTPGetTestAnonymous) {
+TEST_F(URLRequestTest, FTPGetTestAnonymous) {
   scoped_refptr<FTPTestServer> server = FTPTestServer::CreateServer(L"");
   ASSERT_TRUE(NULL != server.get());
   FilePath app_path;
   PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
   app_path = app_path.AppendASCII("LICENSE");
   TestDelegate d;
   {
     TestURLRequest r(server->TestServerPage("/LICENSE"), &d);
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     int64 file_size = 0;
     file_util::GetFileSize(app_path, &file_size);
 
-    EXPECT_TRUE(!r.is_pending());
+    EXPECT_FALSE(r.is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size));
   }
 }
 
-TEST_F(URLRequestTest, MAYBE_FTPGetTest) {
+TEST_F(URLRequestTest, FTPGetTest) {
   scoped_refptr<FTPTestServer> server =
       FTPTestServer::CreateServer(L"", "chrome", "chrome");
   ASSERT_TRUE(NULL != server.get());
   FilePath app_path;
   PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
   app_path = app_path.AppendASCII("LICENSE");
   TestDelegate d;
   {
     TestURLRequest r(server->TestServerPage("/LICENSE"), &d);
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     int64 file_size = 0;
     file_util::GetFileSize(app_path, &file_size);
 
-    EXPECT_TRUE(!r.is_pending());
+    EXPECT_FALSE(r.is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size));
   }
 }
 
-TEST_F(URLRequestTest, MAYBE_FTPCheckWrongPassword) {
+// Needs more work, tracked in http://crbug.com/18036.
+TEST_F(URLRequestTest, DISABLED_FTPCheckWrongPassword) {
   scoped_refptr<FTPTestServer> server =
       FTPTestServer::CreateServer(L"", "chrome", "wrong_password");
   ASSERT_TRUE(NULL != server.get());
   FilePath app_path;
   PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
   app_path = app_path.AppendASCII("LICENSE");
   TestDelegate d;
   {
     TestURLRequest r(server->TestServerPage("/LICENSE"), &d);
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     int64 file_size = 0;
     file_util::GetFileSize(app_path, &file_size);
 
-    EXPECT_TRUE(!r.is_pending());
+    EXPECT_FALSE(r.is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(d.bytes_received(), 0);
   }
 }
 
-TEST_F(URLRequestTest, MAYBE_FTPCheckWrongUser) {
+// Needs more work, tracked in http://crbug.com/18036.
+TEST_F(URLRequestTest, DISABLED_FTPCheckWrongUser) {
   scoped_refptr<FTPTestServer> server =
       FTPTestServer::CreateServer(L"", "wrong_user", "chrome");
   ASSERT_TRUE(NULL != server.get());
   FilePath app_path;
   PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
   app_path = app_path.AppendASCII("LICENSE");
   TestDelegate d;
   {
     TestURLRequest r(server->TestServerPage("/LICENSE"), &d);
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     int64 file_size = 0;
     file_util::GetFileSize(app_path, &file_size);
 
-    EXPECT_TRUE(!r.is_pending());
+    EXPECT_FALSE(r.is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(d.bytes_received(), 0);
   }
 }