Mark ProximityAuthBluetoothLowEnergyWeavePacketGeneratorTest flaky

components/proximity_auth/ble/bluetooth_low_energy_weave_packet_receiver_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_receiver.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 28 matching lines @@
 class ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest
     : public testing::Test {
  protected:
   ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(
       ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest);
 };
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       WellBehavingServerPacketsNoControlDataTest) {
+       DISABLED_WellBehavingServerPacketsNoControlDataTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
 
   std::vector<uint8_t> p0{kControlRequestHeader,   kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteSelectMaxPacketSize};
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::WAITING, receiver->GetState());
@@ skipping 39 matching lines @@
   // -100 ---- : counter = 4
   // ---- 0010 : command = 2 (close)
   // 1100 0010 = 0xC2
   // 0x80 is the hex value for APPLICATION_ERROR
   std::vector<uint8_t> p4{0xC2, kEmptyUpperByte, 0x80};
   receiver->ReceivePacket(p4);
   EXPECT_EQ(State::CONNECTION_CLOSED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::APPLICATION_ERROR, receiver->GetReasonForClose());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       WellBehavingServerPacketsWithFullControlDataTest) {
+       DISABLED_WellBehavingServerPacketsWithFullControlDataTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
 
   std::vector<uint8_t> p0{kControlRequestHeader,
                           kEmptyUpperByte,
                           kByteWeaveVersion,
                           kEmptyUpperByte,
                           kByteWeaveVersion,
                           kEmptyUpperByte,
@@ skipping 44 matching lines @@
   // 1--- ---- : type = 1 (control packet)
   // -011 ---- : counter = 3
   // ---- 0010 : command = 2 (close)
   // 1011 0010 = 0xB2
   std::vector<uint8_t> p3{0xB2, kEmptyUpperByte, kCloseWithoutError};
   receiver->ReceivePacket(p3);
   EXPECT_EQ(State::CONNECTION_CLOSED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::CLOSE_WITHOUT_ERROR, receiver->GetReasonForClose());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       WellBehavingServerPacketsWithSomeControlDataTest) {
+       DISABLED_WellBehavingServerPacketsWithSomeControlDataTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
 
   std::vector<uint8_t> p0{kControlRequestHeader,    kEmptyUpperByte,
                           kByteWeaveVersion,        kEmptyUpperByte,
                           kByteWeaveVersion,        kEmptyUpperByte,
                           kByteSelectMaxPacketSize, 'a'};
 
   receiver->ReceivePacket(p0);
@@ skipping 28 matching lines @@
   // 1--- ---- : type = 1 (control packet)
   // -011 ---- : counter = 3
   // ---- 0010 : command = 2 (close)
   // 1011 0010 = 0xB2
   std::vector<uint8_t> p3{0xB2, kEmptyUpperByte, kCloseWithoutError};
   receiver->ReceivePacket(p3);
   EXPECT_EQ(State::CONNECTION_CLOSED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::CLOSE_WITHOUT_ERROR, receiver->GetReasonForClose());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       WellBehavingClientPacketsNoControlDataTest) {
+       DISABLED_WellBehavingClientPacketsNoControlDataTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::CLIENT);
 
   const uint8_t kSelectedPacketSize = 30;
   std::vector<uint8_t> p0{kControlResponseHeader, kEmptyUpperByte,
                           kByteWeaveVersion, kEmptyUpperByte,
                           kSelectedPacketSize};
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::WAITING, receiver->GetState());
@@ skipping 17 matching lines @@
   // 1--- ---- : type = 1 (control packet)
   // -010 ---- : counter = 2
   // ---- 0010 : command = 2 (close)
   // 1010 0010 = 0xA2
   std::vector<uint8_t> p2{0xA2, kEmptyUpperByte, kApplicationError};
   receiver->ReceivePacket(p2);
   EXPECT_EQ(State::CONNECTION_CLOSED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::APPLICATION_ERROR, receiver->GetReasonForClose());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       WellBehavingClientPacketsWithFullControlDataTest) {
+       DISABLED_WellBehavingClientPacketsWithFullControlDataTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::CLIENT);
 
   std::vector<uint8_t> p0{kControlResponseHeader,
                           kEmptyUpperByte,
                           kByteWeaveVersion,
                           kEmptyUpperByte,
                           kByteDefaultMaxPacketSize,
                           'a',
@@ skipping 31 matching lines @@
   // 1--- ---- : type = 1 (control packet)
   // -010 ---- : counter = 2
   // ---- 0010 : command = 2 (close)
   // 1010 0010 = 0xA2
   std::vector<uint8_t> p2{0xA2, kEmptyUpperByte, kCloseWithoutError};
   receiver->ReceivePacket(p2);
   EXPECT_EQ(State::CONNECTION_CLOSED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::CLOSE_WITHOUT_ERROR, receiver->GetReasonForClose());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       WellBehavingClientPacketsWithSomeControlDataTest) {
+       DISABLED_WellBehavingClientPacketsWithSomeControlDataTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::CLIENT);
 
   std::vector<uint8_t> p0{kControlResponseHeader,
                           kEmptyUpperByte,
                           kByteWeaveVersion,
                           kEmptyUpperByte,
                           kByteDefaultMaxPacketSize,
                           'a',
@@ skipping 19 matching lines @@
   // 1--- ---- : type = 1 (control packet)
   // -010 ---- : counter = 2
   // ---- 0010 : command = 2 (close)
   // 1010 0010 = 0xA2
   std::vector<uint8_t> p2{0xA2, kEmptyUpperByte, kCloseWithoutError};
   receiver->ReceivePacket(p2);
   EXPECT_EQ(State::CONNECTION_CLOSED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::CLOSE_WITHOUT_ERROR, receiver->GetReasonForClose());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       LegacyCloseWithoutReasonTest) {
+       DISABLED_LegacyCloseWithoutReasonTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
 
   std::vector<uint8_t> p0{kControlRequestHeader,   kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteSelectMaxPacketSize};
   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());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       OneBytePacketTest) {
+       DISABLED_OneBytePacketTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::CLIENT);
 
   std::vector<uint8_t> p0{kControlResponseHeader, kEmptyUpperByte,
                           kByteWeaveVersion, kEmptyUpperByte,
                           kByteDefaultMaxPacketSize};
   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());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       EmptyPacketTest) {
+       DISABLED_EmptyPacketTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::CLIENT);
 
   std::vector<uint8_t> p0;
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::EMPTY_PACKET, receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       ServerReceivingConnectionResponseTest) {
+       DISABLED_ServerReceivingConnectionResponseTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
   std::vector<uint8_t> p0{kControlResponseHeader, kEmptyUpperByte,
                           kByteWeaveVersion, kEmptyUpperByte,
                           kByteDefaultMaxPacketSize};
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::CLIENT_RECEIVED_CONNECTION_REQUEST,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       ClientReceivingConnectionRequestTest) {
+       DISABLED_ClientReceivingConnectionRequestTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::CLIENT);
   std::vector<uint8_t> p0{kControlRequestHeader,   kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteSelectMaxPacketSize};
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::SERVER_RECEIVED_CONNECTION_RESPONSE,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       ReceiveConnectionCloseInConnecting) {
+       DISABLED_ReceiveConnectionCloseInConnecting) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::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> p0{0x82, kEmptyUpperByte, kCloseWithoutError};
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::RECEIVED_CONNECTION_CLOSE_IN_CONNECTING,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       ReceiveDataInConnecting) {
+       DISABLED_ReceiveDataInConnecting) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::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_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::RECEIVED_DATA_IN_CONNECTING,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       ConnectionRequestTooSmallTest) {
+       DISABLED_ConnectionRequestTooSmallTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
   std::vector<uint8_t> p0{kControlRequestHeader, kEmptyUpperByte,
                           kByteWeaveVersion,     kEmptyUpperByte,
                           kByteWeaveVersion,     kEmptyUpperByte};
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::INVALID_CONNECTION_REQUEST_SIZE,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       ConnectionRequestTooLargeTest) {
+       DISABLED_ConnectionRequestTooLargeTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
 
   std::vector<uint8_t> p0(kByteDefaultMaxPacketSize + 1, 0);
   p0[0] = kControlRequestHeader;
   p0[2] = kByteWeaveVersion;
   p0[4] = kByteWeaveVersion;
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::INVALID_CONNECTION_REQUEST_SIZE,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       ConnectionResponseTooSmallTest) {
+       DISABLED_ConnectionResponseTooSmallTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::CLIENT);
 
   std::vector<uint8_t> p0{kControlResponseHeader, kEmptyUpperByte,
                           kByteWeaveVersion, kEmptyUpperByte};
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::INVALID_CONNECTION_RESPONSE_SIZE,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       ConnectionResponseTooLargeTest) {
+       DISABLED_ConnectionResponseTooLargeTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::CLIENT);
 
   std::vector<uint8_t> p0(kByteDefaultMaxPacketSize + 1, 0);
   p0[0] = kControlResponseHeader;
   p0[2] = kByteWeaveVersion;
   p0[4] = kByteDefaultMaxPacketSize;
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::INVALID_CONNECTION_RESPONSE_SIZE,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       ConnectionCloseTooLargeTest) {
+       DISABLED_ConnectionCloseTooLargeTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
 
   std::vector<uint8_t> p0{kControlRequestHeader,   kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteSelectMaxPacketSize};
   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, kEmptyUpperByte, kCloseWithoutError, 'a'};
   receiver->ReceivePacket(p1);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReceiverError::INVALID_CONNECTION_CLOSE_SIZE,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       DataPacketTooLargeTest) {
+       DISABLED_DataPacketTooLargeTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
 
   std::vector<uint8_t> p0{kControlRequestHeader,   kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteSelectMaxPacketSize};
   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(kByteDefaultMaxPacketSize + 1, 'a');
   p1[0] = 0x1C;
   receiver->ReceivePacket(p1);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::INVALID_DATA_PACKET_SIZE,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       FirstPacketNoFirstNorLastBitTest) {
+       DISABLED_FirstPacketNoFirstNorLastBitTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
 
   std::vector<uint8_t> p0{kControlRequestHeader,   kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteSelectMaxPacketSize};
   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_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::RECEIVED_PACKET_OUT_OF_SEQUENCE,
             receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::INCORRECT_DATA_FIRST_BIT,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       FirstPacketNoFirstYesLastBitTest) {
+       DISABLED_FirstPacketNoFirstYesLastBitTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
 
   std::vector<uint8_t> p0{kControlRequestHeader,   kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteSelectMaxPacketSize};
   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> p1{0x14};
   receiver->ReceivePacket(p1);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::RECEIVED_PACKET_OUT_OF_SEQUENCE,
             receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::INCORRECT_DATA_FIRST_BIT,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       NonFirstPacketYesFirstBitTest) {
+       DISABLED_NonFirstPacketYesFirstBitTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
 
   std::vector<uint8_t> p0{kControlRequestHeader,   kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteSelectMaxPacketSize};
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::WAITING, receiver->GetState());
@@ skipping 18 matching lines @@
   // 0010 1000 = 0x28
   std::vector<uint8_t> p2{0x28};
   receiver->ReceivePacket(p2);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::RECEIVED_PACKET_OUT_OF_SEQUENCE,
             receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::INCORRECT_DATA_FIRST_BIT,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       OutOfOrderPacketTest) {
+       DISABLED_OutOfOrderPacketTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
 
   std::vector<uint8_t> p0{kControlRequestHeader,   kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteSelectMaxPacketSize};
   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_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::RECEIVED_PACKET_OUT_OF_SEQUENCE,
             receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::PACKET_OUT_OF_SEQUENCE,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       InvalidVersionInConnectionRequestTest) {
+       DISABLED_InvalidVersionInConnectionRequestTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
 
   const uint8_t kWrongVersion = 2;
   std::vector<uint8_t> p0{kControlRequestHeader,   kEmptyUpperByte,
                           kWrongVersion,           kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteSelectMaxPacketSize};
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::NO_COMMON_VERSION_SUPPORTED,
             receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::NOT_SUPPORTED_REQUESTED_VERSION,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       InvalidMaxPacketSizeInConnectionRequestTest) {
+       DISABLED_InvalidMaxPacketSizeInConnectionRequestTest) {
   const uint8_t kSmallMaxPacketSize = 19;
 
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
 
   std::vector<uint8_t> p0{kControlRequestHeader, kEmptyUpperByte,
                           kByteWeaveVersion,     kEmptyUpperByte,
                           kByteWeaveVersion,     kEmptyUpperByte,
                           kSmallMaxPacketSize};
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::INVALID_REQUESTED_MAX_PACKET_SIZE,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       InvalidSelectedVersionInConnectionResponseTest) {
+       DISABLED_InvalidSelectedVersionInConnectionResponseTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::CLIENT);
 
   std::vector<uint8_t> p0{kControlResponseHeader, kByteWeaveVersion,
                           kEmptyUpperByte, kEmptyUpperByte,
                           kByteDefaultMaxPacketSize};
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::NO_COMMON_VERSION_SUPPORTED,
             receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::NOT_SUPPORTED_SELECTED_VERSION,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       InvalidSelectedMaxPacketSizeInConnectionResponseTest) {
+       DISABLED_InvalidSelectedMaxPacketSizeInConnectionResponseTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::CLIENT);
 
   const uint8_t kSmallMaxPacketSize = 19;
   std::vector<uint8_t> p0{kControlResponseHeader, kEmptyUpperByte,
                           kByteWeaveVersion, kEmptyUpperByte,
                           kSmallMaxPacketSize};
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::INVALID_SELECTED_MAX_PACKET_SIZE,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       UnrecognizedReasonForCloseInConnectionCloseTest) {
+       DISABLED_UnrecognizedReasonForCloseInConnectionCloseTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::CLIENT);
 
   std::vector<uint8_t> p0{kControlResponseHeader, kEmptyUpperByte,
                           kByteWeaveVersion, kEmptyUpperByte,
                           kByteDefaultMaxPacketSize};
   receiver->ReceivePacket(p0);
   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> p1{0x92, kEmptyUpperByte, kInvalidReasonForClose};
   receiver->ReceivePacket(p1);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::UNRECOGNIZED_REASON_FOR_CLOSE,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       UnrecognizedControlCommandBitTwoTest) {
+       DISABLED_UnrecognizedControlCommandBitTwoTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::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,
                           kEmptyUpperByte,
                           kByteWeaveVersion,
                           kEmptyUpperByte,
                           kByteWeaveVersion,
                           kEmptyUpperByte,
                           kByteSelectMaxPacketSize};
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::UNRECOGNIZED_CONTROL_COMMAND,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       InvalidControlCommandBitThreeTest) {
+       DISABLED_InvalidControlCommandBitThreeTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::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> p0{0x88, kEmptyUpperByte, kByteWeaveVersion,
                           kEmptyUpperByte, kByteDefaultMaxPacketSize};
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::UNRECOGNIZED_CONTROL_COMMAND,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       InvalidBitOneInDataPacketHeaderTest) {
+       DISABLED_InvalidBitOneInDataPacketHeaderTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::CLIENT);
 
   std::vector<uint8_t> p0{kControlResponseHeader, kEmptyUpperByte,
                           kByteWeaveVersion, kEmptyUpperByte,
                           kByteDefaultMaxPacketSize};
   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
   // ---- --10 : defined by uWeave to be 0, but bit 1 is not
   // 0001 1110 = 0x1E
   std::vector<uint8_t> p1{0x1E, 'a'};
   receiver->ReceivePacket(p1);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::DATA_HEADER_LOW_BITS_NOT_CLEARED,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       InvalidBitZeroInDataPacketHeaderTest) {
+       DISABLED_InvalidBitZeroInDataPacketHeaderTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::CLIENT);
 
   std::vector<uint8_t> p0{kControlResponseHeader, kEmptyUpperByte,
                           kByteWeaveVersion, kEmptyUpperByte,
                           kByteDefaultMaxPacketSize};
   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
   // ---- --01 : defined by uWeave to be 0, but bit 0 is not
   // 0001 1101 = 0x1D
   std::vector<uint8_t> p1{0x1D, 'a'};
   receiver->ReceivePacket(p1);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::DATA_HEADER_LOW_BITS_NOT_CLEARED,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       ReceivedPacketInErrorState) {
+       DISABLED_ReceivedPacketInErrorState) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::CLIENT);
 
   std::vector<uint8_t> p0;
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
 
   std::vector<uint8_t> p1{kControlResponseHeader, kEmptyUpperByte,
                           kByteWeaveVersion, kEmptyUpperByte,
                           kByteSelectMaxPacketSize};
   receiver->ReceivePacket(p1);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::EMPTY_PACKET, receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       ReceivedPacketInConnectionClosedStateTest) {
+       DISABLED_ReceivedPacketInConnectionClosedStateTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
 
   std::vector<uint8_t> p0{kControlRequestHeader,   kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteSelectMaxPacketSize};
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::WAITING, receiver->GetState());
@@ skipping 16 matching lines @@
   // ---- --00 : defined by uWeave to be 0
   // 0010 1100 = 0x2C
   std::vector<uint8_t> p2{0x2C, 'a'};
   receiver->ReceivePacket(p2);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::RECEIVED_PACKET_IN_CONNECTION_CLOSED,
             receiver->GetReceiverError());
 }
 
+// TODO(http://crbug.com/651246) this test is flaky.
 TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
-       MultipleControlPacketTest) {
+       DISABLED_MultipleControlPacketTest) {
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
       BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
           ReceiverType::SERVER);
 
   std::vector<uint8_t> p0{kControlRequestHeader,   kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteWeaveVersion,       kEmptyUpperByte,
                           kByteSelectMaxPacketSize};
   receiver->ReceivePacket(p0);
   EXPECT_EQ(State::WAITING, receiver->GetState());
@@ skipping 13 matching lines @@
   receiver->ReceivePacket(p1);
   EXPECT_EQ(State::ERROR_DETECTED, receiver->GetState());
   EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
   EXPECT_EQ(ReceiverError::INVALID_CONTROL_COMMAND_IN_DATA_TRANSACTION,
             receiver->GetReceiverError());
 }
 
 }  // namespace weave
 
 }  // namespace proximity_auth