[BattOr] Reduce StartTracing time by about four seconds.

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 560 matching lines @@
       SendBytes(BATTOR_MESSAGE_TYPE_CONTROL,
                 BufferEq(&request_samples_msg, sizeof(request_samples_msg)),
                 sizeof(request_samples_msg)));
 
   // We send the agent four frames: a calibration frame, and two real frames,
   // and one zero-length frame to indicate that we're done.
   EXPECT_CALL(*GetAgent()->GetConnection(),
               ReadMessage(BATTOR_MESSAGE_TYPE_SAMPLES))
       .Times(4);
 
+  // Ensure that the proactive reset message is be sent after the trace,
+  BattOrControlMessage reset_msg{BATTOR_CONTROL_MESSAGE_TYPE_RESET, 0, 0};
+  EXPECT_CALL(
+      *GetAgent()->GetConnection(),
+      SendBytes(BATTOR_MESSAGE_TYPE_CONTROL,
+                BufferEq(&reset_msg, sizeof(reset_msg)), sizeof(reset_msg)));
+
   GetAgent()->StopTracing();
+
   RunStopTracingTo(BattOrAgentState::SAMPLES_REQUEST_SENT);
 
   // Send the calibration frame.
   BattOrFrameHeader cal_frame_header{0, 2 * sizeof(RawBattOrSample)};
   RawBattOrSample cal_frame[] = {
       RawBattOrSample{1, 1}, RawBattOrSample{2, 2},
   };
   OnMessageRead(true, BATTOR_MESSAGE_TYPE_SAMPLES,
                 CreateFrame(cal_frame_header, cal_frame, 2));
 
   // Send the two real data frames.
   BattOrFrameHeader frame_header1{1, 3 * sizeof(RawBattOrSample)};
   RawBattOrSample frame1[] = {
       RawBattOrSample{1, 1}, RawBattOrSample{2, 2}, RawBattOrSample{3, 3},
   };
   OnMessageRead(true, BATTOR_MESSAGE_TYPE_SAMPLES,
                 CreateFrame(frame_header1, frame1, 3));
 
   BattOrFrameHeader frame_header2{2, 1 * sizeof(RawBattOrSample)};
   RawBattOrSample frame2[] = {RawBattOrSample{1, 1}};
   OnMessageRead(true, BATTOR_MESSAGE_TYPE_SAMPLES,
                 CreateFrame(frame_header2, frame2, 1));
 
   // Send an empty last frame to indicate that we're done.
   BattOrFrameHeader frame_header3{3, 0 * sizeof(RawBattOrSample)};
   OnMessageRead(true, BATTOR_MESSAGE_TYPE_SAMPLES,
                 CreateFrame(frame_header3, nullptr, 0));
 
+  // Bytes will be sent beause the proactive RESET message will be sent.
+  OnBytesSent(true);
+
   EXPECT_TRUE(IsCommandComplete());
   EXPECT_EQ(BATTOR_ERROR_NONE, GetCommandError());
   EXPECT_EQ(
       "# BattOr\n# voltage_range [-2401.8, 2398.2] mV\n# "
       "current_range [-1200.9, 1199.1] mA\n"
       "# sample_rate 1000 Hz, gain 1.0x\n"
       "0.00 -0.3 -0.6\n1.00 0.3 0.6\n2.00 0.9 1.8\n3.00 -0.3 -0.6\n",
       GetTrace());
 }
 
@@ skipping 61 matching lines @@
   RunStopTracingTo(BattOrAgentState::SAMPLES_REQUEST_SENT);
   // Make a read fail in order to make sure that the agent will retry.
   OnMessageRead(false, BATTOR_MESSAGE_TYPE_SAMPLES, nullptr);
 
   RunStopTracingTo(BattOrAgentState::SAMPLES_REQUEST_SENT);
 
   EXPECT_FALSE(IsCommandComplete());
 
   RunStopTracingTo(BattOrAgentState::SAMPLES_END_FRAME_RECEIVED);
 
+  // Bytes will be sent beause the proactive RESET message will be sent.
+  OnBytesSent(true);
+
   EXPECT_TRUE(IsCommandComplete());
   EXPECT_EQ(BATTOR_ERROR_NONE, GetCommandError());
 }
 
 TEST_F(BattOrAgentTest, StopTracingSucceedsAfterDataFrameReadFailure) {
   GetAgent()->StopTracing();
 
   RunStopTracingTo(BattOrAgentState::CALIBRATION_FRAME_RECEIVED);
 
   // Make a read fail in order to make sure that the agent will retry.
   OnMessageRead(false, BATTOR_MESSAGE_TYPE_SAMPLES, nullptr);
 
   EXPECT_FALSE(IsCommandComplete());
 
   RunStopTracingTo(BattOrAgentState::SAMPLES_END_FRAME_RECEIVED);
 
+  // Bytes will be sent beause the proactive RESET message will be sent.
+  OnBytesSent(true);
+
   EXPECT_TRUE(IsCommandComplete());
   EXPECT_EQ(BATTOR_ERROR_NONE, GetCommandError());
 }
 
 TEST_F(BattOrAgentTest, StopTracingFailsWithManyCalibrationFrameReadFailures) {
   GetAgent()->StopTracing();
 
   for (int i = 0; i < 9; i++) {
     RunStopTracingTo(BattOrAgentState::SAMPLES_REQUEST_SENT);
     OnMessageRead(false, BATTOR_MESSAGE_TYPE_SAMPLES, nullptr);
@@ skipping 38 matching lines @@
 
   RunStopTracingTo(BattOrAgentState::CALIBRATION_FRAME_RECEIVED);
   OnMessageRead(true, BATTOR_MESSAGE_TYPE_SAMPLES,
                 CreateFrame(frame_header, frame, 1));
   OnMessageRead(false, BATTOR_MESSAGE_TYPE_SAMPLES, nullptr);
 
   EXPECT_FALSE(IsCommandComplete());
 
   RunStopTracingTo(BattOrAgentState::SAMPLES_END_FRAME_RECEIVED);
 
+  // Bytes will be sent beause the proactive RESET message will be sent.
+  OnBytesSent(true);

[charliea (OOO until 10-5), 2017/05/24 18:41:29]

I think there should be a test where everything goes to plan, but then the send
of the RESET message fails. (based on the current implementation, this should
result in a send error, and we should just have a test making sure that behavior
is documented and working as intended)

+
   EXPECT_TRUE(IsCommandComplete());
   EXPECT_EQ(BATTOR_ERROR_NONE, GetCommandError());
 }
 
 TEST_F(BattOrAgentTest, StopTracingSucceedsAfterSamplesReadHasWrongType) {
   GetAgent()->StopTracing();
 
   RunStopTracingTo(BattOrAgentState::SAMPLES_REQUEST_SENT);
   OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK, ToCharVector(kInitAck));
 
@@ skipping 304 matching lines @@
                 ToCharVector(kStartTracingAck));
 
   EXPECT_FALSE(IsCommandComplete());
 
   RunGetFirmwareGitHashTo(BattOrAgentState::READ_GIT_HASH_RECEIVED);
 
   EXPECT_TRUE(IsCommandComplete());
   EXPECT_EQ(BATTOR_ERROR_NONE, GetCommandError());
 }
 }  // namespace battor