inference-engine/thirdparty/movidius/mvnc/tests/mvnc_tests_usb.cpp

   1 // Copyright (C) 2018-2019 Intel Corporation
   2 // SPDX-License-Identifier: Apache-2.0
   3 //
   4
   5 #include "mvnc.h"
   6 #include "mvnc_tests_common.hpp"
   7
   8 //  ***********************************************  //
   9 //              Open Device TESTS                    //
  10
  11 class MvncOpenUSBDevice : public MvncTestsCommon {
  12 public:
  13     int available_devices = 0;
  14 protected:
  15     ~MvncOpenUSBDevice() override = default;
  16     void SetUp() override {
  17         MvncTestsCommon::SetUp();
  18         available_devices = getAmountOfNotBootedDevices();
  19         ASSERT_TRUE(available_devices > 0);
  20     }
  21 };
  22
  23 /**
  24 * @brief Open any device with custom firmware path as ncDeviceOpen argument
  25 */
  26 TEST_F(MvncOpenUSBDevice, WithCustomFirmware) {
  27     ncDeviceHandle_t *deviceHandle = nullptr;
  28     ncDeviceDescr_t deviceDesc = {};
  29     deviceDesc.protocol = NC_USB;
  30     deviceDesc.platform = NC_ANY_PLATFORM;
  31
  32     // Use custom firmware dir path as parameter for ncDeviceOpen
  33     ASSERT_NO_ERROR(ncDeviceOpen(&deviceHandle, deviceDesc, watchdogInterval, firmwarePath));
  34     ASSERT_NO_ERROR(ncDeviceClose(&deviceHandle));
  35 }
  36
  37 /**
  38 * @brief Open all available devices and close them
  39 */
  40 TEST_F(MvncOpenUSBDevice, AllAvailableDevices) {
  41     ncDeviceHandle_t * deviceHandle[MAX_DEVICES] = {nullptr};
  42     ncDeviceDescr_t deviceDesc = {};
  43     deviceDesc.protocol = NC_USB;
  44     deviceDesc.platform = NC_ANY_PLATFORM;
  45
  46     for (int index = 0; index < available_devices; ++index) {
  47         ASSERT_NO_ERROR(ncDeviceOpen(&deviceHandle[index], deviceDesc, watchdogInterval, firmwarePath));
  48     }
  49     for (int index = 0; index < available_devices; ++index) {
  50         ASSERT_NO_ERROR(ncDeviceClose(&deviceHandle[index]));
  51     }
  52 }
  53
  54 /**
  55 * @brief Open all available devices in parallel threads and close them
  56 */
  57 TEST_F(MvncOpenUSBDevice, AllAvailableMultiThreads) {
  58     std::thread requests[MAX_DEVICES];
  59     ncDeviceHandle_t * deviceHandle[MAX_DEVICES] = {nullptr};
  60     ncStatus_t rc[MAX_DEVICES];
  61     ncDeviceDescr_t deviceDesc = {};
  62     deviceDesc.protocol = NC_USB;
  63     deviceDesc.platform = NC_ANY_PLATFORM;
  64
  65     for (int i = 0; i < available_devices; ++i) {
  66         requests[i] = std::thread([i, &rc, &deviceHandle, deviceDesc, this]() {
  67             rc[i] = ncDeviceOpen(&deviceHandle[i], deviceDesc, watchdogInterval, firmwarePath);
  68         });
  69     }
  70
  71     for (int i = 0; i < available_devices; ++i) {
  72         requests[i].join();
  73         ASSERT_NO_ERROR(rc[i]);
  74     }
  75
  76     for (int i = 0; i < available_devices; ++i) {
  77         ASSERT_NO_ERROR(ncDeviceClose(&deviceHandle[i]));
  78     }
  79 }
  80
  81 /**
  82 * @brief Open any device with invalid firmware path
  83 */
  84 TEST_F(MvncOpenUSBDevice, WithInvalidFirmwarePath) {
  85     const char invalidPath[MAX_PATH] = "./InvalidPath/";
  86     ncDeviceDescr_t deviceDesc = {};
  87     deviceDesc.protocol = NC_USB;
  88     deviceDesc.platform = NC_ANY_PLATFORM;
  89
  90     // Use custom firmware dir path as parameter for ncDeviceOpen
  91     ncDeviceHandle_t *deviceHandle = nullptr;
  92     ASSERT_ERROR(ncDeviceOpen(&deviceHandle, deviceDesc, watchdogInterval, invalidPath));
  93
  94     ASSERT_EQ(deviceHandle, nullptr);
  95 }
  96
  97 TEST_F(MvncOpenUSBDevice, OpenAvailableDeviceByName) {
  98     ncDeviceHandle_t *deviceHandle = nullptr;
  99     char dev_addr_open[NC_MAX_NAME_SIZE];
 100     unsigned int data_lenght = NC_MAX_NAME_SIZE;
 101     ncDeviceDescr_t deviceDesc = {};
 102     deviceDesc.protocol = NC_USB;
 103     deviceDesc.platform = NC_ANY_PLATFORM;
 104
 105     auto availableDevices = getDevicesList();
 106
 107     ASSERT_TRUE(availableDevices.size());
 108     strncpy(deviceDesc.name, availableDevices[0].c_str(), NC_MAX_NAME_SIZE);
 109
 110     ASSERT_NO_ERROR(ncDeviceOpen(&deviceHandle, deviceDesc, watchdogInterval, firmwarePath));
 111     ASSERT_NO_ERROR(ncDeviceGetOption(deviceHandle, NC_RO_DEVICE_NAME,
 112                                       dev_addr_open, &data_lenght));
 113
 114     ASSERT_TRUE(strncmp(dev_addr_open, deviceDesc.name, NC_MAX_NAME_SIZE) == 0);
 115     ASSERT_NO_ERROR(ncDeviceClose(&deviceHandle));
 116 }
 117
 118 TEST_F(MvncOpenUSBDevice, ErrorWhenWrongDeviceName) {
 119     ncDeviceHandle_t *deviceHandle = nullptr;
 120     char badName[] = "BadName";
 121
 122     ncDeviceDescr_t deviceDesc = {};
 123     deviceDesc.protocol = NC_USB;
 124     deviceDesc.platform = NC_ANY_PLATFORM;
 125     strncpy(deviceDesc.name, badName, NC_MAX_NAME_SIZE);
 126
 127     auto availableDevices = getDevicesList();
 128     ASSERT_TRUE(availableDevices.size());
 129
 130     ASSERT_ERROR(ncDeviceOpen(&deviceHandle, deviceDesc, watchdogInterval, firmwarePath));
 131 }
 132
 133 TEST_F(MvncOpenUSBDevice, OpenTwiceSameHandlerByName) {
 134     ncDeviceHandle_t *deviceHandle = nullptr;
 135     ncDeviceDescr_t deviceDesc = {};
 136     deviceDesc.protocol = NC_USB;
 137     deviceDesc.platform = NC_ANY_PLATFORM;
 138
 139     char dev_addr_first_open[MAX_DEV_NAME];
 140     unsigned int data_lenght_first = MAX_DEV_NAME;
 141
 142     char dev_addr_second_open[MAX_DEV_NAME];
 143     unsigned int data_lenght_second = MAX_DEV_NAME;
 144
 145     auto availableDevices = getDevicesList();
 146
 147     ASSERT_TRUE(availableDevices.size());
 148     strncpy(deviceDesc.name, availableDevices[0].c_str(), NC_MAX_NAME_SIZE);
 149
 150     ASSERT_NO_ERROR(ncDeviceOpen(&deviceHandle, deviceDesc, watchdogInterval, firmwarePath));
 151     ASSERT_NO_ERROR(ncDeviceGetOption(deviceHandle, NC_RO_DEVICE_NAME,
 152                                       dev_addr_first_open, &data_lenght_first));
 153
 154     // Second open, get device name
 155     ASSERT_NO_ERROR(ncDeviceOpen(&deviceHandle, deviceDesc, watchdogInterval, firmwarePath));
 156     ASSERT_NO_ERROR(ncDeviceGetOption(deviceHandle, NC_RO_DEVICE_NAME,
 157                                       dev_addr_second_open, &data_lenght_second));
 158
 159     ASSERT_NO_ERROR(ncDeviceClose(&deviceHandle));
 160     // Should be the same device
 161     ASSERT_STREQ(dev_addr_first_open, dev_addr_second_open);
 162 }
 163
 164 TEST_F(MvncOpenUSBDevice, CheckErrorWhenPlatformConflictWithName) {
 165     ncDeviceHandle_t *deviceHandle = nullptr;
 166     ncDevicePlatform_t wrongPlatform = NC_ANY_PLATFORM;
 167     auto availableDevices = getDevicesList();
 168     ncDeviceDescr_t deviceDesc = {};
 169     deviceDesc.protocol = NC_USB;
 170
 171     ASSERT_TRUE(availableDevices.size());
 172
 173     if(isMyriadXUSBDevice(availableDevices[0])) {
 174         wrongPlatform = NC_MYRIAD_2;
 175     } else {
 176         wrongPlatform = NC_MYRIAD_X;
 177     }
 178
 179     strncpy(deviceDesc.name, availableDevices[0].c_str(), NC_MAX_NAME_SIZE);
 180     deviceDesc.platform = wrongPlatform;
 181
 182     ASSERT_ERROR(ncDeviceOpen(&deviceHandle, deviceDesc, watchdogInterval, firmwarePath));
 183 }
 184
 185 //  ***********************************************  //
 186 //             Specific device TESTS                //
 187
 188 class MvncDevicePlatform : public MvncOpenUSBDevice,
 189                            public testing::WithParamInterface<ncDevicePlatform_t>{
 190 public:
 191     long available_myriadX = 0;
 192     long available_myriad2 = 0;
 193     ncDevicePlatform_t devicePlatform;
 194
 195     ~MvncDevicePlatform() override = default;
 196
 197 protected:
 198     void SetUp() override {
 199         MvncOpenUSBDevice::SetUp();
 200
 201         available_myriadX = getAmountOfMyriadXDevices();
 202         available_myriad2 = getAmountOfMyriad2Devices();
 203
 204         ASSERT_TRUE(available_myriadX > 0);
 205         ASSERT_TRUE(available_myriad2 > 0);
 206         devicePlatform = GetParam();
 207     }
 208 };
 209
 210 /**
 211 * @brief Open specified device and close it
 212 */
 213 TEST_P(MvncDevicePlatform, OpenAndClose) {
 214     ncDeviceHandle_t *deviceHandle = nullptr;
 215     ncDeviceDescr_t deviceDesc = {};
 216     deviceDesc.protocol = NC_USB;
 217     deviceDesc.platform = devicePlatform;
 218
 219     ASSERT_NO_ERROR(ncDeviceOpen(&deviceHandle, deviceDesc, watchdogInterval, firmwarePath));
 220
 221     char deviceName[MAX_DEV_NAME];
 222     unsigned int size = MAX_DEV_NAME;
 223     ASSERT_NO_ERROR(ncDeviceGetOption(deviceHandle, NC_RO_DEVICE_NAME, deviceName, &size));
 224
 225     EXPECT_TRUE(isSamePlatformDevice(deviceName, devicePlatform));
 226
 227     ASSERT_NO_ERROR(ncDeviceClose(&deviceHandle));
 228
 229 }
 230
 231 INSTANTIATE_TEST_CASE_P(MvncTestsPlatform,
 232                         MvncDevicePlatform,
 233                         ::testing::ValuesIn(myriadPlatforms),
 234                         PrintToStringParamName());