host/windows/usb/adb_winapi_test/adb_winapi_test.cpp

/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// This file contains implementation of a test application that tests
// functionality of AdbWinApi interface. In this test we will use AdbWinApi
// interface in order to enumerate USB interfaces for Android ADB class, and
// for each interface found we will test USB I/O on that interface by sending
// a simple "hand shake" message to the device connected via this interface.

#include "stdafx.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// Android ADB interface identifier
const GUID kAdbInterfaceId = ANDROID_USB_CLASS_ID;

// Number of interfaces detected in TestEnumInterfaces.
int interface_count = 0;

// Constants used to initialize a "handshake" message
#define MAX_PAYLOAD 4096
#define A_SYNC 0x434e5953
#define A_CNXN 0x4e584e43
#define A_OPEN 0x4e45504f
#define A_OKAY 0x59414b4f
#define A_CLSE 0x45534c43
#define A_WRTE 0x45545257
#define A_AUTH 0x48545541
#define A_VERSION 0x01000000

// AUTH packets first argument
#define ADB_AUTH_TOKEN         1
#define ADB_AUTH_SIGNATURE     2
#define ADB_AUTH_RSAPUBLICKEY  3

// Interface descriptor constants for ADB interface
#define ADB_CLASS              0xff
#define ADB_SUBCLASS           0x42
#define ADB_PROTOCOL           0x1

// Formats message sent to USB device
struct message {
    unsigned int command;       /* command identifier constant      */
    unsigned int arg0;          /* first argument                   */
    unsigned int arg1;          /* second argument                  */
    unsigned int data_length;   /* length of payload (0 is allowed) */
    unsigned int data_crc32;    /* crc32 of data payload            */
    unsigned int magic;         /* command ^ 0xffffffff             */
};

//
// Test routines declarations.
//

// Tests interface enumeration.
bool TestEnumInterfaces();

// Tests all interfaces detected for our device class.
bool TestInterfaces();

// Tests interface addressed by the given device name.
bool TestInterface(const wchar_t* device_name);

// Tests interface opened with ADB API.
bool TestInterfaceHandle(ADBAPIHANDLE interface_handle);

// Sends a "handshake" message to the given interface.
bool DeviceHandShake(ADBAPIHANDLE adb_interface);

// Test AdbCloseHandle race condition.
bool TestCloseRaceCondition();

int __cdecl _tmain(int argc, TCHAR* argv[], TCHAR* envp[]) {
  // Test enum interfaces.
  if (!TestEnumInterfaces())
    return -1;

  if (0 == interface_count) {
    printf("\nNo ADB interfaces found. Make sure that device is "
           "connected to USB port and is powered on.");
    return 1;
  }

  // Test each interface found in the system
  if (!TestInterfaces())
    return -2;

  // Test for AdbCloseHandle race condition
  if (!TestCloseRaceCondition())
    return -3;

  return 0;
}

bool TestEnumInterfaces() {
  // Enumerate interfaces
  ADBAPIHANDLE enum_handle =
    AdbEnumInterfaces(kAdbInterfaceId, true, true, true);
  if (NULL == enum_handle) {
    printf("\nEnum interfaces failure:");
    printf("\nUnable to enumerate ADB interfaces: %u", GetLastError());
    return false;
  }

  // Unite interface info structure and buffer big enough to contain the
  // largest structure.
  union {
    AdbInterfaceInfo interface_info;
    char buf[4096];
  };
  unsigned long buf_size = sizeof(buf);

  // Enumerate (and count) interfaces, printing information for each found
  // interface.
  interface_count = 0;
  while (AdbNextInterface(enum_handle, &interface_info, &buf_size)) {
    interface_count++;
    printf("\nFound interface %ws:", interface_info.device_name);
    if (interface_info.flags & SPINT_ACTIVE)
      printf(" ACTIVE");
    if (interface_info.flags & SPINT_DEFAULT)
      printf(" DEFAULT");
    if (interface_info.flags & SPINT_REMOVED)
      printf(" REMOVED");

    buf_size = sizeof(buf);
  }

  bool ret = true;
  if (GetLastError() != ERROR_NO_MORE_ITEMS) {
    printf("\n--- AdbNextInterface failure %u", GetLastError());
    ret = false;
  }

  if (!AdbCloseHandle(enum_handle)) {
    printf("\n--- AdbCloseHandle failure %u", GetLastError());
    ret = false;
  }

  return ret;
}

