Checkpoint for event automation porting....

chrome/test/automated_ui_tests/automated_ui_tests.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 <fstream>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
@@ skipping 23 matching lines @@
 const wchar_t* const kReproRepeatSwitch = L"num-reproductions";
 
 const wchar_t* const kInputFilePathSwitch = L"input";
 
 const wchar_t* const kOutputFilePathSwitch = L"output";
 
 const wchar_t* const kDebugModeSwitch = L"debug";
 
 const wchar_t* const kWaitSwitch = L"wait-after-action";
 
-const wchar_t* const kDefaultInputFilePath = L"C:\\automated_ui_tests.txt";
+const FilePath::CharType* const kDefaultInputFilePath =
+#if defined(OS_WIN)
+  L"C:\\automated_ui_tests.txt";
+#else
+  "/tmp/automated_ui_tests.txt";
+#endif
 
-const wchar_t* const kDefaultOutputFilePath
-  = L"C:\\automated_ui_tests_error_report.txt";
+const FilePath::CharType* const kDefaultOutputFilePath =
+#if defined(OS_WIN)
+  L"C:\\automated_ui_tests_error_report.txt";
+#else
+  "/tmp/automated_ui_tests_error_report.txt";
+#endif
 
 const int kDebuggingTimeoutMsec = 5000;
 
 // How many commands to run when testing a dialog box.
 const int kTestDialogActionsToRun = 7;
 
 void SilentRuntimeReportHandler(const std::string& str) {
 }
 
