Weave Packet Receiver

components/proximity_auth/ble/bluetooth_low_energy_weave_packet_receiver_unittest.cc

Index: components/proximity_auth/ble/bluetooth_low_energy_weave_packet_receiver_unittest.cc
diff --git a/components/proximity_auth/ble/bluetooth_low_energy_weave_packet_receiver_unittest.cc b/components/proximity_auth/ble/bluetooth_low_energy_weave_packet_receiver_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..cc4ea8c1f94ee79728d336edd63d801fcb5d64bd
--- /dev/null
+++ b/components/proximity_auth/ble/bluetooth_low_energy_weave_packet_receiver_unittest.cc
@@ -0,0 +1,612 @@
+// 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_receiver.h"
+
+#include <algorithm>
+#include <string>
+
+#include "base/logging.h"
+#include "components/proximity_auth/ble/bluetooth_low_energy_weave_packet_generator.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using proximity_auth::BluetoothLowEnergyWeavePacketGenerator;
+using proximity_auth::BluetoothLowEnergyWeavePacketReceiver;
+
+namespace {
+typedef BluetoothLowEnergyWeavePacketReceiver::State State;
+typedef BluetoothLowEnergyWeavePacketReceiver::ReceiverType ReceiverType;
+typedef BluetoothLowEnergyWeavePacketGenerator::ReasonForClose ReasonForClose;
+
+const uint16_t kDefaultPacketSize = 20;
+const uint8_t kWeaveVersion = 1;
+
+// uWeave Header:
+// 1--- ---- :  type = 1 (control packet)
+// -000 ---- : counter = 0
+// ---- 0000 : command = 0 (request)
+// 1000 0000 = 0x80
+const uint8_t kControlRequestHeader = 0x80;
+
+// uWeave Header:
+// 1--- ---- : type = 1 (control packet)
+// -000 ---- : counter = 0
+// ---- 0001 : command = 1 (response)
+// 1000 0001 = 0x81
+const uint8_t kControlResponseHeader = 0x81;
+}  // namespace
+
+namespace proximity_auth {
+
+class ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest
+    : public testing::Test {
+ protected:
+  ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(
+      ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest);
+};
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       WellBehavingServerPacketsNoControlDataTest) {
+  BluetoothLowEnergyWeavePacketReceiver::Factory factory;
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::SERVER);
+
+  std::vector<uint8_t> p0{
+      kControlRequestHeader, kWeaveVersion, 0, kWeaveVersion, 0, 0, 0};

[Kyle Horimoto, 2016/06/21 02:10:27]

Isn't network order big endian? Shouldn't it be 0 first, then kWeaveVersion?

[Kyle Horimoto, 2016/06/21 18:13:38]

Ping.

[jingxuy, 2016/06/22 01:42:23]

Done.

