Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(2440)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: device/devices_app/usb/device_impl_unittest.cc

Issue 1682363002: Remove //device/devices_app. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Remove two files that somehow survived in //device/devices_app. Created 4 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « device/devices_app/usb/device_impl.cc ('k') | device/devices_app/usb/device_manager_impl.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: device/devices_app/usb/device_impl_unittest.cc
diff --git a/device/devices_app/usb/device_impl_unittest.cc b/device/devices_app/usb/device_impl_unittest.cc
deleted file mode 100644
index b98d330fd3eb75683df1658f8f7446e54597a8cb..0000000000000000000000000000000000000000
--- a/device/devices_app/usb/device_impl_unittest.cc
+++ /dev/null
@@ -1,895 +0,0 @@
-// 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 "device/devices_app/usb/device_impl.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <map>
-#include <numeric>
-#include <queue>
-#include <set>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/macros.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/stl_util.h"
-#include "device/devices_app/usb/fake_permission_provider.h"
-#include "device/usb/mock_usb_device.h"
-#include "device/usb/mock_usb_device_handle.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
-#include "net/base/io_buffer.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::testing::Invoke;
-using ::testing::_;
-
-namespace device {
-namespace usb {
-
-namespace {
-
-class ConfigBuilder {
- public:
- explicit ConfigBuilder(uint8_t value) { config_.configuration_value = value; }
-
- ConfigBuilder& AddInterface(uint8_t interface_number,
- uint8_t alternate_setting,
- uint8_t class_code,
- uint8_t subclass_code,
- uint8_t protocol_code) {
- UsbInterfaceDescriptor interface;
- interface.interface_number = interface_number;
- interface.alternate_setting = alternate_setting;
- interface.interface_class = class_code;
- interface.interface_subclass = subclass_code;
- interface.interface_protocol = protocol_code;
- config_.interfaces.push_back(interface);
- return *this;
- }
-
- const UsbConfigDescriptor& config() const { return config_; }
-
- private:
- UsbConfigDescriptor config_;
-};
-
-void ExpectOpenAndThen(OpenDeviceError expected,
- const base::Closure& continuation,
- OpenDeviceError error) {
- EXPECT_EQ(expected, error);
- continuation.Run();
-}
-
-void ExpectDeviceInfoAndThen(const std::string& guid,
- uint16_t vendor_id,
- uint16_t product_id,
- const std::string& manufacturer_name,
- const std::string& product_name,
- const std::string& serial_number,
- const base::Closure& continuation,
- DeviceInfoPtr device_info) {
- EXPECT_EQ(guid, device_info->guid);
- EXPECT_EQ(vendor_id, device_info->vendor_id);
- EXPECT_EQ(product_id, device_info->product_id);
- EXPECT_EQ(manufacturer_name, device_info->manufacturer_name);
- EXPECT_EQ(product_name, device_info->product_name);
- EXPECT_EQ(serial_number, device_info->serial_number);
- continuation.Run();
-}
-
-void ExpectResultAndThen(bool expected_result,
- const base::Closure& continuation,
- bool actual_result) {
- EXPECT_EQ(expected_result, actual_result);
- continuation.Run();
-}
-
-void ExpectTransferInAndThen(TransferStatus expected_status,
- const std::vector<uint8_t>& expected_bytes,
- const base::Closure& continuation,
- TransferStatus actual_status,
- mojo::Array<uint8_t> actual_bytes) {
- EXPECT_EQ(expected_status, actual_status);
- ASSERT_EQ(expected_bytes.size(), actual_bytes.size());
- for (size_t i = 0; i < actual_bytes.size(); ++i) {
- EXPECT_EQ(expected_bytes[i], actual_bytes[i])
- << "Contents differ at index: " << i;
- }
- continuation.Run();
-}
-
-void ExpectPacketsOutAndThen(const std::vector<uint32_t>& expected_packets,
- const base::Closure& continuation,
- mojo::Array<IsochronousPacketPtr> actual_packets) {
- ASSERT_EQ(expected_packets.size(), actual_packets.size());
- for (size_t i = 0; i < expected_packets.size(); ++i) {
- EXPECT_EQ(expected_packets[i], actual_packets[i]->transferred_length)
- << "Packet lengths differ at index: " << i;
- EXPECT_EQ(TransferStatus::COMPLETED, actual_packets[i]->status)
- << "Packet at index " << i << " not completed.";
- }
- continuation.Run();
-}
-
-void ExpectPacketsInAndThen(const std::vector<uint8_t>& expected_bytes,
- const std::vector<uint32_t>& expected_packets,
- const base::Closure& continuation,
- mojo::Array<uint8_t> actual_bytes,
- mojo::Array<IsochronousPacketPtr> actual_packets) {
- ASSERT_EQ(expected_packets.size(), actual_packets.size());
- for (size_t i = 0; i < expected_packets.size(); ++i) {
- EXPECT_EQ(expected_packets[i], actual_packets[i]->transferred_length)
- << "Packet lengths differ at index: " << i;
- EXPECT_EQ(TransferStatus::COMPLETED, actual_packets[i]->status)
- << "Packet at index " << i << " not completed.";
- }
- ASSERT_EQ(expected_bytes.size(), actual_bytes.size());
- for (size_t i = 0; i < expected_bytes.size(); ++i) {
- EXPECT_EQ(expected_bytes[i], actual_bytes[i])
- << "Contents differ at index: " << i;
- }
- continuation.Run();
-}
-
-void ExpectTransferStatusAndThen(TransferStatus expected_status,
- const base::Closure& continuation,
- TransferStatus actual_status) {
- EXPECT_EQ(expected_status, actual_status);
- continuation.Run();
-}
-
-class USBDeviceImplTest : public testing::Test {
- public:
- USBDeviceImplTest()
- : message_loop_(new base::MessageLoop),
- is_device_open_(false),
- allow_reset_(false),
- current_config_(0) {}
-
- ~USBDeviceImplTest() override {}
-
- protected:
- MockUsbDevice& mock_device() { return *mock_device_.get(); }
- bool is_device_open() const { return is_device_open_; }
- MockUsbDeviceHandle& mock_handle() { return *mock_handle_.get(); }
-
- void set_allow_reset(bool allow_reset) { allow_reset_ = allow_reset; }
-
- // Creates a mock device and binds a Device proxy to a Device service impl
- // wrapping the mock device.
- DevicePtr GetMockDeviceProxy(uint16_t vendor_id,
- uint16_t product_id,
- const std::string& manufacturer,
- const std::string& product,
- const std::string& serial) {
- mock_device_ =
- new MockUsbDevice(vendor_id, product_id, manufacturer, product, serial);
- mock_handle_ = new MockUsbDeviceHandle(mock_device_.get());
-
- PermissionProviderPtr permission_provider;
- permission_provider_.Bind(mojo::GetProxy(&permission_provider));
- DevicePtr proxy;
- new DeviceImpl(mock_device_, std::move(permission_provider),
- mojo::GetProxy(&proxy));
-
- // Set up mock handle calls to respond based on mock device configs
- // established by the test.
- ON_CALL(mock_device(), Open(_))
- .WillByDefault(Invoke(this, &USBDeviceImplTest::OpenMockHandle));
- ON_CALL(mock_device(), GetActiveConfiguration())
- .WillByDefault(
- Invoke(this, &USBDeviceImplTest::GetActiveConfiguration));
- ON_CALL(mock_handle(), Close())
- .WillByDefault(Invoke(this, &USBDeviceImplTest::CloseMockHandle));
- ON_CALL(mock_handle(), SetConfiguration(_, _))
- .WillByDefault(Invoke(this, &USBDeviceImplTest::SetConfiguration));
- ON_CALL(mock_handle(), ClaimInterface(_, _))
- .WillByDefault(Invoke(this, &USBDeviceImplTest::ClaimInterface));
- ON_CALL(mock_handle(), ReleaseInterface(_, _))
- .WillByDefault(Invoke(this, &USBDeviceImplTest::ReleaseInterface));
- ON_CALL(mock_handle(), SetInterfaceAlternateSetting(_, _, _))
- .WillByDefault(
- Invoke(this, &USBDeviceImplTest::SetInterfaceAlternateSetting));
- ON_CALL(mock_handle(), ResetDevice(_))
- .WillByDefault(Invoke(this, &USBDeviceImplTest::ResetDevice));
- ON_CALL(mock_handle(), ControlTransfer(_, _, _, _, _, _, _, _, _, _))
- .WillByDefault(Invoke(this, &USBDeviceImplTest::ControlTransfer));
- ON_CALL(mock_handle(), GenericTransfer(_, _, _, _, _, _))
- .WillByDefault(Invoke(this, &USBDeviceImplTest::GenericTransfer));
- ON_CALL(mock_handle(), IsochronousTransferIn(_, _, _, _))
- .WillByDefault(Invoke(this, &USBDeviceImplTest::IsochronousTransferIn));
- ON_CALL(mock_handle(), IsochronousTransferOut(_, _, _, _, _))
- .WillByDefault(
- Invoke(this, &USBDeviceImplTest::IsochronousTransferOut));
-
- return proxy;
- }
-
- DevicePtr GetMockDeviceProxy() {
- return GetMockDeviceProxy(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF");
- }
-
- void AddMockConfig(const ConfigBuilder& builder) {
- const UsbConfigDescriptor& config = builder.config();
- DCHECK(!ContainsKey(mock_configs_, config.configuration_value));
- mock_configs_[config.configuration_value] = config;
- }
-
- void AddMockInboundData(const std::vector<uint8_t>& data) {
- mock_inbound_data_.push(data);
- }
-
- void AddMockInboundPackets(
- const std::vector<uint8_t>& data,
- const std::vector<UsbDeviceHandle::IsochronousPacket>& packets) {
- mock_inbound_data_.push(data);
- mock_inbound_packets_.push(packets);
- }
-
- void AddMockOutboundData(const std::vector<uint8_t>& data) {
- mock_outbound_data_.push(data);
- }
-
- void AddMockOutboundPackets(
- const std::vector<uint8_t>& data,
- const std::vector<UsbDeviceHandle::IsochronousPacket>& packets) {
- mock_outbound_data_.push(data);
- mock_outbound_packets_.push(packets);
- }
-
- private:
- void OpenMockHandle(const UsbDevice::OpenCallback& callback) {
- EXPECT_FALSE(is_device_open_);
- is_device_open_ = true;
- callback.Run(mock_handle_);
- }
-
- void CloseMockHandle() {
- EXPECT_TRUE(is_device_open_);
- is_device_open_ = false;
- }
-
- const UsbConfigDescriptor* GetActiveConfiguration() {
- if (current_config_ == 0) {
- return nullptr;
- } else {
- const auto it = mock_configs_.find(current_config_);
- EXPECT_TRUE(it != mock_configs_.end());
- return &it->second;
- }
- }
-
- void SetConfiguration(uint8_t value,
- const UsbDeviceHandle::ResultCallback& callback) {
- if (mock_configs_.find(value) != mock_configs_.end()) {
- current_config_ = value;
- callback.Run(true);
- } else {
- callback.Run(false);
- }
- }
-
- void ClaimInterface(uint8_t interface_number,
- const UsbDeviceHandle::ResultCallback& callback) {
- for (const auto& config : mock_configs_) {
- for (const auto& interface : config.second.interfaces) {
- if (interface.interface_number == interface_number) {
- claimed_interfaces_.insert(interface_number);
- callback.Run(true);
- return;
- }
- }
- }
- callback.Run(false);
- }
-
- void ReleaseInterface(uint8_t interface_number,
- const UsbDeviceHandle::ResultCallback& callback) {
- if (ContainsKey(claimed_interfaces_, interface_number)) {
- claimed_interfaces_.erase(interface_number);
- callback.Run(true);
- } else {
- callback.Run(false);
- }
- }
-
- void SetInterfaceAlternateSetting(
- uint8_t interface_number,
- uint8_t alternate_setting,
- const UsbDeviceHandle::ResultCallback& callback) {
- for (const auto& config : mock_configs_) {
- for (const auto& interface : config.second.interfaces) {
- if (interface.interface_number == interface_number &&
- interface.alternate_setting == alternate_setting) {
- callback.Run(true);
- return;
- }
- }
- }
- callback.Run(false);
- }
-
- void ResetDevice(const UsbDeviceHandle::ResultCallback& callback) {
- callback.Run(allow_reset_);
- }
-
- void InboundTransfer(const UsbDeviceHandle::TransferCallback& callback) {
- ASSERT_GE(mock_inbound_data_.size(), 1u);
- const std::vector<uint8_t>& bytes = mock_inbound_data_.front();
- size_t length = bytes.size();
- scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(length);
- std::copy(bytes.begin(), bytes.end(), buffer->data());
- mock_inbound_data_.pop();
- callback.Run(USB_TRANSFER_COMPLETED, buffer, length);
- }
-
- void OutboundTransfer(scoped_refptr<net::IOBuffer> buffer,
- size_t length,
- const UsbDeviceHandle::TransferCallback& callback) {
- ASSERT_GE(mock_outbound_data_.size(), 1u);
- const std::vector<uint8_t>& bytes = mock_outbound_data_.front();
- ASSERT_EQ(bytes.size(), length);
- for (size_t i = 0; i < length; ++i) {
- EXPECT_EQ(bytes[i], buffer->data()[i])
- << "Contents differ at index: " << i;
- }
- mock_outbound_data_.pop();
- callback.Run(USB_TRANSFER_COMPLETED, buffer, length);
- }
-
- void ControlTransfer(UsbEndpointDirection direction,
- UsbDeviceHandle::TransferRequestType request_type,
- UsbDeviceHandle::TransferRecipient recipient,
- uint8_t request,
- uint16_t value,
- uint16_t index,
- scoped_refptr<net::IOBuffer> buffer,
- size_t length,
- unsigned int timeout,
- const UsbDeviceHandle::TransferCallback& callback) {
- if (direction == USB_DIRECTION_INBOUND)
- InboundTransfer(callback);
- else
- OutboundTransfer(buffer, length, callback);
- }
-
- void GenericTransfer(UsbEndpointDirection direction,
- uint8_t endpoint,
- scoped_refptr<net::IOBuffer> buffer,
- size_t length,
- unsigned int timeout,
- const UsbDeviceHandle::TransferCallback& callback) {
- if (direction == USB_DIRECTION_INBOUND)
- InboundTransfer(callback);
- else
- OutboundTransfer(buffer, length, callback);
- }
-
- void IsochronousTransferIn(
- uint8_t endpoint_number,
- const std::vector<uint32_t>& packet_lengths,
- unsigned int timeout,
- const UsbDeviceHandle::IsochronousTransferCallback& callback) {
- ASSERT_FALSE(mock_inbound_data_.empty());
- const std::vector<uint8_t>& bytes = mock_inbound_data_.front();
- size_t length = bytes.size();
- scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(length);
- std::copy(bytes.begin(), bytes.end(), buffer->data());
- mock_inbound_data_.pop();
-
- ASSERT_FALSE(mock_inbound_packets_.empty());
- std::vector<UsbDeviceHandle::IsochronousPacket> packets =
- mock_inbound_packets_.front();
- ASSERT_EQ(packets.size(), packet_lengths.size());
- for (size_t i = 0; i < packets.size(); ++i) {
- EXPECT_EQ(packets[i].length, packet_lengths[i])
- << "Packet lengths differ at index: " << i;
- }
- mock_inbound_packets_.pop();
-
- callback.Run(buffer, packets);
- }
-
- void IsochronousTransferOut(
- uint8_t endpoint_number,
- scoped_refptr<net::IOBuffer> buffer,
- const std::vector<uint32_t>& packet_lengths,
- unsigned int timeout,
- const UsbDeviceHandle::IsochronousTransferCallback& callback) {
- ASSERT_FALSE(mock_outbound_data_.empty());
- const std::vector<uint8_t>& bytes = mock_outbound_data_.front();
- size_t length =
- std::accumulate(packet_lengths.begin(), packet_lengths.end(), 0u);
- ASSERT_EQ(bytes.size(), length);
- for (size_t i = 0; i < length; ++i) {
- EXPECT_EQ(bytes[i], buffer->data()[i]) << "Contents differ at index: "
- << i;
- }
- mock_outbound_data_.pop();
-
- ASSERT_FALSE(mock_outbound_packets_.empty());
- std::vector<UsbDeviceHandle::IsochronousPacket> packets =
- mock_outbound_packets_.front();
- ASSERT_EQ(packets.size(), packet_lengths.size());
- for (size_t i = 0; i < packets.size(); ++i) {
- EXPECT_EQ(packets[i].length, packet_lengths[i])
- << "Packet lengths differ at index: " << i;
- }
- mock_outbound_packets_.pop();
-
- callback.Run(buffer, packets);
- }
-
- scoped_ptr<base::MessageLoop> message_loop_;
- scoped_refptr<MockUsbDevice> mock_device_;
- scoped_refptr<MockUsbDeviceHandle> mock_handle_;
- bool is_device_open_;
- bool allow_reset_;
-
- std::map<uint8_t, UsbConfigDescriptor> mock_configs_;
- uint8_t current_config_;
-
- std::queue<std::vector<uint8_t>> mock_inbound_data_;
- std::queue<std::vector<uint8_t>> mock_outbound_data_;
- std::queue<std::vector<UsbDeviceHandle::IsochronousPacket>>
- mock_inbound_packets_;
- std::queue<std::vector<UsbDeviceHandle::IsochronousPacket>>
- mock_outbound_packets_;
-
- std::set<uint8_t> claimed_interfaces_;
-
- FakePermissionProvider permission_provider_;
-
- DISALLOW_COPY_AND_ASSIGN(USBDeviceImplTest);
-};
-
-} // namespace
-
-TEST_F(USBDeviceImplTest, Open) {
- DevicePtr device = GetMockDeviceProxy();
-
- EXPECT_FALSE(is_device_open());
-
- EXPECT_CALL(mock_device(), Open(_));
-
- base::RunLoop loop;
- device->Open(
- base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK, loop.QuitClosure()));
- loop.Run();
-
- EXPECT_CALL(mock_handle(), Close());
-}
-
-TEST_F(USBDeviceImplTest, Close) {
- DevicePtr device = GetMockDeviceProxy();
-
- EXPECT_FALSE(is_device_open());
-
- EXPECT_CALL(mock_device(), Open(_));
-
- {
- base::RunLoop loop;
- device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
- loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), Close());
-
- {
- base::RunLoop loop;
- device->Close(loop.QuitClosure());
- loop.Run();
- }
-
- EXPECT_FALSE(is_device_open());
-}
-
-// Test that the information returned via the Device::GetDeviceInfo matches that
-// of the underlying device.
-TEST_F(USBDeviceImplTest, GetDeviceInfo) {
- DevicePtr device =
- GetMockDeviceProxy(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF");
-
- base::RunLoop loop;
- device->GetDeviceInfo(base::Bind(&ExpectDeviceInfoAndThen,
- mock_device().guid(), 0x1234, 0x5678, "ACME",
- "Frobinator", "ABCDEF", loop.QuitClosure()));
- loop.Run();
-}
-
-TEST_F(USBDeviceImplTest, SetInvalidConfiguration) {
- DevicePtr device = GetMockDeviceProxy();
-
- EXPECT_CALL(mock_device(), Open(_));
-
- {
- base::RunLoop loop;
- device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
- loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), SetConfiguration(42, _));
-
- {
- // SetConfiguration should fail because 42 is not a valid mock
- // configuration.
- base::RunLoop loop;
- device->SetConfiguration(
- 42, base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), Close());
-}
-
-TEST_F(USBDeviceImplTest, SetValidConfiguration) {
- DevicePtr device = GetMockDeviceProxy();
-
- EXPECT_CALL(mock_device(), Open(_));
-
- {
- base::RunLoop loop;
- device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
- loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), SetConfiguration(42, _));
-
- AddMockConfig(ConfigBuilder(42));
-
- {
- // SetConfiguration should succeed because 42 is a valid mock configuration.
- base::RunLoop loop;
- device->SetConfiguration(
- 42, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), Close());
-}
-
-// Verify that the result of Reset() reflects the underlying UsbDeviceHandle's
-// ResetDevice() result.
-TEST_F(USBDeviceImplTest, Reset) {
- DevicePtr device = GetMockDeviceProxy();
-
- EXPECT_CALL(mock_device(), Open(_));
-
- {
- base::RunLoop loop;
- device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
- loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), ResetDevice(_));
-
- set_allow_reset(true);
-
- {
- base::RunLoop loop;
- device->Reset(base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), ResetDevice(_));
-
- set_allow_reset(false);
-
- {
- base::RunLoop loop;
- device->Reset(base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), Close());
-}
-
-TEST_F(USBDeviceImplTest, ClaimAndReleaseInterface) {
- DevicePtr device = GetMockDeviceProxy();
-
- EXPECT_CALL(mock_device(), Open(_));
-
- {
- base::RunLoop loop;
- device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
- loop.QuitClosure()));
- loop.Run();
- }
-
- // Now add a mock interface #1.
- AddMockConfig(ConfigBuilder(1).AddInterface(1, 0, 1, 2, 3));
-
- EXPECT_CALL(mock_handle(), SetConfiguration(1, _));
-
- {
- base::RunLoop loop;
- device->SetConfiguration(
- 1, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_device(), GetActiveConfiguration());
- EXPECT_CALL(mock_handle(), ClaimInterface(2, _));
-
- {
- // Try to claim an invalid interface and expect failure.
- base::RunLoop loop;
- device->ClaimInterface(
- 2, base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_device(), GetActiveConfiguration());
- EXPECT_CALL(mock_handle(), ClaimInterface(1, _));
-
- {
- base::RunLoop loop;
- device->ClaimInterface(
- 1, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), ReleaseInterface(2, _));
-
- {
- // Releasing a non-existent interface should fail.
- base::RunLoop loop;
- device->ReleaseInterface(
- 2, base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), ReleaseInterface(1, _));
-
- {
- // Now this should release the claimed interface and close the handle.
- base::RunLoop loop;
- device->ReleaseInterface(
- 1, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), Close());
-}
-
-TEST_F(USBDeviceImplTest, SetInterfaceAlternateSetting) {
- DevicePtr device = GetMockDeviceProxy();
-
- EXPECT_CALL(mock_device(), Open(_));
-
- {
- base::RunLoop loop;
- device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
- loop.QuitClosure()));
- loop.Run();
- }
-
- AddMockConfig(ConfigBuilder(1)
- .AddInterface(1, 0, 1, 2, 3)
- .AddInterface(1, 42, 1, 2, 3)
- .AddInterface(2, 0, 1, 2, 3));
-
- EXPECT_CALL(mock_handle(), SetInterfaceAlternateSetting(1, 42, _));
-
- {
- base::RunLoop loop;
- device->SetInterfaceAlternateSetting(
- 1, 42, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), SetInterfaceAlternateSetting(1, 100, _));
-
- {
- base::RunLoop loop;
- device->SetInterfaceAlternateSetting(
- 1, 100, base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), Close());
-}
-
-TEST_F(USBDeviceImplTest, ControlTransfer) {
- DevicePtr device = GetMockDeviceProxy();
-
- EXPECT_CALL(mock_device(), Open(_));
-
- {
- base::RunLoop loop;
- device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
- loop.QuitClosure()));
- loop.Run();
- }
-
- AddMockConfig(ConfigBuilder(1).AddInterface(7, 0, 1, 2, 3));
-
- EXPECT_CALL(mock_device(), GetActiveConfiguration());
- EXPECT_CALL(mock_handle(), SetConfiguration(1, _));
-
- {
- base::RunLoop loop;
- device->SetConfiguration(
- 1, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
- loop.Run();
- }
-
- std::vector<uint8_t> fake_data;
- fake_data.push_back(41);
- fake_data.push_back(42);
- fake_data.push_back(43);
-
- AddMockInboundData(fake_data);
-
- EXPECT_CALL(mock_handle(),
- ControlTransfer(USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD,
- UsbDeviceHandle::DEVICE, 5, 6, 7, _, _, 0, _));
-
- {
- auto params = ControlTransferParams::New();
- params->type = ControlTransferType::STANDARD;
- params->recipient = ControlTransferRecipient::DEVICE;
- params->request = 5;
- params->value = 6;
- params->index = 7;
- base::RunLoop loop;
- device->ControlTransferIn(
- std::move(params), static_cast<uint32_t>(fake_data.size()), 0,
- base::Bind(&ExpectTransferInAndThen, TransferStatus::COMPLETED,
- fake_data, loop.QuitClosure()));
- loop.Run();
- }
-
- AddMockOutboundData(fake_data);
-
- EXPECT_CALL(mock_device(), GetActiveConfiguration());
- EXPECT_CALL(mock_handle(),
- ControlTransfer(USB_DIRECTION_OUTBOUND, UsbDeviceHandle::STANDARD,
- UsbDeviceHandle::INTERFACE, 5, 6, 7, _, _, 0, _));
-
- {
- auto params = ControlTransferParams::New();
- params->type = ControlTransferType::STANDARD;
- params->recipient = ControlTransferRecipient::INTERFACE;
- params->request = 5;
- params->value = 6;
- params->index = 7;
- base::RunLoop loop;
- device->ControlTransferOut(
- std::move(params), mojo::Array<uint8_t>::From(fake_data), 0,
- base::Bind(&ExpectTransferStatusAndThen, TransferStatus::COMPLETED,
- loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), Close());
-}
-
-TEST_F(USBDeviceImplTest, GenericTransfer) {
- DevicePtr device = GetMockDeviceProxy();
-
- EXPECT_CALL(mock_device(), Open(_));
-
- {
- base::RunLoop loop;
- device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
- loop.QuitClosure()));
- loop.Run();
- }
-
- std::string message1 = "say hello please";
- std::vector<uint8_t> fake_outbound_data(message1.size());
- std::copy(message1.begin(), message1.end(), fake_outbound_data.begin());
-
- std::string message2 = "hello world!";
- std::vector<uint8_t> fake_inbound_data(message2.size());
- std::copy(message2.begin(), message2.end(), fake_inbound_data.begin());
-
- AddMockConfig(ConfigBuilder(1).AddInterface(7, 0, 1, 2, 3));
- AddMockOutboundData(fake_outbound_data);
- AddMockInboundData(fake_inbound_data);
-
- EXPECT_CALL(mock_handle(), GenericTransfer(USB_DIRECTION_OUTBOUND, 0x01, _,
- fake_outbound_data.size(), 0, _));
-
- {
- base::RunLoop loop;
- device->GenericTransferOut(
- 1, mojo::Array<uint8_t>::From(fake_outbound_data), 0,
- base::Bind(&ExpectTransferStatusAndThen, TransferStatus::COMPLETED,
- loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), GenericTransfer(USB_DIRECTION_INBOUND, 0x81, _,
- fake_inbound_data.size(), 0, _));
-
- {
- base::RunLoop loop;
- device->GenericTransferIn(
- 1, static_cast<uint32_t>(fake_inbound_data.size()), 0,
- base::Bind(&ExpectTransferInAndThen, TransferStatus::COMPLETED,
- fake_inbound_data, loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), Close());
-}
-
-TEST_F(USBDeviceImplTest, IsochronousTransfer) {
- DevicePtr device = GetMockDeviceProxy();
-
- EXPECT_CALL(mock_device(), Open(_));
-
- {
- base::RunLoop loop;
- device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
- loop.QuitClosure()));
- loop.Run();
- }
-
- std::vector<UsbDeviceHandle::IsochronousPacket> fake_packets(4);
- for (size_t i = 0; i < fake_packets.size(); ++i) {
- fake_packets[i].length = 8;
- fake_packets[i].transferred_length = 8;
- fake_packets[i].status = USB_TRANSFER_COMPLETED;
- }
- std::vector<uint32_t> fake_packet_lengths(4, 8);
-
- std::vector<uint32_t> expected_transferred_lengths(4, 8);
-
- std::string outbound_data = "aaaaaaaabbbbbbbbccccccccdddddddd";
- std::vector<uint8_t> fake_outbound_data(outbound_data.size());
- std::copy(outbound_data.begin(), outbound_data.end(),
- fake_outbound_data.begin());
-
- std::string inbound_data = "ddddddddccccccccbbbbbbbbaaaaaaaa";
- std::vector<uint8_t> fake_inbound_data(inbound_data.size());
- std::copy(inbound_data.begin(), inbound_data.end(),
- fake_inbound_data.begin());
-
- AddMockConfig(ConfigBuilder(1).AddInterface(7, 0, 1, 2, 3));
- AddMockOutboundPackets(fake_outbound_data, fake_packets);
- AddMockInboundPackets(fake_inbound_data, fake_packets);
-
- EXPECT_CALL(mock_handle(),
- IsochronousTransferOut(0x01, _, fake_packet_lengths, 0, _));
-
- {
- base::RunLoop loop;
- device->IsochronousTransferOut(
- 1, mojo::Array<uint8_t>::From(fake_outbound_data),
- mojo::Array<uint32_t>::From(fake_packet_lengths), 0,
- base::Bind(&ExpectPacketsOutAndThen, expected_transferred_lengths,
- loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(),
- IsochronousTransferIn(0x81, fake_packet_lengths, 0, _));
-
- {
- base::RunLoop loop;
- device->IsochronousTransferIn(
- 1, mojo::Array<uint32_t>::From(fake_packet_lengths), 0,
- base::Bind(&ExpectPacketsInAndThen, fake_inbound_data,
- expected_transferred_lengths, loop.QuitClosure()));
- loop.Run();
- }
-
- EXPECT_CALL(mock_handle(), Close());
-}
-
-} // namespace usb
-} // namespace device
« no previous file with comments | « device/devices_app/usb/device_impl.cc ('k') | device/devices_app/usb/device_manager_impl.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698