Move weave packet to common location b/t generator and receiver

components/proximity_auth/ble/bluetooth_low_energy_weave_packet_generator_unittest.cc

 // Copyright 2016 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 "components/proximity_auth/ble/bluetooth_low_energy_weave_packet_generator.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using proximity_auth::BluetoothLowEnergyWeavePacketGenerator;
-
-namespace {
-typedef BluetoothLowEnergyWeavePacketGenerator::ReasonForClose ReasonForClose;
-typedef BluetoothLowEnergyWeavePacketGenerator::Packet Packet;
-
-const uint8_t kDefaultPacketSize = 20;
-const uint8_t kWeaveVersion = 1;
-const uint8_t kMaxCounter = 8;
-const uint8_t kEmptyUpperByte = 0;
-const uint8_t kSelectDefaultPacketSize = 0;
-const uint8_t kDataType = 0;
-
-}  // namespace
-
 namespace proximity_auth {
+namespace weave {
 
 class ProximityAuthBluetoothLowEnergyWeavePacketGeneratorTest
     : public testing::Test {
  protected:
   ProximityAuthBluetoothLowEnergyWeavePacketGeneratorTest() {}
 
   void TestConnectionCloseWithReason(ReasonForClose reason_for_close,
                                      uint8_t expected_reason_for_close) {
     std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator> generator =
         BluetoothLowEnergyWeavePacketGenerator::Factory::NewInstance();
@@ skipping 28 matching lines @@
 
   Packet packet = generator->CreateConnectionRequest();
 
   const uint16_t kRequestSize = 7;
   Packet expected(kRequestSize, 0);
   // uWeave Header:
   // 1--- ---- :  type = 1 (control packet)
   // -000 ---- : counter = 0
   // ---- 0000 : command = 0 (request)
   // 1000 0000 = 0x80
-  expected = {
-      0x80,          kEmptyUpperByte, kWeaveVersion,           kEmptyUpperByte,
-      kWeaveVersion, kEmptyUpperByte, kSelectDefaultPacketSize};
+  expected = {0x80,
+              kEmptyUpperByte,
+              kByteWeaveVersion,
+              kEmptyUpperByte,
+              kByteWeaveVersion,
+              kEmptyUpperByte,
+              kByteSelectMaxPacketSize};
 
   EXPECT_EQ(expected, packet);
 }
 
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketGeneratorTest,
        CreateConnectionResponseWithDefaultPacketSizeTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator> generator =
       BluetoothLowEnergyWeavePacketGenerator::Factory::NewInstance();
 
   Packet packet = generator->CreateConnectionResponse();
 
   const uint16_t kResponseSize = 5;
   Packet expected_default(kResponseSize, 0);
   // uWeave Header:
   // 1--- ---- : type = 1 (control packet)
   // -000 ---- : counter = 0
   // ---- 0001 : command = 1 (response)
   // 1000 0001 = 0x81
-  expected_default = {0x81, kEmptyUpperByte, kWeaveVersion, kEmptyUpperByte,
-                      kDefaultPacketSize};
+  expected_default = {0x81, kEmptyUpperByte, kByteWeaveVersion, kEmptyUpperByte,
+                      kByteDefaultMaxPacketSize};
 
   EXPECT_EQ(expected_default, packet);
 }
 
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketGeneratorTest,
        CreateConnectionResponseWithSelectedPacketSizeTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator> generator =
       BluetoothLowEnergyWeavePacketGenerator::Factory::NewInstance();
 
   const uint8_t kSelectedPacketSize = 30;
   const uint16_t kResponseSize = 5;
 
   generator->SetMaxPacketSize(kSelectedPacketSize);
 
   Packet packet = generator->CreateConnectionResponse();
 
   Packet expected_selected(kResponseSize, 0);
   // uWeave Header:
   // 1--- ---- : type = 1 (control packet)
   // -000 ---- : counter = 0
   // ---- 0001 : command = 1 (response)
   // 1000 0001 = 0x81
-  expected_selected = {0x81, kEmptyUpperByte, kWeaveVersion, kEmptyUpperByte,
-                       kSelectedPacketSize};
+  expected_selected = {0x81, kEmptyUpperByte, kByteWeaveVersion,
+                       kEmptyUpperByte, kSelectedPacketSize};
   EXPECT_EQ(expected_selected, packet);
 }
 
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketGeneratorTest,
        CreateConnectionCloseTest) {
   // Reason for close spec of uWeave.
   // 0x00: Close without error
   // 0x01: Unknown error
   // 0x02: No common version supported
   // 0x03: Received packet out of sequence
@@ skipping 111 matching lines @@
 
   EXPECT_EQ(2, GetCounterFromHeader(packet[0]));
 }
 
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketGeneratorTest,
        PacketCounterWrappedAroundTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator> generator =
       BluetoothLowEnergyWeavePacketGenerator::Factory::NewInstance();
 
   const uint8_t kNumPackets = 100;
-  std::string data(kNumPackets * kDefaultPacketSize, 'a');
+  std::string data(kNumPackets * kByteDefaultMaxPacketSize, 'a');
 
   std::vector<Packet> packets = generator->EncodeDataMessage(data);
 
   std::vector<Packet> expected(kNumPackets);
 
+  const uint8_t kDataType = 0;
+
   for (uint8_t i = 0; i < kNumPackets; ++i) {
     uint8_t header = packets[i][0];
-    EXPECT_EQ(i % kMaxCounter, GetCounterFromHeader(header));
+    EXPECT_EQ(i % kMaxPacketCounter, GetCounterFromHeader(header));
     EXPECT_EQ(kDataType, GetPacketType(header));
   }
 }
 
+}  // namespace weave
 }  // namespace proximity_auth