bool TestInterfaces() {
  bool ret = true;

  // Enumerate interfaces
  ADBAPIHANDLE enum_handle =
    AdbEnumInterfaces(kAdbInterfaceId, true, true, true);
  if (NULL == enum_handle) {
    printf("\nTest interfaces failure:");
    printf("\nUnable to enumerate ADB interfaces: %u", GetLastError());
    ret = false;
  } else {
    // Unite interface info structure and buffer big enough to contain the
    // largest structure.
    union {
      AdbInterfaceInfo interface_info;
      char buf[4096];
    };
    unsigned long buf_size = sizeof(buf);

    // Test each found interface
    while (AdbNextInterface(enum_handle, &interface_info, &buf_size)) {
      TestInterface(interface_info.device_name);
      buf_size = sizeof(buf);
    }

    if (GetLastError() != ERROR_NO_MORE_ITEMS) {
      printf("\n--- AdbNextInterface failure %u", GetLastError());
      ret = false;
    }

    if (!AdbCloseHandle(enum_handle)) {
      printf("\n--- AdbCloseHandle failure %u", GetLastError());
      ret = false;
    }
  }

  return ret;
}

bool TestInterface(const wchar_t* device_name) {
  printf("\n*** Test interface( %ws )", device_name);

  // Get ADB handle to the interface by its name
  ADBAPIHANDLE interface_handle = AdbCreateInterfaceByName(device_name);
  if (NULL == interface_handle) {
    printf(" FAILED:\nUnable to create interface by name: %u", GetLastError());
    return false;
  }

  // Test it
  TestInterfaceHandle(interface_handle);
  if (!AdbCloseHandle(interface_handle)) {
    printf("\n--- AdbCloseHandle failure %u", GetLastError());
    return false;
  }

  return true;
}

bool TestInterfaceName(ADBAPIHANDLE interface_handle) {
  bool ret = true;
  unsigned long intr_name_size = 0;
  char* buf = NULL;

  if (AdbGetInterfaceName(interface_handle, NULL, &intr_name_size, true)) {
    printf("\n--- AdbGetInterfaceName unexpectedly succeeded %u",
           GetLastError());
    ret = false;
    goto exit;
  }
  if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
    printf("\n--- AdbGetInterfaceName failure %u", GetLastError());
    ret = false;
    goto exit;
  }
  if (intr_name_size == 0) {
    printf("\n--- AdbGetInterfaceName returned name size of zero");
    ret = false;
    goto exit;
  }

  const size_t buf_size = intr_name_size + 16; // extra in case of overwrite
  buf = reinterpret_cast<char*>(malloc(buf_size));
  if (buf == NULL) {
    printf("\n--- could not malloc %d bytes, errno %u", buf_size, errno);
    ret = false;
    goto exit;
  }
  const char buf_fill = (unsigned char)0xFF;
  memset(buf, buf_fill, buf_size);

  if (!AdbGetInterfaceName(interface_handle, buf, &intr_name_size, true)) {
    printf("\n--- AdbGetInterfaceName failure %u", GetLastError());
    ret = false;
    goto exit;
  }
  if (buf[intr_name_size - 1] != '\0') {
    printf("\n--- AdbGetInterfaceName returned non-NULL terminated string");
    ret = false;
    goto exit;
  }
  for (size_t i = intr_name_size; i < buf_size; ++i) {
    if (buf[i] != buf_fill) {
      printf("\n--- AdbGetInterfaceName overwrote past the end of the buffer at"
             " index %u with 0x%02X", i, (unsigned char)buf[i]);
      ret = false;
      goto exit;
    }
  }

  printf("\n+++ Interface name %s", buf);

exit:
  free(buf);

  return ret;
}

