checkpoint Blink-side work to use Apache on Windows

Tools/Scripts/webkitpy/layout_tests/port/port_testcase.py

 # Copyright (C) 2010 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #    * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #    * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 25 matching lines @@
 import time
 import webkitpy.thirdparty.unittest2 as unittest
 
 from webkitpy.common.system.executive_mock import MockExecutive, MockExecutive2
 from webkitpy.common.system.filesystem_mock import MockFileSystem
 from webkitpy.common.system.outputcapture import OutputCapture
 from webkitpy.common.system.systemhost_mock import MockSystemHost
 from webkitpy.layout_tests.models import test_run_results
 from webkitpy.layout_tests.port.base import Port, TestConfiguration
 from webkitpy.layout_tests.port.server_process_mock import MockServerProcess
-from webkitpy.layout_tests.servers import http_server_base
 from webkitpy.tool.mocktool import MockOptions
 
 
 # FIXME: get rid of this fixture
 class TestWebKitPort(Port):
     port_name = "testwebkitport"
 
     def __init__(self, port_name=None, symbols_string=None,
                  expectations_file=None, skips_file=None, host=None, config=None,
                  **kwargs):
@@ skipping 44 matching lines @@
     def make_wdiff_available(self, port):
         port._wdiff_available = True
 
     def test_check_build(self):
         port = self.make_port()
         port._check_file_exists = lambda path, desc: True
         if port._dump_reader:
             port._dump_reader.check_is_functional = lambda: True
         port._options.build = True
         port._check_driver_build_up_to_date = lambda config: True
+        port.check_httpd = lambda: True
         oc = OutputCapture()
         try:
             oc.capture_output()
             self.assertEqual(port.check_build(needs_http=True, printer=FakePrinter()),
                              test_run_results.OK_EXIT_STATUS)
         finally:
             out, err, logs = oc.restore_output()
             self.assertIn('pretty patches', logs)         # We should get a warning about PrettyPatch being missing,
             self.assertNotIn('build requirements', logs)  # but not the driver itself.
 
@@ skipping 26 matching lines @@
         port = self.make_port()
         self.assertTrue(len(port.driver_cmd_line()))
 
         options = MockOptions(additional_drt_flag=['--foo=bar', '--foo=baz'])
         port = self.make_port(options=options)
         cmd_line = port.driver_cmd_line()
         self.assertTrue('--foo=bar' in cmd_line)
         self.assertTrue('--foo=baz' in cmd_line)
 
     def test_uses_apache(self):
-        self.assertTrue(self.make_port()._uses_apache())
+        self.assertTrue(self.make_port().uses_apache())
 
     def assert_servers_are_down(self, host, ports):
         for port in ports:
             try:
                 test_socket = socket.socket()
                 test_socket.connect((host, port))
                 self.fail()
             except IOError, e:
                 self.assertTrue(e.errno in (errno.ECONNREFUSED, errno.ECONNRESET))
             finally:
@@ skipping 273 matching lines @@
         self._assert_config_file_for_platform(port, 'mac', 'apache2-httpd.conf')
         self._assert_config_file_for_platform(port, 'win32', 'apache2-httpd.conf')  # win32 isn't a supported sys.platform.  AppleWin/WinCairo/WinCE ports all use cygwin.
         self._assert_config_file_for_platform(port, 'barf', 'apache2-httpd.conf')
 
     def test_path_to_apache_config_file(self):
         port = TestWebKitPort()
 
         saved_environ = os.environ.copy()
         try:
             os.environ['WEBKIT_HTTP_SERVER_CONF_PATH'] = '/path/to/httpd.conf'
-            self.assertRaises(IOError, port._path_to_apache_config_file)
+            self.assertRaises(IOError, port.path_to_apache_config_file)
             port._filesystem.write_text_file('/existing/httpd.conf', 'Hello, world!')
             os.environ['WEBKIT_HTTP_SERVER_CONF_PATH'] = '/existing/httpd.conf'
-            self.assertEqual(port._path_to_apache_config_file(), '/existing/httpd.conf')
+            self.assertEqual(port.path_to_apache_config_file(), '/existing/httpd.conf')
         finally:
             os.environ = saved_environ.copy()
 
         # Mock out _apache_config_file_name_for_platform to ignore the passed sys.platform value.
         port._apache_config_file_name_for_platform = lambda platform: 'httpd.conf'
-        self.assertEqual(port._path_to_apache_config_file(), '/mock-checkout/third_party/WebKit/LayoutTests/http/conf/httpd.conf')
+        self.assertEqual(port.path_to_apache_config_file(), '/mock-checkout/third_party/WebKit/LayoutTests/http/conf/httpd.conf')
 
         # Check that even if we mock out _apache_config_file_name, the environment variable takes precedence.
         saved_environ = os.environ.copy()
         try:
             os.environ['WEBKIT_HTTP_SERVER_CONF_PATH'] = '/existing/httpd.conf'
-            self.assertEqual(port._path_to_apache_config_file(), '/existing/httpd.conf')
+            self.assertEqual(port.path_to_apache_config_file(), '/existing/httpd.conf')
         finally:
             os.environ = saved_environ.copy()
 
     def test_additional_platform_directory(self):
         port = self.make_port(options=MockOptions(additional_platform_directory=['/tmp/foo']))
         self.assertEqual(port.baseline_search_path()[0], '/tmp/foo')