For actions, switch bool success into an exit code.

postinstall_runner_action_unittest.cc

 // Copyright (c) 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 <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <string>
 #include <vector>
 #include <gtest/gtest.h>
 #include "update_engine/postinstall_runner_action.h"
 #include "update_engine/test_utils.h"
 #include "update_engine/utils.h"
 
 using std::string;
 using std::vector;
 
 namespace chromeos_update_engine {
 
 class PostinstallRunnerActionTest : public ::testing::Test {
  public:
   void DoTest(bool do_losetup, bool do_err_script);
 };
 
 class PostinstActionProcessorDelegate : public ActionProcessorDelegate {
  public:
-  PostinstActionProcessorDelegate() : success_(false), success_set_(false) {}
+  PostinstActionProcessorDelegate()
+      : code_(kActionCodeError),
+        code_set_(false) {}
   void ActionCompleted(ActionProcessor* processor,
                        AbstractAction* action,
-                       bool success) {
+                       ActionExitCode code) {
     if (action->Type() == PostinstallRunnerAction::StaticType()) {
-      success_ = success;
-      success_set_ = true;
+      code_ = code;
+      code_set_ = true;
     }
   }
-  bool success_;
-  bool success_set_;
+  ActionExitCode code_;
+  bool code_set_;
 };
 
 TEST_F(PostinstallRunnerActionTest, RunAsRootSimpleTest) {
   ASSERT_EQ(0, getuid());
   DoTest(true, false);
 }
 
 TEST_F(PostinstallRunnerActionTest, RunAsRootCantMountTest) {
   ASSERT_EQ(0, getuid());
   DoTest(false, false);
@@ skipping 72 matching lines @@
   BondActions(&runner_action, &collector_action);
   PostinstActionProcessorDelegate delegate;
   processor.EnqueueAction(&feeder_action);
   processor.EnqueueAction(&runner_action);
   processor.EnqueueAction(&collector_action);
   processor.set_delegate(&delegate);
   processor.StartProcessing();
   ASSERT_FALSE(processor.IsRunning())
       << "Update test to handle non-asynch actions";
 
-  EXPECT_TRUE(delegate.success_set_);
-  EXPECT_EQ(do_losetup && !do_err_script, delegate.success_);
+  EXPECT_TRUE(delegate.code_set_);
+  EXPECT_EQ(do_losetup && !do_err_script, delegate.code_ == kActionCodeSuccess);
   EXPECT_EQ(do_losetup && !do_err_script,
             !collector_action.object().install_path.empty());
   if (do_losetup && !do_err_script) {
     EXPECT_TRUE(install_plan == collector_action.object());
   }
 
   struct stat stbuf;
   int rc = lstat((string(cwd) + "/postinst_called").c_str(), &stbuf);
   if (do_losetup && !do_err_script)
     ASSERT_EQ(0, rc);
   else
     ASSERT_LT(rc, 0);
 
   if (do_losetup)
     ASSERT_EQ(0, System(string("losetup -d ") + dev));
   ASSERT_EQ(0, System(string("rm -f ") + cwd + "/postinst_called"));
   ASSERT_EQ(0, System(string("rm -f ") + cwd + "/image.dat"));
 }
 
 // Death tests don't seem to be working on Hardy
 TEST_F(PostinstallRunnerActionTest, DISABLED_RunAsRootDeathTest) {
   ASSERT_EQ(0, getuid());
   PostinstallRunnerAction runner_action(true);
   ASSERT_DEATH({ runner_action.TerminateProcessing(); },
                "postinstall_runner_action.h:.*] Check failed");
 }
 
 }  // namespace chromeos_update_engine