void DumpEndpointInformation(const AdbEndpointInformation* pipe_info) {
  printf("\n          max_packet_size   = %u", pipe_info->max_packet_size);
  printf("\n          max_transfer_size = %u", pipe_info->max_transfer_size);
  printf("\n          endpoint_type     = %u", pipe_info->endpoint_type);
  const char* endpoint_type_desc = NULL;
  switch (pipe_info->endpoint_type) {
#define CASE_TYPE(type) case type: endpoint_type_desc = #type; break
    CASE_TYPE(AdbEndpointTypeInvalid);
    CASE_TYPE(AdbEndpointTypeControl);
    CASE_TYPE(AdbEndpointTypeIsochronous);
    CASE_TYPE(AdbEndpointTypeBulk);
    CASE_TYPE(AdbEndpointTypeInterrupt);
#undef CASE_TYPE
  }
  if (endpoint_type_desc != NULL) {
    printf(" (%s)", endpoint_type_desc);
  }
  printf("\n          endpoint_address  = %02X", pipe_info->endpoint_address);
  printf("\n          polling_interval  = %u", pipe_info->polling_interval);
  printf("\n          setting_index     = %u", pipe_info->setting_index);
}

bool TestInterfaceHandle(ADBAPIHANDLE interface_handle) {
  // Get interface name.
  if (!TestInterfaceName(interface_handle)) {
    return false;
  }

  // Get device descriptor for the interface
  USB_DEVICE_DESCRIPTOR dev_desc;
  if (AdbGetUsbDeviceDescriptor(interface_handle, &dev_desc)) {
    printf("\n+++ Device descriptor:");
    printf("\n        bLength            = %u", dev_desc.bLength);
    printf("\n        bDescriptorType    = %u", dev_desc.bDescriptorType);
    printf("\n        bcdUSB             = %u", dev_desc.bcdUSB);
    printf("\n        bDeviceClass       = %u", dev_desc.bDeviceClass);
    printf("\n        bDeviceSubClass    = %u", dev_desc.bDeviceSubClass);
    printf("\n        bDeviceProtocol    = %u", dev_desc.bDeviceProtocol);
    printf("\n        bMaxPacketSize0    = %u", dev_desc.bMaxPacketSize0);
    printf("\n        idVendor           = %X", dev_desc.idVendor);
    printf("\n        idProduct          = %X", dev_desc.idProduct);
    printf("\n        bcdDevice          = %u", dev_desc.bcdDevice);
    printf("\n        iManufacturer      = %u", dev_desc.iManufacturer);
    printf("\n        iProduct           = %u", dev_desc.iProduct);
    printf("\n        iSerialNumber      = %u", dev_desc.iSerialNumber);
    printf("\n        bNumConfigurations = %u", dev_desc.bNumConfigurations);
  } else {
    printf("\n--- AdbGetUsbDeviceDescriptor failure %u", GetLastError());
    return false;
  }

  // Get configuration descriptor for the interface
  USB_CONFIGURATION_DESCRIPTOR config_desc;
  if (AdbGetUsbConfigurationDescriptor(interface_handle, &config_desc)) {
    printf("\n+++ Configuration descriptor:");
    printf("\n        bLength             = %u", config_desc.bLength);
    printf("\n        bDescriptorType     = %u", config_desc.bDescriptorType);
    printf("\n        wTotalLength        = %u", config_desc.wTotalLength);
    printf("\n        bNumInterfaces      = %u", config_desc.bNumInterfaces);
    printf("\n        bConfigurationValue = %u", config_desc.bConfigurationValue);
    printf("\n        iConfiguration      = %u", config_desc.iConfiguration);
    printf("\n        bmAttributes        = %u", config_desc.bmAttributes);
    printf("\n        MaxPower            = %u", config_desc.MaxPower);
  } else {
    printf("\n--- AdbGetUsbConfigurationDescriptor failure %u", GetLastError());
    return false;
  }

  // Get device serial number
  char ser_num[1024];
  unsigned long ser_num_size = sizeof(ser_num);
  if (AdbGetSerialNumber(interface_handle, ser_num, &ser_num_size, true)) {
    printf("\n+++ Serial number: %s", ser_num);
  } else {
    printf("\n--- AdbGetSerialNumber failure %u", GetLastError());
    return false;
  }

  // Get interface descriptor
  USB_INTERFACE_DESCRIPTOR intr_desc;
  if (AdbGetUsbInterfaceDescriptor(interface_handle, &intr_desc)) {
    printf("\n+++ Interface descriptor:");
    printf("\n        bDescriptorType    = %u", intr_desc.bDescriptorType);
    printf("\n        bInterfaceNumber   = %u", intr_desc.bInterfaceNumber);
    printf("\n        bAlternateSetting  = %u", intr_desc.bAlternateSetting);
    printf("\n        bNumEndpoints      = %u", intr_desc.bNumEndpoints);
    printf("\n        bInterfaceClass    = %u", intr_desc.bInterfaceClass);
    if (intr_desc.bInterfaceClass == ADB_CLASS) {
      printf(" (ADB_CLASS)");
    }
    printf("\n        bInterfaceSubClass = %u", intr_desc.bInterfaceSubClass);
    if (intr_desc.bInterfaceSubClass == ADB_SUBCLASS) {
      printf(" (ADB_SUBCLASS)");
    }
    printf("\n        bInterfaceProtocol = %u", intr_desc.bInterfaceProtocol);
    if (intr_desc.bInterfaceProtocol == ADB_PROTOCOL) {
      printf(" (ADB_PROTOCOL)");
    }
    printf("\n        iInterface         = %u", intr_desc.iInterface);
  } else {
    printf("\n--- AdbGetUsbInterfaceDescriptor failure %u", GetLastError());
    return false;
  }

  // Enumerate interface's endpoints
  AdbEndpointInformation pipe_info;
  for (UCHAR pipe = 0; pipe < intr_desc.bNumEndpoints; pipe++) {
    if (AdbGetEndpointInformation(interface_handle, pipe, &pipe_info)) {
      printf("\n      PIPE %u info:", pipe);
      DumpEndpointInformation(&pipe_info);
    } else {
      printf("\n--- AdbGetEndpointInformation(%u) failure %u", pipe,
             GetLastError());
      return false;
    }
  }

  // Get default bulk read endpoint info
  if (AdbGetDefaultBulkReadEndpointInformation(interface_handle, &pipe_info)) {
    printf("\n      Default Bulk Read Pipe info:");
    DumpEndpointInformation(&pipe_info);
  } else {
    printf("\n--- AdbGetDefaultBulkReadEndpointInformation failure %u",
           GetLastError());
    return false;
  }

  // Get default bulk write endpoint info
  if (AdbGetDefaultBulkWriteEndpointInformation(interface_handle, &pipe_info)) {
    printf("\n      Default Bulk Write Pipe info:");
    DumpEndpointInformation(&pipe_info);
  } else {
    printf("\n--- AdbGetDefaultBulkWriteEndpointInformation failure %u",
           GetLastError());
    return false;
  }

  // Test a handshake on that interface
  DeviceHandShake(interface_handle);

  return true;
}