+FilePath GetInputFilePath() {
+  const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
+  if (parsed_command_line.HasSwitch(kInputFilePathSwitch)) {
+    return FilePath::FromWStringHack(
+        parsed_command_line.GetSwitchValue(kInputFilePathSwitch));
+  } else {
+    return FilePath(kDefaultInputFilePath);
+  }
+}
+
+FilePath GetOutputFilePath() {
+  const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
+  if (parsed_command_line.HasSwitch(kOutputFilePathSwitch)) {
+    return FilePath::FromWStringHack(
+        parsed_command_line.GetSwitchValue(kOutputFilePathSwitch));
+  } else {
+    return FilePath(kDefaultOutputFilePath);
+  }
+}
+
 }  // namespace
 
 // This subset of commands is used to test dialog boxes, which aren't likely
 // to respond to most other commands.
 const std::string kTestDialogPossibleActions[] = {
   // See FuzzyTestDialog for details on why Enter and SpaceBar must appear first
   // in this list.
   "PressEnterKey",
   "PressSpaceBar",
   "PressTabKey",
@@ skipping 19 matching lines @@
       post_action_delay_(0) {
   show_window_ = true;
   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
   if (parsed_command_line.HasSwitch(kDebugModeSwitch))
     debug_logging_enabled_ = true;
   if (parsed_command_line.HasSwitch(kWaitSwitch)) {
     std::wstring str = parsed_command_line.GetSwitchValue(kWaitSwitch);
     if (str.empty()) {
       post_action_delay_ = 1;
     } else {
-      post_action_delay_ = static_cast<int>(StringToInt64(str));
+      post_action_delay_ = static_cast<int>(StringToInt64(WideToUTF16(str)));
     }
   }
   if (base::SysInfo::HasEnvVar(env_vars::kHeadless))
     logging::SetLogReportHandler(SilentRuntimeReportHandler);
 }
 
 AutomatedUITest::~AutomatedUITest() {}
 
 void AutomatedUITest::RunReproduction() {
   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
   xml_writer_.StartWriting();
   xml_writer_.StartElement("Report");
   std::string action_string =
       WideToASCII(parsed_command_line.GetSwitchValue(kReproSwitch));
 
   int64 num_reproductions = 1;
   if (parsed_command_line.HasSwitch(kReproRepeatSwitch)) {
     std::wstring num_reproductions_string =
         parsed_command_line.GetSwitchValue(kReproRepeatSwitch);
     std::string test = WideToASCII(num_reproductions_string);
-    num_reproductions = StringToInt64(num_reproductions_string);
+    num_reproductions = StringToInt64(test);
   }
   std::vector<std::string> actions;
   SplitString(action_string, L',', &actions);
   bool did_crash = false;
   bool command_complete = false;
 
   for (int64 i = 0; i < num_reproductions && !did_crash; ++i) {
     bool did_teardown = false;
     xml_writer_.StartElement("Executed");
     for (size_t j = 0; j < actions.size(); ++j) {
@@ skipping 147 matching lines @@
   } else if (LowerCaseEqualsASCII(action, "clearbrowsingdata")) {
     did_complete_action = OpenClearBrowsingDataDialog();
   } else if (LowerCaseEqualsASCII(action, "crash")) {
     did_complete_action = ForceCrash();
   } else if (LowerCaseEqualsASCII(action, "dialog")) {
     did_complete_action = ExerciseDialog();
   } else if (LowerCaseEqualsASCII(action, "downarrow")) {
     did_complete_action = PressDownArrow();
   } else if (LowerCaseEqualsASCII(action, "downloads")) {
     did_complete_action = ShowDownloads();
+// TODO(estade): port.
+#if defined(OS_WIN)
   } else if (LowerCaseEqualsASCII(action, "dragtableft")) {
     did_complete_action = DragActiveTab(false);
   } else if (LowerCaseEqualsASCII(action, "dragtabout")) {
     did_complete_action = DragTabOut();
   } else if (LowerCaseEqualsASCII(action, "dragtabright")) {
     did_complete_action = DragActiveTab(true);
+#endif  // defined(OS_WIN)
   } else if (LowerCaseEqualsASCII(action, "duplicatetab")) {
     did_complete_action = DuplicateTab();
   } else if (LowerCaseEqualsASCII(action, "editsearchengines")) {
     did_complete_action = OpenEditSearchEnginesDialog();
   } else if (LowerCaseEqualsASCII(action, "findinpage")) {
     did_complete_action = FindInPage();
   } else if (LowerCaseEqualsASCII(action, "forward")) {
     did_complete_action = ForwardButton();
   } else if (LowerCaseEqualsASCII(action, "goofftherecord")) {
     did_complete_action = GoOffTheRecord();
@@ skipping 82 matching lines @@
   } else {
     NOTREACHED() << "Unknown command passed into DoAction: "
                  << action.c_str();
   }
 
   if (!did_complete_action)
     xml_writer_.AddAttribute("failed_to_complete", "yes");
   xml_writer_.EndElement();
 
   if (post_action_delay_)
-    ::Sleep(1000 * post_action_delay_);
+    PlatformThread::Sleep(1000 * post_action_delay_);
 
   return did_complete_action;
 }
 
 bool AutomatedUITest::ChangeEncoding() {
   // Get the encoding list that is used to populate the UI (encoding menu)
   std::string cur_locale = g_browser_process->GetApplicationLocale();
   const std::vector<CharacterEncoding::EncodingInfo>* encodings =
       CharacterEncoding::GetCurrentDisplayEncodings(
           cur_locale, L"ISO-8859-1,windows-1252", L"");
@@ skipping 198 matching lines @@
     return false;
   }
   if (!window->SimulateOSKeyPress(key, flags)) {
     AddWarningAttribute("failure_simulating_key_press");
     return false;
   }
   return true;
 }
 
 bool AutomatedUITest::InitXMLReader() {
-  std::wstring input_path;
-  const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
-  if (parsed_command_line.HasSwitch(kInputFilePathSwitch))
-    input_path = parsed_command_line.GetSwitchValue(kInputFilePathSwitch);
-  else
-    input_path = kDefaultInputFilePath;
+  FilePath input_path = GetInputFilePath();
 
   if (!file_util::ReadFileToString(input_path, &xml_init_file_))
     return false;
   return init_reader_.Load(xml_init_file_);
 }
 
 bool AutomatedUITest::WriteReportToFile() {
+  FilePath path = GetOutputFilePath();
   std::ofstream error_file;
-  std::wstring path;
-  const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
-  if (parsed_command_line.HasSwitch(kOutputFilePathSwitch))
-    path = parsed_command_line.GetSwitchValue(kOutputFilePathSwitch);
-  else
-    path = kDefaultOutputFilePath;
-
   if (!path.empty())
-    error_file.open(path.c_str(), std::ios::out);
+    error_file.open(path.value().c_str(), std::ios::out);
 
   // Closes all open elements and free the writer. This is required
   // in order to retrieve the contents of the buffer.
   xml_writer_.StopWriting();
   error_file << xml_writer_.GetWrittenString();
   error_file.close();
   return true;
 }
 
 void AutomatedUITest::AppendToOutputFile(const std::string &append_string) {
+  FilePath path = GetOutputFilePath();
   std::ofstream error_file;
-  std::wstring path;
-  const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
-  if (parsed_command_line.HasSwitch(kOutputFilePathSwitch))
-    path = parsed_command_line.GetSwitchValue(kOutputFilePathSwitch);
-  else
-    path = kDefaultOutputFilePath;
-
   if (!path.empty())
-    error_file.open(path.c_str(), std::ios::out | std::ios_base::app);
+    error_file.open(path.value().c_str(), std::ios::out | std::ios_base::app);
 
   error_file << append_string << " ";
   error_file.close();
 }
 
 void AutomatedUITest::LogCrashResult(const std::string &crash_dump,
                                      bool command_completed) {
   xml_writer_.StartElement("result");
   xml_writer_.StartElement("crash");
   xml_writer_.AddAttribute("crash_dump", crash_dump);
@@ skipping 30 matching lines @@
 
 void AutomatedUITest::LogWarningMessage(const std::string &warning) {
   AddWarningAttribute(warning);
 }
 
 void AutomatedUITest::LogInfoMessage(const std::string &info) {
   AddWarningAttribute(info);
 }
 
 std::wstring AutomatedUITest::GetMostRecentCrashDump() {
+// TODO(estade): port.
+#if defined(OS_WIN)
   std::wstring crash_dump_path;
   int file_count = 0;
   FILETIME most_recent_file_time;
   std::wstring most_recent_file_name;
   WIN32_FIND_DATA find_file_data;
 
   PathService::Get(chrome::DIR_CRASH_DUMPS, &crash_dump_path);
   // All files in the given directory.
   std::wstring filename_spec = crash_dump_path + L"\\*";
   HANDLE find_handle = FindFirstFile(filename_spec.c_str(), &find_file_data);
@@ skipping 17 matching lines @@
     } while (FindNextFile(find_handle, &find_file_data));
     FindClose(find_handle);
   }
 
   if (most_recent_file_name.empty()) {
     return L"";
   } else {
     file_util::AppendToPath(&crash_dump_path, most_recent_file_name);
     return crash_dump_path;
   }
+#else
+  NOTIMPLEMENTED();
+  return std::wstring();
+#endif
 }
 
 bool AutomatedUITest::DidCrash(bool update_total_crashes) {
   FilePath crash_dump_path;
   PathService::Get(chrome::DIR_CRASH_DUMPS, &crash_dump_path);
   // Each crash creates two dump files, so we divide by two here.
   int actual_crashes = file_util::CountFilesCreatedAfter(
     crash_dump_path, test_start_time_) / 2;
 
   // If there are more crash dumps than the total dumps which we have recorded
   // then this is a new crash.
   if (actual_crashes > total_crashes_) {
     if (update_total_crashes)
       total_crashes_ = actual_crashes;
     return true;
   } else {
     return false;
   }
 }
 
 TEST_F(AutomatedUITest, TheOneAndOnlyTest) {
   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
   if (parsed_command_line.HasSwitch(kReproSwitch))
     RunReproduction();
   else
     RunAutomatedUITest();
 }