Make the BattOr agent retry start tracing when we fail to read an ack

tools/battor_agent/battor_agent_unittest.cc

 // Copyright 2015 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 <memory>
 
 #include "tools/battor_agent/battor_agent.h"
 
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 102 matching lines @@
     command_error_ = error;
     trace_ = trace;
   }
 
   void OnRecordClockSyncMarkerComplete(BattOrError error) override {
     is_command_complete_ = true;
     command_error_ = error;
   }
 
   void OnGetFirmwareGitHashComplete(const std::string& firmware_git_hash,
-                            BattOrError error) override {
+                                    BattOrError error) override {
     is_command_complete_ = true;
     command_error_ = error;
     firmware_git_hash_ = firmware_git_hash;
   }
 
   void OnBytesSent(bool success) {
     agent_->OnBytesSent(success);
     task_runner_->RunUntilIdle();
   }
 
@@ skipping 260 matching lines @@
 }
 
 TEST_F(BattOrAgentTest, StartTracingFailsIfInitAckReadFails) {
   RunStartTracingTo(BattOrAgentState::INIT_SENT);
 
   for (int i = 0; i < 21; i++) {
     OnMessageRead(false, BATTOR_MESSAGE_TYPE_CONTROL_ACK, nullptr);
 
     // Bytes will be sent because INIT will be retried.
     OnBytesSent(true);
-   }
+  }
 
   EXPECT_TRUE(IsCommandComplete());
   EXPECT_EQ(BATTOR_ERROR_TOO_MANY_INIT_RETRIES, GetCommandError());
 }
 
 TEST_F(BattOrAgentTest, StartTracingFailsIfInitWrongAckRead) {
   RunStartTracingTo(BattOrAgentState::INIT_SENT);
 
   for (int i = 0; i < 21; i++) {
     OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
@@ skipping 33 matching lines @@
 }
 
 TEST_F(BattOrAgentTest, StartTracingFailsIfStartTracingSendFails) {
   RunStartTracingTo(BattOrAgentState::INIT_SENT);
   OnBytesSent(false);
 
   EXPECT_TRUE(IsCommandComplete());
   EXPECT_EQ(BATTOR_ERROR_SEND_ERROR, GetCommandError());
 }
 
-TEST_F(BattOrAgentTest, StartTracingFailsIfStartTracingAckReadFails) {
-  RunStartTracingTo(BattOrAgentState::START_TRACING_SENT);
-  OnMessageRead(false, BATTOR_MESSAGE_TYPE_CONTROL_ACK, nullptr);
+TEST_F(BattOrAgentTest, StartTracingSucceedsAfterRetriesIfWrongAckRead) {
+  RunStartTracingTo(BattOrAgentState::CONNECTED);
+
+  for (int i = 0; i < 4; i++) {
+    // Go through the correct init sequence, but give the wrong ack to
+    // START_TRACING.
+    OnBytesSent(true);
+    OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                  ToCharVector(kInitAck));
+    OnBytesSent(true);
+    OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                  ToCharVector(kSetGainAck));
+    OnBytesSent(true);
+    OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                  ToCharVector(kInitAck));
+  }
+
+  // On the last attempt, give the correct ack to START_TRACING.
+  OnBytesSent(true);
+  OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK, ToCharVector(kInitAck));
+  OnBytesSent(true);
+  OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                ToCharVector(kSetGainAck));
+  OnBytesSent(true);
+  OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                ToCharVector(kStartTracingAck));
 
   EXPECT_TRUE(IsCommandComplete());
-  EXPECT_EQ(BATTOR_ERROR_RECEIVE_ERROR, GetCommandError());
+  EXPECT_EQ(BATTOR_ERROR_NONE, GetCommandError());
 }
 