void HexDump(const void* data, const size_t read_bytes) {
  const unsigned char* buf = reinterpret_cast<const unsigned char*>(data);
  const size_t line_length = 16;
  for (size_t n = 0; n < read_bytes; n += line_length) {
    const unsigned char* line = &buf[n];
    const size_t max_line = min(line_length, read_bytes - n);

    printf("\n          ");
    for (size_t i = 0; i < line_length; ++i) {
      if (i >= max_line) {
        printf("   ");
      } else {
        printf("%02X ", line[i]);
      }
    }
    printf(" ");
    for (size_t i = 0; i < max_line; ++i) {
      if (isprint(line[i])) {
        printf("%c", line[i]);
      } else {
        printf(".");
      }
    }
  }
}

void DumpMessageArg0(unsigned int command, unsigned int arg0) {
  if (command == A_AUTH) {
    const char* desc = NULL;
    switch (arg0) {
#define CASE_ARG0(arg) case arg: desc = # arg; break
      CASE_ARG0(ADB_AUTH_TOKEN);
      CASE_ARG0(ADB_AUTH_SIGNATURE);
      CASE_ARG0(ADB_AUTH_RSAPUBLICKEY);
#undef CASE_ARG0
    }
    if (desc != NULL) {
      printf(" (%s)", desc);
    }
  }
}

