work in progress 2

content/browser/bluetooth/bluetooth_device_chooser_controller_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 "content/browser/bluetooth/bluetooth_device_chooser_controller.h"
+
+#include "base/memory/ptr_util.h"
+#include "base/memory/ref_counted.h"
+#include "content/browser/bluetooth/web_bluetooth_service_impl.h"
+#include "content/test/test_render_view_host.h"
+#include "content/test/test_web_contents.h"
+#include "device/bluetooth/bluetooth_gatt_connection.h"
+#include "device/bluetooth/test/mock_bluetooth_adapter.h"
+#include "device/bluetooth/test/mock_bluetooth_device.h"
+#include "device/bluetooth/test/mock_bluetooth_gatt_connection.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#include "base/logging.h"
+
 namespace content {
 
-class BluetoothDeviceChooserControllerTest : public testing::Test {};
+typedef testing::NiceMock<device::MockBluetoothAdapter>
+    NiceMockBluetoothAdapter;
+typedef testing::NiceMock<device::MockBluetoothDevice> NiceMockBluetoothDevice;
+//typedef testing::NiceMock<device::MockBluetoothGattConnection>
+//    NiceMockBluetoothGattConnection;
 
+//using testing::Return;
+//using testing::StrEq;
+//using testing::_;
+
+namespace {
+
+const WebBluetoothDeviceId kDeviceId("000000000000000000000A==");
+constexpr char kDeviceAddress[] = "0";
+constexpr char kDeviceName[] = "Device0";  
+
+} // namespace
+
+// class BluetoothDeviceChooserControllerTest : public testing::Test {};
+class BluetoothDeviceChooserControllerTest
+    : public RenderViewHostImplTestHarness {
+ public:
+  BluetoothDeviceChooserControllerTest()
+      : adapter_(new NiceMockBluetoothAdapter()),
+        device_(adapter_.get(),
+                 0 /* class */,
+                 kDeviceName,
+                 kDeviceAddress,
+                 false /* paired */,
+                 false /* connected */) {
+    LOG(ERROR) << "[DJKim] BluetoothDeviceChooserControllerTest::BluetoothDeviceChooserControllerTest";
+    //ON_CALL(*adapter_, GetDevice(_)).WillByDefault(Return(nullptr));
+    //ON_CALL(*adapter_, GetDevice(StrEq(kDeviceAddress)))
+    //    .WillByDefault(Return(&device_));
+  }
+
+  ~BluetoothDeviceChooserControllerTest() override {}
+
+  void SetUp() override {
+    LOG(ERROR) << "[DJKim] BluetoothDeviceChooserControllerTest::SetUp";
+    RenderViewHostImplTestHarness::SetUp();
+
+    // Create subframe to simulate two maps on the same WebContents.
+    // contents()->GetMainFrame()->InitializeRenderFrameIfNeeded();
+    //TestRenderFrameHost* subframe =
+    //    contents()->GetMainFrame()->AppendChild("bluetooth_frame");
+    //subframe->InitializeRenderFrameIfNeeded();
+
+    service_ =
+        contents()->GetMainFrame()->CreateWebBluetoothServiceForTesting();
+
+    //contents()->GetMainFrame()->SimulateRequestDevice(service_);
+    //controller_ = new BluetoothDeviceChooserController(service_, contents()->GetMainFrame(), adapter_.get());
+    //service_->DeviceAdded(adapter_.get(), &device_);
+
+    //service_->SimulateRequestDevice();
+  }
+
+  void TearDown() override {
+    LOG(ERROR) << "[DJKim] BluetoothDeviceChooserControllerTest::TearDown";
+    service_ = nullptr;
+    RenderViewHostImplTestHarness::TearDown();
+  }
+
+  //std::unique_ptr<NiceMockBluetoothGattConnection> GetConnection(
+  //    const std::string& address) {
+  //  LOG(ERROR) << "[DJKim] BluetoothDeviceChooserControllerTest::GetConnection";
+  //  return base::MakeUnique<NiceMockBluetoothGattConnection>(adapter_.get(),
+  //                                                           address);
+  //}
+
+  void StartDeviceDiscovery() {
+    controller_->StartDeviceDiscoveryForTesting();
+  }
+  void AdapterDiscoveringChanged(bool discovering) {
+    LOG(ERROR) << "[DJKim] BluetoothDeviceChooserControllerTest::AdapterDiscoveringChanged";
+    service_->AdapterDiscoveringChanged(adapter_.get(), discovering);
+  }
+
+  bool IsDiscoverySessionActive() {
+    return service_->IsDiscoverySessionActive();
+  }
+
+ private:
+  WebBluetoothServiceImpl* service_;
+  scoped_refptr<NiceMockBluetoothAdapter> adapter_;
+  NiceMockBluetoothDevice device_;
+  BluetoothDeviceChooserController* controller_;
+};
+
+#if 0
 TEST_F(BluetoothDeviceChooserControllerTest, CalculateSignalStrengthLevel) {
   EXPECT_EQ(
       0, BluetoothDeviceChooserController::CalculateSignalStrengthLevel(-128));
   EXPECT_EQ(
       0, BluetoothDeviceChooserController::CalculateSignalStrengthLevel(-72));
 
   EXPECT_EQ(
       1, BluetoothDeviceChooserController::CalculateSignalStrengthLevel(-71));
   EXPECT_EQ(
       1, BluetoothDeviceChooserController::CalculateSignalStrengthLevel(-64));
 
   EXPECT_EQ(
       2, BluetoothDeviceChooserController::CalculateSignalStrengthLevel(-63));
   EXPECT_EQ(
       2, BluetoothDeviceChooserController::CalculateSignalStrengthLevel(-56));
 
   EXPECT_EQ(
       3, BluetoothDeviceChooserController::CalculateSignalStrengthLevel(-55));
   EXPECT_EQ(
       3, BluetoothDeviceChooserController::CalculateSignalStrengthLevel(-48));
 
   EXPECT_EQ(
       4, BluetoothDeviceChooserController::CalculateSignalStrengthLevel(-47));
   EXPECT_EQ(
       4, BluetoothDeviceChooserController::CalculateSignalStrengthLevel(127));
 }
+#endif
+
+TEST_F(BluetoothDeviceChooserControllerTest, AdapterDiscoveringChanged) {
+  LOG(ERROR) << "[DJKim] BluetoothDeviceChooserControllerTest::AdapterDiscoveringChanged start";
+  StartDeviceDiscovery();
+  EXPECT_TRUE(IsDiscoverySessionActive());
+  AdapterDiscoveringChanged(true);
+  EXPECT_FALSE(IsDiscoverySessionActive());
+}
 
 }  // namespace content