-TEST_F(BattOrAgentTest, StartTracingFailsIfStartTracingWrongAckRead) {
-  RunStartTracingTo(BattOrAgentState::START_TRACING_SENT);
+TEST_F(BattOrAgentTest, StartTracingSucceedsAfterRetriesWithReadFailure) {
+  RunStartTracingTo(BattOrAgentState::CONNECTED);
+
+  for (int i = 0; i < 4; i++) {
+    // Go through the correct init sequence, but indicate that we failed to read
+    // the START_TRACING ack.
+    OnBytesSent(true);
+    OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                  ToCharVector(kInitAck));
+    OnBytesSent(true);
+    OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                  ToCharVector(kSetGainAck));
+    OnBytesSent(true);
+    OnMessageRead(false, BATTOR_MESSAGE_TYPE_CONTROL_ACK, nullptr);
+  }
+
+  // On the last attempt, give the correct ack to START_TRACING.
+  OnBytesSent(true);
   OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK, ToCharVector(kInitAck));
+  OnBytesSent(true);
+  OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                ToCharVector(kSetGainAck));
+  OnBytesSent(true);
+  OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                ToCharVector(kStartTracingAck));
 
   EXPECT_TRUE(IsCommandComplete());
-  EXPECT_EQ(BATTOR_ERROR_UNEXPECTED_MESSAGE, GetCommandError());
+  EXPECT_EQ(BATTOR_ERROR_NONE, GetCommandError());
+}
+
+TEST_F(BattOrAgentTest, StartTracingFailsIfStartTracingWrongAckReadTooMuch) {
+  RunStartTracingTo(BattOrAgentState::CONNECTED);
+
+  for (int i = 0; i < 5; i++) {
+    // Go through the correct init sequence, but give the wrong ack to
+    // START_TRACING.
+    OnBytesSent(true);
+    OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                  ToCharVector(kInitAck));
+    OnBytesSent(true);
+    OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                  ToCharVector(kSetGainAck));
+    OnBytesSent(true);
+    OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                  ToCharVector(kInitAck));
+  }
+
+  EXPECT_TRUE(IsCommandComplete());
+  EXPECT_EQ(BATTOR_ERROR_TOO_MANY_START_TRACING_RETRIES, GetCommandError());
 }
 
 TEST_F(BattOrAgentTest, StartTracingSucceedsWithOneInitFailure) {
   RunStartTracingTo(BattOrAgentState::INIT_SENT);
 
   // Send some samples instead of an INIT ACK. This will force an INIT retry.
   BattOrFrameHeader frame_header{1, 3 * sizeof(RawBattOrSample)};
   RawBattOrSample frame[] = {
       RawBattOrSample{1, 1}, RawBattOrSample{2, 2}, RawBattOrSample{3, 3},
   };
@@ skipping 398 matching lines @@
 
   EXPECT_TRUE(IsCommandComplete());
   EXPECT_EQ(BATTOR_ERROR_NONE, GetCommandError());
   EXPECT_EQ(
       "# BattOr\n# voltage_range [-2401.2, 2398.8] mV\n# "
       "current_range [-1200.6, 1199.4] mA\n"
       "# sample_rate 1000 Hz, gain 1.0x\n"
       "0.00 0.0 0.0 <MY_MARKER>\n"
       "1.00 0.6 1.2\n",
       GetTrace());
-
 }
 
 TEST_F(BattOrAgentTest, RecordClockSyncMarkerFailsWithoutConnection) {
   GetAgent()->RecordClockSyncMarker("my_marker");
   GetTaskRunner()->RunUntilIdle();
 
   GetAgent()->OnConnectionOpened(false);
   GetTaskRunner()->RunUntilIdle();
 
   EXPECT_TRUE(IsCommandComplete());
@@ skipping 55 matching lines @@
   RunGetFirmwareGitHashTo(BattOrAgentState::GIT_FIRMWARE_HASH_REQUEST_SENT);
 
   uint32_t current_sample = 1;
   OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL,
                 ToCharVector(current_sample));
 
   EXPECT_TRUE(IsCommandComplete());
   EXPECT_EQ(BATTOR_ERROR_UNEXPECTED_MESSAGE, GetCommandError());
 }
 }  // namespace battor