bool DeviceHandShake(ADBAPIHANDLE adb_interface) {
  // Get interface name
  char interf_name[512];
  unsigned long name_size = sizeof(interf_name);
  if (!AdbGetInterfaceName(adb_interface, interf_name, &name_size, true)) {
    printf("\nDeviceHandShake: AdbGetInterfaceName returned error %u",
           GetLastError());
    return false;
  }

  printf("\n\nDeviceHandShake on %s", interf_name);

  char* ser_num = NULL;
  name_size = 0;
  if (!AdbGetSerialNumber(adb_interface, ser_num, &name_size, true)) {
    ser_num = reinterpret_cast<char*>(malloc(name_size));
    if (NULL != ser_num) {
      if (!AdbGetSerialNumber(adb_interface, ser_num, &name_size, true)) {
        printf("\n      AdbGetSerialNumber returned error %u", GetLastError());
        AdbCloseHandle(adb_interface);
        return false;
      }
      printf("\nInterface serial number is %s", ser_num);
      free(ser_num);
    }
  }

  // Get default read endpoint
  ADBAPIHANDLE adb_read = AdbOpenDefaultBulkReadEndpoint(adb_interface,
                                                         AdbOpenAccessTypeReadWrite,
                                                         AdbOpenSharingModeReadWrite);
  if (NULL == adb_read) {
    printf("\n      AdbOpenDefaultBulkReadEndpoint returned error %u", GetLastError());
    return false;
  }

  // Get default write endpoint
  ADBAPIHANDLE adb_write = AdbOpenDefaultBulkWriteEndpoint(adb_interface,
                                                           AdbOpenAccessTypeReadWrite,
                                                           AdbOpenSharingModeReadWrite);
  if (NULL == adb_write) {
    printf("\n      AdbOpenDefaultBulkWriteEndpoint returned error %u", GetLastError());
    AdbCloseHandle(adb_read);
    return false;
  }

  // Send connect message
  message msg_send;
  msg_send.command = A_CNXN;
  msg_send.arg0 = A_VERSION;
  msg_send.arg1 = MAX_PAYLOAD;
  msg_send.data_length = 0;
  msg_send.data_crc32 = 0;
  msg_send.magic = msg_send.command ^ 0xffffffff;

  ULONG written_bytes = 0;
  bool write_res = AdbWriteEndpointSync(adb_write, &msg_send, sizeof(msg_send), &written_bytes, 500);
  if (!write_res) {
    printf("\n       AdbWriteEndpointSync returned error %u", GetLastError());
    AdbCloseHandle(adb_write);
    AdbCloseHandle(adb_read);
    return false;
  }

  // Receive handshake
  message msg_rcv;
  ULONG read_bytes = 0;
  bool read_res = AdbReadEndpointSync(adb_read, &msg_rcv, sizeof(msg_rcv), &read_bytes, 512);
  if (!read_res) {
    printf("\n       AdbReadEndpointSync returned error %u", GetLastError());
    AdbCloseHandle(adb_write);
    AdbCloseHandle(adb_read);
    return false;
  }

  printf("\n      Read handshake: %u bytes received", read_bytes);
  char* cmd_ansi = reinterpret_cast<char*>(&msg_rcv.command);
  printf("\n         command     = %08X (%c%c%c%c)", msg_rcv.command,
         cmd_ansi[0], cmd_ansi[1], cmd_ansi[2], cmd_ansi[3]);
  printf("\n         arg0        = %08X", msg_rcv.arg0);
  DumpMessageArg0(msg_rcv.command, msg_rcv.arg0);
  printf("\n         arg1        = %08X", msg_rcv.arg1);
  printf("\n         data_length = %u", msg_rcv.data_length);
  printf("\n         data_crc32  = %08X", msg_rcv.data_crc32);
  printf("\n         magic       = %08X", msg_rcv.magic);
  printf(" (%s)", (msg_rcv.magic == (msg_rcv.command ^ 0xffffffff)) ?
           "valid" : "invalid");

  if (0 != msg_rcv.data_length) {
    char* buf = reinterpret_cast<char*>(malloc(msg_rcv.data_length));
    read_res = AdbReadEndpointSync(adb_read, buf, msg_rcv.data_length, &read_bytes, 512);
    if (!read_res) {
      printf("\n       AdbReadEndpointSync (data) returned error %u", GetLastError());
      free(buf);
      AdbCloseHandle(adb_write);
      AdbCloseHandle(adb_read);
      return false;
    }

    HexDump(buf, read_bytes);

    free(buf);
  }

  if (!AdbCloseHandle(adb_write)) {
    printf("\n--- AdbCloseHandle failure %u", GetLastError());
  }
  if (!AdbCloseHandle(adb_read)) {
    printf("\n--- AdbCloseHandle failure %u", GetLastError());
  }

  return true;
}