+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+
+  std::vector<uint8_t> p1(kDefaultPacketSize, 'a');
+  // uWeave Header:
+  // 0--- ---- : type = 0 (data packet)
+  // -001 ---- : counter = 1
+  // ---- 1--- : first packet = true
+  // ---- -0-- : last packet = false
+  // ---- --00 : defined by uWeave to be 0
+  // 0001 1000 = 0x18
+  p1[0] = 0x18;
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::RECEIVING_DATA, receiver->GetState());
+
+  // uWeave Header:
+  // 0--- ---- : type = 0 (data packet)
+  // -010 ---- : counter = 2
+  // ---- 0--- : first packet = false
+  // ---- -1-- : last packet = true
+  // ---- --00 : defined by uWeave to be 0
+  // 0010 0100 = 0x24
+  std::vector<uint8_t> p2{0x24, 'c', 'd'};
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+  EXPECT_EQ("aaaaaaaaaaaaaaaaaaacd", receiver->GetDataMessage());
+
+  // uWeave Header:
+  // 0--- ---- : type = 0 (data packet)
+  // -011 ---- : counter = 3
+  // ---- 1--- : first packet = true
+  // ---- -1-- : last packet = true
+  // ---- --00 : defined by uWeave to be 0
+  // 0011 1100 = 0x3C
+  std::vector<uint8_t> p3{0x3C, 'g', 'o', 'o', 'g', 'l', 'e'};
+  receiver->ReceivePacket(p3);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+  EXPECT_EQ("google", receiver->GetDataMessage());
+
+  // uWeave Header:
+  // 1--- ---- : type = 1 (control packet)
+  // -100 ---- : counter = 4
+  // ---- 0010 : command = 2 (close)
+  // 1100 0010 = 0xC2
+  // 0x80 is the hex value for APPLICATION_ERROR
+  std::vector<uint8_t> p4{0xC2, 0x80, 0};
+  receiver->ReceivePacket(p4);
+  EXPECT_EQ(State::CONNECTION_CLOSED, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::APPLICATION_ERROR, receiver->GetReasonForClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       WellBehavingServerPacketsWithControlDataTest) {

[Kyle Horimoto, 2016/06/21 18:13:38]

Also test:

*when less than the full 13 bytes of control data are sent
*the error condition where >13 bytes are sent.

[jingxuy, 2016/06/22 01:42:24]

greater than 13 bytes is tested in controlpacketsizetest

+  BluetoothLowEnergyWeavePacketReceiver::Factory factory;
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::SERVER);
+
+  std::vector<uint8_t> p0{kControlRequestHeader,
+                          kWeaveVersion,
+                          0,
+                          kWeaveVersion,
+                          0,
+                          0,
+                          0,
+                          'a',
+                          'b',
+                          'c',
+                          'd',
+                          'e',
+                          'f',
+                          'g',
+                          'h',
+                          'i',
+                          'j',
+                          'l',
+                          'm',
+                          'n'};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+  EXPECT_EQ("abcdefghijklmn", receiver->GetDataMessage());
+
+  // uWeave Header:
+  // 0--- ---- : type = 0 (data packet)
+  // -001 ---- : counter = 1
+  // ---- 1--- : first packet = true
+  // ---- -0-- : last packet = false
+  // ---- --00 : defined by uWeave to be 0
+  // 0001 1000 = 0x18
+  std::vector<uint8_t> p1(20, 'o');
+  p1[0] = 0x18;
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::RECEIVING_DATA, receiver->GetState());
+
+  // uWeave Header:
+  // 0--- ---- : type = 0 (data packet)
+  // -010 ---- : counter = 2
+  // ---- 0--- : first packet = false
+  // ---- -1-- : last packet = true
+  // ---- --00 : defined by uWeave to be 0
+  // 0010 0100 = 0x24
+  std::vector<uint8_t> p2{0x24, 'p', 'q'};
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+  EXPECT_EQ("ooooooooooooooooooopq", receiver->GetDataMessage());
+
+  // uWeave Header:
+  // 1--- ---- : type = 1 (control packet)
+  // -011 ---- : counter = 3
+  // ---- 0010 : command = 2 (close)
+  // 1011 0010 = 0xB2
+  std::vector<uint8_t> p3{0xB2, 0, 0};
+  receiver->ReceivePacket(p3);
+  EXPECT_EQ(State::CONNECTION_CLOSED, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::CLOSE_WITHOUT_ERROR, receiver->GetReasonForClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       WellBehavingClientPacketsNoControlDataTest) {
+  BluetoothLowEnergyWeavePacketReceiver::Factory factory;
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::CLIENT);
+
+  std::vector<uint8_t> p0{kControlResponseHeader, kWeaveVersion, 0, 30, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+  EXPECT_EQ((uint32_t)30, receiver->GetMaxPacketSize());

[Kyle Horimoto, 2016/06/21 18:13:38]

For this test, can you actually try passing a packet which is the max size?
Thanks!

[jingxuy, 2016/06/22 01:42:24]

Done.

+
+  // uWeave Header:
+  // 0--- ---- : type = 0 (data packet)
+  // -001 ---- : counter = 1
+  // ---- 1--- : first packet = true
+  // ---- -1-- : last packet = true
+  // ---- --00 : defined by uWeave to be 0
+  // 0001 1100 = 0x1C
+  std::vector<uint8_t> p1{0x1C, 'g', 'o', 'o', 'g', 'l', 'e'};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+  EXPECT_EQ("google", receiver->GetDataMessage());
+
+  // uWeave Header:
+  // 1--- ---- : type = 1 (control packet)
+  // -010 ---- : counter = 2
+  // ---- 0010 : command = 2 (close)
+  // 1010 0010 = 0xA2
+  std::vector<uint8_t> p2{0xA2, 0x80, 0};
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::CONNECTION_CLOSED, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::APPLICATION_ERROR, receiver->GetReasonForClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       WellBehavingClientPacketsWithControlDataTest) {

[Kyle Horimoto, 2016/06/21 18:13:38]

Also test:

*when the full 15 bytes of control data are sent
*the error condition where >15 bytes are sent.

[jingxuy, 2016/06/22 01:42:23]

Both the full packet and Error condition > 15 is tested in
controlpacketsizetest. But I created a more through max size test.

+  BluetoothLowEnergyWeavePacketReceiver::Factory factory;
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::CLIENT);
+
+  std::vector<uint8_t> p0{kControlResponseHeader,
+                          kWeaveVersion,
+                          0,
+                          kDefaultPacketSize,
+                          0,
+                          'a',
+                          'b',
+                          'c',
+                          'd'};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+  EXPECT_EQ("abcd", receiver->GetDataMessage());
+
+  // uWeave Header:
+  // 0--- ---- : type = 0 (data packet)
+  // -001 ---- : counter = 1
+  // ---- 1--- : first packet = true
+  // ---- -1-- : last packet = true
+  // ---- --00 : defined by uWeave to be 0
+  // 0001 1100 = 0x1C
+  std::vector<uint8_t> p1{0x1C, 'g', 'o', 'o', 'g', 'l', 'e'};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+  EXPECT_EQ("google", receiver->GetDataMessage());
+
+  // uWeave Header:
+  // 1--- ---- : type = 1 (control packet)
+  // -010 ---- : counter = 2
+  // ---- 0010 : command = 2 (close)
+  // 1010 0010 = 0xA2
+  std::vector<uint8_t> p2{0xA2, 0, 0};
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::CONNECTION_CLOSED, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::CLOSE_WITHOUT_ERROR, receiver->GetReasonForClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       LegacyCloseWithoutReasonTest) {
+  BluetoothLowEnergyWeavePacketReceiver::Factory factory;
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::SERVER);
+
+  std::vector<uint8_t> p0{
+      kControlRequestHeader, kWeaveVersion, 0, kWeaveVersion, 0, 0, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+
+  // uWeave Header:
+  // 1--- ---- : type = 1 (control packet)
+  // -001 ---- : counter = 1
+  // ---- 0010 : command = 2 (close)
+  // 1001 0010 = 0x92
+  std::vector<uint8_t> p1{0x92};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::CONNECTION_CLOSED, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonForClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       ShortPacketTest) {
+  BluetoothLowEnergyWeavePacketReceiver::Factory factory;
+
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::CLIENT);
+
+  std::vector<uint8_t> p0{kControlResponseHeader, kWeaveVersion, 0,
+                          kDefaultPacketSize, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+
+  // uWeave Header:
+  // 0--- ---- : type = 0 (data packet)
+  // -001 ---- : counter = 1
+  // ---- 1--- : first packet = true
+  // ---- -1-- : last packet = true
+  // ---- --00 : defined by uWeave to be 0
+  // 0001 1100 = 0x1C
+  std::vector<uint8_t> p1{0x1C};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+  EXPECT_EQ("", receiver->GetDataMessage());
+
+  std::vector<uint8_t> p2;
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,

[Kyle Horimoto, 2016/06/21 18:13:38]

nit: For this test and the ones below, please just test one thing per test.
Break each of these sub-tests out into its own top-level test. Thanks!

[jingxuy, 2016/06/22 01:42:23]

Done.

+       InappropriateConnectingTypeTest) {

[Kyle Horimoto, 2016/06/21 18:13:38]

Also test that if a packet is received after we've reached an error state that
we remain in an error state.

[jingxuy, 2016/06/22 01:42:24]

Done.

+  BluetoothLowEnergyWeavePacketReceiver::Factory factory;
+
+  // Server receives connection response.
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::SERVER);
+  std::vector<uint8_t> p0{kControlResponseHeader, kWeaveVersion, 0,
+                          kDefaultPacketSize, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Client receives connection request.
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  std::vector<uint8_t> p1{
+      kControlRequestHeader, kWeaveVersion, 0, kWeaveVersion, 0, 0, 0};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Receiving connection close as the first packet.
+  receiver = factory.NewInstance(ReceiverType::SERVER);
+  // uWeave Header:
+  // 1--- ---- : type = 1 (control packet)
+  // -000 ---- : counter = 0
+  // ---- 0010 : command = 2 (close)
+  // 1000 0010 = 0x82
+  std::vector<uint8_t> p2{0x82, 0, 0};
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Receiving data packet as the first packet.
+  receiver = factory.NewInstance(ReceiverType::SERVER);
+  // uWeave Header:
+  // 0--- ---- : type = 0 (data packet)
+  // -000 ---- : counter = 0
+  // ---- 1--- : first packet = true
+  // ---- -0-- : last packet = false
+  // ---- --00 : defined by uWeave to be 0
+  // 0000 1000 = 0x08
+  std::vector<uint8_t> p3{0x08, 'a', 'b', 'c', 'd'};
+  receiver->ReceivePacket(p3);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       ControlPacketSizeTest) {
+  BluetoothLowEnergyWeavePacketReceiver::Factory factory;
+
+  // Connection request missing a byte.
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::SERVER);
+  std::vector<uint8_t> p0{
+      kControlRequestHeader, kWeaveVersion, 0, kWeaveVersion, 0, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Connection response missing a byte.
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  std::vector<uint8_t> p1{kControlResponseHeader, kWeaveVersion, 0,
+                          kDefaultPacketSize};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Max length connection request is accepted.
+  receiver = factory.NewInstance(ReceiverType::SERVER);
+  std::vector<uint8_t> p2(kDefaultPacketSize, 0);
+  p2[0] = kControlRequestHeader;
+  p2[1] = 1;
+  p2[3] = 1;
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+
+  // Connection request that's a byte too long.
+  receiver = factory.NewInstance(ReceiverType::SERVER);
+  p2.push_back(0);
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Max length connection response is accepted.
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  std::vector<uint8_t> p3(kDefaultPacketSize, 0);
+  p3[0] = kControlResponseHeader;
+  p3[1] = 1;
+  p3[3] = kDefaultPacketSize;
+  receiver->ReceivePacket(p3);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+
+  // Connection response that's a byte too long.
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  p3.push_back(0);
+  receiver->ReceivePacket(p3);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       WrongFirstLastBitTest) {
+  BluetoothLowEnergyWeavePacketReceiver::Factory factory;
+  ;

[Kyle Horimoto, 2016/06/21 18:13:38]

nit: Remove ;

[jingxuy, 2016/06/22 01:42:23]

Done.

+
+  // First bit is not set when it's supposed to be with last bit not set.

[Kyle Horimoto, 2016/06/21 18:13:39]

I'm not sure I understand this - can you explain?

[jingxuy, 2016/06/22 01:42:23]

You receive the first packet and first bit and last bit is not set.

The test below is you receive first packet and first bit is not set but the last
bit is set.

+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::SERVER);
+  std::vector<uint8_t> p0{
+      kControlRequestHeader, kWeaveVersion, 0, kWeaveVersion, 0, 0, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+
+  // uWeave Header:
+  // 0--- ---- : type = 0 (data packet)
+  // -001 ---- : counter = 1
+  // ---- 0--- : first packet = false
+  // ---- -0-- : last packet = false
+  // ---- --00 : defined by uWeave to be 0
+  // 0001 0000 = 0x10
+  std::vector<uint8_t> p1{0x10};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::RECEIVED_PACKET_OUT_OF_SEQUENCE,
+            receiver->GetReasonToClose());
+
+  // First bit is not set when it's supposed to be when last bit is set.
+  receiver = factory.NewInstance(ReceiverType::SERVER);
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+
+  // uWeave Header:
+  // 0--- ---- : type = 0 (data packet)
+  // -001 ---- : counter = 1
+  // ---- 0--- : first packet = false
+  // ---- -1-- : last packet = true
+  // ---- --00 : defined by uWeave to be 0
+  // 0001 0100 = 0x14
+  std::vector<uint8_t> p2{0x14};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::RECEIVED_PACKET_OUT_OF_SEQUENCE,
+            receiver->GetReasonToClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       OutOfOrderPacketTest) {
+  BluetoothLowEnergyWeavePacketReceiver::Factory factory;
+
+  // Skip a packet in number.
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::SERVER);
+  std::vector<uint8_t> p0{
+      kControlRequestHeader, kWeaveVersion, 0, kWeaveVersion, 0, 0, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+
+  // uWeave Header:
+  // 0--- ---- : type = 0 (data packet)
+  // -010 ---- : counter = 2
+  // ---- 0--- : first packet = false
+  // ---- -0-- : last packet = false
+  // ---- --00 : defined by uWeave to be 0
+  // 0010 0000 = 0x20
+  std::vector<uint8_t> p1{0x20};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::RECEIVED_PACKET_OUT_OF_SEQUENCE,
+            receiver->GetReasonToClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       IncorrectValuesInControlPacketTest) {
+  BluetoothLowEnergyWeavePacketReceiver::Factory factory;
+
+  // Invalid version in request.
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::SERVER);
+  const uint8_t kWrongVersion = 2;
+  std::vector<uint8_t> p0{
+      kControlRequestHeader, kWrongVersion, 0, kWeaveVersion, 0, 0, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::NO_COMMON_VERSION_SUPPORTED,
+            receiver->GetReasonToClose());
+
+  const uint8_t kSmallMaxPacketSize = 19;
+
+  // Invalid max packet size in request.
+  receiver = factory.NewInstance(ReceiverType::SERVER);
+  std::vector<uint8_t> p1{kControlRequestHeader,
+                          kWeaveVersion,
+                          0,
+                          kWeaveVersion,
+                          0,
+                          kSmallMaxPacketSize,
+                          0};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());