// Randomly delay the current thread.
class RandomDelayer {
public:
  // Prepare for a call to Delay() by getting random data. This call might grab
  // locks, causing serialization, so this should be called before
  // time-sensitive code.
  void SeedRandom() {
    r_ = rand();
  }

  // Randomly delay the current thread based on a previous call to SeedRandom().
  void Delay() {
    switch (r_ % 5) {
      case 0:
        Sleep(0); // Give up time slice to another read-to-run thread.
        break;
      case 1:
        // Try to sleep for 1 ms, but probably more based on OS scheduler
        // minimum granularity.
        Sleep(1);
        break;
      case 2:
        // Yield to another thread ready-to-run on the current processor.
        SwitchToThread();
        break;
      case 3:
        // Busy-wait for a random amount of time.
        for (int i = 0; i < r_; ++i) {
          GetLastError();
        }
        break;
      case 4:
        break; // Do nothing, no delay.
    }
  }

private:
  int r_;
};

volatile ADBAPIHANDLE g_read_handle;
volatile ADBAPIHANDLE g_interface_handle;
volatile bool g_stop_close_race_thread;

unsigned __stdcall CloseRaceThread(void*) {
  RandomDelayer r;

  while (!g_stop_close_race_thread) {
    r.SeedRandom();

    // Do volatile reads of both globals
    ADBAPIHANDLE read_handle = g_read_handle;
    ADBAPIHANDLE interface_handle = g_interface_handle;

    // If we got both handles, close them and clear the globals
    if (read_handle != NULL && interface_handle != NULL) {
      // Delay random amount before calling the API that conflicts with
      // Adb{Read,Write}EndpointSync().
      r.Delay();

      if (!AdbCloseHandle(read_handle)) {
        printf("\nAdbCloseHandle(read) failure: %u", GetLastError());
      }
      if (!AdbCloseHandle(interface_handle)) {
        printf("\nAdbCloseHandle(interface) failure: %u", GetLastError());
      }

      // Clear globals so that read thread is free to set them.
      g_read_handle = NULL;
      g_interface_handle = NULL;
    }
  }
  return 0;
}

#define EXPECTED_ERROR_LIST(FOR_EACH) \
  FOR_EACH(ERROR_INVALID_HANDLE) \
  FOR_EACH(ERROR_HANDLES_CLOSED) \
  FOR_EACH(ERROR_OPERATION_ABORTED)

#define MAKE_ARRAY_ITEM(x) x,
const DWORD g_expected_errors[] = {
  EXPECTED_ERROR_LIST(MAKE_ARRAY_ITEM)
};
#undef MAKE_ARRAY_ITEM

#define MAKE_STRING_ITEM(x) #x,
const char* g_expected_error_strings[] = {
  EXPECTED_ERROR_LIST(MAKE_STRING_ITEM)
};
#undef MAKE_STRING_ITEM

std::string get_error_description(const DWORD err) {
  const DWORD* end = g_expected_errors + ARRAYSIZE(g_expected_errors);
  const DWORD* found = std::find(g_expected_errors, end, err);
  if (found != end) {
    return g_expected_error_strings[found - g_expected_errors];
  } else {
    char buf[64];
    _snprintf(buf, sizeof(buf), "%u", err);
    return std::string(buf);
  }
}

bool is_expected_error(const DWORD err) {
  const DWORD* end = g_expected_errors + ARRAYSIZE(g_expected_errors);
  return std::find(g_expected_errors, end, err) != end;
}

// Test to reproduce https://code.google.com/p/android/issues/detail?id=161890
bool TestCloseRaceCondition() {
  const DWORD test_duration_sec = 10;
  printf("\nTesting close race condition for %u seconds... ",
         test_duration_sec);

  ADBAPIHANDLE enum_handle =
    AdbEnumInterfaces(kAdbInterfaceId, true, true, true);
  if (NULL == enum_handle) {
    printf("\nUnable to enumerate ADB interfaces: %u", GetLastError());
    return false;
  }

  union {
    AdbInterfaceInfo interface_info;
    char buf[4096];
  };
  unsigned long buf_size = sizeof(buf);

  // Get the first interface
  if (!AdbNextInterface(enum_handle, &interface_info, &buf_size)) {
    printf("\n--- AdbNextInterface failure %u", GetLastError());
    return false;
  }

  if (!AdbCloseHandle(enum_handle)) {
    printf("\nAdbCloseHandle(enum_handle) failure: %u", GetLastError());
  }

  HANDLE thread_handle = reinterpret_cast<HANDLE>(
    _beginthreadex(NULL, 0, CloseRaceThread, NULL, 0, NULL));
  if (thread_handle == NULL) {
    printf("\n--- _beginthreadex failure %u", errno);
    return false;
  }

  // Run the test for 10 seconds. It usually reproduces the crash in 1 second.
  const DWORD tick_start = GetTickCount();
  const DWORD test_duration_ticks = test_duration_sec * 1000;
  RandomDelayer r;

  std::map<DWORD, size_t> read_errors;

  while (GetTickCount() < tick_start + test_duration_ticks) {
    // Busy-wait until close thread has cleared the handles, so that we don't
    // leak handles during the test.
    while (g_read_handle != NULL) {}
    while (g_interface_handle != NULL) {}

    ADBAPIHANDLE interface_handle = AdbCreateInterfaceByName(
      interface_info.device_name);
    if (interface_handle == NULL) {
      // Not really expected to encounter an error here.
      printf("\n--- AdbCreateInterfaceByName failure %u", GetLastError());
      continue; // try again
    }
    ADBAPIHANDLE read_handle = AdbOpenDefaultBulkReadEndpoint(
      interface_handle, AdbOpenAccessTypeReadWrite,
      AdbOpenSharingModeReadWrite);
    if (read_handle == NULL) {
      // Not really expected to encounter an error here, so report, cleanup,
      // and retry.
      printf("\n--- AdbOpenDefaultBulkReadEndpoint failure %u", GetLastError());
      AdbCloseHandle(interface_handle);
      continue;
    }

    r.SeedRandom();

    // Set handles to allow other thread to close them.
    g_read_handle = read_handle;
    g_interface_handle = interface_handle;

    // Delay random amount before calling the API that conflicts with
    // AdbCloseHandle().
    r.Delay();

    message msg_rcv;
    ULONG read_bytes = 0;

    while (AdbReadEndpointSync(read_handle, &msg_rcv, sizeof(msg_rcv),
                               &read_bytes, 0 /* infinite timeout */)) {
      // Keep reading until a crash or we're broken out of the read
      // (with an error) by the CloseRaceThread.
    }
    read_errors[GetLastError()]++;
  }

  g_stop_close_race_thread = true;
  if (WaitForSingleObject(thread_handle, INFINITE) != WAIT_OBJECT_0) {
    printf("\n--- WaitForSingleObject failure %u", GetLastError());
  }
  if (!CloseHandle(thread_handle)) {
    printf("\n--- CloseHandle failure %u", GetLastError());
  }

  // The expected errors are the errors that would be encountered if the code
  // had all the major concurrent interleavings. So the test only passes if
  // we encountered all the expected errors, and thus stress tested all the
  // possible major concurrent interleavings.
  bool pass = true;
  for (size_t i = 0; i < ARRAYSIZE(g_expected_errors); ++i) {
    // If we didn't encounter the expected error code, then the test failed.
    if (read_errors.count(g_expected_errors[i]) == 0) {
      pass = false;
      break;
    }
  }

  if (pass) {
    printf("passed");
  } else {
    printf("failed.");
    printf("\nPerhaps you just need to run the test longer or again.");
  }

  printf("\nRead Error Code\t\tCount");
  printf("\n=============================");

  for (std::map<DWORD, size_t>::iterator it = read_errors.begin();
       it != read_errors.end(); ++it) {
    printf("\n%s\t%u%s", get_error_description(it->first).c_str(), it->second,
           is_expected_error(it->first) ? " (expected)" : "");
  }

  for (size_t i = 0; i < ARRAYSIZE(g_expected_errors); ++i) {
    if (read_errors.count(g_expected_errors[i]) == 0) {
      printf("\n%s\t%u (was not encountered, but was expected)",
             get_error_description(g_expected_errors[i]).c_str(), 0);
    }
  }

  return pass;
}