[Kyle Horimoto, 2016/06/21 18:13:38]

Let's make error values for these cases - it seems a lot of them have an
"unknown error" value. I realize that you're just reusing the error values for
the connection close packet, but since this is a class that encapsulates this
logic, we can create our own values.

[jingxuy, 2016/06/22 01:42:23]

GetReasonToClose has to return ReasonForClose because that would be what's
receiver's user sent over a connectionClose packet. We can get our own error
code in addition to ReasonToClose.
Will be a TODO

[Kyle Horimoto, 2016/06/22 01:56:19]

Oops, my mistake. Sounds good.

[jingxuy, 2016/06/22 22:37:43]

Done.

+
+  // Invalid selected version in response.
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  std::vector<uint8_t> p2{kControlResponseHeader, 0, kWeaveVersion,
+                          kDefaultPacketSize, 0};
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::NO_COMMON_VERSION_SUPPORTED,
+            receiver->GetReasonToClose());
+
+  // Invalid selected max packet size in response.
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  std::vector<uint8_t> p3{kControlResponseHeader, kWeaveVersion, 0,
+                          kSmallMaxPacketSize, 0};
+  receiver->ReceivePacket(p3);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Invalid reason for close.
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  std::vector<uint8_t> p4{kControlResponseHeader, kWeaveVersion, 0,
+                          kDefaultPacketSize, 0};
+  receiver->ReceivePacket(p4);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+
+  const uint8_t kInvalidReasonForClose = 5;
+  // uWeave Header:
+  // 1--- ---- : type = 1 (control packet)
+  // -001 ---- : counter = 1
+  // ---- 0010 : command = 2 (close)
+  // 1001 0010 = 0x92
+  std::vector<uint8_t> p5{0x92, kInvalidReasonForClose, 0};
+  receiver->ReceivePacket(p5);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       MaliciousHeaderTest) {
+  BluetoothLowEnergyWeavePacketReceiver::Factory factory;
+
+  // Invalid control command bit 2
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::SERVER);
+  // uWeave Header:
+  // 1--- ---- :  type = 1 (control packet)
+  // -000 ---- : counter = 0
+  // ---- 0100 : command = 4 (INVALID)
+  // 1000 0100 = 0x84
+  std::vector<uint8_t> p0{0x84, kWeaveVersion, 0, kWeaveVersion, 0, 0, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Invalid control command bit 3
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  // uWeave Header:
+  // 1--- ---- :  type = 1 (control packet)
+  // -000 ---- : counter = 0
+  // ---- 1000 : command = 8 (INVALID)
+  // 1000 1000 = 0x88
+  std::vector<uint8_t> p1{0x88, kWeaveVersion, 0, kDefaultPacketSize, 0};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Invalid bit 1 of data packet header
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  std::vector<uint8_t> p2{kControlResponseHeader, kWeaveVersion, 0,
+                          kDefaultPacketSize, 0};
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+
+  // uWeave Header:
+  // 0--- ---- : type = 0 (data packet)
+  // -001 ---- : counter = 1
+  // ---- 1--- : first packet = true
+  // ---- -1-- : last packet = true
+  // ---- --10 : defined by uWeave to be 0, but bit 1 is not
+  // 0001 1110 = 0x1E
+  std::vector<uint8_t> p3{0x1E, 'a'};
+  receiver->ReceivePacket(p3);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Invalid bit 0 of data packet header
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  std::vector<uint8_t> p4{kControlResponseHeader, kWeaveVersion, 0,
+                          kDefaultPacketSize, 0};
+  receiver->ReceivePacket(p4);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+
+  // uWeave Header:
+  // 0--- ---- : type = 0 (data packet)
+  // -001 ---- : counter = 1
+  // ---- 1--- : first packet = true
+  // ---- -1-- : last packet = true
+  // ---- --01 : defined by uWeave to be 0, but bit 0 is not
+  // 0001 1101 = 0x1D
+  std::vector<uint8_t> p5{0x1E, 'a'};
+  receiver->ReceivePacket(p5);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+}
+
+}  // namespace proximity_auth