diff --git a/README.md b/README.md
index c7a6bcc..9c9f549 100644
--- a/README.md
+++ b/README.md
@@ -13,17 +13,21 @@
 * Bison 3.x.x (tested with 3.0.x, 3.2.x and 3.7.x)
 
 You'll want to download some pre-requisite packages as well. If you're currently
-configured for AOSP development, you should have all required packages.
-Otherwise, you can use the following apt-get list:
+configured for AOSP development, you should have most required packages.
+Otherwise, you can use the following apt-get list or use the bootstrap script
+(see below) to get a list of packages missing on your system:
 
 ```sh
 sudo apt-get install repo git-core gnupg flex bison gperf build-essential \
   zip curl zlib1g-dev gcc-multilib g++-multilib \
-  x11proto-core-dev libx11-dev lib32z-dev libncurses5 \
+  x11proto-core-dev libx11-dev libncurses5 \
   libgl1-mesa-dev libxml2-utils xsltproc unzip liblz4-tool libssl-dev \
   libc++-dev libevent-dev \
-  flatbuffers-compiler libflatbuffers1 \
-  openssl openssl-dev
+  flatbuffers-compiler libflatbuffers1 openssl \
+  libflatbuffers-dev libtinyxml2-dev \
+  libglib2.0-dev libevent-dev libnss3-dev libdbus-1-dev \
+  libprotobuf-dev ninja-build generate-ninja protobuf-compiler \
+  libre2-9
 ```
 
 You will also need a recent-ish version of Rust and Cargo. Please follow the
@@ -37,14 +41,20 @@
 git clone https://android.googlesource.com/platform/system/bt
 ```
 
-Install dependencies (require sudo access). This adds some Ubuntu dependencies
-and also installs GN (which is the build tool we're using).
+### Use bootstrap.py
 
+`bootstrap.py` is a helper script provided to set up your build environment. It
+will set up your build staging directory and also make sure you have all
+required system packages to build (should work on Debian and Ubuntu). You will
+still need to build some unpackaged dependencies.
+
+To use it:
 ```sh
-cd ~/fluoride/bt
-build/install_deps.sh
+./bootstrap.py --base-dir=path/to/staging/dir --bt-dir=path/to/bt/dir
 ```
 
+### Build dependencies
+
 The following third-party dependencies are necessary but currently unavailable
 via a package manager. You may have to build these from source and install them
 to your local environment.
@@ -52,24 +62,59 @@
 * libchrome
 * modp_b64
 
-We provide a script to produce debian packages for those components, please
-follow the instructions in build/dpkg/README.txt.
+We provide a script to produce debian packages for those components. Please
+see the instructions in build/dpkg/README.txt for more details.
+
+```sh
+cd build/dpkg
+mkdir -p outdir/{modp_b64,libchrome}
+
+# Build and install modp_b64
+pushd modp_b64
+./gen-src-pkg.sh $(readlink -f ../outdir/modp_b64)
+popd
+sudo dpkg -i outdir/modp_b64/*.dpkg
+
+# Build and install libchrome
+pushd libchrome
+./gen-src-pkg.sh $(readlink -f ../outdir/libchrome)
+popd
+sudo dpkg -i outdir/libchrome/*.dpkg
+```
 
 The googletest packages provided by Debian/Ubuntu (libgmock-dev and
 libgtest-dev) do not provide pkg-config files, so you can build your own
 googletest using the steps below:
 
+```sh
+git clone https://github.com/google/googletest.git -b release-1.10.0
+cd googletest        # Main directory of the cloned repository.
+mkdir build          # Create a directory to hold the build output.
+cd build
+cmake ..             # Generate native build scripts for GoogleTest.
+sudo make install -DCMAKE_INSTALL_PREFIX=/usr
+
+# Optional steps if pkgconfig isn't installed to desired location
+# Modify the source (/usr/lib/x86_64-linux-gnu) and target (/usr/lib) based on
+# your local installation.
+for f in $(ls /usr/lib/x86_64-linux-gnu/pkgconfig/{gtest,gmock}*); do \
+  ln -sf $f /usr/lib/pkgconfig/$(basename $f);
+done
 ```
-$ git clone https://github.com/google/googletest.git -b release-1.10.0
-$ cd googletest        # Main directory of the cloned repository.
-$ mkdir build          # Create a directory to hold the build output.
-$ cd build
-$ cmake ..             # Generate native build scripts for GoogleTest.
-$ sudo make install -DCMAKE_INSTALL_PREFIX=/usr
+
+### Rust dependencies
+
+**Note**: Handled by bootstrap script.
+
+Run the following to install Rust dependencies:
+```
+cargo install cxxbridge-cmd
 ```
 
 ### Stage your build environment
 
+**Note**: Handled by bootstrap script.
+
 For host build, we depend on a few other repositories:
 * [Platform2](https://chromium.googlesource.com/chromiumos/platform2/)
 * [Rust crates](https://chromium.googlesource.com/chromiumos/third_party/rust_crates/)
@@ -89,7 +134,10 @@
 ### Build
 
 We provide a build script to automate building assuming you've staged your build
-environment already as above.
+environment already as above. At this point, make sure you have all the
+pre-requisites installed (i.e. bootstrap script and other dependencies above) or
+you will see failures. In addition, you may need to set a `--libdir=` if your
+libraries are not stored in `/usr/lib64` by default.
 
 
 ```sh
@@ -114,9 +162,9 @@
 ### Run
 
 By default on Linux, we statically link libbluetooth so you can just run the
-binary directly:
+binary directly. By default, it will try to run on hci0 but you can pass it
+--hci=N, where N corresponds to /sys/class/bluetooth/hciN.
 
 ```sh
-cd ~/fluoride/bt/out/Default
-./bluetoothtbd -create-ipc-socket=fluoride
+$OUTPUT_DIR/debug/btadapterd --hci=$HCI INIT_gd_hci=true
 ```
diff --git a/bootstrap.py b/bootstrap.py
new file mode 100755
index 0000000..5d03f6e
--- /dev/null
+++ b/bootstrap.py
@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+
+#  Copyright 2021 Google, Inc.
+#
+#  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.
+""" Bootstrap script to help set up Linux build. """
+
+import argparse
+import os
+import subprocess
+
+PLATFORM2_GIT = 'https://chromium.googlesource.com/chromiumos/platform2'
+RUST_CRATES_GIT = 'https://chromium.googlesource.com/chromiumos/third_party/rust_crates'
+PROTO_LOGGING_GIT = 'https://android.googlesource.com/platform/frameworks/proto_logging'
+
+# List of packages required for linux build
+REQUIRED_APT_PACKAGES = [
+    'bison',
+    'build-essential',
+    'curl',
+    'flatbuffers-compiler',
+    'flex',
+    'g++-multilib',
+    'gcc-multilib',
+    'generate-ninja',
+    'gnupg',
+    'gperf',
+    'libc++-dev',
+    'libdbus-1-dev',
+    'libevent-dev',
+    'libevent-dev',
+    'libflatbuffers-dev',
+    'libflatbuffers1',
+    'libgl1-mesa-dev',
+    'libglib2.0-dev',
+    'liblz4-tool',
+    'libncurses5',
+    'libnss3-dev',
+    'libprotobuf-dev',
+    'libre2-9',
+    'libssl-dev',
+    'libtinyxml2-dev',
+    'libx11-dev',
+    'libxml2-utils',
+    'ninja-build',
+    'openssl',
+    'protobuf-compiler',
+    'unzip',
+    'x11proto-core-dev',
+    'xsltproc',
+    'zip',
+    'zlib1g-dev',
+]
+
+# List of cargo packages required for linux build
+REQUIRED_CARGO_PACKAGES = ['cxxbridge-cmd']
+
+APT_PKG_LIST = ['apt', '-qq', 'list']
+CARGO_PKG_LIST = ['cargo', 'install', '--list']
+
+
+class Bootstrap():
+
+    def __init__(self, base_dir, bt_dir):
+        """ Construct bootstrapper.
+
+        Args:
+            base_dir: Where to stage everything.
+            bt_dir: Where bluetooth source is kept (will be symlinked)
+        """
+        self.base_dir = os.path.abspath(base_dir)
+        self.bt_dir = os.path.abspath(bt_dir)
+
+        if not os.path.isdir(self.base_dir):
+            raise Exception('{} is not a valid directory'.format(self.base_dir))
+
+        if not os.path.isdir(self.bt_dir):
+            raise Exception('{} is not a valid directory'.format(self.bt_dir))
+
+        self.git_dir = os.path.join(self.base_dir, 'repos')
+        self.staging_dir = os.path.join(self.base_dir, 'staging')
+        self.output_dir = os.path.join(self.base_dir, 'output')
+        self.external_dir = os.path.join(self.base_dir, 'staging', 'external')
+
+        self.dir_setup_complete = os.path.join(self.base_dir, '.setup-complete')
+
+    def _setup_platform2(self):
+        """ Set up platform2.
+
+        This will check out all the git repos and symlink everything correctly.
+        """
+
+        # If already set up, exit early
+        if os.path.isfile(self.dir_setup_complete):
+            print('{} is already set-up'.format(self.base_dir))
+            return
+
+        # Create all directories we will need to use
+        for dirpath in [self.git_dir, self.staging_dir, self.output_dir, self.external_dir]:
+            os.makedirs(dirpath)
+
+        # Check out all repos in git directory
+        for repo in [PLATFORM2_GIT, RUST_CRATES_GIT, PROTO_LOGGING_GIT]:
+            subprocess.check_call(['git', 'clone', repo], cwd=self.git_dir)
+
+        # Symlink things
+        symlinks = [
+            (os.path.join(self.git_dir, 'platform2', 'common-mk'), os.path.join(self.staging_dir, 'common-mk')),
+            (os.path.join(self.git_dir, 'platform2', '.gn'), os.path.join(self.staging_dir, '.gn')),
+            (os.path.join(self.bt_dir), os.path.join(self.staging_dir, 'bt')),
+            (os.path.join(self.git_dir, 'rust_crates'), os.path.join(self.external_dir, 'rust')),
+            (os.path.join(self.git_dir, 'proto_logging'), os.path.join(self.external_dir, 'proto_logging')),
+        ]
+
+        # Create symlinks
+        for pairs in symlinks:
+            (src, dst) = pairs
+            os.symlink(src, dst)
+
+        # Write to setup complete file so we don't repeat this step
+        with open(self.dir_setup_complete, 'w') as f:
+            f.write('Setup complete.')
+
+    def _pretty_print_install(self, install_cmd, packages, line_limit=80):
+        """ Pretty print an install command.
+
+        Args:
+            install_cmd: Prefixed install command.
+            packages: Enumerate packages and append them to install command.
+            line_limit: Number of characters per line.
+
+        Return:
+            Array of lines to join and print.
+        """
+        install = [install_cmd]
+        line = '  '
+        # Remainder needed = space + len(pkg) + space + \
+        # Assuming 80 character lines, that's 80 - 3 = 77
+        line_limit = line_limit - 3
+        for pkg in packages:
+            if len(line) + len(pkg) < line_limit:
+                line = '{}{} '.format(line, pkg)
+            else:
+                install.append(line)
+                line = '  {} '.format(pkg)
+
+        if len(line) > 0:
+            install.append(line)
+
+        return install
+
+    def _check_package_installed(self, package, cmd, predicate):
+        """Check that the given package is installed.
+
+        Args:
+            package: Check that this package is installed.
+            cmd: Command prefix to check if installed (package appended to end)
+            predicate: Function/lambda to check if package is installed based
+                       on output. Takes string output and returns boolean.
+
+        Return:
+            True if package is installed.
+        """
+        try:
+            output = subprocess.check_output(cmd + [package], stderr=subprocess.STDOUT)
+            is_installed = predicate(output.decode('utf-8'))
+            print('  {} is {}'.format(package, 'installed' if is_installed else 'missing'))
+
+            return is_installed
+        except Exception as e:
+            print(e)
+            return False
+
+    def _print_missing_packages(self):
+        """Print any missing packages found via apt.
+
+        This will find any missing packages necessary for build using apt and
+        print it out as an apt-get install printf.
+        """
+        print('Checking for any missing packages...')
+        need_packages = []
+        for pkg in REQUIRED_APT_PACKAGES:
+            if not self._check_package_installed(pkg, APT_PKG_LIST, lambda output: 'installed' in output):
+                need_packages.append(pkg)
+
+        # No packages need to be installed
+        if len(need_packages) == 0:
+            print('All required packages are installed')
+            return
+
+        install = self._pretty_print_install('sudo apt-get install', need_packages)
+
+        # Print all lines so they can be run in cmdline
+        print('Missing system packages. Run the following command: ')
+        print(' \\\n'.join(install))
+
+    def _print_missing_rust_packages(self):
+        """Print any missing packages found via cargo.
+
+        This will find any missing packages necessary for build using cargo and
+        print it out as a cargo-install printf.
+        """
+        print('Checking for any missing cargo packages...')
+        need_packages = []
+
+        for pkg in REQUIRED_CARGO_PACKAGES:
+            if not self._check_package_installed(pkg, CARGO_PKG_LIST, lambda output: pkg in output):
+                need_packages.append(pkg)
+
+        # No packages to be installed
+        if len(need_packages) == 0:
+            print('All required cargo packages are installed')
+            return
+
+        install = self._pretty_print_install('cargo install', need_packages)
+        print('Missing cargo packages. Run the following command: ')
+        print(' \\\n'.join(install))
+
+    def bootstrap(self):
+        """ Bootstrap the Linux build."""
+        self._setup_platform2()
+        self._print_missing_packages()
+        self._print_missing_rust_packages()
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Bootstrap Linux build')
+    parser.add_argument('--base-dir', help='Where to create build directories.', required=True)
+    parser.add_argument('--bt-dir', help='Path to system/bt', required=True)
+
+    args = parser.parse_args()
+    bootstrap = Bootstrap(args.base_dir, args.bt_dir)
+    bootstrap.bootstrap()
diff --git a/bta/Android.bp b/bta/Android.bp
index 9b33f72..dc4f171 100644
--- a/bta/Android.bp
+++ b/bta/Android.bp
@@ -173,6 +173,8 @@
         ":TestMockMainShim",
         ":TestMockStack",
         ":TestStubOsi",
+        "ar/bta_ar.cc",
+        "dm/bta_dm_api.cc",
         "dm/bta_dm_act.cc",
         "dm/bta_dm_cfg.cc",
         "dm/bta_dm_ci.cc",
diff --git a/bta/dm/bta_dm_act.cc b/bta/dm/bta_dm_act.cc
index a80ffa4..f95d8d2 100644
--- a/bta/dm/bta_dm_act.cc
+++ b/bta/dm/bta_dm_act.cc
@@ -269,7 +269,7 @@
  *
  ******************************************************************************/
 void bta_dm_init_cb(void) {
-  memset(&bta_dm_cb, 0, sizeof(bta_dm_cb));
+  bta_dm_cb = {};
   bta_dm_cb.disable_timer = alarm_new("bta_dm.disable_timer");
   bta_dm_cb.switch_delay_timer = alarm_new("bta_dm.switch_delay_timer");
   for (size_t i = 0; i < BTA_DM_NUM_PM_TIMER; i++) {
@@ -301,7 +301,7 @@
       alarm_free(bta_dm_cb.pm_timer[i].timer[j]);
     }
   }
-  memset(&bta_dm_cb, 0, sizeof(bta_dm_cb));
+  bta_dm_cb = {};
 }
 
 void BTA_dm_on_hw_off() {
@@ -401,7 +401,8 @@
      which forces
      the DM_ENABLE_EVT to be sent only after all the init steps are complete
      */
-  BTM_ReadLocalDeviceNameFromController(bta_dm_local_name_cback);
+  get_btm_client_interface().local.BTM_ReadLocalDeviceNameFromController(
+      bta_dm_local_name_cback);
 
   bta_sys_rm_register(bta_dm_rm_cback);
 
@@ -508,7 +509,7 @@
 
 /** Sets local device name */
 void bta_dm_set_dev_name(const std::vector<uint8_t>& name) {
-  BTM_SetLocalDeviceName((char*)name.data());
+  BTM_SetLocalDeviceName((const char*)name.data());
   bta_dm_set_eir((char*)name.data());
 }
 
@@ -2883,6 +2884,7 @@
 
   /* Allocate a buffer to hold HCI command */
   BT_HDR* p_buf = (BT_HDR*)osi_malloc(BTM_CMD_BUF_SIZE);
+  ASSERT(p_buf != nullptr);
   p = (uint8_t*)p_buf + BTM_HCI_EIR_OFFSET;
 
   memset(p, 0x00, HCI_EXT_INQ_RESPONSE_LEN);
diff --git a/bta/dm/bta_dm_int.h b/bta/dm/bta_dm_int.h
index 996af21..4689b05 100644
--- a/bta/dm/bta_dm_int.h
+++ b/bta/dm/bta_dm_int.h
@@ -218,7 +218,7 @@
 #define BTA_DM_PM_EXECUTE 3
 typedef uint8_t tBTA_DM_PM_REQ;
 
-struct sBTA_DM_PEER_DEVICE {
+struct tBTA_DM_PEER_DEVICE {
   RawAddress peer_bdaddr;
   tBTA_DM_CONN_STATE conn_state;
   tBTA_PREF_ROLES pref_role;
@@ -229,7 +229,7 @@
   friend void bta_dm_pm_btm_status(const RawAddress& bd_addr,
                                    tBTM_PM_STATUS status, uint16_t value,
                                    tHCI_STATUS hci_status);
-  friend void bta_dm_pm_sniff(struct sBTA_DM_PEER_DEVICE* p_peer_dev,
+  friend void bta_dm_pm_sniff(struct tBTA_DM_PEER_DEVICE* p_peer_dev,
                               uint8_t index);
   friend void bta_dm_rm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id,
                               uint8_t app_id, const RawAddress& peer_addr);
@@ -246,7 +246,6 @@
   bool remove_dev_pending;
   tBT_TRANSPORT transport;
 };
-typedef struct sBTA_DM_PEER_DEVICE tBTA_DM_PEER_DEVICE;
 
 /* structure to store list of
   active connections */
diff --git a/bta/test/bta_dm_cust_uuid_test.cc b/bta/test/bta_dm_cust_uuid_test.cc
index 205f7a7..39360f1 100644
--- a/bta/test/bta_dm_cust_uuid_test.cc
+++ b/bta/test/bta_dm_cust_uuid_test.cc
@@ -36,9 +36,7 @@
 
 class BtaCustUuid : public testing::Test {
  protected:
-  void SetUp() override {
-    memset(&bta_dm_cb, 0, sizeof(bta_dm_cb));
-  }
+  void SetUp() override { bta_dm_cb = {}; }
 };
 
 namespace {
diff --git a/bta/test/common/btm_api_mock.cc b/bta/test/common/btm_api_mock.cc
index 88d511a..e595c9d 100644
--- a/bta/test/common/btm_api_mock.cc
+++ b/bta/test/common/btm_api_mock.cc
@@ -24,11 +24,8 @@
   btm_interface = mock_btm_interface;
 }
 
-bool BTM_GetSecurityFlagsByTransport(const RawAddress& bd_addr,
-                                     uint8_t* p_sec_flags,
-                                     tBT_TRANSPORT transport) {
-  return btm_interface->GetSecurityFlagsByTransport(bd_addr, p_sec_flags,
-                                                    transport);
+bool BTM_IsEncrypted(const RawAddress& bd_addr, tBT_TRANSPORT transport) {
+  return btm_interface->BTM_IsEncrypted(bd_addr, transport);
 }
 
 tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr,
diff --git a/bta/test/common/btm_api_mock.h b/bta/test/common/btm_api_mock.h
index d337b85..3c5c20f4 100644
--- a/bta/test/common/btm_api_mock.h
+++ b/bta/test/common/btm_api_mock.h
@@ -25,9 +25,8 @@
 
 class BtmInterface {
  public:
-  virtual bool GetSecurityFlagsByTransport(const RawAddress& bd_addr,
-                                           uint8_t* p_sec_flags,
-                                           tBT_TRANSPORT transport) = 0;
+  virtual bool BTM_IsEncrypted(const RawAddress& bd_addr,
+                               tBT_TRANSPORT transport) = 0;
   virtual tBTM_STATUS SetEncryption(const RawAddress& bd_addr,
                                     tBT_TRANSPORT transport,
                                     tBTM_SEC_CALLBACK* p_callback,
@@ -38,10 +37,8 @@
 
 class MockBtmInterface : public BtmInterface {
  public:
-  MOCK_METHOD((bool), GetSecurityFlagsByTransport,
-              (const RawAddress& bd_addr, uint8_t* p_sec_flags,
-               tBT_TRANSPORT transport),
-              (override));
+  MOCK_METHOD((bool), BTM_IsEncrypted,
+              (const RawAddress& bd_addr, tBT_TRANSPORT transport), (override));
   MOCK_METHOD((tBTM_STATUS), SetEncryption,
               (const RawAddress& bd_addr, tBT_TRANSPORT transport,
                tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,
diff --git a/bta/vc/device.cc b/bta/vc/device.cc
index 9e059e7..0b5b258 100644
--- a/bta/vc/device.cc
+++ b/bta/vc/device.cc
@@ -228,12 +228,7 @@
 }
 
 bool VolumeControlDevice::IsEncryptionEnabled() {
-  uint8_t sec_flag = 0;
-  bool device_found =
-      BTM_GetSecurityFlagsByTransport(address, &sec_flag, BT_TRANSPORT_LE);
-  LOG(INFO) << __func__ << ": found=" << static_cast<int>(device_found)
-            << " sec_flag=" << loghex(sec_flag);
-  return device_found && (sec_flag & BTM_SEC_FLAG_ENCRYPTED);
+  return BTM_IsEncrypted(address, BT_TRANSPORT_LE);
 }
 
 bool VolumeControlDevice::EnableEncryption(tBTM_SEC_CALLBACK* callback) {
diff --git a/bta/vc/devices_test.cc b/bta/vc/devices_test.cc
index e1fb3d4..6763406 100644
--- a/bta/vc/devices_test.cc
+++ b/bta/vc/devices_test.cc
@@ -428,17 +428,12 @@
 }
 
 TEST_F(VolumeControlDeviceTest, test_check_link_encrypted) {
-  ON_CALL(btm_interface, GetSecurityFlagsByTransport(_, _, _))
-      .WillByDefault(
-          DoAll(SetArgPointee<1>(BTM_SEC_FLAG_ENCRYPTED), Return(true)));
+  ON_CALL(btm_interface, BTM_IsEncrypted(_, _))
+      .WillByDefault(DoAll(Return(true)));
   ASSERT_EQ(true, device->IsEncryptionEnabled());
 
-  ON_CALL(btm_interface, GetSecurityFlagsByTransport(_, _, _))
-      .WillByDefault(DoAll(SetArgPointee<1>(0), Return(false)));
-  ASSERT_NE(true, device->IsEncryptionEnabled());
-
-  ON_CALL(btm_interface, GetSecurityFlagsByTransport(_, _, _))
-      .WillByDefault(DoAll(SetArgPointee<1>(0), Return(true)));
+  ON_CALL(btm_interface, BTM_IsEncrypted(_, _))
+      .WillByDefault(DoAll(Return(false)));
   ASSERT_NE(true, device->IsEncryptionEnabled());
 }
 
diff --git a/bta/vc/vc_test.cc b/bta/vc/vc_test.cc
index dadea57..69fe509 100644
--- a/bta/vc/vc_test.cc
+++ b/bta/vc/vc_test.cc
@@ -250,9 +250,8 @@
 
   void TestConnect(const RawAddress& address) {
     // by default indicate link as encrypted
-    ON_CALL(btm_interface, GetSecurityFlagsByTransport(address, NotNull(), _))
-        .WillByDefault(
-            DoAll(SetArgPointee<1>(BTM_SEC_FLAG_ENCRYPTED), Return(true)));
+    ON_CALL(btm_interface, BTM_IsEncrypted(address, _))
+        .WillByDefault(DoAll(Return(true)));
 
     EXPECT_CALL(gatt_interface, Open(gatt_if, address, true, _));
     VolumeControl::Get()->Connect(address);
@@ -269,9 +268,8 @@
 
   void TestAddFromStorage(const RawAddress& address, bool auto_connect) {
     // by default indicate link as encrypted
-    ON_CALL(btm_interface, GetSecurityFlagsByTransport(address, NotNull(), _))
-        .WillByDefault(
-            DoAll(SetArgPointee<1>(BTM_SEC_FLAG_ENCRYPTED), Return(true)));
+    ON_CALL(btm_interface, BTM_IsEncrypted(address, _))
+        .WillByDefault(DoAll(Return(true)));
 
     if (auto_connect) {
       EXPECT_CALL(gatt_interface, Open(gatt_if, address, false, _));
@@ -360,8 +358,8 @@
   }
 
   void SetEncryptionResult(const RawAddress& address, bool success) {
-    ON_CALL(btm_interface, GetSecurityFlagsByTransport(address, NotNull(), _))
-        .WillByDefault(DoAll(SetArgPointee<1>(0), Return(true)));
+    ON_CALL(btm_interface, BTM_IsEncrypted(address, _))
+        .WillByDefault(DoAll(Return(false)));
     EXPECT_CALL(btm_interface,
                 SetEncryption(address, _, NotNull(), _, BTM_BLE_SEC_ENCRYPT))
         .WillOnce(Invoke(
diff --git a/btif/src/bluetooth.cc b/btif/src/bluetooth.cc
index 6619eee..1e299a6 100644
--- a/btif/src/bluetooth.cc
+++ b/btif/src/bluetooth.cc
@@ -630,6 +630,7 @@
 
     copy = (bt_property_t*)osi_calloc((sizeof(bt_property_t) * num_properties) +
                                       content_len);
+    ASSERT(copy != nullptr);
     uint8_t* content = (uint8_t*)(copy + num_properties);
 
     for (int i = 0; i < num_properties; i++) {
diff --git a/build/install_deps.sh b/build/install_deps.sh
deleted file mode 100755
index 4826b38..0000000
--- a/build/install_deps.sh
+++ /dev/null
@@ -1,58 +0,0 @@
-#!/bin/bash
-CLANG_PACKAGE=clang
-GNSHA1_URL="https://chromium.googlesource.com/chromium/buildtools/\
-  +/central/linux64/gn.sha1?format=TEXT"
-
-# Check if clang is already installed on current system
-clang_path=`which clang`
-if [ -f "$clang_path" ]; then
-  # if clang binary is avalable, check its version
-  clang_version=$($clang_path --version | grep clang | sed "s/.*version\s*\([0-9]*\.[0-9]*\).*/\1/")
-  IFS="." read -ra clang_version_array <<< "$clang_version"
-  clang_version_major=${clang_version_array[0]}
-  clang_version_minor=${clang_version_array[1]}
-  # if the version is greater than 3.5 then do not install clang here
-  if [ $clang_version_major -ge 3 ] && [ $clang_version_minor -ge 5 ]; then
-    echo "Detected clang $clang_version"
-    CLANG_PACKAGE=""
-  fi
-fi
-
-if [ ! -z "$CLANG_PACKAGE" ]; then
-  # Try to find clang from a known list
-  for clang_version in 12.0 11.0
-  do
-    clang_path=`which clang-$clang_version`
-    if [ -f "$clang_path" ]; then
-      echo "Detected clang-$clang_version"
-      CLANG_PACKAGE=""
-      break
-    fi
-  done
-fi
-
-if [ ! -z "$CLANG_PACKAGE" ]; then
-  echo "clang not found on current system, installing"
-  if [ -f /etc/lsb-release ]; then
-    # Ubuntu
-    ubuntu_version=$(lsb_release --release --short)
-    IFS="." read -ra ubuntu_version_array <<< "$ubuntu_version"
-    ubuntu_version_major=${ubuntu_version_array[0]}
-    ubuntu_version_minor=${ubuntu_version_array[1]}
-    if [ $ubuntu_version_major -lt 15 ]; then
-      echo "Choose clang-3.8 for Ubuntu 14 and below"
-      CLANG_PACKAGE=clang-3.8
-    fi
-  fi
-fi
-
-sudo apt-get -y install $CLANG_PACKAGE libevent-dev libc++-dev libc++abi-dev \
-  ninja-build libflatbuffers-dev libtinyxml2-dev
-
-gn_path=`which gn`
-if [ -z $gn_path ]; then
-  gnsha1=$(curl $GNSHA1_URL | base64 -d)
-  wget -O gn http://storage.googleapis.com/chromium-gn/$gnsha1
-  chmod a+x ./gn
-  sudo mv ./gn /usr/bin/
-fi
diff --git a/common/message_loop_thread.cc b/common/message_loop_thread.cc
index 643de64..21f2206 100644
--- a/common/message_loop_thread.cc
+++ b/common/message_loop_thread.cc
@@ -117,6 +117,7 @@
   {
     if (is_main_ && init_flags::gd_rust_is_enabled()) {
       delete rust_thread_;
+      rust_thread_ = nullptr;
       thread_id_ = -1;
       linux_tid_ = -1;
       return;
diff --git a/gd/dumpsys/bundler/bundler.gni b/gd/dumpsys/bundler/bundler.gni
index c3b893b..d58697a 100644
--- a/gd/dumpsys/bundler/bundler.gni
+++ b/gd/dumpsys/bundler/bundler.gni
@@ -58,7 +58,7 @@
 
       # headers get generated ito subdirectories based on relative path
       if (gen_header) {
-        header_name = string_replace(s, ".fbs", ".h")
+        header_name = string_replace(s, ".fbs", "_generated.h")
         outputs += [ "${target_gen_dir}/${header_name}" ]
       }
     }
diff --git a/gd/rust/linux/client/Cargo.toml b/gd/rust/linux/client/Cargo.toml
index 5cd23c5..9b4d7de 100644
--- a/gd/rust/linux/client/Cargo.toml
+++ b/gd/rust/linux/client/Cargo.toml
@@ -5,6 +5,7 @@
 
 [dependencies]
 rustyline = "8.0"
+rustyline-derive = "0.4.0"
 bt_topshim = { path = "../../topshim" }
 btstack = { path = "../stack" }
 manager_service = { path = "../mgmt" }
diff --git a/gd/rust/linux/client/src/command_handler.rs b/gd/rust/linux/client/src/command_handler.rs
index 787d317..48dbbe4 100644
--- a/gd/rust/linux/client/src/command_handler.rs
+++ b/gd/rust/linux/client/src/command_handler.rs
@@ -11,6 +11,7 @@
 
 use crate::console_yellow;
 use crate::print_info;
+use crate::{BluetoothDBus, BluetoothManagerDBus};
 
 struct BtCallback {
     objpath: String,
@@ -60,21 +61,37 @@
 }
 
 /// Handles string command entered from command line.
-pub struct CommandHandler<TBluetoothManager: IBluetoothManager, TBluetooth: IBluetooth> {
-    bluetooth_manager: Arc<Mutex<Box<TBluetoothManager>>>,
-    bluetooth: Arc<Mutex<Box<TBluetooth>>>,
+pub(crate) struct CommandHandler {
+    bluetooth_manager: Arc<Mutex<Box<BluetoothManagerDBus>>>,
+    bluetooth: Arc<Mutex<Box<BluetoothDBus>>>,
 
     is_bluetooth_callback_registered: bool,
+
+    commands: Vec<String>,
 }
 
-impl<TBluetoothManager: IBluetoothManager, TBluetooth: IBluetooth>
-    CommandHandler<TBluetoothManager, TBluetooth>
-{
+impl CommandHandler {
+    /// Creates a new CommandHandler.
+    ///
+    /// * `commands` - List of commands for `help`.
     pub fn new(
-        bluetooth_manager: Arc<Mutex<Box<TBluetoothManager>>>,
-        bluetooth: Arc<Mutex<Box<TBluetooth>>>,
-    ) -> CommandHandler<TBluetoothManager, TBluetooth> {
-        CommandHandler { bluetooth_manager, bluetooth, is_bluetooth_callback_registered: false }
+        bluetooth_manager: Arc<Mutex<Box<BluetoothManagerDBus>>>,
+        bluetooth: Arc<Mutex<Box<BluetoothDBus>>>,
+        commands: Vec<String>,
+    ) -> CommandHandler {
+        CommandHandler {
+            bluetooth_manager,
+            bluetooth,
+            is_bluetooth_callback_registered: false,
+            commands,
+        }
+    }
+
+    pub fn cmd_help(&self) {
+        println!("Available commands:");
+        for cmd in &self.commands {
+            println!("{}", cmd);
+        }
     }
 
     pub fn cmd_enable(&self, _cmd: String) {
diff --git a/gd/rust/linux/client/src/dbus_iface.rs b/gd/rust/linux/client/src/dbus_iface.rs
index 9640efb..22ce08c 100644
--- a/gd/rust/linux/client/src/dbus_iface.rs
+++ b/gd/rust/linux/client/src/dbus_iface.rs
@@ -21,6 +21,10 @@
 
 use crate::dbus_arg::{DBusArg, DBusArgError, RefArgToRust};
 
+fn make_object_path(idx: i32, name: &str) -> dbus::Path {
+    dbus::Path::new(format!("/org/chromium/bluetooth/hci{}/{}", idx, name)).unwrap()
+}
+
 impl_dbus_arg_enum!(BluetoothTransport);
 impl_dbus_arg_enum!(BtSspVariant);
 
@@ -115,14 +119,17 @@
 }
 
 impl BluetoothDBus {
-    pub(crate) fn new(conn: Arc<SyncConnection>, cr: Arc<Mutex<Crossroads>>) -> BluetoothDBus {
-        // TODO: Adapter client should dynamically accept hci # and be initialized
+    pub(crate) fn new(
+        conn: Arc<SyncConnection>,
+        cr: Arc<Mutex<Crossroads>>,
+        index: i32,
+    ) -> BluetoothDBus {
         BluetoothDBus {
             client_proxy: ClientDBusProxy {
                 conn: conn.clone(),
                 cr: cr,
                 bus_name: String::from("org.chromium.bluetooth"),
-                objpath: dbus::Path::new("/org/chromium/bluetooth/adapter0").unwrap(),
+                objpath: make_object_path(index, "adapter"),
                 interface: String::from("org.chromium.bluetooth.Bluetooth"),
             },
         }
diff --git a/gd/rust/linux/client/src/editor.rs b/gd/rust/linux/client/src/editor.rs
index b7ede2c..10a1dd9 100644
--- a/gd/rust/linux/client/src/editor.rs
+++ b/gd/rust/linux/client/src/editor.rs
@@ -2,7 +2,13 @@
 
 use futures::Future;
 
-use rustyline::{Config, Editor};
+use rustyline::completion::Completer;
+use rustyline::error::ReadlineError;
+use rustyline::highlight::Highlighter;
+use rustyline::hint::Hinter;
+use rustyline::validate::Validator;
+use rustyline::{CompletionType, Config, Editor};
+use rustyline_derive::Helper;
 
 use std::pin::Pin;
 use std::sync::{Arc, Mutex};
@@ -10,13 +16,50 @@
 
 use crate::console_blue;
 
+#[derive(Helper)]
+struct BtHelper {
+    commands: Vec<String>,
+}
+
+impl Completer for BtHelper {
+    type Candidate = String;
+
+    // Returns completion based on supported commands.
+    // TODO: Add support to autocomplete BT address, command parameters, etc.
+    fn complete(
+        &self,
+        line: &str,
+        pos: usize,
+        _ctx: &rustyline::Context<'_>,
+    ) -> Result<(usize, Vec<String>), ReadlineError> {
+        let slice = &line[..pos];
+        let mut completions = vec![];
+
+        for cmd in self.commands.iter() {
+            if cmd.starts_with(slice) {
+                completions.push(cmd.clone());
+            }
+        }
+
+        Ok((0, completions))
+    }
+}
+
+impl Hinter for BtHelper {
+    type Hint = String;
+}
+
+impl Highlighter for BtHelper {}
+
+impl Validator for BtHelper {}
+
 /// A future that does async readline().
 ///
 /// async readline() is implemented by spawning a thread for the blocking readline(). While this
 /// readline() thread is blocked, it yields back to executor and will wake the executor up when the
 /// blocked thread has proceeded and got input from readline().
 pub struct AsyncReadline {
-    rl: Arc<Mutex<Editor<()>>>,
+    rl: Arc<Mutex<Editor<BtHelper>>>,
     result: Arc<Mutex<Option<rustyline::Result<String>>>>,
 }
 
@@ -44,15 +87,22 @@
 
 /// Wrapper of rustyline editor that supports async readline().
 pub struct AsyncEditor {
-    rl: Arc<Mutex<Editor<()>>>,
+    rl: Arc<Mutex<Editor<BtHelper>>>,
 }
 
 impl AsyncEditor {
     /// Creates new async rustyline editor.
-    pub fn new() -> AsyncEditor {
-        let builder = Config::builder().auto_add_history(true).history_ignore_dups(true);
+    ///
+    /// * `commands` - List of commands for autocomplete.
+    pub fn new(commands: Vec<String>) -> AsyncEditor {
+        let builder = Config::builder()
+            .auto_add_history(true)
+            .history_ignore_dups(true)
+            .completion_type(CompletionType::List);
         let config = builder.build();
-        let rl = rustyline::Editor::<()>::with_config(config);
+        let mut rl = rustyline::Editor::with_config(config);
+        let helper = BtHelper { commands };
+        rl.set_helper(Some(helper));
         AsyncEditor { rl: Arc::new(Mutex::new(rl)) }
     }
 
diff --git a/gd/rust/linux/client/src/main.rs b/gd/rust/linux/client/src/main.rs
index be7e6a0..808b1fe 100644
--- a/gd/rust/linux/client/src/main.rs
+++ b/gd/rust/linux/client/src/main.rs
@@ -50,11 +50,13 @@
 }
 
 // This creates the API implementations over D-Bus.
-fn create_api_dbus(conn: Arc<SyncConnection>, cr: Arc<Mutex<Crossroads>>) -> API {
-    let bluetooth = Arc::new(Mutex::new(Box::new(BluetoothDBus::new(conn.clone(), cr.clone()))));
+fn create_api_dbus(conn: Arc<SyncConnection>, cr: Arc<Mutex<Crossroads>>, idx: i32) -> API {
     let bluetooth_manager =
         Arc::new(Mutex::new(Box::new(BluetoothManagerDBus::new(conn.clone(), cr.clone()))));
 
+    let bluetooth =
+        Arc::new(Mutex::new(Box::new(BluetoothDBus::new(conn.clone(), cr.clone(), idx))));
+
     API { bluetooth_manager, bluetooth }
 }
 
@@ -90,7 +92,9 @@
             }),
         );
 
-        let api = create_api_dbus(conn, cr);
+        // We only need hci index 0 for now.
+        // TODO: Have a mechanism (e.g. CLI argument or btclient command) to select the hci index.
+        let api = create_api_dbus(conn, cr, 0);
 
         // TODO: Registering the callback should be done when btmanagerd is ready (detect with
         // ObjectManager).
@@ -98,9 +102,26 @@
             objpath: String::from("/org/chromium/bluetooth/client/bluetooth_manager_callback"),
         }));
 
-        let mut handler = CommandHandler::new(api.bluetooth_manager.clone(), api.bluetooth.clone());
+        // TODO(b/193719802): Refactor this into a dedicated "Help" data structure.
+        let commands = vec![
+            String::from("help"),
+            String::from("enable"),
+            String::from("disable"),
+            String::from("get_address"),
+            String::from("start_discovery"),
+            String::from("cancel_discovery"),
+            String::from("create_bond"),
+        ];
+
+        let mut handler = CommandHandler::new(
+            api.bluetooth_manager.clone(),
+            api.bluetooth.clone(),
+            commands.clone(),
+        );
 
         let mut handle_cmd = move |cmd: String| match cmd.split(' ').collect::<Vec<&str>>()[0] {
+            "help" => handler.cmd_help(),
+
             "enable" => handler.cmd_enable(cmd),
             "disable" => handler.cmd_disable(cmd),
             "get_address" => handler.cmd_get_address(cmd),
@@ -115,7 +136,7 @@
             _ => print_info!("Command \"{}\" not recognized", cmd),
         };
 
-        let editor = AsyncEditor::new();
+        let editor = AsyncEditor::new(commands.clone());
 
         loop {
             let result = editor.readline().await;
diff --git a/gd/rust/linux/mgmt/src/bin/btmanagerd/state_machine.rs b/gd/rust/linux/mgmt/src/bin/btmanagerd/state_machine.rs
index 61189cd..fdcdf84 100644
--- a/gd/rust/linux/mgmt/src/bin/btmanagerd/state_machine.rs
+++ b/gd/rust/linux/mgmt/src/bin/btmanagerd/state_machine.rs
@@ -5,7 +5,7 @@
 use nix::unistd::Pid;
 use regex::Regex;
 use std::process::{Child, Command, Stdio};
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 use std::time::Duration;
 use tokio::io::unix::AsyncFd;
 use tokio::sync::mpsc;
@@ -265,7 +265,7 @@
                 {
                     prev_state = *context.state_machine.state.lock().unwrap();
                 }
-                let mut hci = 0;
+                let hci;
 
                 match action {
                     AdapterStateActions::StartBluetooth(i) => {
@@ -487,6 +487,9 @@
 }
 
 impl ManagerStateMachine<NativeSubprocess> {
+    // NativeSubprocess is not used but is still useful for testing in Linux without upstart.
+    // Don't remove just yet.
+    #[allow(dead_code)]
     pub fn new_native() -> ManagerStateMachine<NativeSubprocess> {
         ManagerStateMachine::new(NativeSubprocess::new())
     }
diff --git a/gd/rust/linux/service/src/main.rs b/gd/rust/linux/service/src/main.rs
index ae4b57f..9e5104a 100644
--- a/gd/rust/linux/service/src/main.rs
+++ b/gd/rust/linux/service/src/main.rs
@@ -27,9 +27,6 @@
 mod iface_bluetooth_media;
 
 const DBUS_SERVICE_NAME: &str = "org.chromium.bluetooth";
-const OBJECT_BLUETOOTH: &str = "/org/chromium/bluetooth/adapter";
-const OBJECT_BLUETOOTH_GATT: &str = "/org/chromium/bluetooth/gatt";
-const OBJECT_BLUETOOTH_MEDIA: &str = "/org/chromium/bluetooth/media";
 
 /// Check command line arguments for target hci adapter (--hci=N). If no adapter
 /// is set, default to 0.
@@ -46,6 +43,10 @@
     0
 }
 
+fn make_object_name(idx: i32, name: &str) -> String {
+    String::from(format!("/org/chromium/bluetooth/hci{}/{}", idx, name))
+}
+
 /// Runs the Bluetooth daemon serving D-Bus IPC.
 fn main() -> Result<(), Box<dyn Error>> {
     let (tx, rx) = Stack::create_channel();
@@ -103,7 +104,7 @@
 
         // Register D-Bus method handlers of IBluetooth.
         iface_bluetooth::export_bluetooth_dbus_obj(
-            String::from(format!("{}{}", OBJECT_BLUETOOTH, adapter_index)),
+            make_object_name(adapter_index, "adapter"),
             conn.clone(),
             &mut cr,
             bluetooth,
@@ -111,7 +112,7 @@
         );
         // Register D-Bus method handlers of IBluetoothGatt.
         iface_bluetooth_gatt::export_bluetooth_gatt_dbus_obj(
-            String::from(format!("{}{}", OBJECT_BLUETOOTH_GATT, adapter_index)),
+            make_object_name(adapter_index, "gatt"),
             conn.clone(),
             &mut cr,
             bluetooth_gatt,
@@ -119,7 +120,7 @@
         );
 
         iface_bluetooth_media::export_bluetooth_media_dbus_obj(
-            String::from(format!("{}{}", OBJECT_BLUETOOTH_MEDIA, adapter_index)),
+            make_object_name(adapter_index, "media"),
             conn.clone(),
             &mut cr,
             bluetooth_media,
diff --git a/main/shim/btm_api.h b/main/shim/btm_api.h
index 82dcc5f..bf5ed84 100644
--- a/main/shim/btm_api.h
+++ b/main/shim/btm_api.h
@@ -871,7 +871,7 @@
  * Returns          BTM_CMD_STARTED if successful, otherwise an error
  *
  ******************************************************************************/
-tBTM_STATUS BTM_SetLocalDeviceName(char* p_name);
+tBTM_STATUS BTM_SetLocalDeviceName(const char* p_name);
 
 /*******************************************************************************
  *
diff --git a/osi/Android.bp b/osi/Android.bp
index 611e37f..97a507d 100644
--- a/osi/Android.bp
+++ b/osi/Android.bp
@@ -45,6 +45,13 @@
     },
 }
 
+filegroup {
+  name: "OsiCompatSources",
+  srcs: [
+    "src/compat.cc",
+  ],
+}
+
 // libosi static library for target
 cc_library_static {
     name: "libosi",
@@ -52,12 +59,12 @@
     // TODO(mcchou): Remove socket_utils sources after platform specific
     // dependencies are abstracted.
     srcs: [
+        ":OsiCompatSources",
         "src/alarm.cc",
         "src/allocation_tracker.cc",
         "src/allocator.cc",
         "src/array.cc",
         "src/buffer.cc",
-        "src/compat.cc",
         "src/config.cc",
         "src/fixed_queue.cc",
         "src/future.cc",
@@ -73,6 +80,7 @@
         "src/socket_utils/socket_local_client.cc",
         "src/socket_utils/socket_local_server.cc",
         "src/thread.cc",
+        "src/thread_scheduler.cc",
         "src/wakelock.cc",
     ],
     shared_libs: [
diff --git a/osi/include/properties.h b/osi/include/properties.h
index b186f4f..8617612 100644
--- a/osi/include/properties.h
+++ b/osi/include/properties.h
@@ -20,7 +20,10 @@
 
 #include <cstdint>
 
+#ifndef PROPERTY_VALUE_MAX
 #define PROPERTY_VALUE_MAX 92
+#endif  // PROPERTY_VALUE_MAX
+
 #define BUILD_SANITY_PROPERTY_VALUE_MAX 92
 
 // Get value associated with key |key| into |value|.
diff --git a/osi/include/thread_scheduler.h b/osi/include/thread_scheduler.h
new file mode 100644
index 0000000..e377268
--- /dev/null
+++ b/osi/include/thread_scheduler.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2021 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.
+ */
+
+#pragma once
+
+bool thread_scheduler_enable_real_time(pid_t pid);
+bool thread_scheduler_get_priority_range(int& min, int& max);
diff --git a/osi/src/thread_scheduler.cc b/osi/src/thread_scheduler.cc
new file mode 100644
index 0000000..b001c2c
--- /dev/null
+++ b/osi/src/thread_scheduler.cc
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2021 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.
+ */
+
+#include <sched.h>
+#include <sys/types.h>
+
+namespace {
+constexpr int kRealTimeFifoSchedulingPriority = 1;
+}  // namespace
+
+bool thread_scheduler_enable_real_time(pid_t linux_tid) {
+  struct sched_param rt_params = {.sched_priority =
+                                      kRealTimeFifoSchedulingPriority};
+  return sched_setscheduler(linux_tid, SCHED_FIFO, &rt_params) == 0;
+}
+
+bool thread_scheduler_get_priority_range(int& min, int& max) {
+  min = sched_get_priority_min(SCHED_FIFO);
+  max = sched_get_priority_max(SCHED_FIFO);
+  return (min != -1 && max != -1) ? true : false;
+}
diff --git a/stack/Android.bp b/stack/Android.bp
index 502c266..c231662 100644
--- a/stack/Android.bp
+++ b/stack/Android.bp
@@ -1012,6 +1012,7 @@
         "BluetoothGeneratedPackets_h",
     ],
     srcs: [
+        ":OsiCompatSources",
         ":TestMockBta",
         ":TestMockBtif",
         ":TestMockHci",
diff --git a/stack/btm/btm_devctl.cc b/stack/btm/btm_devctl.cc
index 598c64f..0ecdde0 100644
--- a/stack/btm/btm_devctl.cc
+++ b/stack/btm/btm_devctl.cc
@@ -313,7 +313,7 @@
  * Returns          status of the operation
  *
  ******************************************************************************/
-tBTM_STATUS BTM_SetLocalDeviceName(char* p_name) {
+tBTM_STATUS BTM_SetLocalDeviceName(const char* p_name) {
   uint8_t* p;
 
   if (!p_name || !p_name[0] || (strlen((char*)p_name) > BD_NAME_LEN))
diff --git a/stack/gap/gap_ble.cc b/stack/gap/gap_ble.cc
index f6b047c..e3175cc 100644
--- a/stack/gap/gap_ble.cc
+++ b/stack/gap/gap_ble.cc
@@ -502,7 +502,7 @@
           break;
 
         case GATT_UUID_GAP_DEVICE_NAME:
-          BTM_SetLocalDeviceName((char*)p_value->p_dev_name);
+          BTM_SetLocalDeviceName((const char*)p_value->p_dev_name);
           break;
 
         case GATT_UUID_GAP_CENTRAL_ADDR_RESOL:
diff --git a/stack/include/btm_api.h b/stack/include/btm_api.h
index 8cf6ac8..0428311 100644
--- a/stack/include/btm_api.h
+++ b/stack/include/btm_api.h
@@ -71,7 +71,7 @@
  * Returns          BTM_CMD_STARTED if successful, otherwise an error
  *
  ******************************************************************************/
-tBTM_STATUS BTM_SetLocalDeviceName(char* p_name);
+tBTM_STATUS BTM_SetLocalDeviceName(const char* p_name);
 
 /*******************************************************************************
  *
diff --git a/stack/include/btm_client_interface.h b/stack/include/btm_client_interface.h
index 52333cb..c63a0f2 100644
--- a/stack/include/btm_client_interface.h
+++ b/stack/include/btm_client_interface.h
@@ -201,7 +201,7 @@
   struct {
     tBTM_STATUS (*BTM_ReadLocalDeviceNameFromController)(
         tBTM_CMPL_CB* p_rln_cmpl_cback);
-    tBTM_STATUS (*BTM_SetLocalDeviceName)(char* p_name);
+    tBTM_STATUS (*BTM_SetLocalDeviceName)(const char* p_name);
     tBTM_STATUS (*BTM_SetDeviceClass)(DEV_CLASS dev_class);
     bool (*BTM_IsDeviceUp)();
     uint8_t* (*BTM_ReadDeviceClass)();
diff --git a/stack/test/common/mock_bta_dm_act.cc b/stack/test/common/mock_bta_dm_act.cc
deleted file mode 100644
index 0b64f6f..0000000
--- a/stack/test/common/mock_bta_dm_act.cc
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Copyright 2020 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.
- */
-
-/*
- * Generated mock file from original source file
- *   Functions generated:53
- */
-
-#include <map>
-#include <string>
-
-extern std::map<std::string, int> mock_function_count_map;
-
-#include "bta/dm/bta_dm_int.h"
-#include "types/raw_address.h"
-
-#ifndef UNUSED_ATTR
-#define UNUSED_ATTR
-#endif
-
-void BTA_dm_acl_down(const RawAddress bd_addr, tBT_TRANSPORT transport) {
-  mock_function_count_map[__func__]++;
-}
-void BTA_dm_acl_up(const RawAddress bd_addr, tBT_TRANSPORT transport) {
-  mock_function_count_map[__func__]++;
-}
-void BTA_dm_notify_remote_features_complete(const RawAddress bd_addr) {
-  mock_function_count_map[__func__]++;
-}
-
-void BTA_dm_on_hw_off() { mock_function_count_map[__func__]++; }
-void BTA_dm_on_hw_on() { mock_function_count_map[__func__]++; }
-void BTA_dm_report_role_change(const RawAddress bd_addr, tHCI_ROLE new_role,
-                               tHCI_STATUS hci_status) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_add_device(std::unique_ptr<tBTA_DM_API_ADD_DEVICE> msg) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_bond(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
-                 tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_bond_cancel(const RawAddress& bd_addr) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_ci_rmt_oob_act(std::unique_ptr<tBTA_DM_CI_RMT_OOB> msg) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_close_acl(const RawAddress& bd_addr, bool remove_dev,
-                      tBT_TRANSPORT transport) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_confirm(const RawAddress& bd_addr, bool accept) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_deinit_cb(void) { mock_function_count_map[__func__]++; }
-void bta_dm_disable() { mock_function_count_map[__func__]++; }
-void bta_dm_disc_result(tBTA_DM_MSG* p_data) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_disc_rmt_name(tBTA_DM_MSG* p_data) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_discover(tBTA_DM_MSG* p_data) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_free_sdp_db() { mock_function_count_map[__func__]++; }
-void bta_dm_init_cb(void) { mock_function_count_map[__func__]++; }
-void bta_dm_inq_cmpl(uint8_t num) { mock_function_count_map[__func__]++; }
-void bta_dm_pin_reply(std::unique_ptr<tBTA_DM_API_PIN_REPLY> msg) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_process_remove_device(const RawAddress& bd_addr) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_queue_disc(tBTA_DM_MSG* p_data) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_queue_search(tBTA_DM_MSG* p_data) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_remove_device(const RawAddress& bd_addr) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_rmt_name(tBTA_DM_MSG* p_data) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_sdp_result(tBTA_DM_MSG* p_data) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_search_cancel() { mock_function_count_map[__func__]++; }
-void bta_dm_search_cancel_cmpl() { mock_function_count_map[__func__]++; }
-void bta_dm_search_cancel_notify() { mock_function_count_map[__func__]++; }
-void bta_dm_execute_queued_request() { mock_function_count_map[__func__]++; }
-bool bta_dm_is_search_request_queued() {
-  mock_function_count_map[__func__]++;
-  return false;
-}
-void bta_dm_search_clear_queue() { mock_function_count_map[__func__]++; }
-void bta_dm_search_cmpl() { mock_function_count_map[__func__]++; }
-void bta_dm_search_result(tBTA_DM_MSG* p_data) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_search_start(tBTA_DM_MSG* p_data) {
-  mock_function_count_map[__func__]++;
-}
-void bta_dm_set_dev_name(const std::vector<uint8_t>& name) {
-  mock_function_count_map[__func__]++;
-}
diff --git a/stack/test/common/mock_main_shim_btm_api.cc b/stack/test/common/mock_main_shim_btm_api.cc
deleted file mode 100644
index 927cb73..0000000
--- a/stack/test/common/mock_main_shim_btm_api.cc
+++ /dev/null
@@ -1,466 +0,0 @@
-/*
- * Copyright 2020 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.
- */
-
-/*
- * Generated mock file from original source file
- *   Functions generated:85
- */
-
-#include <map>
-#include <string>
-
-extern std::map<std::string, int> mock_function_count_map;
-
-#include <base/callback.h>
-#include <mutex>
-#include "common/metric_id_allocator.h"
-#include "common/time_util.h"
-#include "device/include/controller.h"
-#include "main/shim/btm_api.h"
-#include "main/shim/controller.h"
-#include "main/shim/link_policy.h"
-#include "main/shim/shim.h"
-#include "stack/btm/btm_int_types.h"
-#include "types/raw_address.h"
-
-#ifndef UNUSED_ATTR
-#define UNUSED_ATTR
-#endif
-
-Octet16 octet16;
-
-bool bluetooth::shim::BTM_BleDataSignature(const RawAddress& bd_addr,
-                                           uint8_t* p_text, uint16_t len,
-                                           BLE_SIGNATURE signature) {
-  mock_function_count_map[__func__]++;
-  return false;
-}
-bool bluetooth::shim::BTM_BleLocalPrivacyEnabled(void) {
-  mock_function_count_map[__func__]++;
-  return false;
-}
-bool bluetooth::shim::BTM_BleSecurityProcedureIsRunning(
-    const RawAddress& bd_addr) {
-  mock_function_count_map[__func__]++;
-  return false;
-}
-bool bluetooth::shim::BTM_BleVerifySignature(const RawAddress& bd_addr,
-                                             uint8_t* p_orig, uint16_t len,
-                                             uint32_t counter,
-                                             uint8_t* p_comp) {
-  mock_function_count_map[__func__]++;
-  return false;
-}
-bool bluetooth::shim::BTM_GetLeSecurityState(const RawAddress& bd_addr,
-                                             uint8_t* p_le_dev_sec_flags,
-                                             uint8_t* p_le_key_size) {
-  mock_function_count_map[__func__]++;
-  return false;
-}
-bool bluetooth::shim::BTM_HasEirService(const uint32_t* p_eir_uuid,
-                                        uint16_t uuid16) {
-  mock_function_count_map[__func__]++;
-  return false;
-}
-bool bluetooth::shim::BTM_ReadConnectedTransportAddress(
-    RawAddress* remote_bda, tBT_TRANSPORT transport) {
-  mock_function_count_map[__func__]++;
-  return false;
-}
-bool bluetooth::shim::BTM_ReadRemoteConnectionAddr(
-    const RawAddress& pseudo_addr, RawAddress& conn_addr,
-    tBLE_ADDR_TYPE* p_addr_type) {
-  mock_function_count_map[__func__]++;
-  return false;
-}
-bool bluetooth::shim::BTM_SecAddDevice(const RawAddress& bd_addr,
-                                       DEV_CLASS dev_class, BD_NAME bd_name,
-                                       uint8_t* features, LinkKey* link_key,
-                                       uint8_t key_type, uint8_t pin_length) {
-  mock_function_count_map[__func__]++;
-  return false;
-}
-bool bluetooth::shim::BTM_SecAddRmtNameNotifyCallback(
-    tBTM_RMT_NAME_CALLBACK* p_callback) {
-  mock_function_count_map[__func__]++;
-  return false;
-}
-bool bluetooth::shim::BTM_SecDeleteDevice(const RawAddress& bd_addr) {
-  mock_function_count_map[__func__]++;
-  return false;
-}
-bool bluetooth::shim::BTM_SecDeleteRmtNameNotifyCallback(
-    tBTM_RMT_NAME_CALLBACK* p_callback) {
-  mock_function_count_map[__func__]++;
-  return false;
-}
-bool bluetooth::shim::BTM_SecRegister(const tBTM_APPL_INFO* bta_callbacks) {
-  mock_function_count_map[__func__]++;
-  return false;
-}
-bool bluetooth::shim::BTM_UseLeLink(const RawAddress& raw_address) {
-  mock_function_count_map[__func__]++;
-  return false;
-}
-char* bluetooth::shim::BTM_SecReadDevName(const RawAddress& address) {
-  mock_function_count_map[__func__]++;
-  return nullptr;
-}
-const Octet16& bluetooth::shim::BTM_GetDeviceEncRoot() {
-  mock_function_count_map[__func__]++;
-  return octet16;
-}
-const Octet16& bluetooth::shim::BTM_GetDeviceDHK() {
-  mock_function_count_map[__func__]++;
-  return octet16;
-}
-const Octet16& bluetooth::shim::BTM_GetDeviceIDRoot() {
-  mock_function_count_map[__func__]++;
-  return octet16;
-}
-tBTM_EIR_SEARCH_RESULT bluetooth::shim::BTM_HasInquiryEirService(
-    tBTM_INQ_RESULTS* p_results, uint16_t uuid16) {
-  mock_function_count_map[__func__]++;
-  return 0;
-}
-tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbFirst(void) {
-  mock_function_count_map[__func__]++;
-  return nullptr;
-}
-tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbNext(tBTM_INQ_INFO* p_cur) {
-  mock_function_count_map[__func__]++;
-  return nullptr;
-}
-tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbRead(const RawAddress& p_bda) {
-  mock_function_count_map[__func__]++;
-  return nullptr;
-}
-tBTM_STATUS bluetooth::shim::BTM_BleObserve(bool start, uint8_t duration_sec,
-                                            tBTM_INQ_RESULTS_CB* p_results_cb,
-                                            tBTM_CMPL_CB* p_cmpl_cb) {
-  mock_function_count_map[__func__]++;
-  return BTM_SUCCESS;
-}
-tBTM_STATUS bluetooth::shim::BTM_CancelRemoteDeviceName(void) {
-  mock_function_count_map[__func__]++;
-  return BTM_SUCCESS;
-}
-tBTM_STATUS bluetooth::shim::BTM_ClearInqDb(const RawAddress* p_bda) {
-  mock_function_count_map[__func__]++;
-  return BTM_SUCCESS;
-}
-tBTM_STATUS bluetooth::shim::BTM_ReadRemoteDeviceName(
-    const RawAddress& raw_address, tBTM_CMPL_CB* callback,
-    tBT_TRANSPORT transport) {
-  mock_function_count_map[__func__]++;
-  return BTM_SUCCESS;
-}
-tBTM_STATUS bluetooth::shim::BTM_SecBond(const RawAddress& bd_addr,
-                                         tBLE_ADDR_TYPE addr_type,
-                                         tBT_TRANSPORT transport,
-                                         tBT_DEVICE_TYPE device_type) {
-  mock_function_count_map[__func__]++;
-  return BTM_SUCCESS;
-}
-tBTM_STATUS bluetooth::shim::BTM_SecBondCancel(const RawAddress& bd_addr) {
-  mock_function_count_map[__func__]++;
-  return BTM_SUCCESS;
-}
-tBTM_STATUS bluetooth::shim::BTM_SetConnectability(uint16_t page_mode,
-                                                   uint16_t window,
-                                                   uint16_t interval) {
-  mock_function_count_map[__func__]++;
-  return BTM_SUCCESS;
-}
-tBTM_STATUS bluetooth::shim::BTM_SetDeviceClass(DEV_CLASS dev_class) {
-  mock_function_count_map[__func__]++;
-  return BTM_SUCCESS;
-}
-tBTM_STATUS bluetooth::shim::BTM_SetDiscoverability(uint16_t discoverable_mode,
-                                                    uint16_t window,
-                                                    uint16_t interval) {
-  mock_function_count_map[__func__]++;
-  return BTM_SUCCESS;
-}
-tBTM_STATUS bluetooth::shim::BTM_SetEncryption(const RawAddress& bd_addr,
-                                               tBT_TRANSPORT transport,
-                                               tBTM_SEC_CALLBACK* p_callback,
-                                               void* p_ref_data,
-                                               tBTM_BLE_SEC_ACT sec_act) {
-  mock_function_count_map[__func__]++;
-  return BTM_SUCCESS;
-}
-tBTM_STATUS bluetooth::shim::BTM_SetInquiryMode(uint8_t inquiry_mode) {
-  mock_function_count_map[__func__]++;
-  return BTM_SUCCESS;
-}
-tBTM_STATUS bluetooth::shim::BTM_StartInquiry(tBTM_INQ_RESULTS_CB* p_results_cb,
-                                              tBTM_CMPL_CB* p_cmpl_cb) {
-  mock_function_count_map[__func__]++;
-  return BTM_SUCCESS;
-}
-tBTM_STATUS bluetooth::shim::BTM_WriteEIR(BT_HDR* p_buff) {
-  mock_function_count_map[__func__]++;
-  return BTM_SUCCESS;
-}
-tBTM_STATUS bluetooth::shim::btm_sec_mx_access_request(
-    const RawAddress& bd_addr, bool is_originator,
-    uint16_t security_requirement, tBTM_SEC_CALLBACK* p_callback,
-    void* p_ref_data) {
-  mock_function_count_map[__func__]++;
-  return BTM_SUCCESS;
-}
-uint16_t bluetooth::shim::BTM_GetHCIConnHandle(const RawAddress& remote_bda,
-                                               tBT_TRANSPORT transport) {
-  mock_function_count_map[__func__]++;
-  return 0;
-}
-uint16_t bluetooth::shim::BTM_IsInquiryActive(void) {
-  mock_function_count_map[__func__]++;
-  return 0;
-}
-uint8_t bluetooth::shim::BTM_BleGetSupportedKeySize(const RawAddress& bd_addr) {
-  mock_function_count_map[__func__]++;
-  return 0;
-}
-uint8_t bluetooth::shim::BTM_BleMaxMultiAdvInstanceCount() {
-  mock_function_count_map[__func__]++;
-  return 0;
-}
-uint8_t bluetooth::shim::BTM_GetEirSupportedServices(uint32_t* p_eir_uuid,
-                                                     uint8_t** p,
-                                                     uint8_t max_num_uuid16,
-                                                     uint8_t* p_num_uuid16) {
-  mock_function_count_map[__func__]++;
-  return 0;
-}
-uint8_t bluetooth::shim::BTM_GetEirUuidList(uint8_t* p_eir, size_t eir_len,
-                                            uint8_t uuid_size,
-                                            uint8_t* p_num_uuid,
-                                            uint8_t* p_uuid_list,
-                                            uint8_t max_num_uuid) {
-  mock_function_count_map[__func__]++;
-  return 0;
-}
-void bluetooth::shim::BTM_AddEirService(uint32_t* p_eir_uuid, uint16_t uuid16) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_BleAdvFilterParamSetup(
-    int action, tBTM_BLE_PF_FILT_INDEX filt_index,
-    std::unique_ptr<btgatt_filt_param_setup_t> p_filt_params,
-    tBTM_BLE_PF_PARAM_CB cb) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_BleEnableDisableFilterFeature(
-    uint8_t enable, tBTM_BLE_PF_STATUS_CBACK p_stat_cback) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_BleLoadLocalKeys(uint8_t key_type,
-                                           tBTM_BLE_LOCAL_KEYS* p_key) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_BleOobDataReply(const RawAddress& bd_addr,
-                                          uint8_t res, uint8_t len,
-                                          uint8_t* p_data) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_BleReadPhy(
-    const RawAddress& bd_addr,
-    base::Callback<void(uint8_t tx_phy, uint8_t rx_phy, uint8_t status)> cb) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_BleReceiverTest(uint8_t rx_freq,
-                                          tBTM_CMPL_CB* p_cmd_cmpl_cback) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_BleSecureConnectionOobDataReply(
-    const RawAddress& bd_addr, uint8_t* p_c, uint8_t* p_r) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_BleSetConnScanParams(uint32_t scan_interval,
-                                               uint32_t scan_window) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_BleSetPhy(const RawAddress& bd_addr, uint8_t tx_phys,
-                                    uint8_t rx_phys, uint16_t phy_options) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_BleSetPrefConnParams(const RawAddress& bd_addr,
-                                               uint16_t min_conn_int,
-                                               uint16_t max_conn_int,
-                                               uint16_t peripheral_latency,
-                                               uint16_t supervision_tout) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_BleTestEnd(tBTM_CMPL_CB* p_cmd_cmpl_cback) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_BleTransmitterTest(uint8_t tx_freq,
-                                             uint8_t test_data_len,
-                                             uint8_t packet_payload,
-                                             tBTM_CMPL_CB* p_cmd_cmpl_cback) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_BleUpdateAdvFilterPolicy(tBTM_BLE_AFP adv_policy) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_CancelInquiry(void) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_ConfirmReqReply(tBTM_STATUS res,
-                                          const RawAddress& bd_addr) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_EnableInterlacedInquiryScan() {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_EnableInterlacedPageScan() {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_LE_PF_addr_filter(tBTM_BLE_SCAN_COND_OP action,
-                                            tBTM_BLE_PF_FILT_INDEX filt_index,
-                                            tBLE_BD_ADDR addr,
-                                            tBTM_BLE_PF_CFG_CBACK cb) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_LE_PF_clear(tBTM_BLE_PF_FILT_INDEX filt_index,
-                                      tBTM_BLE_PF_CFG_CBACK cb) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_LE_PF_local_name(tBTM_BLE_SCAN_COND_OP action,
-                                           tBTM_BLE_PF_FILT_INDEX filt_index,
-                                           std::vector<uint8_t> name,
-                                           tBTM_BLE_PF_CFG_CBACK cb) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_LE_PF_manu_data(
-    tBTM_BLE_SCAN_COND_OP action, tBTM_BLE_PF_FILT_INDEX filt_index,
-    uint16_t company_id, uint16_t company_id_mask, std::vector<uint8_t> data,
-    std::vector<uint8_t> data_mask, tBTM_BLE_PF_CFG_CBACK cb) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_LE_PF_set(tBTM_BLE_PF_FILT_INDEX filt_index,
-                                    std::vector<ApcfCommand> commands,
-                                    tBTM_BLE_PF_CFG_CBACK cb) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_LE_PF_srvc_data(tBTM_BLE_SCAN_COND_OP action,
-                                          tBTM_BLE_PF_FILT_INDEX filt_index) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_LE_PF_srvc_data_pattern(
-    tBTM_BLE_SCAN_COND_OP action, tBTM_BLE_PF_FILT_INDEX filt_index,
-    std::vector<uint8_t> data, std::vector<uint8_t> data_mask,
-    tBTM_BLE_PF_CFG_CBACK cb) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_LE_PF_uuid_filter(tBTM_BLE_SCAN_COND_OP action,
-                                            tBTM_BLE_PF_FILT_INDEX filt_index,
-                                            tBTM_BLE_PF_COND_TYPE filter_type,
-                                            const bluetooth::Uuid& uuid,
-                                            tBTM_BLE_PF_LOGIC_TYPE cond_logic,
-                                            const bluetooth::Uuid& uuid_mask,
-                                            tBTM_BLE_PF_CFG_CBACK cb) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_PINCodeReply(const RawAddress& bd_addr,
-                                       tBTM_STATUS res, uint8_t pin_len,
-                                       uint8_t* p_pin) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_ReadConnectionAddr(const RawAddress& remote_bda,
-                                             RawAddress& local_conn_addr,
-                                             tBLE_ADDR_TYPE* p_addr_type) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_ReadDevInfo(const RawAddress& remote_bda,
-                                      tBT_DEVICE_TYPE* p_dev_type,
-                                      tBLE_ADDR_TYPE* p_addr_type) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_RemoteOobDataReply(tBTM_STATUS res,
-                                             const RawAddress& bd_addr,
-                                             const Octet16& c,
-                                             const Octet16& r) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_RemoveEirService(uint32_t* p_eir_uuid,
-                                           uint16_t uuid16) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_SecAddBleDevice(const RawAddress& bd_addr,
-                                          tBT_DEVICE_TYPE dev_type,
-                                          tBLE_ADDR_TYPE addr_type) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_SecAddBleKey(const RawAddress& bd_addr,
-                                       tBTM_LE_KEY_VALUE* p_le_key,
-                                       tBTM_LE_KEY_TYPE key_type) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_SecClearSecurityFlags(const RawAddress& bd_addr) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::BTM_SecurityGrant(const RawAddress& bd_addr,
-                                        uint8_t res) {
-  mock_function_count_map[__func__]++;
-}
-void bluetooth::shim::SendRemoteNameRequest(const RawAddress& raw_address) {
-  mock_function_count_map[__func__]++;
-}
-void btm_api_process_extended_inquiry_result(RawAddress raw_address,
-                                             uint8_t page_scan_rep_mode,
-                                             DEV_CLASS device_class,
-                                             uint16_t clock_offset, int8_t rssi,
-                                             const uint8_t* eir_data,
-                                             size_t eir_len) {
-  mock_function_count_map[__func__]++;
-}
-void btm_api_process_inquiry_result(const RawAddress& raw_address,
-                                    uint8_t page_scan_rep_mode,
-                                    DEV_CLASS device_class,
-                                    uint16_t clock_offset) {
-  mock_function_count_map[__func__]++;
-}
-void btm_api_process_inquiry_result_with_rssi(RawAddress raw_address,
-                                              uint8_t page_scan_rep_mode,
-                                              DEV_CLASS device_class,
-                                              uint16_t clock_offset,
-                                              int8_t rssi) {
-  mock_function_count_map[__func__]++;
-}
-tBTM_STATUS bluetooth::shim::BTM_SetPowerMode(uint16_t, tBTM_PM_PWR_MD const&) {
-  mock_function_count_map[__func__]++;
-  return BTM_SUCCESS;
-}
-void bluetooth::shim::btm_pm_on_mode_change(tHCI_STATUS status, uint16_t handle,
-                                            tHCI_MODE current_mode,
-                                            uint16_t interval) {
-  mock_function_count_map[__func__]++;
-}
-tBTM_STATUS bluetooth::shim::BTM_SetSsrParams(uint16_t, uint16_t max_lat,
-                                              uint16_t min_rmt_to,
-                                              uint16_t min_loc_to) {
-  mock_function_count_map[__func__]++;
-  return BTM_SUCCESS;
-}
-void bluetooth::shim::btm_pm_on_sniff_subrating(
-    tHCI_STATUS status, uint16_t handle, uint16_t maximum_transmit_latency,
-    uint16_t maximum_receive_latency,
-    UNUSED_ATTR uint16_t minimum_remote_timeout,
-    UNUSED_ATTR uint16_t minimum_local_timeout) {
-  mock_function_count_map[__func__]++;
-}
diff --git a/test/Android.bp b/test/Android.bp
index e4e7a8c..20c06de 100644
--- a/test/Android.bp
+++ b/test/Android.bp
@@ -160,6 +160,13 @@
 }
 
 filegroup {
+  name: "TestMockOsi",
+    srcs: [
+      "mock/mock_osi_*.cc",
+    ],
+}
+
+filegroup {
   name: "TestMockStackAcl",
   srcs: [
       "mock/mock_stack_acl*.cc",
@@ -228,3 +235,10 @@
       "common/main_handler.cc",
   ],
 }
+
+filegroup {
+  name: "TestCommonInitFlags",
+  srcs: [
+      "common/init_flags.cc",
+  ],
+}
diff --git a/test/common/init_flags.cc b/test/common/init_flags.cc
new file mode 100644
index 0000000..9b8585b
--- /dev/null
+++ b/test/common/init_flags.cc
@@ -0,0 +1,23 @@
+
+
+#include <map>
+#include <string>
+
+#include "gd/common/init_flags.h"
+
+namespace bluetooth {
+namespace common {
+
+bool InitFlags::logging_debug_enabled_for_all = false;
+std::unordered_map<std::string, bool>
+    InitFlags::logging_debug_explicit_tag_settings = {};
+void InitFlags::Load(const char** flags) {}
+void InitFlags::SetAll(bool value) {
+  InitFlags::logging_debug_enabled_for_all = value;
+}
+void InitFlags::SetAllForTesting() {
+  InitFlags::logging_debug_enabled_for_all = true;
+}
+
+}  // namespace common
+}  // namespace bluetooth
diff --git a/test/common/mock_functions.cc b/test/common/mock_functions.cc
new file mode 100644
index 0000000..20462b8
--- /dev/null
+++ b/test/common/mock_functions.cc
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2021 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.
+ */
+
+#include <map>
+
+#include "osi/include/log.h"
+#include "test/common/mock_functions.h"
+
+// tLEGACY_TRACE_LEVEL
+// uint8_t btu_trace_level = 6;
+uint8_t appl_trace_level = 6;
+uint8_t btif_trace_level = 6;
+
+std::map<std::string, int> mock_function_count_map;
+
+void dump_mock_function_count_map() {
+  LOG_INFO("Mock function count map size:%zu", mock_function_count_map.size());
+
+  for (auto it : mock_function_count_map) {
+    LOG_INFO("function:%s: call_count:%d", it.first.c_str(), it.second);
+  }
+}
diff --git a/test/common/mock_functions.h b/test/common/mock_functions.h
new file mode 100644
index 0000000..8889b86
--- /dev/null
+++ b/test/common/mock_functions.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2021 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.
+ */
+
+#pragma once
+
+#include <map>
+
+extern std::map<std::string, int> mock_function_count_map;
+void dump_mock_function_count_map();
diff --git a/test/mock/mock_bta_dm_act.cc b/test/mock/mock_bta_dm_act.cc
index 087935d..5fc6687 100644
--- a/test/mock/mock_bta_dm_act.cc
+++ b/test/mock/mock_bta_dm_act.cc
@@ -16,149 +16,369 @@
 
 /*
  * Generated mock file from original source file
- *   Functions generated:57
+ *   Functions generated:62
+ *
+ *  mockcify.pl ver 0.3.0
  */
 
+#include <cstdint>
+#include <functional>
 #include <map>
 #include <string>
 
 extern std::map<std::string, int> mock_function_count_map;
 
-#include <cstdint>
-#include "bta/dm/bta_dm_int.h"
-#include "bta/gatt/bta_gattc_int.h"
-#include "bta/include/bta_dm_ci.h"
-#include "btif/include/btif_dm.h"
-#include "btif/include/btif_storage.h"
-#include "btif/include/stack_manager.h"
-#include "device/include/controller.h"
-#include "device/include/interop.h"
-#include "main/shim/acl_api.h"
-#include "main/shim/btm_api.h"
-#include "main/shim/dumpsys.h"
-#include "main/shim/shim.h"
-#include "osi/include/log.h"
-#include "osi/include/osi.h"
-#include "stack/btm/btm_sec.h"
-#include "stack/btm/neighbor_inquiry.h"
-#include "stack/gatt/connection_manager.h"
-#include "stack/include/acl_api.h"
-#include "stack/include/bt_types.h"
-#include "stack/include/btm_client_interface.h"
-#include "stack/include/btu.h"
-#include "types/raw_address.h"
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_bta_dm_act.h"
 
-#ifndef UNUSED_ATTR
-#define UNUSED_ATTR
-#endif
+// Mocked internal structures, if any
 
-void bta_dm_enable(tBTA_DM_SEC_CBACK* p_sec_cback) {
+namespace test {
+namespace mock {
+namespace bta_dm_act {
+
+// Function state capture and return values, if needed
+struct BTA_DmSetVisibility BTA_DmSetVisibility;
+struct BTA_dm_acl_down BTA_dm_acl_down;
+struct BTA_dm_acl_up BTA_dm_acl_up;
+struct BTA_dm_notify_remote_features_complete
+    BTA_dm_notify_remote_features_complete;
+struct BTA_dm_on_hw_off BTA_dm_on_hw_off;
+struct BTA_dm_on_hw_on BTA_dm_on_hw_on;
+struct BTA_dm_report_role_change BTA_dm_report_role_change;
+struct bta_dm_acl_up bta_dm_acl_up;
+struct bta_dm_add_ble_device bta_dm_add_ble_device;
+struct bta_dm_add_blekey bta_dm_add_blekey;
+struct bta_dm_add_device bta_dm_add_device;
+struct bta_dm_ble_config_local_privacy bta_dm_ble_config_local_privacy;
+struct bta_dm_ble_confirm_reply bta_dm_ble_confirm_reply;
+struct bta_dm_ble_csis_observe bta_dm_ble_csis_observe;
+struct bta_dm_ble_get_energy_info bta_dm_ble_get_energy_info;
+struct bta_dm_ble_observe bta_dm_ble_observe;
+struct bta_dm_ble_passkey_reply bta_dm_ble_passkey_reply;
+struct bta_dm_ble_scan bta_dm_ble_scan;
+struct bta_dm_ble_set_conn_params bta_dm_ble_set_conn_params;
+struct bta_dm_ble_set_data_length bta_dm_ble_set_data_length;
+struct bta_dm_ble_update_conn_params bta_dm_ble_update_conn_params;
+struct bta_dm_bond bta_dm_bond;
+struct bta_dm_bond_cancel bta_dm_bond_cancel;
+struct bta_dm_check_if_only_hd_connected bta_dm_check_if_only_hd_connected;
+struct bta_dm_ci_rmt_oob_act bta_dm_ci_rmt_oob_act;
+struct bta_dm_close_acl bta_dm_close_acl;
+struct bta_dm_close_gatt_conn bta_dm_close_gatt_conn;
+struct bta_dm_confirm bta_dm_confirm;
+struct bta_dm_deinit_cb bta_dm_deinit_cb;
+struct bta_dm_disable bta_dm_disable;
+struct bta_dm_disc_result bta_dm_disc_result;
+struct bta_dm_disc_rmt_name bta_dm_disc_rmt_name;
+struct bta_dm_discover bta_dm_discover;
+struct bta_dm_eir_update_cust_uuid bta_dm_eir_update_cust_uuid;
+struct bta_dm_eir_update_uuid bta_dm_eir_update_uuid;
+struct bta_dm_enable bta_dm_enable;
+struct bta_dm_encrypt_cback bta_dm_encrypt_cback;
+struct bta_dm_execute_queued_request bta_dm_execute_queued_request;
+struct bta_dm_free_sdp_db bta_dm_free_sdp_db;
+struct bta_dm_init_cb bta_dm_init_cb;
+struct bta_dm_inq_cmpl bta_dm_inq_cmpl;
+struct bta_dm_is_search_request_queued bta_dm_is_search_request_queued;
+struct bta_dm_pin_reply bta_dm_pin_reply;
+struct bta_dm_proc_open_evt bta_dm_proc_open_evt;
+struct bta_dm_process_remove_device bta_dm_process_remove_device;
+struct bta_dm_queue_disc bta_dm_queue_disc;
+struct bta_dm_queue_search bta_dm_queue_search;
+struct bta_dm_remove_device bta_dm_remove_device;
+struct bta_dm_rm_cback bta_dm_rm_cback;
+struct bta_dm_rmt_name bta_dm_rmt_name;
+struct bta_dm_sdp_result bta_dm_sdp_result;
+struct bta_dm_search_cancel bta_dm_search_cancel;
+struct bta_dm_search_cancel_cmpl bta_dm_search_cancel_cmpl;
+struct bta_dm_search_cancel_notify bta_dm_search_cancel_notify;
+struct bta_dm_search_clear_queue bta_dm_search_clear_queue;
+struct bta_dm_search_cmpl bta_dm_search_cmpl;
+struct bta_dm_search_result bta_dm_search_result;
+struct bta_dm_search_start bta_dm_search_start;
+struct bta_dm_set_dev_name bta_dm_set_dev_name;
+struct bta_dm_set_encryption bta_dm_set_encryption;
+struct btm_dm_start_gatt_discovery btm_dm_start_gatt_discovery;
+struct handle_remote_features_complete handle_remote_features_complete;
+
+}  // namespace bta_dm_act
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+bool BTA_DmSetVisibility(bt_scan_mode_t mode) {
   mock_function_count_map[__func__]++;
+  return test::mock::bta_dm_act::BTA_DmSetVisibility(mode);
 }
 void BTA_dm_acl_down(const RawAddress bd_addr, tBT_TRANSPORT transport) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::BTA_dm_acl_down(bd_addr, transport);
 }
 void BTA_dm_acl_up(const RawAddress bd_addr, tBT_TRANSPORT transport) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::BTA_dm_acl_up(bd_addr, transport);
 }
 void BTA_dm_notify_remote_features_complete(const RawAddress bd_addr) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::BTA_dm_notify_remote_features_complete(bd_addr);
 }
-void BTA_dm_on_hw_off() { mock_function_count_map[__func__]++; }
-void BTA_dm_on_hw_on() { mock_function_count_map[__func__]++; }
+void BTA_dm_on_hw_off() {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::BTA_dm_on_hw_off();
+}
+void BTA_dm_on_hw_on() {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::BTA_dm_on_hw_on();
+}
 void BTA_dm_report_role_change(const RawAddress bd_addr, tHCI_ROLE new_role,
                                tHCI_STATUS hci_status) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::BTA_dm_report_role_change(bd_addr, new_role,
+                                                    hci_status);
 }
 void bta_dm_acl_up(const RawAddress& bd_addr, tBT_TRANSPORT transport) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_acl_up(bd_addr, transport);
+}
+void bta_dm_add_ble_device(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
+                           tBT_DEVICE_TYPE dev_type) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_add_ble_device(bd_addr, addr_type, dev_type);
+}
+void bta_dm_add_blekey(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE blekey,
+                       tBTM_LE_KEY_TYPE key_type) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_add_blekey(bd_addr, blekey, key_type);
 }
 void bta_dm_add_device(std::unique_ptr<tBTA_DM_API_ADD_DEVICE> msg) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_add_device(std::move(msg));
+}
+void bta_dm_ble_config_local_privacy(bool privacy_enable) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_ble_config_local_privacy(privacy_enable);
+}
+void bta_dm_ble_confirm_reply(const RawAddress& bd_addr, bool accept) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_ble_confirm_reply(bd_addr, accept);
+}
+void bta_dm_ble_csis_observe(bool observe, tBTA_DM_SEARCH_CBACK* p_cback) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_ble_csis_observe(observe, p_cback);
+}
+void bta_dm_ble_get_energy_info(
+    tBTA_BLE_ENERGY_INFO_CBACK* p_energy_info_cback) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_ble_get_energy_info(p_energy_info_cback);
+}
+void bta_dm_ble_observe(bool start, uint8_t duration,
+                        tBTA_DM_SEARCH_CBACK* p_cback) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_ble_observe(start, duration, p_cback);
+}
+void bta_dm_ble_passkey_reply(const RawAddress& bd_addr, bool accept,
+                              uint32_t passkey) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_ble_passkey_reply(bd_addr, accept, passkey);
+}
+void bta_dm_ble_scan(bool start, uint8_t duration_sec) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_ble_scan(start, duration_sec);
+}
+void bta_dm_ble_set_conn_params(const RawAddress& bd_addr,
+                                uint16_t conn_int_min, uint16_t conn_int_max,
+                                uint16_t peripheral_latency,
+                                uint16_t supervision_tout) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_ble_set_conn_params(
+      bd_addr, conn_int_min, conn_int_max, peripheral_latency,
+      supervision_tout);
+}
+void bta_dm_ble_set_data_length(const RawAddress& bd_addr) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_ble_set_data_length(bd_addr);
+}
+void bta_dm_ble_update_conn_params(const RawAddress& bd_addr, uint16_t min_int,
+                                   uint16_t max_int, uint16_t latency,
+                                   uint16_t timeout, uint16_t min_ce_len,
+                                   uint16_t max_ce_len) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_ble_update_conn_params(
+      bd_addr, min_int, max_int, latency, timeout, min_ce_len, max_ce_len);
 }
 void bta_dm_bond(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
                  tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_bond(bd_addr, addr_type, transport,
+                                      device_type);
 }
 void bta_dm_bond_cancel(const RawAddress& bd_addr) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_bond_cancel(bd_addr);
+}
+bool bta_dm_check_if_only_hd_connected(const RawAddress& peer_addr) {
+  mock_function_count_map[__func__]++;
+  return test::mock::bta_dm_act::bta_dm_check_if_only_hd_connected(peer_addr);
 }
 void bta_dm_ci_rmt_oob_act(std::unique_ptr<tBTA_DM_CI_RMT_OOB> msg) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_ci_rmt_oob_act(std::move(msg));
 }
 void bta_dm_close_acl(const RawAddress& bd_addr, bool remove_dev,
                       tBT_TRANSPORT transport) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_close_acl(bd_addr, remove_dev, transport);
+}
+void bta_dm_close_gatt_conn(tBTA_DM_MSG* p_data) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_close_gatt_conn(p_data);
 }
 void bta_dm_confirm(const RawAddress& bd_addr, bool accept) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_confirm(bd_addr, accept);
 }
-void bta_dm_deinit_cb(void) { mock_function_count_map[__func__]++; }
-void bta_dm_disable() { mock_function_count_map[__func__]++; }
+void bta_dm_deinit_cb(void) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_deinit_cb();
+}
+void bta_dm_disable() {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_disable();
+}
 void bta_dm_disc_result(tBTA_DM_MSG* p_data) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_disc_result(p_data);
 }
 void bta_dm_disc_rmt_name(tBTA_DM_MSG* p_data) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_disc_rmt_name(p_data);
 }
 void bta_dm_discover(tBTA_DM_MSG* p_data) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_discover(p_data);
 }
-void bta_dm_free_sdp_db() { mock_function_count_map[__func__]++; }
-void bta_dm_init_cb(void) { mock_function_count_map[__func__]++; }
-void bta_dm_inq_cmpl(uint8_t num) { mock_function_count_map[__func__]++; }
+void bta_dm_eir_update_cust_uuid(const tBTA_CUSTOM_UUID& curr, bool adding) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_eir_update_cust_uuid(curr, adding);
+}
+void bta_dm_eir_update_uuid(uint16_t uuid16, bool adding) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_eir_update_uuid(uuid16, adding);
+}
+void bta_dm_enable(tBTA_DM_SEC_CBACK* p_sec_cback) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_enable(p_sec_cback);
+}
+void bta_dm_encrypt_cback(const RawAddress* bd_addr, tBT_TRANSPORT transport,
+                          void* p_ref_data, tBTM_STATUS result) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_encrypt_cback(bd_addr, transport, p_ref_data,
+                                               result);
+}
+void bta_dm_execute_queued_request() {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_execute_queued_request();
+}
+void bta_dm_free_sdp_db() {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_free_sdp_db();
+}
+void bta_dm_init_cb(void) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_init_cb();
+}
+void bta_dm_inq_cmpl(uint8_t num) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_inq_cmpl(num);
+}
+bool bta_dm_is_search_request_queued() {
+  mock_function_count_map[__func__]++;
+  return test::mock::bta_dm_act::bta_dm_is_search_request_queued();
+}
 void bta_dm_pin_reply(std::unique_ptr<tBTA_DM_API_PIN_REPLY> msg) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_pin_reply(std::move(msg));
+}
+void bta_dm_proc_open_evt(tBTA_GATTC_OPEN* p_data) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_proc_open_evt(p_data);
 }
 void bta_dm_process_remove_device(const RawAddress& bd_addr) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_process_remove_device(bd_addr);
 }
 void bta_dm_queue_disc(tBTA_DM_MSG* p_data) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_queue_disc(p_data);
 }
 void bta_dm_queue_search(tBTA_DM_MSG* p_data) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_queue_search(p_data);
 }
 void bta_dm_remove_device(const RawAddress& bd_addr) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_remove_device(bd_addr);
 }
 void bta_dm_rm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id, uint8_t app_id,
                      const RawAddress& peer_addr) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_rm_cback(status, id, app_id, peer_addr);
 }
 void bta_dm_rmt_name(tBTA_DM_MSG* p_data) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_rmt_name(p_data);
 }
 void bta_dm_sdp_result(tBTA_DM_MSG* p_data) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_sdp_result(p_data);
 }
-void bta_dm_search_cancel() { mock_function_count_map[__func__]++; }
-void bta_dm_search_cancel_cmpl() { mock_function_count_map[__func__]++; }
-void bta_dm_search_cancel_notify() { mock_function_count_map[__func__]++; }
-void bta_dm_execute_queued_request() { mock_function_count_map[__func__]++; }
-bool bta_dm_is_search_request_queued() {
+void bta_dm_search_cancel() {
   mock_function_count_map[__func__]++;
-  return false;
+  test::mock::bta_dm_act::bta_dm_search_cancel();
 }
-void bta_dm_search_clear_queue() { mock_function_count_map[__func__]++; }
-void bta_dm_search_cmpl() { mock_function_count_map[__func__]++; }
+void bta_dm_search_cancel_cmpl() {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_search_cancel_cmpl();
+}
+void bta_dm_search_cancel_notify() {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_search_cancel_notify();
+}
+void bta_dm_search_clear_queue() {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_search_clear_queue();
+}
+void bta_dm_search_cmpl() {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_search_cmpl();
+}
 void bta_dm_search_result(tBTA_DM_MSG* p_data) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_search_result(p_data);
 }
 void bta_dm_search_start(tBTA_DM_MSG* p_data) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_search_start(p_data);
 }
 void bta_dm_set_dev_name(const std::vector<uint8_t>& name) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::bta_dm_set_dev_name(name);
 }
-bool BTA_DmSetVisibility(bt_scan_mode_t mode) {
+void bta_dm_set_encryption(const RawAddress& bd_addr, tBT_TRANSPORT transport,
+                           tBTA_DM_ENCRYPT_CBACK* p_callback,
+                           tBTM_BLE_SEC_ACT sec_act) {
   mock_function_count_map[__func__]++;
-  return false;
+  test::mock::bta_dm_act::bta_dm_set_encryption(bd_addr, transport, p_callback,
+                                                sec_act);
+}
+void btm_dm_start_gatt_discovery(const RawAddress& bd_addr) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::btm_dm_start_gatt_discovery(bd_addr);
 }
 void handle_remote_features_complete(const RawAddress& bd_addr) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_act::handle_remote_features_complete(bd_addr);
 }
-bool bta_dm_check_if_only_hd_connected(const RawAddress& peer_addr) {
-  mock_function_count_map[__func__]++;
-  return false;
-}
+
+// END mockcify generation
diff --git a/test/mock/mock_bta_dm_act.h b/test/mock/mock_bta_dm_act.h
new file mode 100644
index 0000000..95716b6
--- /dev/null
+++ b/test/mock/mock_bta_dm_act.h
@@ -0,0 +1,764 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:62
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <cstdint>
+
+#include "bta/dm/bta_dm_int.h"
+#include "bta/gatt/bta_gattc_int.h"
+#include "bta/include/bta_dm_ci.h"
+#include "btif/include/btif_dm.h"
+#include "btif/include/btif_storage.h"
+#include "btif/include/stack_manager.h"
+#include "device/include/controller.h"
+#include "device/include/interop.h"
+#include "gap_api.h"
+#include "main/shim/acl_api.h"
+#include "main/shim/btm_api.h"
+#include "main/shim/dumpsys.h"
+#include "main/shim/shim.h"
+#include "osi/include/fixed_queue.h"
+#include "osi/include/log.h"
+#include "osi/include/osi.h"
+#include "stack/btm/btm_sec.h"
+#include "stack/btm/neighbor_inquiry.h"
+#include "stack/gatt/connection_manager.h"
+#include "stack/include/acl_api.h"
+#include "stack/include/bt_types.h"
+#include "stack/include/btm_client_interface.h"
+#include "stack/include/btu.h"
+#include "types/raw_address.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace bta_dm_act {
+
+// Shared state between mocked functions and tests
+// Name: BTA_DmSetVisibility
+// Params: bt_scan_mode_t mode
+// Return: bool
+struct BTA_DmSetVisibility {
+  bool return_value{false};
+  std::function<bool(bt_scan_mode_t mode)> body{
+      [this](bt_scan_mode_t mode) { return return_value; }};
+  bool operator()(bt_scan_mode_t mode) { return body(mode); };
+};
+extern struct BTA_DmSetVisibility BTA_DmSetVisibility;
+
+// Name: BTA_dm_acl_down
+// Params: const RawAddress bd_addr, tBT_TRANSPORT transport
+// Return: void
+struct BTA_dm_acl_down {
+  std::function<void(const RawAddress bd_addr, tBT_TRANSPORT transport)> body{
+      [](const RawAddress bd_addr, tBT_TRANSPORT transport) {}};
+  void operator()(const RawAddress bd_addr, tBT_TRANSPORT transport) {
+    body(bd_addr, transport);
+  };
+};
+extern struct BTA_dm_acl_down BTA_dm_acl_down;
+
+// Name: BTA_dm_acl_up
+// Params: const RawAddress bd_addr, tBT_TRANSPORT transport
+// Return: void
+struct BTA_dm_acl_up {
+  std::function<void(const RawAddress bd_addr, tBT_TRANSPORT transport)> body{
+      [](const RawAddress bd_addr, tBT_TRANSPORT transport) {}};
+  void operator()(const RawAddress bd_addr, tBT_TRANSPORT transport) {
+    body(bd_addr, transport);
+  };
+};
+extern struct BTA_dm_acl_up BTA_dm_acl_up;
+
+// Name: BTA_dm_notify_remote_features_complete
+// Params: const RawAddress bd_addr
+// Return: void
+struct BTA_dm_notify_remote_features_complete {
+  std::function<void(const RawAddress bd_addr)> body{
+      [](const RawAddress bd_addr) {}};
+  void operator()(const RawAddress bd_addr) { body(bd_addr); };
+};
+extern struct BTA_dm_notify_remote_features_complete
+    BTA_dm_notify_remote_features_complete;
+
+// Name: BTA_dm_on_hw_off
+// Params:
+// Return: void
+struct BTA_dm_on_hw_off {
+  std::function<void()> body{[]() {}};
+  void operator()() { body(); };
+};
+extern struct BTA_dm_on_hw_off BTA_dm_on_hw_off;
+
+// Name: BTA_dm_on_hw_on
+// Params:
+// Return: void
+struct BTA_dm_on_hw_on {
+  std::function<void()> body{[]() {}};
+  void operator()() { body(); };
+};
+extern struct BTA_dm_on_hw_on BTA_dm_on_hw_on;
+
+// Name: BTA_dm_report_role_change
+// Params: const RawAddress bd_addr, tHCI_ROLE new_role, tHCI_STATUS hci_status
+// Return: void
+struct BTA_dm_report_role_change {
+  std::function<void(const RawAddress bd_addr, tHCI_ROLE new_role,
+                     tHCI_STATUS hci_status)>
+      body{[](const RawAddress bd_addr, tHCI_ROLE new_role,
+              tHCI_STATUS hci_status) {}};
+  void operator()(const RawAddress bd_addr, tHCI_ROLE new_role,
+                  tHCI_STATUS hci_status) {
+    body(bd_addr, new_role, hci_status);
+  };
+};
+extern struct BTA_dm_report_role_change BTA_dm_report_role_change;
+
+// Name: bta_dm_acl_up
+// Params: const RawAddress& bd_addr, tBT_TRANSPORT transport
+// Return: void
+struct bta_dm_acl_up {
+  std::function<void(const RawAddress& bd_addr, tBT_TRANSPORT transport)> body{
+      [](const RawAddress& bd_addr, tBT_TRANSPORT transport) {}};
+  void operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport) {
+    body(bd_addr, transport);
+  };
+};
+extern struct bta_dm_acl_up bta_dm_acl_up;
+
+// Name: bta_dm_add_ble_device
+// Params: const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, tBT_DEVICE_TYPE
+// dev_type Return: void
+struct bta_dm_add_ble_device {
+  std::function<void(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
+                     tBT_DEVICE_TYPE dev_type)>
+      body{[](const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
+              tBT_DEVICE_TYPE dev_type) {}};
+  void operator()(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
+                  tBT_DEVICE_TYPE dev_type) {
+    body(bd_addr, addr_type, dev_type);
+  };
+};
+extern struct bta_dm_add_ble_device bta_dm_add_ble_device;
+
+// Name: bta_dm_add_blekey
+// Params: const RawAddress& bd_addr, tBTA_LE_KEY_VALUE blekey, tBTM_LE_KEY_TYPE
+// key_type Return: void
+struct bta_dm_add_blekey {
+  std::function<void(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE blekey,
+                     tBTM_LE_KEY_TYPE key_type)>
+      body{[](const RawAddress& bd_addr, tBTA_LE_KEY_VALUE blekey,
+              tBTM_LE_KEY_TYPE key_type) {}};
+  void operator()(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE blekey,
+                  tBTM_LE_KEY_TYPE key_type) {
+    body(bd_addr, blekey, key_type);
+  };
+};
+extern struct bta_dm_add_blekey bta_dm_add_blekey;
+
+// Name: bta_dm_add_device
+// Params: std::unique_ptr<tBTA_DM_API_ADD_DEVICE> msg
+// Return: void
+struct bta_dm_add_device {
+  std::function<void(std::unique_ptr<tBTA_DM_API_ADD_DEVICE> msg)> body{
+      [](std::unique_ptr<tBTA_DM_API_ADD_DEVICE> msg) {}};
+  void operator()(std::unique_ptr<tBTA_DM_API_ADD_DEVICE> msg) {
+    body(std::move(msg));
+  };
+};
+extern struct bta_dm_add_device bta_dm_add_device;
+
+// Name: bta_dm_ble_config_local_privacy
+// Params: bool privacy_enable
+// Return: void
+struct bta_dm_ble_config_local_privacy {
+  std::function<void(bool privacy_enable)> body{[](bool privacy_enable) {}};
+  void operator()(bool privacy_enable) { body(privacy_enable); };
+};
+extern struct bta_dm_ble_config_local_privacy bta_dm_ble_config_local_privacy;
+
+// Name: bta_dm_ble_confirm_reply
+// Params: const RawAddress& bd_addr, bool accept
+// Return: void
+struct bta_dm_ble_confirm_reply {
+  std::function<void(const RawAddress& bd_addr, bool accept)> body{
+      [](const RawAddress& bd_addr, bool accept) {}};
+  void operator()(const RawAddress& bd_addr, bool accept) {
+    body(bd_addr, accept);
+  };
+};
+extern struct bta_dm_ble_confirm_reply bta_dm_ble_confirm_reply;
+
+// Name: bta_dm_ble_csis_observe
+// Params: bool observe, tBTA_DM_SEARCH_CBACK* p_cback
+// Return: void
+struct bta_dm_ble_csis_observe {
+  std::function<void(bool observe, tBTA_DM_SEARCH_CBACK* p_cback)> body{
+      [](bool observe, tBTA_DM_SEARCH_CBACK* p_cback) {}};
+  void operator()(bool observe, tBTA_DM_SEARCH_CBACK* p_cback) {
+    body(observe, p_cback);
+  };
+};
+extern struct bta_dm_ble_csis_observe bta_dm_ble_csis_observe;
+
+// Name: bta_dm_ble_get_energy_info
+// Params: tBTA_BLE_ENERGY_INFO_CBACK* p_energy_info_cback
+// Return: void
+struct bta_dm_ble_get_energy_info {
+  std::function<void(tBTA_BLE_ENERGY_INFO_CBACK* p_energy_info_cback)> body{
+      [](tBTA_BLE_ENERGY_INFO_CBACK* p_energy_info_cback) {}};
+  void operator()(tBTA_BLE_ENERGY_INFO_CBACK* p_energy_info_cback) {
+    body(p_energy_info_cback);
+  };
+};
+extern struct bta_dm_ble_get_energy_info bta_dm_ble_get_energy_info;
+
+// Name: bta_dm_ble_observe
+// Params: bool start, uint8_t duration, tBTA_DM_SEARCH_CBACK* p_cback
+// Return: void
+struct bta_dm_ble_observe {
+  std::function<void(bool start, uint8_t duration,
+                     tBTA_DM_SEARCH_CBACK* p_cback)>
+      body{[](bool start, uint8_t duration, tBTA_DM_SEARCH_CBACK* p_cback) {}};
+  void operator()(bool start, uint8_t duration, tBTA_DM_SEARCH_CBACK* p_cback) {
+    body(start, duration, p_cback);
+  };
+};
+extern struct bta_dm_ble_observe bta_dm_ble_observe;
+
+// Name: bta_dm_ble_passkey_reply
+// Params: const RawAddress& bd_addr, bool accept, uint32_t passkey
+// Return: void
+struct bta_dm_ble_passkey_reply {
+  std::function<void(const RawAddress& bd_addr, bool accept, uint32_t passkey)>
+      body{[](const RawAddress& bd_addr, bool accept, uint32_t passkey) {}};
+  void operator()(const RawAddress& bd_addr, bool accept, uint32_t passkey) {
+    body(bd_addr, accept, passkey);
+  };
+};
+extern struct bta_dm_ble_passkey_reply bta_dm_ble_passkey_reply;
+
+// Name: bta_dm_ble_scan
+// Params: bool start, uint8_t duration_sec
+// Return: void
+struct bta_dm_ble_scan {
+  std::function<void(bool start, uint8_t duration_sec)> body{
+      [](bool start, uint8_t duration_sec) {}};
+  void operator()(bool start, uint8_t duration_sec) {
+    body(start, duration_sec);
+  };
+};
+extern struct bta_dm_ble_scan bta_dm_ble_scan;
+
+// Name: bta_dm_ble_set_conn_params
+// Params: const RawAddress& bd_addr, uint16_t conn_int_min, uint16_t
+// conn_int_max, uint16_t peripheral_latency, uint16_t supervision_tout Return:
+// void
+struct bta_dm_ble_set_conn_params {
+  std::function<void(const RawAddress& bd_addr, uint16_t conn_int_min,
+                     uint16_t conn_int_max, uint16_t peripheral_latency,
+                     uint16_t supervision_tout)>
+      body{[](const RawAddress& bd_addr, uint16_t conn_int_min,
+              uint16_t conn_int_max, uint16_t peripheral_latency,
+              uint16_t supervision_tout) {}};
+  void operator()(const RawAddress& bd_addr, uint16_t conn_int_min,
+                  uint16_t conn_int_max, uint16_t peripheral_latency,
+                  uint16_t supervision_tout) {
+    body(bd_addr, conn_int_min, conn_int_max, peripheral_latency,
+         supervision_tout);
+  };
+};
+extern struct bta_dm_ble_set_conn_params bta_dm_ble_set_conn_params;
+
+// Name: bta_dm_ble_set_data_length
+// Params: const RawAddress& bd_addr
+// Return: void
+struct bta_dm_ble_set_data_length {
+  std::function<void(const RawAddress& bd_addr)> body{
+      [](const RawAddress& bd_addr) {}};
+  void operator()(const RawAddress& bd_addr) { body(bd_addr); };
+};
+extern struct bta_dm_ble_set_data_length bta_dm_ble_set_data_length;
+
+// Name: bta_dm_ble_update_conn_params
+// Params: const RawAddress& bd_addr, uint16_t min_int, uint16_t max_int,
+// uint16_t latency, uint16_t timeout, uint16_t min_ce_len, uint16_t max_ce_len
+// Return: void
+struct bta_dm_ble_update_conn_params {
+  std::function<void(const RawAddress& bd_addr, uint16_t min_int,
+                     uint16_t max_int, uint16_t latency, uint16_t timeout,
+                     uint16_t min_ce_len, uint16_t max_ce_len)>
+      body{[](const RawAddress& bd_addr, uint16_t min_int, uint16_t max_int,
+              uint16_t latency, uint16_t timeout, uint16_t min_ce_len,
+              uint16_t max_ce_len) {}};
+  void operator()(const RawAddress& bd_addr, uint16_t min_int, uint16_t max_int,
+                  uint16_t latency, uint16_t timeout, uint16_t min_ce_len,
+                  uint16_t max_ce_len) {
+    body(bd_addr, min_int, max_int, latency, timeout, min_ce_len, max_ce_len);
+  };
+};
+extern struct bta_dm_ble_update_conn_params bta_dm_ble_update_conn_params;
+
+// Name: bta_dm_bond
+// Params: const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, tBT_TRANSPORT
+// transport, tBT_DEVICE_TYPE device_type Return: void
+struct bta_dm_bond {
+  std::function<void(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
+                     tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type)>
+      body{[](const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
+              tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type) {}};
+  void operator()(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
+                  tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type) {
+    body(bd_addr, addr_type, transport, device_type);
+  };
+};
+extern struct bta_dm_bond bta_dm_bond;
+
+// Name: bta_dm_bond_cancel
+// Params: const RawAddress& bd_addr
+// Return: void
+struct bta_dm_bond_cancel {
+  std::function<void(const RawAddress& bd_addr)> body{
+      [](const RawAddress& bd_addr) {}};
+  void operator()(const RawAddress& bd_addr) { body(bd_addr); };
+};
+extern struct bta_dm_bond_cancel bta_dm_bond_cancel;
+
+// Name: bta_dm_check_if_only_hd_connected
+// Params: const RawAddress& peer_addr
+// Return: bool
+struct bta_dm_check_if_only_hd_connected {
+  bool return_value{false};
+  std::function<bool(const RawAddress& peer_addr)> body{
+      [this](const RawAddress& peer_addr) { return return_value; }};
+  bool operator()(const RawAddress& peer_addr) { return body(peer_addr); };
+};
+extern struct bta_dm_check_if_only_hd_connected
+    bta_dm_check_if_only_hd_connected;
+
+// Name: bta_dm_ci_rmt_oob_act
+// Params: std::unique_ptr<tBTA_DM_CI_RMT_OOB> msg
+// Return: void
+struct bta_dm_ci_rmt_oob_act {
+  std::function<void(std::unique_ptr<tBTA_DM_CI_RMT_OOB> msg)> body{
+      [](std::unique_ptr<tBTA_DM_CI_RMT_OOB> msg) {}};
+  void operator()(std::unique_ptr<tBTA_DM_CI_RMT_OOB> msg) {
+    body(std::move(msg));
+  };
+};
+extern struct bta_dm_ci_rmt_oob_act bta_dm_ci_rmt_oob_act;
+
+// Name: bta_dm_close_acl
+// Params: const RawAddress& bd_addr, bool remove_dev, tBT_TRANSPORT transport
+// Return: void
+struct bta_dm_close_acl {
+  std::function<void(const RawAddress& bd_addr, bool remove_dev,
+                     tBT_TRANSPORT transport)>
+      body{[](const RawAddress& bd_addr, bool remove_dev,
+              tBT_TRANSPORT transport) {}};
+  void operator()(const RawAddress& bd_addr, bool remove_dev,
+                  tBT_TRANSPORT transport) {
+    body(bd_addr, remove_dev, transport);
+  };
+};
+extern struct bta_dm_close_acl bta_dm_close_acl;
+
+// Name: bta_dm_close_gatt_conn
+// Params:  tBTA_DM_MSG* p_data
+// Return: void
+struct bta_dm_close_gatt_conn {
+  std::function<void(tBTA_DM_MSG* p_data)> body{[](tBTA_DM_MSG* p_data) {}};
+  void operator()(tBTA_DM_MSG* p_data) { body(p_data); };
+};
+extern struct bta_dm_close_gatt_conn bta_dm_close_gatt_conn;
+
+// Name: bta_dm_confirm
+// Params: const RawAddress& bd_addr, bool accept
+// Return: void
+struct bta_dm_confirm {
+  std::function<void(const RawAddress& bd_addr, bool accept)> body{
+      [](const RawAddress& bd_addr, bool accept) {}};
+  void operator()(const RawAddress& bd_addr, bool accept) {
+    body(bd_addr, accept);
+  };
+};
+extern struct bta_dm_confirm bta_dm_confirm;
+
+// Name: bta_dm_deinit_cb
+// Params: void
+// Return: void
+struct bta_dm_deinit_cb {
+  std::function<void(void)> body{[](void) {}};
+  void operator()(void) { body(); };
+};
+extern struct bta_dm_deinit_cb bta_dm_deinit_cb;
+
+// Name: bta_dm_disable
+// Params:
+// Return: void
+struct bta_dm_disable {
+  std::function<void()> body{[]() {}};
+  void operator()() { body(); };
+};
+extern struct bta_dm_disable bta_dm_disable;
+
+// Name: bta_dm_disc_result
+// Params: tBTA_DM_MSG* p_data
+// Return: void
+struct bta_dm_disc_result {
+  std::function<void(tBTA_DM_MSG* p_data)> body{[](tBTA_DM_MSG* p_data) {}};
+  void operator()(tBTA_DM_MSG* p_data) { body(p_data); };
+};
+extern struct bta_dm_disc_result bta_dm_disc_result;
+
+// Name: bta_dm_disc_rmt_name
+// Params: tBTA_DM_MSG* p_data
+// Return: void
+struct bta_dm_disc_rmt_name {
+  std::function<void(tBTA_DM_MSG* p_data)> body{[](tBTA_DM_MSG* p_data) {}};
+  void operator()(tBTA_DM_MSG* p_data) { body(p_data); };
+};
+extern struct bta_dm_disc_rmt_name bta_dm_disc_rmt_name;
+
+// Name: bta_dm_discover
+// Params: tBTA_DM_MSG* p_data
+// Return: void
+struct bta_dm_discover {
+  std::function<void(tBTA_DM_MSG* p_data)> body{[](tBTA_DM_MSG* p_data) {}};
+  void operator()(tBTA_DM_MSG* p_data) { body(p_data); };
+};
+extern struct bta_dm_discover bta_dm_discover;
+
+// Name: bta_dm_eir_update_cust_uuid
+// Params: const tBTA_CUSTOM_UUID& curr, bool adding
+// Return: void
+struct bta_dm_eir_update_cust_uuid {
+  std::function<void(const tBTA_CUSTOM_UUID& curr, bool adding)> body{
+      [](const tBTA_CUSTOM_UUID& curr, bool adding) {}};
+  void operator()(const tBTA_CUSTOM_UUID& curr, bool adding) {
+    body(curr, adding);
+  };
+};
+extern struct bta_dm_eir_update_cust_uuid bta_dm_eir_update_cust_uuid;
+
+// Name: bta_dm_eir_update_uuid
+// Params: uint16_t uuid16, bool adding
+// Return: void
+struct bta_dm_eir_update_uuid {
+  std::function<void(uint16_t uuid16, bool adding)> body{
+      [](uint16_t uuid16, bool adding) {}};
+  void operator()(uint16_t uuid16, bool adding) { body(uuid16, adding); };
+};
+extern struct bta_dm_eir_update_uuid bta_dm_eir_update_uuid;
+
+// Name: bta_dm_enable
+// Params: tBTA_DM_SEC_CBACK* p_sec_cback
+// Return: void
+struct bta_dm_enable {
+  std::function<void(tBTA_DM_SEC_CBACK* p_sec_cback)> body{
+      [](tBTA_DM_SEC_CBACK* p_sec_cback) {}};
+  void operator()(tBTA_DM_SEC_CBACK* p_sec_cback) { body(p_sec_cback); };
+};
+extern struct bta_dm_enable bta_dm_enable;
+
+// Name: bta_dm_encrypt_cback
+// Params: const RawAddress* bd_addr, tBT_TRANSPORT transport, void* p_ref_data,
+// tBTM_STATUS result Return: void
+struct bta_dm_encrypt_cback {
+  std::function<void(const RawAddress* bd_addr, tBT_TRANSPORT transport,
+                     void* p_ref_data, tBTM_STATUS result)>
+      body{[](const RawAddress* bd_addr, tBT_TRANSPORT transport,
+              void* p_ref_data, tBTM_STATUS result) {}};
+  void operator()(const RawAddress* bd_addr, tBT_TRANSPORT transport,
+                  void* p_ref_data, tBTM_STATUS result) {
+    body(bd_addr, transport, p_ref_data, result);
+  };
+};
+extern struct bta_dm_encrypt_cback bta_dm_encrypt_cback;
+
+// Name: bta_dm_execute_queued_request
+// Params:
+// Return: void
+struct bta_dm_execute_queued_request {
+  std::function<void()> body{[]() {}};
+  void operator()() { body(); };
+};
+extern struct bta_dm_execute_queued_request bta_dm_execute_queued_request;
+
+// Name: bta_dm_free_sdp_db
+// Params:
+// Return: void
+struct bta_dm_free_sdp_db {
+  std::function<void()> body{[]() {}};
+  void operator()() { body(); };
+};
+extern struct bta_dm_free_sdp_db bta_dm_free_sdp_db;
+
+// Name: bta_dm_init_cb
+// Params: void
+// Return: void
+struct bta_dm_init_cb {
+  std::function<void(void)> body{[](void) {}};
+  void operator()(void) { body(); };
+};
+extern struct bta_dm_init_cb bta_dm_init_cb;
+
+// Name: bta_dm_inq_cmpl
+// Params: uint8_t num
+// Return: void
+struct bta_dm_inq_cmpl {
+  std::function<void(uint8_t num)> body{[](uint8_t num) {}};
+  void operator()(uint8_t num) { body(num); };
+};
+extern struct bta_dm_inq_cmpl bta_dm_inq_cmpl;
+
+// Name: bta_dm_is_search_request_queued
+// Params:
+// Return: bool
+struct bta_dm_is_search_request_queued {
+  bool return_value{false};
+  std::function<bool()> body{[this]() { return return_value; }};
+  bool operator()() { return body(); };
+};
+extern struct bta_dm_is_search_request_queued bta_dm_is_search_request_queued;
+
+// Name: bta_dm_pin_reply
+// Params: std::unique_ptr<tBTA_DM_API_PIN_REPLY> msg
+// Return: void
+struct bta_dm_pin_reply {
+  std::function<void(std::unique_ptr<tBTA_DM_API_PIN_REPLY> msg)> body{
+      [](std::unique_ptr<tBTA_DM_API_PIN_REPLY> msg) {}};
+  void operator()(std::unique_ptr<tBTA_DM_API_PIN_REPLY> msg) {
+    body(std::move(msg));
+  };
+};
+extern struct bta_dm_pin_reply bta_dm_pin_reply;
+
+// Name: bta_dm_proc_open_evt
+// Params: tBTA_GATTC_OPEN* p_data
+// Return: void
+struct bta_dm_proc_open_evt {
+  std::function<void(tBTA_GATTC_OPEN* p_data)> body{
+      [](tBTA_GATTC_OPEN* p_data) {}};
+  void operator()(tBTA_GATTC_OPEN* p_data) { body(p_data); };
+};
+extern struct bta_dm_proc_open_evt bta_dm_proc_open_evt;
+
+// Name: bta_dm_process_remove_device
+// Params: const RawAddress& bd_addr
+// Return: void
+struct bta_dm_process_remove_device {
+  std::function<void(const RawAddress& bd_addr)> body{
+      [](const RawAddress& bd_addr) {}};
+  void operator()(const RawAddress& bd_addr) { body(bd_addr); };
+};
+extern struct bta_dm_process_remove_device bta_dm_process_remove_device;
+
+// Name: bta_dm_queue_disc
+// Params: tBTA_DM_MSG* p_data
+// Return: void
+struct bta_dm_queue_disc {
+  std::function<void(tBTA_DM_MSG* p_data)> body{[](tBTA_DM_MSG* p_data) {}};
+  void operator()(tBTA_DM_MSG* p_data) { body(p_data); };
+};
+extern struct bta_dm_queue_disc bta_dm_queue_disc;
+
+// Name: bta_dm_queue_search
+// Params: tBTA_DM_MSG* p_data
+// Return: void
+struct bta_dm_queue_search {
+  std::function<void(tBTA_DM_MSG* p_data)> body{[](tBTA_DM_MSG* p_data) {}};
+  void operator()(tBTA_DM_MSG* p_data) { body(p_data); };
+};
+extern struct bta_dm_queue_search bta_dm_queue_search;
+
+// Name: bta_dm_remove_device
+// Params: const RawAddress& bd_addr
+// Return: void
+struct bta_dm_remove_device {
+  std::function<void(const RawAddress& bd_addr)> body{
+      [](const RawAddress& bd_addr) {}};
+  void operator()(const RawAddress& bd_addr) { body(bd_addr); };
+};
+extern struct bta_dm_remove_device bta_dm_remove_device;
+
+// Name: bta_dm_rm_cback
+// Params: tBTA_SYS_CONN_STATUS status, uint8_t id, uint8_t app_id, const
+// RawAddress& peer_addr Return: void
+struct bta_dm_rm_cback {
+  std::function<void(tBTA_SYS_CONN_STATUS status, uint8_t id, uint8_t app_id,
+                     const RawAddress& peer_addr)>
+      body{[](tBTA_SYS_CONN_STATUS status, uint8_t id, uint8_t app_id,
+              const RawAddress& peer_addr) {}};
+  void operator()(tBTA_SYS_CONN_STATUS status, uint8_t id, uint8_t app_id,
+                  const RawAddress& peer_addr) {
+    body(status, id, app_id, peer_addr);
+  };
+};
+extern struct bta_dm_rm_cback bta_dm_rm_cback;
+
+// Name: bta_dm_rmt_name
+// Params: tBTA_DM_MSG* p_data
+// Return: void
+struct bta_dm_rmt_name {
+  std::function<void(tBTA_DM_MSG* p_data)> body{[](tBTA_DM_MSG* p_data) {}};
+  void operator()(tBTA_DM_MSG* p_data) { body(p_data); };
+};
+extern struct bta_dm_rmt_name bta_dm_rmt_name;
+
+// Name: bta_dm_sdp_result
+// Params: tBTA_DM_MSG* p_data
+// Return: void
+struct bta_dm_sdp_result {
+  std::function<void(tBTA_DM_MSG* p_data)> body{[](tBTA_DM_MSG* p_data) {}};
+  void operator()(tBTA_DM_MSG* p_data) { body(p_data); };
+};
+extern struct bta_dm_sdp_result bta_dm_sdp_result;
+
+// Name: bta_dm_search_cancel
+// Params:
+// Return: void
+struct bta_dm_search_cancel {
+  std::function<void()> body{[]() {}};
+  void operator()() { body(); };
+};
+extern struct bta_dm_search_cancel bta_dm_search_cancel;
+
+// Name: bta_dm_search_cancel_cmpl
+// Params:
+// Return: void
+struct bta_dm_search_cancel_cmpl {
+  std::function<void()> body{[]() {}};
+  void operator()() { body(); };
+};
+extern struct bta_dm_search_cancel_cmpl bta_dm_search_cancel_cmpl;
+
+// Name: bta_dm_search_cancel_notify
+// Params:
+// Return: void
+struct bta_dm_search_cancel_notify {
+  std::function<void()> body{[]() {}};
+  void operator()() { body(); };
+};
+extern struct bta_dm_search_cancel_notify bta_dm_search_cancel_notify;
+
+// Name: bta_dm_search_clear_queue
+// Params:
+// Return: void
+struct bta_dm_search_clear_queue {
+  std::function<void()> body{[]() {}};
+  void operator()() { body(); };
+};
+extern struct bta_dm_search_clear_queue bta_dm_search_clear_queue;
+
+// Name: bta_dm_search_cmpl
+// Params:
+// Return: void
+struct bta_dm_search_cmpl {
+  std::function<void()> body{[]() {}};
+  void operator()() { body(); };
+};
+extern struct bta_dm_search_cmpl bta_dm_search_cmpl;
+
+// Name: bta_dm_search_result
+// Params: tBTA_DM_MSG* p_data
+// Return: void
+struct bta_dm_search_result {
+  std::function<void(tBTA_DM_MSG* p_data)> body{[](tBTA_DM_MSG* p_data) {}};
+  void operator()(tBTA_DM_MSG* p_data) { body(p_data); };
+};
+extern struct bta_dm_search_result bta_dm_search_result;
+
+// Name: bta_dm_search_start
+// Params: tBTA_DM_MSG* p_data
+// Return: void
+struct bta_dm_search_start {
+  std::function<void(tBTA_DM_MSG* p_data)> body{[](tBTA_DM_MSG* p_data) {}};
+  void operator()(tBTA_DM_MSG* p_data) { body(p_data); };
+};
+extern struct bta_dm_search_start bta_dm_search_start;
+
+// Name: bta_dm_set_dev_name
+// Params: const std::vector<uint8_t>& name
+// Return: void
+struct bta_dm_set_dev_name {
+  std::function<void(const std::vector<uint8_t>& name)> body{
+      [](const std::vector<uint8_t>& name) {}};
+  void operator()(const std::vector<uint8_t>& name) { body(name); };
+};
+extern struct bta_dm_set_dev_name bta_dm_set_dev_name;
+
+// Name: bta_dm_set_encryption
+// Params: const RawAddress& bd_addr, tBT_TRANSPORT transport,
+// tBTA_DM_ENCRYPT_CBACK* p_callback, tBTM_BLE_SEC_ACT sec_act Return: void
+struct bta_dm_set_encryption {
+  std::function<void(const RawAddress& bd_addr, tBT_TRANSPORT transport,
+                     tBTA_DM_ENCRYPT_CBACK* p_callback,
+                     tBTM_BLE_SEC_ACT sec_act)>
+      body{[](const RawAddress& bd_addr, tBT_TRANSPORT transport,
+              tBTA_DM_ENCRYPT_CBACK* p_callback, tBTM_BLE_SEC_ACT sec_act) {}};
+  void operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport,
+                  tBTA_DM_ENCRYPT_CBACK* p_callback, tBTM_BLE_SEC_ACT sec_act) {
+    body(bd_addr, transport, p_callback, sec_act);
+  };
+};
+extern struct bta_dm_set_encryption bta_dm_set_encryption;
+
+// Name: btm_dm_start_gatt_discovery
+// Params: const RawAddress& bd_addr
+// Return: void
+struct btm_dm_start_gatt_discovery {
+  std::function<void(const RawAddress& bd_addr)> body{
+      [](const RawAddress& bd_addr) {}};
+  void operator()(const RawAddress& bd_addr) { body(bd_addr); };
+};
+extern struct btm_dm_start_gatt_discovery btm_dm_start_gatt_discovery;
+
+// Name: handle_remote_features_complete
+// Params: const RawAddress& bd_addr
+// Return: void
+struct handle_remote_features_complete {
+  std::function<void(const RawAddress& bd_addr)> body{
+      [](const RawAddress& bd_addr) {}};
+  void operator()(const RawAddress& bd_addr) { body(bd_addr); };
+};
+extern struct handle_remote_features_complete handle_remote_features_complete;
+
+}  // namespace bta_dm_act
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file
diff --git a/test/mock/mock_bta_dm_api.cc b/test/mock/mock_bta_dm_api.cc
index 3a7d3ca..d7fb22e 100644
--- a/test/mock/mock_bta_dm_api.cc
+++ b/test/mock/mock_bta_dm_api.cc
@@ -16,136 +16,232 @@
 
 /*
  * Generated mock file from original source file
- *   Functions generated:33
+ *   Functions generated:34
+ *
+ *  mockcify.pl ver 0.3.0
  */
 
+#include <cstdint>
+#include <functional>
 #include <map>
 #include <string>
 
 extern std::map<std::string, int> mock_function_count_map;
 
-#include <base/bind.h>
-#include <vector>
-#include "bt_target.h"
-#include "bta/dm/bta_dm_int.h"
-#include "osi/include/allocator.h"
-#include "stack/btm/btm_sec.h"
-#include "stack/include/btm_api.h"
-#include "stack/include/btu.h"
-#include "types/bluetooth/uuid.h"
-#include "types/raw_address.h"
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_bta_dm_api.h"
 
-#ifndef UNUSED_ATTR
-#define UNUSED_ATTR
-#endif
+// Mocked internal structures, if any
 
-void BTA_dm_init() { mock_function_count_map[__func__]++; }
-bool BTA_DmGetConnectionState(const RawAddress& bd_addr) {
+namespace test {
+namespace mock {
+namespace bta_dm_api {
+
+// Function state capture and return values, if needed
+struct BTA_AddEirUuid BTA_AddEirUuid;
+struct BTA_DmAddBleDevice BTA_DmAddBleDevice;
+struct BTA_DmAddBleKey BTA_DmAddBleKey;
+struct BTA_DmAddDevice BTA_DmAddDevice;
+struct BTA_DmBleConfigLocalPrivacy BTA_DmBleConfigLocalPrivacy;
+struct BTA_DmBleConfirmReply BTA_DmBleConfirmReply;
+struct BTA_DmBleCsisObserve BTA_DmBleCsisObserve;
+struct BTA_DmBleGetEnergyInfo BTA_DmBleGetEnergyInfo;
+struct BTA_DmBleObserve BTA_DmBleObserve;
+struct BTA_DmBlePasskeyReply BTA_DmBlePasskeyReply;
+struct BTA_DmBleRequestMaxTxDataLength BTA_DmBleRequestMaxTxDataLength;
+struct BTA_DmBleScan BTA_DmBleScan;
+struct BTA_DmBleSecurityGrant BTA_DmBleSecurityGrant;
+struct BTA_DmBleUpdateConnectionParams BTA_DmBleUpdateConnectionParams;
+struct BTA_DmBond BTA_DmBond;
+struct BTA_DmBondCancel BTA_DmBondCancel;
+struct BTA_DmCloseACL BTA_DmCloseACL;
+struct BTA_DmConfirm BTA_DmConfirm;
+struct BTA_DmDiscover BTA_DmDiscover;
+struct BTA_DmGetConnectionState BTA_DmGetConnectionState;
+struct BTA_DmLocalOob BTA_DmLocalOob;
+struct BTA_DmPinReply BTA_DmPinReply;
+struct BTA_DmRemoveDevice BTA_DmRemoveDevice;
+struct BTA_DmSearch BTA_DmSearch;
+struct BTA_DmSearchCancel BTA_DmSearchCancel;
+struct BTA_DmSetBlePrefConnParams BTA_DmSetBlePrefConnParams;
+struct BTA_DmSetDeviceName BTA_DmSetDeviceName;
+struct BTA_DmSetEncryption BTA_DmSetEncryption;
+struct BTA_DmSetLocalDiRecord BTA_DmSetLocalDiRecord;
+struct BTA_EnableTestMode BTA_EnableTestMode;
+struct BTA_GetEirService BTA_GetEirService;
+struct BTA_RemoveEirUuid BTA_RemoveEirUuid;
+struct BTA_VendorInit BTA_VendorInit;
+struct BTA_dm_init BTA_dm_init;
+
+}  // namespace bta_dm_api
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+void BTA_AddEirUuid(uint16_t uuid16) {
   mock_function_count_map[__func__]++;
-  return false;
+  test::mock::bta_dm_api::BTA_AddEirUuid(uuid16);
 }
-tBTA_STATUS BTA_DmRemoveDevice(const RawAddress& bd_addr) {
-  mock_function_count_map[__func__]++;
-  return BTA_SUCCESS;
-}
-tBTA_STATUS BTA_DmSetLocalDiRecord(tSDP_DI_RECORD* p_device_info,
-                                   uint32_t* p_handle) {
-  mock_function_count_map[__func__]++;
-  return BTA_SUCCESS;
-}
-void BTA_AddEirUuid(uint16_t uuid16) { mock_function_count_map[__func__]++; }
 void BTA_DmAddBleDevice(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
                         tBT_DEVICE_TYPE dev_type) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmAddBleDevice(bd_addr, addr_type, dev_type);
 }
 void BTA_DmAddBleKey(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE* p_le_key,
                      tBTM_LE_KEY_TYPE key_type) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmAddBleKey(bd_addr, p_le_key, key_type);
 }
 void BTA_DmAddDevice(const RawAddress& bd_addr, DEV_CLASS dev_class,
                      const LinkKey& link_key, uint8_t key_type,
                      uint8_t pin_length) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmAddDevice(bd_addr, dev_class, link_key,
+                                          key_type, pin_length);
 }
 void BTA_DmBleConfigLocalPrivacy(bool privacy_enable) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmBleConfigLocalPrivacy(privacy_enable);
 }
 void BTA_DmBleConfirmReply(const RawAddress& bd_addr, bool accept) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmBleConfirmReply(bd_addr, accept);
+}
+void BTA_DmBleCsisObserve(bool observe, tBTA_DM_SEARCH_CBACK* p_results_cb) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmBleCsisObserve(observe, p_results_cb);
 }
 void BTA_DmBleGetEnergyInfo(tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmBleGetEnergyInfo(p_cmpl_cback);
+}
+void BTA_DmBleObserve(bool start, uint8_t duration,
+                      tBTA_DM_SEARCH_CBACK* p_results_cb) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmBleObserve(start, duration, p_results_cb);
 }
 void BTA_DmBlePasskeyReply(const RawAddress& bd_addr, bool accept,
                            uint32_t passkey) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmBlePasskeyReply(bd_addr, accept, passkey);
 }
 void BTA_DmBleRequestMaxTxDataLength(const RawAddress& remote_device) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmBleRequestMaxTxDataLength(remote_device);
+}
+void BTA_DmBleScan(bool start, uint8_t duration) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmBleScan(start, duration);
 }
 void BTA_DmBleSecurityGrant(const RawAddress& bd_addr,
                             tBTA_DM_BLE_SEC_GRANT res) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmBleSecurityGrant(bd_addr, res);
 }
 void BTA_DmBleUpdateConnectionParams(const RawAddress& bd_addr,
                                      uint16_t min_int, uint16_t max_int,
                                      uint16_t latency, uint16_t timeout,
                                      uint16_t min_ce_len, uint16_t max_ce_len) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmBleUpdateConnectionParams(
+      bd_addr, min_int, max_int, latency, timeout, min_ce_len, max_ce_len);
 }
 void BTA_DmBond(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
                 tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmBond(bd_addr, addr_type, transport,
+                                     device_type);
 }
 void BTA_DmBondCancel(const RawAddress& bd_addr) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmBondCancel(bd_addr);
 }
 void BTA_DmCloseACL(const RawAddress& bd_addr, bool remove_dev,
                     tBT_TRANSPORT transport) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmCloseACL(bd_addr, remove_dev, transport);
 }
 void BTA_DmConfirm(const RawAddress& bd_addr, bool accept) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmConfirm(bd_addr, accept);
 }
 void BTA_DmDiscover(const RawAddress& bd_addr, tBTA_DM_SEARCH_CBACK* p_cback,
                     tBT_TRANSPORT transport, bool is_bonding_or_sd) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmDiscover(bd_addr, p_cback, transport,
+                                         is_bonding_or_sd);
 }
-void BTA_DmLocalOob(void) { mock_function_count_map[__func__]++; }
+bool BTA_DmGetConnectionState(const RawAddress& bd_addr) {
+  mock_function_count_map[__func__]++;
+  return test::mock::bta_dm_api::BTA_DmGetConnectionState(bd_addr);
+}
+void BTA_DmLocalOob(void) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmLocalOob();
+}
 void BTA_DmPinReply(const RawAddress& bd_addr, bool accept, uint8_t pin_len,
                     uint8_t* p_pin) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmPinReply(bd_addr, accept, pin_len, p_pin);
+}
+tBTA_STATUS BTA_DmRemoveDevice(const RawAddress& bd_addr) {
+  mock_function_count_map[__func__]++;
+  return test::mock::bta_dm_api::BTA_DmRemoveDevice(bd_addr);
 }
 void BTA_DmSearch(tBTA_DM_SEARCH_CBACK* p_cback, bool is_bonding_or_sdp) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmSearch(p_cback, is_bonding_or_sdp);
 }
-void BTA_DmSearchCancel(void) { mock_function_count_map[__func__]++; }
+void BTA_DmSearchCancel(void) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmSearchCancel();
+}
 void BTA_DmSetBlePrefConnParams(const RawAddress& bd_addr,
                                 uint16_t min_conn_int, uint16_t max_conn_int,
                                 uint16_t peripheral_latency,
                                 uint16_t supervision_tout) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmSetBlePrefConnParams(
+      bd_addr, min_conn_int, max_conn_int, peripheral_latency,
+      supervision_tout);
 }
-void BTA_DmSetDeviceName(char* p_name) { mock_function_count_map[__func__]++; }
+void BTA_DmSetDeviceName(char* p_name) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmSetDeviceName(p_name);
+}
 void BTA_DmSetEncryption(const RawAddress& bd_addr, tBT_TRANSPORT transport,
                          tBTA_DM_ENCRYPT_CBACK* p_callback,
                          tBTM_BLE_SEC_ACT sec_act) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_DmSetEncryption(bd_addr, transport, p_callback,
+                                              sec_act);
 }
-void BTA_EnableTestMode(void) { mock_function_count_map[__func__]++; }
+tBTA_STATUS BTA_DmSetLocalDiRecord(tSDP_DI_RECORD* p_device_info,
+                                   uint32_t* p_handle) {
+  mock_function_count_map[__func__]++;
+  return test::mock::bta_dm_api::BTA_DmSetLocalDiRecord(p_device_info,
+                                                        p_handle);
+}
+void BTA_EnableTestMode(void) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_EnableTestMode();
+}
 void BTA_GetEirService(uint8_t* p_eir, size_t eir_len,
                        tBTA_SERVICE_MASK* p_services) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_GetEirService(p_eir, eir_len, p_services);
 }
-void BTA_RemoveEirUuid(uint16_t uuid16) { mock_function_count_map[__func__]++; }
-void BTA_DmBleObserve(bool start, uint8_t duration,
-                      tBTA_DM_SEARCH_CBACK* p_results_cb) {
+void BTA_RemoveEirUuid(uint16_t uuid16) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_RemoveEirUuid(uuid16);
 }
-void BTA_DmBleScan(bool start, uint8_t duration) {
+void BTA_VendorInit(void) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_VendorInit();
 }
-void BTA_DmBleCsisObserve(bool observe, tBTA_DM_SEARCH_CBACK* p_results_cb) {
+void BTA_dm_init() {
   mock_function_count_map[__func__]++;
+  test::mock::bta_dm_api::BTA_dm_init();
 }
-void BTA_VendorInit(void) { mock_function_count_map[__func__]++; }
+
+// END mockcify generation
diff --git a/test/mock/mock_bta_dm_api.h b/test/mock/mock_bta_dm_api.h
new file mode 100644
index 0000000..324b9ec
--- /dev/null
+++ b/test/mock/mock_bta_dm_api.h
@@ -0,0 +1,488 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:34
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <base/bind.h>
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "bt_target.h"
+#include "bta/dm/bta_dm_int.h"
+#include "osi/include/allocator.h"
+#include "stack/btm/btm_sec.h"
+#include "stack/include/btm_api.h"
+#include "stack/include/btu.h"
+#include "types/bluetooth/uuid.h"
+#include "types/raw_address.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace bta_dm_api {
+
+// Shared state between mocked functions and tests
+// Name: BTA_AddEirUuid
+// Params: uint16_t uuid16
+// Return: void
+struct BTA_AddEirUuid {
+  std::function<void(uint16_t uuid16)> body{[](uint16_t uuid16) {}};
+  void operator()(uint16_t uuid16) { body(uuid16); };
+};
+extern struct BTA_AddEirUuid BTA_AddEirUuid;
+
+// Name: BTA_DmAddBleDevice
+// Params: const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, tBT_DEVICE_TYPE
+// dev_type Return: void
+struct BTA_DmAddBleDevice {
+  std::function<void(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
+                     tBT_DEVICE_TYPE dev_type)>
+      body{[](const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
+              tBT_DEVICE_TYPE dev_type) {}};
+  void operator()(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
+                  tBT_DEVICE_TYPE dev_type) {
+    body(bd_addr, addr_type, dev_type);
+  };
+};
+extern struct BTA_DmAddBleDevice BTA_DmAddBleDevice;
+
+// Name: BTA_DmAddBleKey
+// Params: const RawAddress& bd_addr, tBTA_LE_KEY_VALUE* p_le_key,
+// tBTM_LE_KEY_TYPE key_type Return: void
+struct BTA_DmAddBleKey {
+  std::function<void(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE* p_le_key,
+                     tBTM_LE_KEY_TYPE key_type)>
+      body{[](const RawAddress& bd_addr, tBTA_LE_KEY_VALUE* p_le_key,
+              tBTM_LE_KEY_TYPE key_type) {}};
+  void operator()(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE* p_le_key,
+                  tBTM_LE_KEY_TYPE key_type) {
+    body(bd_addr, p_le_key, key_type);
+  };
+};
+extern struct BTA_DmAddBleKey BTA_DmAddBleKey;
+
+// Name: BTA_DmAddDevice
+// Params: const RawAddress& bd_addr, DEV_CLASS dev_class, const LinkKey&
+// link_key, uint8_t key_type, uint8_t pin_length Return: void
+struct BTA_DmAddDevice {
+  std::function<void(const RawAddress& bd_addr, DEV_CLASS dev_class,
+                     const LinkKey& link_key, uint8_t key_type,
+                     uint8_t pin_length)>
+      body{[](const RawAddress& bd_addr, DEV_CLASS dev_class,
+              const LinkKey& link_key, uint8_t key_type,
+              uint8_t pin_length) {}};
+  void operator()(const RawAddress& bd_addr, DEV_CLASS dev_class,
+                  const LinkKey& link_key, uint8_t key_type,
+                  uint8_t pin_length) {
+    body(bd_addr, dev_class, link_key, key_type, pin_length);
+  };
+};
+extern struct BTA_DmAddDevice BTA_DmAddDevice;
+
+// Name: BTA_DmBleConfigLocalPrivacy
+// Params: bool privacy_enable
+// Return: void
+struct BTA_DmBleConfigLocalPrivacy {
+  std::function<void(bool privacy_enable)> body{[](bool privacy_enable) {}};
+  void operator()(bool privacy_enable) { body(privacy_enable); };
+};
+extern struct BTA_DmBleConfigLocalPrivacy BTA_DmBleConfigLocalPrivacy;
+
+// Name: BTA_DmBleConfirmReply
+// Params: const RawAddress& bd_addr, bool accept
+// Return: void
+struct BTA_DmBleConfirmReply {
+  std::function<void(const RawAddress& bd_addr, bool accept)> body{
+      [](const RawAddress& bd_addr, bool accept) {}};
+  void operator()(const RawAddress& bd_addr, bool accept) {
+    body(bd_addr, accept);
+  };
+};
+extern struct BTA_DmBleConfirmReply BTA_DmBleConfirmReply;
+
+// Name: BTA_DmBleCsisObserve
+// Params: bool observe, tBTA_DM_SEARCH_CBACK* p_results_cb
+// Return: void
+struct BTA_DmBleCsisObserve {
+  std::function<void(bool observe, tBTA_DM_SEARCH_CBACK* p_results_cb)> body{
+      [](bool observe, tBTA_DM_SEARCH_CBACK* p_results_cb) {}};
+  void operator()(bool observe, tBTA_DM_SEARCH_CBACK* p_results_cb) {
+    body(observe, p_results_cb);
+  };
+};
+extern struct BTA_DmBleCsisObserve BTA_DmBleCsisObserve;
+
+// Name: BTA_DmBleGetEnergyInfo
+// Params: tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback
+// Return: void
+struct BTA_DmBleGetEnergyInfo {
+  std::function<void(tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback)> body{
+      [](tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback) {}};
+  void operator()(tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback) {
+    body(p_cmpl_cback);
+  };
+};
+extern struct BTA_DmBleGetEnergyInfo BTA_DmBleGetEnergyInfo;
+
+// Name: BTA_DmBleObserve
+// Params: bool start, uint8_t duration, tBTA_DM_SEARCH_CBACK* p_results_cb
+// Return: void
+struct BTA_DmBleObserve {
+  std::function<void(bool start, uint8_t duration,
+                     tBTA_DM_SEARCH_CBACK* p_results_cb)>
+      body{[](bool start, uint8_t duration,
+              tBTA_DM_SEARCH_CBACK* p_results_cb) {}};
+  void operator()(bool start, uint8_t duration,
+                  tBTA_DM_SEARCH_CBACK* p_results_cb) {
+    body(start, duration, p_results_cb);
+  };
+};
+extern struct BTA_DmBleObserve BTA_DmBleObserve;
+
+// Name: BTA_DmBlePasskeyReply
+// Params: const RawAddress& bd_addr, bool accept, uint32_t passkey
+// Return: void
+struct BTA_DmBlePasskeyReply {
+  std::function<void(const RawAddress& bd_addr, bool accept, uint32_t passkey)>
+      body{[](const RawAddress& bd_addr, bool accept, uint32_t passkey) {}};
+  void operator()(const RawAddress& bd_addr, bool accept, uint32_t passkey) {
+    body(bd_addr, accept, passkey);
+  };
+};
+extern struct BTA_DmBlePasskeyReply BTA_DmBlePasskeyReply;
+
+// Name: BTA_DmBleRequestMaxTxDataLength
+// Params: const RawAddress& remote_device
+// Return: void
+struct BTA_DmBleRequestMaxTxDataLength {
+  std::function<void(const RawAddress& remote_device)> body{
+      [](const RawAddress& remote_device) {}};
+  void operator()(const RawAddress& remote_device) { body(remote_device); };
+};
+extern struct BTA_DmBleRequestMaxTxDataLength BTA_DmBleRequestMaxTxDataLength;
+
+// Name: BTA_DmBleScan
+// Params: bool start, uint8_t duration
+// Return: void
+struct BTA_DmBleScan {
+  std::function<void(bool start, uint8_t duration)> body{
+      [](bool start, uint8_t duration) {}};
+  void operator()(bool start, uint8_t duration) { body(start, duration); };
+};
+extern struct BTA_DmBleScan BTA_DmBleScan;
+
+// Name: BTA_DmBleSecurityGrant
+// Params: const RawAddress& bd_addr, tBTA_DM_BLE_SEC_GRANT res
+// Return: void
+struct BTA_DmBleSecurityGrant {
+  std::function<void(const RawAddress& bd_addr, tBTA_DM_BLE_SEC_GRANT res)>
+      body{[](const RawAddress& bd_addr, tBTA_DM_BLE_SEC_GRANT res) {}};
+  void operator()(const RawAddress& bd_addr, tBTA_DM_BLE_SEC_GRANT res) {
+    body(bd_addr, res);
+  };
+};
+extern struct BTA_DmBleSecurityGrant BTA_DmBleSecurityGrant;
+
+// Name: BTA_DmBleUpdateConnectionParams
+// Params: const RawAddress& bd_addr, uint16_t min_int, uint16_t max_int,
+// uint16_t latency, uint16_t timeout, uint16_t min_ce_len, uint16_t max_ce_len
+// Return: void
+struct BTA_DmBleUpdateConnectionParams {
+  std::function<void(const RawAddress& bd_addr, uint16_t min_int,
+                     uint16_t max_int, uint16_t latency, uint16_t timeout,
+                     uint16_t min_ce_len, uint16_t max_ce_len)>
+      body{[](const RawAddress& bd_addr, uint16_t min_int, uint16_t max_int,
+              uint16_t latency, uint16_t timeout, uint16_t min_ce_len,
+              uint16_t max_ce_len) {}};
+  void operator()(const RawAddress& bd_addr, uint16_t min_int, uint16_t max_int,
+                  uint16_t latency, uint16_t timeout, uint16_t min_ce_len,
+                  uint16_t max_ce_len) {
+    body(bd_addr, min_int, max_int, latency, timeout, min_ce_len, max_ce_len);
+  };
+};
+extern struct BTA_DmBleUpdateConnectionParams BTA_DmBleUpdateConnectionParams;
+
+// Name: BTA_DmBond
+// Params: const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, tBT_TRANSPORT
+// transport, tBT_DEVICE_TYPE device_type Return: void
+struct BTA_DmBond {
+  std::function<void(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
+                     tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type)>
+      body{[](const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
+              tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type) {}};
+  void operator()(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
+                  tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type) {
+    body(bd_addr, addr_type, transport, device_type);
+  };
+};
+extern struct BTA_DmBond BTA_DmBond;
+
+// Name: BTA_DmBondCancel
+// Params: const RawAddress& bd_addr
+// Return: void
+struct BTA_DmBondCancel {
+  std::function<void(const RawAddress& bd_addr)> body{
+      [](const RawAddress& bd_addr) {}};
+  void operator()(const RawAddress& bd_addr) { body(bd_addr); };
+};
+extern struct BTA_DmBondCancel BTA_DmBondCancel;
+
+// Name: BTA_DmCloseACL
+// Params: const RawAddress& bd_addr, bool remove_dev, tBT_TRANSPORT transport
+// Return: void
+struct BTA_DmCloseACL {
+  std::function<void(const RawAddress& bd_addr, bool remove_dev,
+                     tBT_TRANSPORT transport)>
+      body{[](const RawAddress& bd_addr, bool remove_dev,
+              tBT_TRANSPORT transport) {}};
+  void operator()(const RawAddress& bd_addr, bool remove_dev,
+                  tBT_TRANSPORT transport) {
+    body(bd_addr, remove_dev, transport);
+  };
+};
+extern struct BTA_DmCloseACL BTA_DmCloseACL;
+
+// Name: BTA_DmConfirm
+// Params: const RawAddress& bd_addr, bool accept
+// Return: void
+struct BTA_DmConfirm {
+  std::function<void(const RawAddress& bd_addr, bool accept)> body{
+      [](const RawAddress& bd_addr, bool accept) {}};
+  void operator()(const RawAddress& bd_addr, bool accept) {
+    body(bd_addr, accept);
+  };
+};
+extern struct BTA_DmConfirm BTA_DmConfirm;
+
+// Name: BTA_DmDiscover
+// Params: const RawAddress& bd_addr, tBTA_DM_SEARCH_CBACK* p_cback,
+// tBT_TRANSPORT transport, bool is_bonding_or_sd Return: void
+struct BTA_DmDiscover {
+  std::function<void(const RawAddress& bd_addr, tBTA_DM_SEARCH_CBACK* p_cback,
+                     tBT_TRANSPORT transport, bool is_bonding_or_sd)>
+      body{[](const RawAddress& bd_addr, tBTA_DM_SEARCH_CBACK* p_cback,
+              tBT_TRANSPORT transport, bool is_bonding_or_sd) {}};
+  void operator()(const RawAddress& bd_addr, tBTA_DM_SEARCH_CBACK* p_cback,
+                  tBT_TRANSPORT transport, bool is_bonding_or_sd) {
+    body(bd_addr, p_cback, transport, is_bonding_or_sd);
+  };
+};
+extern struct BTA_DmDiscover BTA_DmDiscover;
+
+// Name: BTA_DmGetConnectionState
+// Params: const RawAddress& bd_addr
+// Return: bool
+struct BTA_DmGetConnectionState {
+  bool return_value{false};
+  std::function<bool(const RawAddress& bd_addr)> body{
+      [this](const RawAddress& bd_addr) { return return_value; }};
+  bool operator()(const RawAddress& bd_addr) { return body(bd_addr); };
+};
+extern struct BTA_DmGetConnectionState BTA_DmGetConnectionState;
+
+// Name: BTA_DmLocalOob
+// Params: void
+// Return: void
+struct BTA_DmLocalOob {
+  std::function<void(void)> body{[](void) {}};
+  void operator()(void) { body(); };
+};
+extern struct BTA_DmLocalOob BTA_DmLocalOob;
+
+// Name: BTA_DmPinReply
+// Params: const RawAddress& bd_addr, bool accept, uint8_t pin_len, uint8_t*
+// p_pin Return: void
+struct BTA_DmPinReply {
+  std::function<void(const RawAddress& bd_addr, bool accept, uint8_t pin_len,
+                     uint8_t* p_pin)>
+      body{[](const RawAddress& bd_addr, bool accept, uint8_t pin_len,
+              uint8_t* p_pin) {}};
+  void operator()(const RawAddress& bd_addr, bool accept, uint8_t pin_len,
+                  uint8_t* p_pin) {
+    body(bd_addr, accept, pin_len, p_pin);
+  };
+};
+extern struct BTA_DmPinReply BTA_DmPinReply;
+
+// Name: BTA_DmRemoveDevice
+// Params: const RawAddress& bd_addr
+// Return: tBTA_STATUS
+struct BTA_DmRemoveDevice {
+  tBTA_STATUS return_value{0};
+  std::function<tBTA_STATUS(const RawAddress& bd_addr)> body{
+      [this](const RawAddress& bd_addr) { return return_value; }};
+  tBTA_STATUS operator()(const RawAddress& bd_addr) { return body(bd_addr); };
+};
+extern struct BTA_DmRemoveDevice BTA_DmRemoveDevice;
+
+// Name: BTA_DmSearch
+// Params: tBTA_DM_SEARCH_CBACK* p_cback, bool is_bonding_or_sdp
+// Return: void
+struct BTA_DmSearch {
+  std::function<void(tBTA_DM_SEARCH_CBACK* p_cback, bool is_bonding_or_sdp)>
+      body{[](tBTA_DM_SEARCH_CBACK* p_cback, bool is_bonding_or_sdp) {}};
+  void operator()(tBTA_DM_SEARCH_CBACK* p_cback, bool is_bonding_or_sdp) {
+    body(p_cback, is_bonding_or_sdp);
+  };
+};
+extern struct BTA_DmSearch BTA_DmSearch;
+
+// Name: BTA_DmSearchCancel
+// Params: void
+// Return: void
+struct BTA_DmSearchCancel {
+  std::function<void(void)> body{[](void) {}};
+  void operator()(void) { body(); };
+};
+extern struct BTA_DmSearchCancel BTA_DmSearchCancel;
+
+// Name: BTA_DmSetBlePrefConnParams
+// Params: const RawAddress& bd_addr, uint16_t min_conn_int, uint16_t
+// max_conn_int, uint16_t peripheral_latency, uint16_t supervision_tout Return:
+// void
+struct BTA_DmSetBlePrefConnParams {
+  std::function<void(const RawAddress& bd_addr, uint16_t min_conn_int,
+                     uint16_t max_conn_int, uint16_t peripheral_latency,
+                     uint16_t supervision_tout)>
+      body{[](const RawAddress& bd_addr, uint16_t min_conn_int,
+              uint16_t max_conn_int, uint16_t peripheral_latency,
+              uint16_t supervision_tout) {}};
+  void operator()(const RawAddress& bd_addr, uint16_t min_conn_int,
+                  uint16_t max_conn_int, uint16_t peripheral_latency,
+                  uint16_t supervision_tout) {
+    body(bd_addr, min_conn_int, max_conn_int, peripheral_latency,
+         supervision_tout);
+  };
+};
+extern struct BTA_DmSetBlePrefConnParams BTA_DmSetBlePrefConnParams;
+
+// Name: BTA_DmSetDeviceName
+// Params: char* p_name
+// Return: void
+struct BTA_DmSetDeviceName {
+  std::function<void(char* p_name)> body{[](char* p_name) {}};
+  void operator()(char* p_name) { body(p_name); };
+};
+extern struct BTA_DmSetDeviceName BTA_DmSetDeviceName;
+
+// Name: BTA_DmSetEncryption
+// Params: const RawAddress& bd_addr, tBT_TRANSPORT transport,
+// tBTA_DM_ENCRYPT_CBACK* p_callback, tBTM_BLE_SEC_ACT sec_act Return: void
+struct BTA_DmSetEncryption {
+  std::function<void(const RawAddress& bd_addr, tBT_TRANSPORT transport,
+                     tBTA_DM_ENCRYPT_CBACK* p_callback,
+                     tBTM_BLE_SEC_ACT sec_act)>
+      body{[](const RawAddress& bd_addr, tBT_TRANSPORT transport,
+              tBTA_DM_ENCRYPT_CBACK* p_callback, tBTM_BLE_SEC_ACT sec_act) {}};
+  void operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport,
+                  tBTA_DM_ENCRYPT_CBACK* p_callback, tBTM_BLE_SEC_ACT sec_act) {
+    body(bd_addr, transport, p_callback, sec_act);
+  };
+};
+extern struct BTA_DmSetEncryption BTA_DmSetEncryption;
+
+// Name: BTA_DmSetLocalDiRecord
+// Params: tSDP_DI_RECORD* p_device_info, uint32_t* p_handle
+// Return: tBTA_STATUS
+struct BTA_DmSetLocalDiRecord {
+  tBTA_STATUS return_value{0};
+  std::function<tBTA_STATUS(tSDP_DI_RECORD* p_device_info, uint32_t* p_handle)>
+      body{[this](tSDP_DI_RECORD* p_device_info, uint32_t* p_handle) {
+        return return_value;
+      }};
+  tBTA_STATUS operator()(tSDP_DI_RECORD* p_device_info, uint32_t* p_handle) {
+    return body(p_device_info, p_handle);
+  };
+};
+extern struct BTA_DmSetLocalDiRecord BTA_DmSetLocalDiRecord;
+
+// Name: BTA_EnableTestMode
+// Params: void
+// Return: void
+struct BTA_EnableTestMode {
+  std::function<void(void)> body{[](void) {}};
+  void operator()(void) { body(); };
+};
+extern struct BTA_EnableTestMode BTA_EnableTestMode;
+
+// Name: BTA_GetEirService
+// Params: uint8_t* p_eir, size_t eir_len, tBTA_SERVICE_MASK* p_services
+// Return: void
+struct BTA_GetEirService {
+  std::function<void(uint8_t* p_eir, size_t eir_len,
+                     tBTA_SERVICE_MASK* p_services)>
+      body{
+          [](uint8_t* p_eir, size_t eir_len, tBTA_SERVICE_MASK* p_services) {}};
+  void operator()(uint8_t* p_eir, size_t eir_len,
+                  tBTA_SERVICE_MASK* p_services) {
+    body(p_eir, eir_len, p_services);
+  };
+};
+extern struct BTA_GetEirService BTA_GetEirService;
+
+// Name: BTA_RemoveEirUuid
+// Params: uint16_t uuid16
+// Return: void
+struct BTA_RemoveEirUuid {
+  std::function<void(uint16_t uuid16)> body{[](uint16_t uuid16) {}};
+  void operator()(uint16_t uuid16) { body(uuid16); };
+};
+extern struct BTA_RemoveEirUuid BTA_RemoveEirUuid;
+
+// Name: BTA_VendorInit
+// Params: void
+// Return: void
+struct BTA_VendorInit {
+  std::function<void(void)> body{[](void) {}};
+  void operator()(void) { body(); };
+};
+extern struct BTA_VendorInit BTA_VendorInit;
+
+// Name: BTA_dm_init
+// Params:
+// Return: void
+struct BTA_dm_init {
+  std::function<void()> body{[]() {}};
+  void operator()() { body(); };
+};
+extern struct BTA_dm_init BTA_dm_init;
+
+}  // namespace bta_dm_api
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file
diff --git a/test/mock/mock_bta_hh_utils.cc b/test/mock/mock_bta_hh_utils.cc
new file mode 100644
index 0000000..2f77f71
--- /dev/null
+++ b/test/mock/mock_bta_hh_utils.cc
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:10
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_bta_hh_utils.h"
+
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace bta_hh_utils {
+
+// Function state capture and return values, if needed
+struct bta_hh_add_device_to_list bta_hh_add_device_to_list;
+struct bta_hh_clean_up_kdev bta_hh_clean_up_kdev;
+struct bta_hh_cleanup_disable bta_hh_cleanup_disable;
+struct bta_hh_dev_handle_to_cb_idx bta_hh_dev_handle_to_cb_idx;
+struct bta_hh_find_cb bta_hh_find_cb;
+struct bta_hh_get_cb bta_hh_get_cb;
+struct bta_hh_read_ssr_param bta_hh_read_ssr_param;
+struct bta_hh_tod_spt bta_hh_tod_spt;
+struct bta_hh_trace_dev_db bta_hh_trace_dev_db;
+struct bta_hh_update_di_info bta_hh_update_di_info;
+
+}  // namespace bta_hh_utils
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+void bta_hh_add_device_to_list(tBTA_HH_DEV_CB* p_cb, uint8_t handle,
+                               uint16_t attr_mask,
+                               const tHID_DEV_DSCP_INFO* p_dscp_info,
+                               uint8_t sub_class, uint16_t ssr_max_latency,
+                               uint16_t ssr_min_tout, uint8_t app_id) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_hh_utils::bta_hh_add_device_to_list(
+      p_cb, handle, attr_mask, p_dscp_info, sub_class, ssr_max_latency,
+      ssr_min_tout, app_id);
+}
+void bta_hh_clean_up_kdev(tBTA_HH_DEV_CB* p_cb) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_hh_utils::bta_hh_clean_up_kdev(p_cb);
+}
+void bta_hh_cleanup_disable(tBTA_HH_STATUS status) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_hh_utils::bta_hh_cleanup_disable(status);
+}
+uint8_t bta_hh_dev_handle_to_cb_idx(uint8_t dev_handle) {
+  mock_function_count_map[__func__]++;
+  return test::mock::bta_hh_utils::bta_hh_dev_handle_to_cb_idx(dev_handle);
+}
+uint8_t bta_hh_find_cb(const RawAddress& bda) {
+  mock_function_count_map[__func__]++;
+  return test::mock::bta_hh_utils::bta_hh_find_cb(bda);
+}
+tBTA_HH_DEV_CB* bta_hh_get_cb(const RawAddress& bda) {
+  mock_function_count_map[__func__]++;
+  return test::mock::bta_hh_utils::bta_hh_get_cb(bda);
+}
+tBTA_HH_STATUS bta_hh_read_ssr_param(const RawAddress& bd_addr,
+                                     uint16_t* p_max_ssr_lat,
+                                     uint16_t* p_min_ssr_tout) {
+  mock_function_count_map[__func__]++;
+  return test::mock::bta_hh_utils::bta_hh_read_ssr_param(bd_addr, p_max_ssr_lat,
+                                                         p_min_ssr_tout);
+}
+bool bta_hh_tod_spt(tBTA_HH_DEV_CB* p_cb, uint8_t sub_class) {
+  mock_function_count_map[__func__]++;
+  return test::mock::bta_hh_utils::bta_hh_tod_spt(p_cb, sub_class);
+}
+void bta_hh_trace_dev_db(void) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_hh_utils::bta_hh_trace_dev_db();
+}
+void bta_hh_update_di_info(tBTA_HH_DEV_CB* p_cb, uint16_t vendor_id,
+                           uint16_t product_id, uint16_t version,
+                           uint8_t flag) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_hh_utils::bta_hh_update_di_info(p_cb, vendor_id, product_id,
+                                                  version, flag);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_bta_hh_utils.h b/test/mock/mock_bta_hh_utils.h
new file mode 100644
index 0000000..7407a80
--- /dev/null
+++ b/test/mock/mock_bta_hh_utils.h
@@ -0,0 +1,190 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:10
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <string.h>
+
+#include <cstring>
+
+#include "bt_target.h"
+#include "bt_trace.h"
+#include "bta/hh/bta_hh_int.h"
+#include "btif/include/btif_storage.h"
+#include "device/include/interop.h"
+#include "osi/include/osi.h"
+#include "stack/include/acl_api.h"
+#include "stack/include/btm_client_interface.h"
+#include "types/raw_address.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace bta_hh_utils {
+
+// Shared state between mocked functions and tests
+// Name: bta_hh_add_device_to_list
+// Params: tBTA_HH_DEV_CB* p_cb, uint8_t handle, uint16_t attr_mask, const
+// tHID_DEV_DSCP_INFO* p_dscp_info, uint8_t sub_class, uint16_t ssr_max_latency,
+// uint16_t ssr_min_tout, uint8_t app_id Return: void
+struct bta_hh_add_device_to_list {
+  std::function<void(tBTA_HH_DEV_CB* p_cb, uint8_t handle, uint16_t attr_mask,
+                     const tHID_DEV_DSCP_INFO* p_dscp_info, uint8_t sub_class,
+                     uint16_t ssr_max_latency, uint16_t ssr_min_tout,
+                     uint8_t app_id)>
+      body{[](tBTA_HH_DEV_CB* p_cb, uint8_t handle, uint16_t attr_mask,
+              const tHID_DEV_DSCP_INFO* p_dscp_info, uint8_t sub_class,
+              uint16_t ssr_max_latency, uint16_t ssr_min_tout,
+              uint8_t app_id) {}};
+  void operator()(tBTA_HH_DEV_CB* p_cb, uint8_t handle, uint16_t attr_mask,
+                  const tHID_DEV_DSCP_INFO* p_dscp_info, uint8_t sub_class,
+                  uint16_t ssr_max_latency, uint16_t ssr_min_tout,
+                  uint8_t app_id) {
+    body(p_cb, handle, attr_mask, p_dscp_info, sub_class, ssr_max_latency,
+         ssr_min_tout, app_id);
+  };
+};
+extern struct bta_hh_add_device_to_list bta_hh_add_device_to_list;
+
+// Name: bta_hh_clean_up_kdev
+// Params: tBTA_HH_DEV_CB* p_cb
+// Return: void
+struct bta_hh_clean_up_kdev {
+  std::function<void(tBTA_HH_DEV_CB* p_cb)> body{[](tBTA_HH_DEV_CB* p_cb) {}};
+  void operator()(tBTA_HH_DEV_CB* p_cb) { body(p_cb); };
+};
+extern struct bta_hh_clean_up_kdev bta_hh_clean_up_kdev;
+
+// Name: bta_hh_cleanup_disable
+// Params: tBTA_HH_STATUS status
+// Return: void
+struct bta_hh_cleanup_disable {
+  std::function<void(tBTA_HH_STATUS status)> body{[](tBTA_HH_STATUS status) {}};
+  void operator()(tBTA_HH_STATUS status) { body(status); };
+};
+extern struct bta_hh_cleanup_disable bta_hh_cleanup_disable;
+
+// Name: bta_hh_dev_handle_to_cb_idx
+// Params: uint8_t dev_handle
+// Return: uint8_t
+struct bta_hh_dev_handle_to_cb_idx {
+  uint8_t return_value{0};
+  std::function<uint8_t(uint8_t dev_handle)> body{
+      [this](uint8_t dev_handle) { return return_value; }};
+  uint8_t operator()(uint8_t dev_handle) { return body(dev_handle); };
+};
+extern struct bta_hh_dev_handle_to_cb_idx bta_hh_dev_handle_to_cb_idx;
+
+// Name: bta_hh_find_cb
+// Params: const RawAddress& bda
+// Return: uint8_t
+struct bta_hh_find_cb {
+  uint8_t return_value{0};
+  std::function<uint8_t(const RawAddress& bda)> body{
+      [this](const RawAddress& bda) { return return_value; }};
+  uint8_t operator()(const RawAddress& bda) { return body(bda); };
+};
+extern struct bta_hh_find_cb bta_hh_find_cb;
+
+// Name: bta_hh_get_cb
+// Params: const RawAddress& bda
+// Return: tBTA_HH_DEV_CB*
+struct bta_hh_get_cb {
+  tBTA_HH_DEV_CB* return_value{0};
+  std::function<tBTA_HH_DEV_CB*(const RawAddress& bda)> body{
+      [this](const RawAddress& bda) { return return_value; }};
+  tBTA_HH_DEV_CB* operator()(const RawAddress& bda) { return body(bda); };
+};
+extern struct bta_hh_get_cb bta_hh_get_cb;
+
+// Name: bta_hh_read_ssr_param
+// Params: const RawAddress& bd_addr, uint16_t* p_max_ssr_lat, uint16_t*
+// p_min_ssr_tout Return: tBTA_HH_STATUS
+struct bta_hh_read_ssr_param {
+  tBTA_HH_STATUS return_value{0};
+  std::function<tBTA_HH_STATUS(const RawAddress& bd_addr,
+                               uint16_t* p_max_ssr_lat,
+                               uint16_t* p_min_ssr_tout)>
+      body{[this](const RawAddress& bd_addr, uint16_t* p_max_ssr_lat,
+                  uint16_t* p_min_ssr_tout) { return return_value; }};
+  tBTA_HH_STATUS operator()(const RawAddress& bd_addr, uint16_t* p_max_ssr_lat,
+                            uint16_t* p_min_ssr_tout) {
+    return body(bd_addr, p_max_ssr_lat, p_min_ssr_tout);
+  };
+};
+extern struct bta_hh_read_ssr_param bta_hh_read_ssr_param;
+
+// Name: bta_hh_tod_spt
+// Params: tBTA_HH_DEV_CB* p_cb, uint8_t sub_class
+// Return: bool
+struct bta_hh_tod_spt {
+  bool return_value{false};
+  std::function<bool(tBTA_HH_DEV_CB* p_cb, uint8_t sub_class)> body{
+      [this](tBTA_HH_DEV_CB* p_cb, uint8_t sub_class) { return return_value; }};
+  bool operator()(tBTA_HH_DEV_CB* p_cb, uint8_t sub_class) {
+    return body(p_cb, sub_class);
+  };
+};
+extern struct bta_hh_tod_spt bta_hh_tod_spt;
+
+// Name: bta_hh_trace_dev_db
+// Params: void
+// Return: void
+struct bta_hh_trace_dev_db {
+  std::function<void(void)> body{[](void) {}};
+  void operator()(void) { body(); };
+};
+extern struct bta_hh_trace_dev_db bta_hh_trace_dev_db;
+
+// Name: bta_hh_update_di_info
+// Params: tBTA_HH_DEV_CB* p_cb, uint16_t vendor_id, uint16_t product_id,
+// uint16_t version, uint8_t flag Return: void
+struct bta_hh_update_di_info {
+  std::function<void(tBTA_HH_DEV_CB* p_cb, uint16_t vendor_id,
+                     uint16_t product_id, uint16_t version, uint8_t flag)>
+      body{[](tBTA_HH_DEV_CB* p_cb, uint16_t vendor_id, uint16_t product_id,
+              uint16_t version, uint8_t flag) {}};
+  void operator()(tBTA_HH_DEV_CB* p_cb, uint16_t vendor_id, uint16_t product_id,
+                  uint16_t version, uint8_t flag) {
+    body(p_cb, vendor_id, product_id, version, flag);
+  };
+};
+extern struct bta_hh_update_di_info bta_hh_update_di_info;
+
+}  // namespace bta_hh_utils
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file
diff --git a/test/mock/mock_bta_sys_main.cc b/test/mock/mock_bta_sys_main.cc
index 9871349..5b74faa 100644
--- a/test/mock/mock_bta_sys_main.cc
+++ b/test/mock/mock_bta_sys_main.cc
@@ -17,48 +17,84 @@
 /*
  * Generated mock file from original source file
  *   Functions generated:10
+ *
+ *  mockcify.pl ver 0.3.0
  */
 
+#include <cstdint>
+#include <functional>
 #include <map>
 #include <string>
 
 extern std::map<std::string, int> mock_function_count_map;
 
-#include <base/bind.h>
-#include <cstring>
-#include "bt_target.h"
-#include "bta/sys/bta_sys.h"
-#include "bta/sys/bta_sys_int.h"
-#include "include/hardware/bluetooth.h"
-#include "osi/include/alarm.h"
-#include "osi/include/allocator.h"
-#include "osi/include/log.h"
-#include "stack/include/bt_types.h"
-#include "stack/include/btu.h"
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_bta_sys_main.h"
 
-#ifndef UNUSED_ATTR
-#define UNUSED_ATTR
-#endif
+// Mocked internal structures, if any
 
-bool bta_sys_is_register(uint8_t id) {
+namespace test {
+namespace mock {
+namespace bta_sys_main {
+
+// Function state capture and return values, if needed
+struct BTA_sys_signal_hw_error BTA_sys_signal_hw_error;
+struct bta_set_forward_hw_failures bta_set_forward_hw_failures;
+struct bta_sys_deregister bta_sys_deregister;
+struct bta_sys_disable bta_sys_disable;
+struct bta_sys_init bta_sys_init;
+struct bta_sys_is_register bta_sys_is_register;
+struct bta_sys_register bta_sys_register;
+struct bta_sys_sendmsg bta_sys_sendmsg;
+struct bta_sys_sendmsg_delayed bta_sys_sendmsg_delayed;
+struct bta_sys_start_timer bta_sys_start_timer;
+
+}  // namespace bta_sys_main
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+void BTA_sys_signal_hw_error() {
   mock_function_count_map[__func__]++;
-  return false;
+  test::mock::bta_sys_main::BTA_sys_signal_hw_error();
 }
-void BTA_sys_signal_hw_error() { mock_function_count_map[__func__]++; }
 void bta_set_forward_hw_failures(bool value) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_sys_main::bta_set_forward_hw_failures(value);
 }
-void bta_sys_deregister(uint8_t id) { mock_function_count_map[__func__]++; }
-void bta_sys_disable() { mock_function_count_map[__func__]++; }
-void bta_sys_init(void) { mock_function_count_map[__func__]++; }
+void bta_sys_deregister(uint8_t id) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_sys_main::bta_sys_deregister(id);
+}
+void bta_sys_disable() {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_sys_main::bta_sys_disable();
+}
+void bta_sys_init(void) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_sys_main::bta_sys_init();
+}
+bool bta_sys_is_register(uint8_t id) {
+  mock_function_count_map[__func__]++;
+  return test::mock::bta_sys_main::bta_sys_is_register(id);
+}
 void bta_sys_register(uint8_t id, const tBTA_SYS_REG* p_reg) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_sys_main::bta_sys_register(id, p_reg);
 }
-void bta_sys_sendmsg(void* p_msg) { mock_function_count_map[__func__]++; }
+void bta_sys_sendmsg(void* p_msg) {
+  mock_function_count_map[__func__]++;
+  test::mock::bta_sys_main::bta_sys_sendmsg(p_msg);
+}
 void bta_sys_sendmsg_delayed(void* p_msg, const base::TimeDelta& delay) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_sys_main::bta_sys_sendmsg_delayed(p_msg, delay);
 }
 void bta_sys_start_timer(alarm_t* alarm, uint64_t interval_ms, uint16_t event,
                          uint16_t layer_specific) {
   mock_function_count_map[__func__]++;
+  test::mock::bta_sys_main::bta_sys_start_timer(alarm, interval_ms, event,
+                                                layer_specific);
 }
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_bta_sys_main.h b/test/mock/mock_bta_sys_main.h
new file mode 100644
index 0000000..95bc473
--- /dev/null
+++ b/test/mock/mock_bta_sys_main.h
@@ -0,0 +1,166 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:10
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <base/bind.h>
+
+#include <cstring>
+#include <map>
+#include <string>
+
+#include "bt_target.h"
+#include "bta/sys/bta_sys.h"
+#include "bta/sys/bta_sys_int.h"
+#include "include/hardware/bluetooth.h"
+#include "osi/include/alarm.h"
+#include "osi/include/allocator.h"
+#include "osi/include/log.h"
+#include "stack/include/bt_types.h"
+#include "stack/include/btu.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace bta_sys_main {
+
+// Shared state between mocked functions and tests
+// Name: BTA_sys_signal_hw_error
+// Params:
+// Return: void
+struct BTA_sys_signal_hw_error {
+  std::function<void()> body{[]() {}};
+  void operator()() { body(); };
+};
+extern struct BTA_sys_signal_hw_error BTA_sys_signal_hw_error;
+
+// Name: bta_set_forward_hw_failures
+// Params: bool value
+// Return: void
+struct bta_set_forward_hw_failures {
+  std::function<void(bool value)> body{[](bool value) {}};
+  void operator()(bool value) { body(value); };
+};
+extern struct bta_set_forward_hw_failures bta_set_forward_hw_failures;
+
+// Name: bta_sys_deregister
+// Params: uint8_t id
+// Return: void
+struct bta_sys_deregister {
+  std::function<void(uint8_t id)> body{[](uint8_t id) {}};
+  void operator()(uint8_t id) { body(id); };
+};
+extern struct bta_sys_deregister bta_sys_deregister;
+
+// Name: bta_sys_disable
+// Params:
+// Return: void
+struct bta_sys_disable {
+  std::function<void()> body{[]() {}};
+  void operator()() { body(); };
+};
+extern struct bta_sys_disable bta_sys_disable;
+
+// Name: bta_sys_init
+// Params: void
+// Return: void
+struct bta_sys_init {
+  std::function<void(void)> body{[](void) {}};
+  void operator()(void) { body(); };
+};
+extern struct bta_sys_init bta_sys_init;
+
+// Name: bta_sys_is_register
+// Params: uint8_t id
+// Return: bool
+struct bta_sys_is_register {
+  bool return_value{false};
+  std::function<bool(uint8_t id)> body{
+      [this](uint8_t id) { return return_value; }};
+  bool operator()(uint8_t id) { return body(id); };
+};
+extern struct bta_sys_is_register bta_sys_is_register;
+
+// Name: bta_sys_register
+// Params: uint8_t id, const tBTA_SYS_REG* p_reg
+// Return: void
+struct bta_sys_register {
+  std::function<void(uint8_t id, const tBTA_SYS_REG* p_reg)> body{
+      [](uint8_t id, const tBTA_SYS_REG* p_reg) {}};
+  void operator()(uint8_t id, const tBTA_SYS_REG* p_reg) { body(id, p_reg); };
+};
+extern struct bta_sys_register bta_sys_register;
+
+// Name: bta_sys_sendmsg
+// Params: void* p_msg
+// Return: void
+struct bta_sys_sendmsg {
+  std::function<void(void* p_msg)> body{[](void* p_msg) {}};
+  void operator()(void* p_msg) { body(p_msg); };
+};
+extern struct bta_sys_sendmsg bta_sys_sendmsg;
+
+// Name: bta_sys_sendmsg_delayed
+// Params: void* p_msg, const base::TimeDelta& delay
+// Return: void
+struct bta_sys_sendmsg_delayed {
+  std::function<void(void* p_msg, const base::TimeDelta& delay)> body{
+      [](void* p_msg, const base::TimeDelta& delay) {}};
+  void operator()(void* p_msg, const base::TimeDelta& delay) {
+    body(p_msg, delay);
+  };
+};
+extern struct bta_sys_sendmsg_delayed bta_sys_sendmsg_delayed;
+
+// Name: bta_sys_start_timer
+// Params: alarm_t* alarm, uint64_t interval_ms, uint16_t event, uint16_t
+// layer_specific Return: void
+struct bta_sys_start_timer {
+  std::function<void(alarm_t* alarm, uint64_t interval_ms, uint16_t event,
+                     uint16_t layer_specific)>
+      body{[](alarm_t* alarm, uint64_t interval_ms, uint16_t event,
+              uint16_t layer_specific) {}};
+  void operator()(alarm_t* alarm, uint64_t interval_ms, uint16_t event,
+                  uint16_t layer_specific) {
+    body(alarm, interval_ms, event, layer_specific);
+  };
+};
+extern struct bta_sys_start_timer bta_sys_start_timer;
+
+}  // namespace bta_sys_main
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file
diff --git a/test/mock/mock_btcore_module.cc b/test/mock/mock_btcore_module.cc
index c83cb9d..1b53b7a 100644
--- a/test/mock/mock_btcore_module.cc
+++ b/test/mock/mock_btcore_module.cc
@@ -16,46 +16,68 @@
 
 /*
  * Generated mock file from original source file
- *   Functions generated:8
+ *   Functions generated:7
+ *
+ *  mockcify.pl ver 0.3.0
  */
 
+#include <cstdint>
+#include <functional>
 #include <map>
 #include <string>
 
 extern std::map<std::string, int> mock_function_count_map;
 
-#include <base/logging.h>
-#include <dlfcn.h>
-#include <string.h>
-#include <mutex>
-#include <unordered_map>
-#include "btcore/include/module.h"
-#include "common/message_loop_thread.h"
-#include "osi/include/allocator.h"
-#include "osi/include/log.h"
-#include "osi/include/osi.h"
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_btcore_module.h"
 
-#ifndef UNUSED_ATTR
-#define UNUSED_ATTR
-#endif
+// Mocked internal structures, if any
 
+namespace test {
+namespace mock {
+namespace btcore_module {
+
+// Function state capture and return values, if needed
+struct get_module get_module;
+struct module_clean_up module_clean_up;
+struct module_init module_init;
+struct module_management_start module_management_start;
+struct module_management_stop module_management_stop;
+struct module_shut_down module_shut_down;
+struct module_start_up module_start_up;
+
+}  // namespace btcore_module
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+const module_t* get_module(const char* name) {
+  mock_function_count_map[__func__]++;
+  return test::mock::btcore_module::get_module(name);
+}
+void module_clean_up(const module_t* module) {
+  mock_function_count_map[__func__]++;
+  test::mock::btcore_module::module_clean_up(module);
+}
 bool module_init(const module_t* module) {
   mock_function_count_map[__func__]++;
-  return false;
+  return test::mock::btcore_module::module_init(module);
+}
+void module_management_start(void) {
+  mock_function_count_map[__func__]++;
+  test::mock::btcore_module::module_management_start();
+}
+void module_management_stop(void) {
+  mock_function_count_map[__func__]++;
+  test::mock::btcore_module::module_management_stop();
+}
+void module_shut_down(const module_t* module) {
+  mock_function_count_map[__func__]++;
+  test::mock::btcore_module::module_shut_down(module);
 }
 bool module_start_up(const module_t* module) {
   mock_function_count_map[__func__]++;
-  return false;
+  return test::mock::btcore_module::module_start_up(module);
 }
-const module_t* get_module(const char* name) {
-  mock_function_count_map[__func__]++;
-  return nullptr;
-}
-void module_management_start(void) { mock_function_count_map[__func__]++; }
-void module_clean_up(const module_t* module) {
-  mock_function_count_map[__func__]++;
-}
-void module_management_stop(void) { mock_function_count_map[__func__]++; }
-void module_shut_down(const module_t* module) {
-  mock_function_count_map[__func__]++;
-}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_btcore_module.h b/test/mock/mock_btcore_module.h
new file mode 100644
index 0000000..31bbb54
--- /dev/null
+++ b/test/mock/mock_btcore_module.h
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:7
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <base/logging.h>
+#include <dlfcn.h>
+#include <string.h>
+
+#include <mutex>
+#include <unordered_map>
+
+#include "btcore/include/module.h"
+#include "check.h"
+#include "common/message_loop_thread.h"
+#include "osi/include/allocator.h"
+#include "osi/include/log.h"
+#include "osi/include/osi.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace btcore_module {
+
+// Shared state between mocked functions and tests
+// Name: get_module
+// Params: const char* name
+// Return: const module_t*
+struct get_module {
+  const module_t* return_value{0};
+  std::function<const module_t*(const char* name)> body{
+      [this](const char* name) { return return_value; }};
+  const module_t* operator()(const char* name) { return body(name); };
+};
+extern struct get_module get_module;
+
+// Name: module_clean_up
+// Params: const module_t* module
+// Return: void
+struct module_clean_up {
+  std::function<void(const module_t* module)> body{
+      [](const module_t* module) {}};
+  void operator()(const module_t* module) { body(module); };
+};
+extern struct module_clean_up module_clean_up;
+
+// Name: module_init
+// Params: const module_t* module
+// Return: bool
+struct module_init {
+  bool return_value{false};
+  std::function<bool(const module_t* module)> body{
+      [this](const module_t* module) { return return_value; }};
+  bool operator()(const module_t* module) { return body(module); };
+};
+extern struct module_init module_init;
+
+// Name: module_management_start
+// Params: void
+// Return: void
+struct module_management_start {
+  std::function<void(void)> body{[](void) {}};
+  void operator()(void) { body(); };
+};
+extern struct module_management_start module_management_start;
+
+// Name: module_management_stop
+// Params: void
+// Return: void
+struct module_management_stop {
+  std::function<void(void)> body{[](void) {}};
+  void operator()(void) { body(); };
+};
+extern struct module_management_stop module_management_stop;
+
+// Name: module_shut_down
+// Params: const module_t* module
+// Return: void
+struct module_shut_down {
+  std::function<void(const module_t* module)> body{
+      [](const module_t* module) {}};
+  void operator()(const module_t* module) { body(module); };
+};
+extern struct module_shut_down module_shut_down;
+
+// Name: module_start_up
+// Params: const module_t* module
+// Return: bool
+struct module_start_up {
+  bool return_value{false};
+  std::function<bool(const module_t* module)> body{
+      [this](const module_t* module) { return return_value; }};
+  bool operator()(const module_t* module) { return body(module); };
+};
+extern struct module_start_up module_start_up;
+
+}  // namespace btcore_module
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file
diff --git a/test/mock/mock_common_message_loop_thread.cc b/test/mock/mock_common_message_loop_thread.cc
index 7562a1d..cdad37a 100644
--- a/test/mock/mock_common_message_loop_thread.cc
+++ b/test/mock/mock_common_message_loop_thread.cc
@@ -117,6 +117,7 @@
   {
     if (is_main_ && init_flags::gd_rust_is_enabled()) {
       delete rust_thread_;
+      rust_thread_ = nullptr;
       thread_id_ = -1;
       linux_tid_ = -1;
       return;
diff --git a/test/mock/mock_device_esco_parameters.cc b/test/mock/mock_device_esco_parameters.cc
new file mode 100644
index 0000000..86410fe
--- /dev/null
+++ b/test/mock/mock_device_esco_parameters.cc
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:1
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_device_esco_parameters.h"
+
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace device_esco_parameters {
+
+// Function state capture and return values, if needed
+struct esco_parameters_for_codec esco_parameters_for_codec;
+
+}  // namespace device_esco_parameters
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+enh_esco_params_t esco_parameters_for_codec(esco_codec_t codec) {
+  mock_function_count_map[__func__]++;
+  return test::mock::device_esco_parameters::esco_parameters_for_codec(codec);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_device_esco_parameters.h b/test/mock/mock_device_esco_parameters.h
new file mode 100644
index 0000000..46116d9
--- /dev/null
+++ b/test/mock/mock_device_esco_parameters.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:1
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include "base/logging.h"
+#include "check.h"
+#include "device/include/esco_parameters.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace device_esco_parameters {
+
+// Shared state between mocked functions and tests
+// Name: esco_parameters_for_codec
+// Params: esco_codec_t codec
+// Return: enh_esco_params_t
+struct esco_parameters_for_codec {
+  enh_esco_params_t return_value{};
+  std::function<enh_esco_params_t(esco_codec_t codec)> body{
+      [this](esco_codec_t codec) { return return_value; }};
+  enh_esco_params_t operator()(esco_codec_t codec) { return body(codec); };
+};
+extern struct esco_parameters_for_codec esco_parameters_for_codec;
+
+}  // namespace device_esco_parameters
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
diff --git a/test/mock/mock_osi_alarm.cc b/test/mock/mock_osi_alarm.cc
new file mode 100644
index 0000000..c171558
--- /dev/null
+++ b/test/mock/mock_osi_alarm.cc
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:10
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_osi_alarm.h"
+
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace osi_alarm {
+
+// Function state capture and return values, if needed
+struct alarm_cancel alarm_cancel;
+struct alarm_cleanup alarm_cleanup;
+struct alarm_debug_dump alarm_debug_dump;
+struct alarm_free alarm_free;
+struct alarm_get_remaining_ms alarm_get_remaining_ms;
+struct alarm_is_scheduled alarm_is_scheduled;
+struct alarm_new alarm_new;
+struct alarm_new_periodic alarm_new_periodic;
+struct alarm_set alarm_set;
+struct alarm_set_on_mloop alarm_set_on_mloop;
+
+}  // namespace osi_alarm
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+void alarm_cancel(alarm_t* alarm) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_alarm::alarm_cancel(alarm);
+}
+void alarm_cleanup(void) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_alarm::alarm_cleanup();
+}
+void alarm_debug_dump(int fd) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_alarm::alarm_debug_dump(fd);
+}
+void alarm_free(alarm_t* alarm) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_alarm::alarm_free(alarm);
+}
+uint64_t alarm_get_remaining_ms(const alarm_t* alarm) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_alarm::alarm_get_remaining_ms(alarm);
+}
+bool alarm_is_scheduled(const alarm_t* alarm) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_alarm::alarm_is_scheduled(alarm);
+}
+alarm_t* alarm_new(const char* name) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_alarm::alarm_new(name);
+}
+alarm_t* alarm_new_periodic(const char* name) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_alarm::alarm_new_periodic(name);
+}
+void alarm_set(alarm_t* alarm, uint64_t interval_ms, alarm_callback_t cb,
+               void* data) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_alarm::alarm_set(alarm, interval_ms, cb, data);
+}
+void alarm_set_on_mloop(alarm_t* alarm, uint64_t interval_ms,
+                        alarm_callback_t cb, void* data) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_alarm::alarm_set_on_mloop(alarm, interval_ms, cb, data);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_osi_alarm.h b/test/mock/mock_osi_alarm.h
new file mode 100644
index 0000000..d1afdca
--- /dev/null
+++ b/test/mock/mock_osi_alarm.h
@@ -0,0 +1,185 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:10
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <base/cancelable_callback.h>
+#include <base/logging.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <hardware/bluetooth.h>
+#include <inttypes.h>
+#include <malloc.h>
+#include <pthread.h>
+#include <signal.h>
+#include <string.h>
+#include <time.h>
+
+#include <mutex>
+
+#include "check.h"
+#include "internal_include/bt_target.h"
+#include "osi/include/alarm.h"
+#include "osi/include/allocator.h"
+#include "osi/include/fixed_queue.h"
+#include "osi/include/list.h"
+#include "osi/include/log.h"
+#include "osi/include/osi.h"
+#include "osi/include/semaphore.h"
+#include "osi/include/thread.h"
+#include "osi/include/wakelock.h"
+#include "stack/include/btu.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace osi_alarm {
+
+// Shared state between mocked functions and tests
+// Name: alarm_cancel
+// Params: alarm_t* alarm
+// Return: void
+struct alarm_cancel {
+  std::function<void(alarm_t* alarm)> body{[](alarm_t* alarm) {}};
+  void operator()(alarm_t* alarm) { body(alarm); };
+};
+extern struct alarm_cancel alarm_cancel;
+
+// Name: alarm_cleanup
+// Params: void
+// Return: void
+struct alarm_cleanup {
+  std::function<void(void)> body{[](void) {}};
+  void operator()(void) { body(); };
+};
+extern struct alarm_cleanup alarm_cleanup;
+
+// Name: alarm_debug_dump
+// Params: int fd
+// Return: void
+struct alarm_debug_dump {
+  std::function<void(int fd)> body{[](int fd) {}};
+  void operator()(int fd) { body(fd); };
+};
+extern struct alarm_debug_dump alarm_debug_dump;
+
+// Name: alarm_free
+// Params: alarm_t* alarm
+// Return: void
+struct alarm_free {
+  std::function<void(alarm_t* alarm)> body{[](alarm_t* alarm) {}};
+  void operator()(alarm_t* alarm) { body(alarm); };
+};
+extern struct alarm_free alarm_free;
+
+// Name: alarm_get_remaining_ms
+// Params: const alarm_t* alarm
+// Return: uint64_t
+struct alarm_get_remaining_ms {
+  uint64_t return_value{0};
+  std::function<uint64_t(const alarm_t* alarm)> body{
+      [this](const alarm_t* alarm) { return return_value; }};
+  uint64_t operator()(const alarm_t* alarm) { return body(alarm); };
+};
+extern struct alarm_get_remaining_ms alarm_get_remaining_ms;
+
+// Name: alarm_is_scheduled
+// Params: const alarm_t* alarm
+// Return: bool
+struct alarm_is_scheduled {
+  bool return_value{false};
+  std::function<bool(const alarm_t* alarm)> body{
+      [this](const alarm_t* alarm) { return return_value; }};
+  bool operator()(const alarm_t* alarm) { return body(alarm); };
+};
+extern struct alarm_is_scheduled alarm_is_scheduled;
+
+// Name: alarm_new
+// Params: const char* name
+// Return: alarm_t*
+struct alarm_new {
+  alarm_t* return_value{0};
+  std::function<alarm_t*(const char* name)> body{
+      [this](const char* name) { return return_value; }};
+  alarm_t* operator()(const char* name) { return body(name); };
+};
+extern struct alarm_new alarm_new;
+
+// Name: alarm_new_periodic
+// Params: const char* name
+// Return: alarm_t*
+struct alarm_new_periodic {
+  alarm_t* return_value{0};
+  std::function<alarm_t*(const char* name)> body{
+      [this](const char* name) { return return_value; }};
+  alarm_t* operator()(const char* name) { return body(name); };
+};
+extern struct alarm_new_periodic alarm_new_periodic;
+
+// Name: alarm_set
+// Params: alarm_t* alarm, uint64_t interval_ms, alarm_callback_t cb, void* data
+// Return: void
+struct alarm_set {
+  std::function<void(alarm_t* alarm, uint64_t interval_ms, alarm_callback_t cb,
+                     void* data)>
+      body{[](alarm_t* alarm, uint64_t interval_ms, alarm_callback_t cb,
+              void* data) {}};
+  void operator()(alarm_t* alarm, uint64_t interval_ms, alarm_callback_t cb,
+                  void* data) {
+    body(alarm, interval_ms, cb, data);
+  };
+};
+extern struct alarm_set alarm_set;
+
+// Name: alarm_set_on_mloop
+// Params: alarm_t* alarm, uint64_t interval_ms, alarm_callback_t cb, void* data
+// Return: void
+struct alarm_set_on_mloop {
+  std::function<void(alarm_t* alarm, uint64_t interval_ms, alarm_callback_t cb,
+                     void* data)>
+      body{[](alarm_t* alarm, uint64_t interval_ms, alarm_callback_t cb,
+              void* data) {}};
+  void operator()(alarm_t* alarm, uint64_t interval_ms, alarm_callback_t cb,
+                  void* data) {
+    body(alarm, interval_ms, cb, data);
+  };
+};
+extern struct alarm_set_on_mloop alarm_set_on_mloop;
+
+}  // namespace osi_alarm
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file
diff --git a/test/mock/mock_osi_allocation_tracker.cc b/test/mock/mock_osi_allocation_tracker.cc
new file mode 100644
index 0000000..277343f
--- /dev/null
+++ b/test/mock/mock_osi_allocation_tracker.cc
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:8
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_osi_allocation_tracker.h"
+
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace osi_allocation_tracker {
+
+// Function state capture and return values, if needed
+struct allocation_tracker_expect_no_allocations
+    allocation_tracker_expect_no_allocations;
+struct allocation_tracker_init allocation_tracker_init;
+struct allocation_tracker_notify_alloc allocation_tracker_notify_alloc;
+struct allocation_tracker_notify_free allocation_tracker_notify_free;
+struct allocation_tracker_reset allocation_tracker_reset;
+struct allocation_tracker_resize_for_canary
+    allocation_tracker_resize_for_canary;
+struct allocation_tracker_uninit allocation_tracker_uninit;
+struct osi_allocator_debug_dump osi_allocator_debug_dump;
+
+}  // namespace osi_allocation_tracker
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+size_t allocation_tracker_expect_no_allocations(void) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_allocation_tracker::
+      allocation_tracker_expect_no_allocations();
+}
+void allocation_tracker_init(void) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_allocation_tracker::allocation_tracker_init();
+}
+void* allocation_tracker_notify_alloc(uint8_t allocator_id, void* ptr,
+                                      size_t requested_size) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_allocation_tracker::allocation_tracker_notify_alloc(
+      allocator_id, ptr, requested_size);
+}
+void* allocation_tracker_notify_free(uint8_t allocator_id, void* ptr) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_allocation_tracker::allocation_tracker_notify_free(
+      allocator_id, ptr);
+}
+void allocation_tracker_reset(void) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_allocation_tracker::allocation_tracker_reset();
+}
+size_t allocation_tracker_resize_for_canary(size_t size) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_allocation_tracker::
+      allocation_tracker_resize_for_canary(size);
+}
+void allocation_tracker_uninit(void) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_allocation_tracker::allocation_tracker_uninit();
+}
+void osi_allocator_debug_dump(int fd) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_allocation_tracker::osi_allocator_debug_dump(fd);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_osi_allocation_tracker.h b/test/mock/mock_osi_allocation_tracker.h
new file mode 100644
index 0000000..32ceab0
--- /dev/null
+++ b/test/mock/mock_osi_allocation_tracker.h
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:8
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <base/logging.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <mutex>
+#include <unordered_map>
+
+#include "check.h"
+#include "osi/include/allocation_tracker.h"
+#include "osi/include/allocator.h"
+#include "osi/include/log.h"
+#include "osi/include/osi.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace osi_allocation_tracker {
+
+// Shared state between mocked functions and tests
+// Name: allocation_tracker_expect_no_allocations
+// Params: void
+// Return: size_t
+struct allocation_tracker_expect_no_allocations {
+  size_t return_value{0};
+  std::function<size_t(void)> body{[this](void) { return return_value; }};
+  size_t operator()(void) { return body(); };
+};
+extern struct allocation_tracker_expect_no_allocations
+    allocation_tracker_expect_no_allocations;
+
+// Name: allocation_tracker_init
+// Params: void
+// Return: void
+struct allocation_tracker_init {
+  std::function<void(void)> body{[](void) {}};
+  void operator()(void) { body(); };
+};
+extern struct allocation_tracker_init allocation_tracker_init;
+
+// Name: allocation_tracker_notify_alloc
+// Params: uint8_t allocator_id, void* ptr, size_t requested_size
+// Return: void*
+struct allocation_tracker_notify_alloc {
+  void* return_value{};
+  std::function<void*(uint8_t allocator_id, void* ptr, size_t requested_size)>
+      body{[this](uint8_t allocator_id, void* ptr, size_t requested_size) {
+        return return_value;
+      }};
+  void* operator()(uint8_t allocator_id, void* ptr, size_t requested_size) {
+    return body(allocator_id, ptr, requested_size);
+  };
+};
+extern struct allocation_tracker_notify_alloc allocation_tracker_notify_alloc;
+
+// Name: allocation_tracker_notify_free
+// Params:  uint8_t allocator_id, void* ptr
+// Return: void*
+struct allocation_tracker_notify_free {
+  void* return_value{};
+  std::function<void*(uint8_t allocator_id, void* ptr)> body{
+      [this](uint8_t allocator_id, void* ptr) { return return_value; }};
+  void* operator()(uint8_t allocator_id, void* ptr) {
+    return body(allocator_id, ptr);
+  };
+};
+extern struct allocation_tracker_notify_free allocation_tracker_notify_free;
+
+// Name: allocation_tracker_reset
+// Params: void
+// Return: void
+struct allocation_tracker_reset {
+  std::function<void(void)> body{[](void) {}};
+  void operator()(void) { body(); };
+};
+extern struct allocation_tracker_reset allocation_tracker_reset;
+
+// Name: allocation_tracker_resize_for_canary
+// Params: size_t size
+// Return: size_t
+struct allocation_tracker_resize_for_canary {
+  size_t return_value{0};
+  std::function<size_t(size_t size)> body{
+      [this](size_t size) { return return_value; }};
+  size_t operator()(size_t size) { return body(size); };
+};
+extern struct allocation_tracker_resize_for_canary
+    allocation_tracker_resize_for_canary;
+
+// Name: allocation_tracker_uninit
+// Params: void
+// Return: void
+struct allocation_tracker_uninit {
+  std::function<void(void)> body{[](void) {}};
+  void operator()(void) { body(); };
+};
+extern struct allocation_tracker_uninit allocation_tracker_uninit;
+
+// Name: osi_allocator_debug_dump
+// Params: int fd
+// Return: void
+struct osi_allocator_debug_dump {
+  std::function<void(int fd)> body{[](int fd) {}};
+  void operator()(int fd) { body(fd); };
+};
+extern struct osi_allocator_debug_dump osi_allocator_debug_dump;
+
+}  // namespace osi_allocation_tracker
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file
diff --git a/test/mock/mock_osi_allocator.cc b/test/mock/mock_osi_allocator.cc
new file mode 100644
index 0000000..d939085
--- /dev/null
+++ b/test/mock/mock_osi_allocator.cc
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:6
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_osi_allocator.h"
+
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace osi_allocator {
+
+// Function state capture and return values, if needed
+struct osi_calloc osi_calloc;
+struct osi_free osi_free;
+struct osi_free_and_reset osi_free_and_reset;
+struct osi_malloc osi_malloc;
+struct osi_strdup osi_strdup;
+struct osi_strndup osi_strndup;
+
+}  // namespace osi_allocator
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+void* osi_calloc(size_t size) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_allocator::osi_calloc(size);
+}
+void osi_free(void* ptr) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_allocator::osi_free(ptr);
+}
+void osi_free_and_reset(void** p_ptr) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_allocator::osi_free_and_reset(p_ptr);
+}
+void* osi_malloc(size_t size) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_allocator::osi_malloc(size);
+}
+char* osi_strdup(const char* str) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_allocator::osi_strdup(str);
+}
+char* osi_strndup(const char* str, size_t len) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_allocator::osi_strndup(str, len);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_osi_allocator.h b/test/mock/mock_osi_allocator.h
new file mode 100644
index 0000000..4f845f5
--- /dev/null
+++ b/test/mock/mock_osi_allocator.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:6
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <base/logging.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "check.h"
+#include "osi/include/allocation_tracker.h"
+#include "osi/include/allocator.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace osi_allocator {
+
+// Shared state between mocked functions and tests
+// Name: osi_calloc
+// Params: size_t size
+// Return: void*
+struct osi_calloc {
+  void* return_value{};
+  std::function<void*(size_t size)> body{
+      [this](size_t size) { return return_value; }};
+  void* operator()(size_t size) { return body(size); };
+};
+extern struct osi_calloc osi_calloc;
+
+// Name: osi_free
+// Params: void* ptr
+// Return: void
+struct osi_free {
+  std::function<void(void* ptr)> body{[](void* ptr) {}};
+  void operator()(void* ptr) { body(ptr); };
+};
+extern struct osi_free osi_free;
+
+// Name: osi_free_and_reset
+// Params: void** p_ptr
+// Return: void
+struct osi_free_and_reset {
+  std::function<void(void** p_ptr)> body{[](void** p_ptr) {}};
+  void operator()(void** p_ptr) { body(p_ptr); };
+};
+extern struct osi_free_and_reset osi_free_and_reset;
+
+// Name: osi_malloc
+// Params: size_t size
+// Return: void*
+struct osi_malloc {
+  void* return_value{};
+  std::function<void*(size_t size)> body{
+      [this](size_t size) { return return_value; }};
+  void* operator()(size_t size) { return body(size); };
+};
+extern struct osi_malloc osi_malloc;
+
+// Name: osi_strdup
+// Params: const char* str
+// Return: char*
+struct osi_strdup {
+  char* return_value{0};
+  std::function<char*(const char* str)> body{
+      [this](const char* str) { return return_value; }};
+  char* operator()(const char* str) { return body(str); };
+};
+extern struct osi_strdup osi_strdup;
+
+// Name: osi_strndup
+// Params: const char* str, size_t len
+// Return: char*
+struct osi_strndup {
+  char* return_value{0};
+  std::function<char*(const char* str, size_t len)> body{
+      [this](const char* str, size_t len) { return return_value; }};
+  char* operator()(const char* str, size_t len) { return body(str, len); };
+};
+extern struct osi_strndup osi_strndup;
+
+}  // namespace osi_allocator
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file
diff --git a/test/mock/mock_osi_config.cc b/test/mock/mock_osi_config.cc
new file mode 100644
index 0000000..7e57df6
--- /dev/null
+++ b/test/mock/mock_osi_config.cc
@@ -0,0 +1,179 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:24
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_osi_config.h"
+
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace osi_config {
+
+// Function state capture and return values, if needed
+struct checksum_read checksum_read;
+struct checksum_save checksum_save;
+struct config_get_bool config_get_bool;
+struct config_get_int config_get_int;
+struct config_get_string config_get_string;
+struct config_get_uint64 config_get_uint64;
+struct config_has_key config_has_key;
+struct config_has_section config_has_section;
+struct config_new config_new;
+struct config_new_clone config_new_clone;
+struct config_new_empty config_new_empty;
+struct config_remove_key config_remove_key;
+struct config_remove_section config_remove_section;
+struct config_save config_save;
+struct config_set_bool config_set_bool;
+struct config_set_int config_set_int;
+struct config_set_string config_set_string;
+struct config_set_uint64 config_set_uint64;
+struct config_t_Find config_t_Find;
+struct config_t_Has config_t_Has;
+struct section_t_Find section_t_Find;
+struct section_t_Has section_t_Has;
+struct section_t_Set section_t_Set;
+
+}  // namespace osi_config
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+std::string checksum_read(const char* filename) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::checksum_read(filename);
+}
+bool checksum_save(const std::string& checksum, const std::string& filename) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::checksum_save(checksum, filename);
+}
+bool config_get_bool(const config_t& config, const std::string& section,
+                     const std::string& key, bool def_value) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::config_get_bool(config, section, key,
+                                                 def_value);
+}
+int config_get_int(const config_t& config, const std::string& section,
+                   const std::string& key, int def_value) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::config_get_int(config, section, key,
+                                                def_value);
+}
+const std::string* config_get_string(const config_t& config,
+                                     const std::string& section,
+                                     const std::string& key,
+                                     const std::string* def_value) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::config_get_string(config, section, key,
+                                                   def_value);
+}
+uint64_t config_get_uint64(const config_t& config, const std::string& section,
+                           const std::string& key, uint64_t def_value) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::config_get_uint64(config, section, key,
+                                                   def_value);
+}
+bool config_has_key(const config_t& config, const std::string& section,
+                    const std::string& key) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::config_has_key(config, section, key);
+}
+bool config_has_section(const config_t& config, const std::string& section) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::config_has_section(config, section);
+}
+std::unique_ptr<config_t> config_new(const char* filename) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::config_new(filename);
+}
+std::unique_ptr<config_t> config_new_clone(const config_t& src) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::config_new_clone(src);
+}
+std::unique_ptr<config_t> config_new_empty(void) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::config_new_empty();
+}
+bool config_remove_key(config_t* config, const std::string& section,
+                       const std::string& key) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::config_remove_key(config, section, key);
+}
+bool config_remove_section(config_t* config, const std::string& section) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::config_remove_section(config, section);
+}
+bool config_save(const config_t& config, const std::string& filename) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::config_save(config, filename);
+}
+void config_set_bool(config_t* config, const std::string& section,
+                     const std::string& key, bool value) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_config::config_set_bool(config, section, key, value);
+}
+void config_set_int(config_t* config, const std::string& section,
+                    const std::string& key, int value) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_config::config_set_int(config, section, key, value);
+}
+void config_set_string(config_t* config, const std::string& section,
+                       const std::string& key, const std::string& value) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_config::config_set_string(config, section, key, value);
+}
+void config_set_uint64(config_t* config, const std::string& section,
+                       const std::string& key, uint64_t value) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_config::config_set_uint64(config, section, key, value);
+}
+std::list<section_t>::iterator config_t::Find(const std::string& section) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::config_t_Find(section);
+}
+bool config_t::Has(const std::string& key) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::config_t_Has(key);
+}
+std::list<entry_t>::iterator section_t::Find(const std::string& key) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::section_t_Find(key);
+}
+bool section_t::Has(const std::string& key) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_config::section_t_Has(key);
+}
+void section_t::Set(std::string key, std::string value) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_config::section_t_Set(key, value);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_osi_config.h b/test/mock/mock_osi_config.h
new file mode 100644
index 0000000..4924b07
--- /dev/null
+++ b/test/mock/mock_osi_config.h
@@ -0,0 +1,393 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:24
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <base/files/file_util.h>
+#include <base/logging.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <libgen.h>
+#include <log/log.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <sstream>
+#include <type_traits>
+
+#include "check.h"
+#include "osi/include/config.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace osi_config {
+
+// Shared state between mocked functions and tests
+// Name: checksum_read
+// Params: const char* filename
+// Return: std::string
+struct checksum_read {
+  std::string return_value{std::string()};
+  std::function<std::string(const char* filename)> body{
+      [this](const char* filename) { return return_value; }};
+  std::string operator()(const char* filename) { return body(filename); };
+};
+extern struct checksum_read checksum_read;
+
+// Name: checksum_save
+// Params: const std::string& checksum, const std::string& filename
+// Return: bool
+struct checksum_save {
+  bool return_value{false};
+  std::function<bool(const std::string& checksum, const std::string& filename)>
+      body{[this](const std::string& checksum, const std::string& filename) {
+        return return_value;
+      }};
+  bool operator()(const std::string& checksum, const std::string& filename) {
+    return body(checksum, filename);
+  };
+};
+extern struct checksum_save checksum_save;
+
+// Name: config_get_bool
+// Params: const config_t& config, const std::string& section, const
+// std::string& key, bool def_value Return: bool
+struct config_get_bool {
+  bool return_value{false};
+  std::function<bool(const config_t& config, const std::string& section,
+                     const std::string& key, bool def_value)>
+      body{[this](const config_t& config, const std::string& section,
+                  const std::string& key,
+                  bool def_value) { return return_value; }};
+  bool operator()(const config_t& config, const std::string& section,
+                  const std::string& key, bool def_value) {
+    return body(config, section, key, def_value);
+  };
+};
+extern struct config_get_bool config_get_bool;
+
+// Name: config_get_int
+// Params: const config_t& config, const std::string& section, const
+// std::string& key, int def_value Return: int
+struct config_get_int {
+  int return_value{0};
+  std::function<int(const config_t& config, const std::string& section,
+                    const std::string& key, int def_value)>
+      body{[this](const config_t& config, const std::string& section,
+                  const std::string& key,
+                  int def_value) { return return_value; }};
+  int operator()(const config_t& config, const std::string& section,
+                 const std::string& key, int def_value) {
+    return body(config, section, key, def_value);
+  };
+};
+extern struct config_get_int config_get_int;
+
+// Name: config_get_string
+// Params: const config_t& config, const std::string& section, const
+// std::string& key, const std::string* def_value Return: const std::string*
+struct config_get_string {
+  const std::string* return_value{0};
+  std::function<const std::string*(
+      const config_t& config, const std::string& section,
+      const std::string& key, const std::string* def_value)>
+      body{[this](const config_t& config, const std::string& section,
+                  const std::string& key,
+                  const std::string* def_value) { return return_value; }};
+  const std::string* operator()(const config_t& config,
+                                const std::string& section,
+                                const std::string& key,
+                                const std::string* def_value) {
+    return body(config, section, key, def_value);
+  };
+};
+extern struct config_get_string config_get_string;
+
+// Name: config_get_uint64
+// Params: const config_t& config, const std::string& section, const
+// std::string& key, uint64_t def_value Return: uint64_t
+struct config_get_uint64 {
+  uint64_t return_value{0};
+  std::function<uint64_t(const config_t& config, const std::string& section,
+                         const std::string& key, uint64_t def_value)>
+      body{[this](const config_t& config, const std::string& section,
+                  const std::string& key,
+                  uint64_t def_value) { return return_value; }};
+  uint64_t operator()(const config_t& config, const std::string& section,
+                      const std::string& key, uint64_t def_value) {
+    return body(config, section, key, def_value);
+  };
+};
+extern struct config_get_uint64 config_get_uint64;
+
+// Name: config_has_key
+// Params: const config_t& config, const std::string& section, const
+// std::string& key Return: bool
+struct config_has_key {
+  bool return_value{false};
+  std::function<bool(const config_t& config, const std::string& section,
+                     const std::string& key)>
+      body{[this](const config_t& config, const std::string& section,
+                  const std::string& key) { return return_value; }};
+  bool operator()(const config_t& config, const std::string& section,
+                  const std::string& key) {
+    return body(config, section, key);
+  };
+};
+extern struct config_has_key config_has_key;
+
+// Name: config_has_section
+// Params: const config_t& config, const std::string& section
+// Return: bool
+struct config_has_section {
+  bool return_value{false};
+  std::function<bool(const config_t& config, const std::string& section)> body{
+      [this](const config_t& config, const std::string& section) {
+        return return_value;
+      }};
+  bool operator()(const config_t& config, const std::string& section) {
+    return body(config, section);
+  };
+};
+extern struct config_has_section config_has_section;
+
+// Name: config_new
+// Params: const char* filename
+// Return: std::unique_ptr<config_t>
+struct config_new {
+  std::function<std::unique_ptr<config_t>(const char* filename)> body{
+      [](const char* filename) { return std::make_unique<config_t>(); }};
+  std::unique_ptr<config_t> operator()(const char* filename) {
+    return body(filename);
+  };
+};
+extern struct config_new config_new;
+
+// Name: config_new_clone
+// Params: const config_t& src
+// Return: std::unique_ptr<config_t>
+struct config_new_clone {
+  std::function<std::unique_ptr<config_t>(const config_t& src)> body{
+      [](const config_t& src) { return std::make_unique<config_t>(); }};
+  std::unique_ptr<config_t> operator()(const config_t& src) {
+    return body(src);
+  };
+};
+extern struct config_new_clone config_new_clone;
+
+// Name: config_new_empty
+// Params: void
+// Return: std::unique_ptr<config_t>
+struct config_new_empty {
+  std::function<std::unique_ptr<config_t>(void)> body{
+      [](void) { return std::make_unique<config_t>(); }};
+  std::unique_ptr<config_t> operator()(void) { return body(); };
+};
+extern struct config_new_empty config_new_empty;
+
+// Name: config_remove_key
+// Params: config_t* config, const std::string& section, const std::string& key
+// Return: bool
+struct config_remove_key {
+  bool return_value{false};
+  std::function<bool(config_t* config, const std::string& section,
+                     const std::string& key)>
+      body{[this](config_t* config, const std::string& section,
+                  const std::string& key) { return return_value; }};
+  bool operator()(config_t* config, const std::string& section,
+                  const std::string& key) {
+    return body(config, section, key);
+  };
+};
+extern struct config_remove_key config_remove_key;
+
+// Name: config_remove_section
+// Params: config_t* config, const std::string& section
+// Return: bool
+struct config_remove_section {
+  bool return_value{false};
+  std::function<bool(config_t* config, const std::string& section)> body{
+      [this](config_t* config, const std::string& section) {
+        return return_value;
+      }};
+  bool operator()(config_t* config, const std::string& section) {
+    return body(config, section);
+  };
+};
+extern struct config_remove_section config_remove_section;
+
+// Name: config_save
+// Params: const config_t& config, const std::string& filename
+// Return: bool
+struct config_save {
+  bool return_value{false};
+  std::function<bool(const config_t& config, const std::string& filename)> body{
+      [this](const config_t& config, const std::string& filename) {
+        return return_value;
+      }};
+  bool operator()(const config_t& config, const std::string& filename) {
+    return body(config, filename);
+  };
+};
+extern struct config_save config_save;
+
+// Name: config_set_bool
+// Params: config_t* config, const std::string& section, const std::string& key,
+// bool value Return: void
+struct config_set_bool {
+  std::function<void(config_t* config, const std::string& section,
+                     const std::string& key, bool value)>
+      body{[](config_t* config, const std::string& section,
+              const std::string& key, bool value) {}};
+  void operator()(config_t* config, const std::string& section,
+                  const std::string& key, bool value) {
+    body(config, section, key, value);
+  };
+};
+extern struct config_set_bool config_set_bool;
+
+// Name: config_set_int
+// Params: config_t* config, const std::string& section, const std::string& key,
+// int value Return: void
+struct config_set_int {
+  std::function<void(config_t* config, const std::string& section,
+                     const std::string& key, int value)>
+      body{[](config_t* config, const std::string& section,
+              const std::string& key, int value) {}};
+  void operator()(config_t* config, const std::string& section,
+                  const std::string& key, int value) {
+    body(config, section, key, value);
+  };
+};
+extern struct config_set_int config_set_int;
+
+// Name: config_set_string
+// Params: config_t* config, const std::string& section, const std::string& key,
+// const std::string& value Return: void
+struct config_set_string {
+  std::function<void(config_t* config, const std::string& section,
+                     const std::string& key, const std::string& value)>
+      body{[](config_t* config, const std::string& section,
+              const std::string& key, const std::string& value) {}};
+  void operator()(config_t* config, const std::string& section,
+                  const std::string& key, const std::string& value) {
+    body(config, section, key, value);
+  };
+};
+extern struct config_set_string config_set_string;
+
+// Name: config_set_uint64
+// Params: config_t* config, const std::string& section, const std::string& key,
+// uint64_t value Return: void
+struct config_set_uint64 {
+  std::function<void(config_t* config, const std::string& section,
+                     const std::string& key, uint64_t value)>
+      body{[](config_t* config, const std::string& section,
+              const std::string& key, uint64_t value) {}};
+  void operator()(config_t* config, const std::string& section,
+                  const std::string& key, uint64_t value) {
+    body(config, section, key, value);
+  };
+};
+extern struct config_set_uint64 config_set_uint64;
+
+// Name: config_t::Find
+// Params: const std::string& section
+// Return: std::list<section_t>::iterator
+struct config_t_Find {
+  std::list<section_t> section_;
+  std::function<std::list<section_t>::iterator(const std::string& section)>
+      body{[this](const std::string& section) { return section_.begin(); }};
+  std::list<section_t>::iterator operator()(const std::string& section) {
+    return body(section);
+  };
+};
+extern struct config_t_Find config_t_Find;
+
+// Name: config_t_Has
+// Params: const std::string& key
+// Return: bool
+struct config_t_Has {
+  bool return_value{false};
+  std::function<bool(const std::string& key)> body{
+      [this](const std::string& key) { return return_value; }};
+  bool operator()(const std::string& key) { return body(key); };
+};
+extern struct config_t_Has config_t_Has;
+
+// Name: section_t_Find
+// Params: const std::string& key
+// Return: std::list<entry_t>::iterator
+struct section_t_Find {
+  std::list<entry_t> list_;
+  std::function<std::list<entry_t>::iterator(const std::string& key)> body{
+      [this](const std::string& key) { return list_.begin(); }};
+  std::list<entry_t>::iterator operator()(const std::string& key) {
+    return body(key);
+  };
+};
+extern struct section_t_Find section_t_Find;
+
+// Name: section_t_Has
+// Params: const std::string& key
+// Return: bool
+struct section_t_Has {
+  bool return_value{false};
+  std::function<bool(const std::string& key)> body{
+      [this](const std::string& key) { return return_value; }};
+  bool operator()(const std::string& key) { return body(key); };
+};
+extern struct section_t_Has section_t_Has;
+
+// Name: section_t_Set
+// Params: std::string key, std::string value
+// Return: void
+struct section_t_Set {
+  std::function<void(std::string key, std::string value)> body{
+      [](std::string key, std::string value) {}};
+  void operator()(std::string key, std::string value) { body(key, value); };
+};
+extern struct section_t_Set section_t_Set;
+
+}  // namespace osi_config
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
diff --git a/test/mock/mock_osi_fixed_queue.cc b/test/mock/mock_osi_fixed_queue.cc
new file mode 100644
index 0000000..5157049
--- /dev/null
+++ b/test/mock/mock_osi_fixed_queue.cc
@@ -0,0 +1,141 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:18
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_osi_fixed_queue.h"
+
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace osi_fixed_queue {
+
+// Function state capture and return values, if needed
+struct fixed_queue_capacity fixed_queue_capacity;
+struct fixed_queue_dequeue fixed_queue_dequeue;
+struct fixed_queue_enqueue fixed_queue_enqueue;
+struct fixed_queue_flush fixed_queue_flush;
+struct fixed_queue_free fixed_queue_free;
+struct fixed_queue_get_dequeue_fd fixed_queue_get_dequeue_fd;
+struct fixed_queue_get_enqueue_fd fixed_queue_get_enqueue_fd;
+struct fixed_queue_get_list fixed_queue_get_list;
+struct fixed_queue_is_empty fixed_queue_is_empty;
+struct fixed_queue_length fixed_queue_length;
+struct fixed_queue_new fixed_queue_new;
+struct fixed_queue_register_dequeue fixed_queue_register_dequeue;
+struct fixed_queue_try_dequeue fixed_queue_try_dequeue;
+struct fixed_queue_try_enqueue fixed_queue_try_enqueue;
+struct fixed_queue_try_peek_first fixed_queue_try_peek_first;
+struct fixed_queue_try_peek_last fixed_queue_try_peek_last;
+struct fixed_queue_try_remove_from_queue fixed_queue_try_remove_from_queue;
+struct fixed_queue_unregister_dequeue fixed_queue_unregister_dequeue;
+
+}  // namespace osi_fixed_queue
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+size_t fixed_queue_capacity(fixed_queue_t* queue) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_fixed_queue::fixed_queue_capacity(queue);
+}
+void* fixed_queue_dequeue(fixed_queue_t* queue) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_fixed_queue::fixed_queue_dequeue(queue);
+}
+void fixed_queue_enqueue(fixed_queue_t* queue, void* data) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_fixed_queue::fixed_queue_enqueue(queue, data);
+}
+void fixed_queue_flush(fixed_queue_t* queue, fixed_queue_free_cb free_cb) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_fixed_queue::fixed_queue_flush(queue, free_cb);
+}
+void fixed_queue_free(fixed_queue_t* queue, fixed_queue_free_cb free_cb) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_fixed_queue::fixed_queue_free(queue, free_cb);
+}
+int fixed_queue_get_dequeue_fd(const fixed_queue_t* queue) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_fixed_queue::fixed_queue_get_dequeue_fd(queue);
+}
+int fixed_queue_get_enqueue_fd(const fixed_queue_t* queue) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_fixed_queue::fixed_queue_get_enqueue_fd(queue);
+}
+list_t* fixed_queue_get_list(fixed_queue_t* queue) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_fixed_queue::fixed_queue_get_list(queue);
+}
+bool fixed_queue_is_empty(fixed_queue_t* queue) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_fixed_queue::fixed_queue_is_empty(queue);
+}
+size_t fixed_queue_length(fixed_queue_t* queue) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_fixed_queue::fixed_queue_length(queue);
+}
+fixed_queue_t* fixed_queue_new(size_t capacity) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_fixed_queue::fixed_queue_new(capacity);
+}
+void fixed_queue_register_dequeue(fixed_queue_t* queue, reactor_t* reactor,
+                                  fixed_queue_cb ready_cb, void* context) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_fixed_queue::fixed_queue_register_dequeue(queue, reactor,
+                                                            ready_cb, context);
+}
+void* fixed_queue_try_dequeue(fixed_queue_t* queue) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_fixed_queue::fixed_queue_try_dequeue(queue);
+}
+bool fixed_queue_try_enqueue(fixed_queue_t* queue, void* data) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_fixed_queue::fixed_queue_try_enqueue(queue, data);
+}
+void* fixed_queue_try_peek_first(fixed_queue_t* queue) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_fixed_queue::fixed_queue_try_peek_first(queue);
+}
+void* fixed_queue_try_peek_last(fixed_queue_t* queue) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_fixed_queue::fixed_queue_try_peek_last(queue);
+}
+void* fixed_queue_try_remove_from_queue(fixed_queue_t* queue, void* data) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_fixed_queue::fixed_queue_try_remove_from_queue(queue,
+                                                                        data);
+}
+void fixed_queue_unregister_dequeue(fixed_queue_t* queue) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_fixed_queue::fixed_queue_unregister_dequeue(queue);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_osi_fixed_queue.h b/test/mock/mock_osi_fixed_queue.h
new file mode 100644
index 0000000..0534ef8
--- /dev/null
+++ b/test/mock/mock_osi_fixed_queue.h
@@ -0,0 +1,267 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:18
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <base/logging.h>
+#include <string.h>
+
+#include <mutex>
+
+#include "check.h"
+#include "osi/include/allocator.h"
+#include "osi/include/fixed_queue.h"
+#include "osi/include/list.h"
+#include "osi/include/osi.h"
+#include "osi/include/reactor.h"
+#include "osi/include/semaphore.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace osi_fixed_queue {
+
+// Shared state between mocked functions and tests
+// Name: fixed_queue_capacity
+// Params: fixed_queue_t* queue
+// Return: size_t
+struct fixed_queue_capacity {
+  size_t return_value{0};
+  std::function<size_t(fixed_queue_t* queue)> body{
+      [this](fixed_queue_t* queue) { return return_value; }};
+  size_t operator()(fixed_queue_t* queue) { return body(queue); };
+};
+extern struct fixed_queue_capacity fixed_queue_capacity;
+
+// Name: fixed_queue_dequeue
+// Params: fixed_queue_t* queue
+// Return: void*
+struct fixed_queue_dequeue {
+  void* return_value{};
+  std::function<void*(fixed_queue_t* queue)> body{
+      [this](fixed_queue_t* queue) { return return_value; }};
+  void* operator()(fixed_queue_t* queue) { return body(queue); };
+};
+extern struct fixed_queue_dequeue fixed_queue_dequeue;
+
+// Name: fixed_queue_enqueue
+// Params: fixed_queue_t* queue, void* data
+// Return: void
+struct fixed_queue_enqueue {
+  std::function<void(fixed_queue_t* queue, void* data)> body{
+      [](fixed_queue_t* queue, void* data) {}};
+  void operator()(fixed_queue_t* queue, void* data) { body(queue, data); };
+};
+extern struct fixed_queue_enqueue fixed_queue_enqueue;
+
+// Name: fixed_queue_flush
+// Params: fixed_queue_t* queue, fixed_queue_free_cb free_cb
+// Return: void
+struct fixed_queue_flush {
+  std::function<void(fixed_queue_t* queue, fixed_queue_free_cb free_cb)> body{
+      [](fixed_queue_t* queue, fixed_queue_free_cb free_cb) {}};
+  void operator()(fixed_queue_t* queue, fixed_queue_free_cb free_cb) {
+    body(queue, free_cb);
+  };
+};
+extern struct fixed_queue_flush fixed_queue_flush;
+
+// Name: fixed_queue_free
+// Params: fixed_queue_t* queue, fixed_queue_free_cb free_cb
+// Return: void
+struct fixed_queue_free {
+  std::function<void(fixed_queue_t* queue, fixed_queue_free_cb free_cb)> body{
+      [](fixed_queue_t* queue, fixed_queue_free_cb free_cb) {}};
+  void operator()(fixed_queue_t* queue, fixed_queue_free_cb free_cb) {
+    body(queue, free_cb);
+  };
+};
+extern struct fixed_queue_free fixed_queue_free;
+
+// Name: fixed_queue_get_dequeue_fd
+// Params: const fixed_queue_t* queue
+// Return: int
+struct fixed_queue_get_dequeue_fd {
+  int return_value{0};
+  std::function<int(const fixed_queue_t* queue)> body{
+      [this](const fixed_queue_t* queue) { return return_value; }};
+  int operator()(const fixed_queue_t* queue) { return body(queue); };
+};
+extern struct fixed_queue_get_dequeue_fd fixed_queue_get_dequeue_fd;
+
+// Name: fixed_queue_get_enqueue_fd
+// Params: const fixed_queue_t* queue
+// Return: int
+struct fixed_queue_get_enqueue_fd {
+  int return_value{0};
+  std::function<int(const fixed_queue_t* queue)> body{
+      [this](const fixed_queue_t* queue) { return return_value; }};
+  int operator()(const fixed_queue_t* queue) { return body(queue); };
+};
+extern struct fixed_queue_get_enqueue_fd fixed_queue_get_enqueue_fd;
+
+// Name: fixed_queue_get_list
+// Params: fixed_queue_t* queue
+// Return: list_t*
+struct fixed_queue_get_list {
+  list_t* return_value{0};
+  std::function<list_t*(fixed_queue_t* queue)> body{
+      [this](fixed_queue_t* queue) { return return_value; }};
+  list_t* operator()(fixed_queue_t* queue) { return body(queue); };
+};
+extern struct fixed_queue_get_list fixed_queue_get_list;
+
+// Name: fixed_queue_is_empty
+// Params: fixed_queue_t* queue
+// Return: bool
+struct fixed_queue_is_empty {
+  bool return_value{false};
+  std::function<bool(fixed_queue_t* queue)> body{
+      [this](fixed_queue_t* queue) { return return_value; }};
+  bool operator()(fixed_queue_t* queue) { return body(queue); };
+};
+extern struct fixed_queue_is_empty fixed_queue_is_empty;
+
+// Name: fixed_queue_length
+// Params: fixed_queue_t* queue
+// Return: size_t
+struct fixed_queue_length {
+  size_t return_value{0};
+  std::function<size_t(fixed_queue_t* queue)> body{
+      [this](fixed_queue_t* queue) { return return_value; }};
+  size_t operator()(fixed_queue_t* queue) { return body(queue); };
+};
+extern struct fixed_queue_length fixed_queue_length;
+
+// Name: fixed_queue_new
+// Params: size_t capacity
+// Return: fixed_queue_t*
+struct fixed_queue_new {
+  fixed_queue_t* return_value{0};
+  std::function<fixed_queue_t*(size_t capacity)> body{
+      [this](size_t capacity) { return return_value; }};
+  fixed_queue_t* operator()(size_t capacity) { return body(capacity); };
+};
+extern struct fixed_queue_new fixed_queue_new;
+
+// Name: fixed_queue_register_dequeue
+// Params: fixed_queue_t* queue, reactor_t* reactor, fixed_queue_cb ready_cb,
+// void* context Return: void
+struct fixed_queue_register_dequeue {
+  std::function<void(fixed_queue_t* queue, reactor_t* reactor,
+                     fixed_queue_cb ready_cb, void* context)>
+      body{[](fixed_queue_t* queue, reactor_t* reactor, fixed_queue_cb ready_cb,
+              void* context) {}};
+  void operator()(fixed_queue_t* queue, reactor_t* reactor,
+                  fixed_queue_cb ready_cb, void* context) {
+    body(queue, reactor, ready_cb, context);
+  };
+};
+extern struct fixed_queue_register_dequeue fixed_queue_register_dequeue;
+
+// Name: fixed_queue_try_dequeue
+// Params: fixed_queue_t* queue
+// Return: void*
+struct fixed_queue_try_dequeue {
+  void* return_value{};
+  std::function<void*(fixed_queue_t* queue)> body{
+      [this](fixed_queue_t* queue) { return return_value; }};
+  void* operator()(fixed_queue_t* queue) { return body(queue); };
+};
+extern struct fixed_queue_try_dequeue fixed_queue_try_dequeue;
+
+// Name: fixed_queue_try_enqueue
+// Params: fixed_queue_t* queue, void* data
+// Return: bool
+struct fixed_queue_try_enqueue {
+  bool return_value{false};
+  std::function<bool(fixed_queue_t* queue, void* data)> body{
+      [this](fixed_queue_t* queue, void* data) { return return_value; }};
+  bool operator()(fixed_queue_t* queue, void* data) {
+    return body(queue, data);
+  };
+};
+extern struct fixed_queue_try_enqueue fixed_queue_try_enqueue;
+
+// Name: fixed_queue_try_peek_first
+// Params: fixed_queue_t* queue
+// Return: void*
+struct fixed_queue_try_peek_first {
+  void* return_value{};
+  std::function<void*(fixed_queue_t* queue)> body{
+      [this](fixed_queue_t* queue) { return return_value; }};
+  void* operator()(fixed_queue_t* queue) { return body(queue); };
+};
+extern struct fixed_queue_try_peek_first fixed_queue_try_peek_first;
+
+// Name: fixed_queue_try_peek_last
+// Params: fixed_queue_t* queue
+// Return: void*
+struct fixed_queue_try_peek_last {
+  void* return_value{};
+  std::function<void*(fixed_queue_t* queue)> body{
+      [this](fixed_queue_t* queue) { return return_value; }};
+  void* operator()(fixed_queue_t* queue) { return body(queue); };
+};
+extern struct fixed_queue_try_peek_last fixed_queue_try_peek_last;
+
+// Name: fixed_queue_try_remove_from_queue
+// Params: fixed_queue_t* queue, void* data
+// Return: void*
+struct fixed_queue_try_remove_from_queue {
+  void* return_value{};
+  std::function<void*(fixed_queue_t* queue, void* data)> body{
+      [this](fixed_queue_t* queue, void* data) { return return_value; }};
+  void* operator()(fixed_queue_t* queue, void* data) {
+    return body(queue, data);
+  };
+};
+extern struct fixed_queue_try_remove_from_queue
+    fixed_queue_try_remove_from_queue;
+
+// Name: fixed_queue_unregister_dequeue
+// Params: fixed_queue_t* queue
+// Return: void
+struct fixed_queue_unregister_dequeue {
+  std::function<void(fixed_queue_t* queue)> body{[](fixed_queue_t* queue) {}};
+  void operator()(fixed_queue_t* queue) { body(queue); };
+};
+extern struct fixed_queue_unregister_dequeue fixed_queue_unregister_dequeue;
+
+}  // namespace osi_fixed_queue
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file
diff --git a/test/mock/mock_osi_future.cc b/test/mock/mock_osi_future.cc
new file mode 100644
index 0000000..cd6f570
--- /dev/null
+++ b/test/mock/mock_osi_future.cc
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:4
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_osi_future.h"
+
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace osi_future {
+
+// Function state capture and return values, if needed
+struct future_await future_await;
+struct future_new future_new;
+struct future_new_named future_new_named;
+struct future_new_immediate future_new_immediate;
+struct future_ready future_ready;
+
+}  // namespace osi_future
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+void* future_await(future_t* future) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_future::future_await(future);
+}
+future_t* future_new(void) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_future::future_new();
+}
+future_t* future_new_named(const char* name) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_future::future_new_named(name);
+}
+future_t* future_new_immediate(void* value) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_future::future_new_immediate(value);
+}
+void future_ready(future_t* future, void* value) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_future::future_ready(future, value);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_osi_future.h b/test/mock/mock_osi_future.h
new file mode 100644
index 0000000..7d95b85
--- /dev/null
+++ b/test/mock/mock_osi_future.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:4
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <base/logging.h>
+
+#include "check.h"
+#include "osi/include/allocator.h"
+#include "osi/include/future.h"
+#include "osi/include/log.h"
+#include "osi/include/osi.h"
+#include "osi/include/semaphore.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace osi_future {
+
+// Shared state between mocked functions and tests
+// Name: future_await
+// Params: future_t* future
+// Return: void*
+struct future_await {
+  void* return_value{};
+  std::function<void*(future_t* future)> body{
+      [this](future_t* future) { return return_value; }};
+  void* operator()(future_t* future) { return body(future); };
+};
+extern struct future_await future_await;
+
+// Name: future_new
+// Params: void
+// Return: future_t*
+struct future_new {
+  future_t* return_value{0};
+  std::function<future_t*(void)> body{[this](void) { return return_value; }};
+  future_t* operator()(void) { return body(); };
+};
+extern struct future_new future_new;
+
+// Name: future_new_named
+// Params: const char* name
+// Return: future_t*
+struct future_new_named {
+  future_t* return_value{0};
+  std::function<future_t*(const char* name)> body{
+      [this](const char* name) { return return_value; }};
+  future_t* operator()(const char* name) { return body(name); };
+};
+extern struct future_new_named future_new_named;
+
+// Name: future_new_immediate
+// Params: void* value
+// Return: future_t*
+struct future_new_immediate {
+  future_t* return_value{0};
+  std::function<future_t*(void* value)> body{[this](void* value) {
+    CHECK(0);
+    return return_value;
+  }};
+  future_t* operator()(void* value) { return body(value); };
+};
+extern struct future_new_immediate future_new_immediate;
+
+// Name: future_ready
+// Params: future_t* future, void* value
+// Return: void
+struct future_ready {
+  std::function<void(future_t* future, void* value)> body{
+      [](future_t* future, void* value) {}};
+  void operator()(future_t* future, void* value) { body(future, value); };
+};
+extern struct future_ready future_ready;
+
+}  // namespace osi_future
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
diff --git a/test/mock/mock_osi_list.cc b/test/mock/mock_osi_list.cc
new file mode 100644
index 0000000..2d4cd77
--- /dev/null
+++ b/test/mock/mock_osi_list.cc
@@ -0,0 +1,145 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:19
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_osi_list.h"
+
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace osi_list {
+
+// Function state capture and return values, if needed
+struct list_append list_append;
+struct list_back list_back;
+struct list_back_node list_back_node;
+struct list_begin list_begin;
+struct list_clear list_clear;
+struct list_contains list_contains;
+struct list_end list_end;
+struct list_foreach list_foreach;
+struct list_free list_free;
+struct list_front list_front;
+struct list_insert_after list_insert_after;
+struct list_is_empty list_is_empty;
+struct list_length list_length;
+struct list_new list_new;
+struct list_new_internal list_new_internal;
+struct list_next list_next;
+struct list_node list_node;
+struct list_prepend list_prepend;
+struct list_remove list_remove;
+
+}  // namespace osi_list
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+bool list_append(list_t* list, void* data) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_append(list, data);
+}
+void* list_back(const list_t* list) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_back(list);
+}
+list_node_t* list_back_node(const list_t* list) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_back_node(list);
+}
+list_node_t* list_begin(const list_t* list) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_begin(list);
+}
+void list_clear(list_t* list) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_list::list_clear(list);
+}
+bool list_contains(const list_t* list, const void* data) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_contains(list, data);
+}
+list_node_t* list_end(const list_t* list) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_end(list);
+}
+list_node_t* list_foreach(const list_t* list, list_iter_cb callback,
+                          void* context) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_foreach(list, callback, context);
+}
+void list_free(list_t* list) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_list::list_free(list);
+}
+void* list_front(const list_t* list) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_front(list);
+}
+bool list_insert_after(list_t* list, list_node_t* prev_node, void* data) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_insert_after(list, prev_node, data);
+}
+bool list_is_empty(const list_t* list) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_is_empty(list);
+}
+size_t list_length(const list_t* list) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_length(list);
+}
+list_t* list_new(list_free_cb callback) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_new(callback);
+}
+list_t* list_new_internal(list_free_cb callback,
+                          const allocator_t* zeroed_allocator) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_new_internal(callback, zeroed_allocator);
+}
+list_node_t* list_next(const list_node_t* node) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_next(node);
+}
+void* list_node(const list_node_t* node) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_node(node);
+}
+bool list_prepend(list_t* list, void* data) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_prepend(list, data);
+}
+bool list_remove(list_t* list, void* data) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_list::list_remove(list, data);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_osi_list.h b/test/mock/mock_osi_list.h
new file mode 100644
index 0000000..55b1ee2
--- /dev/null
+++ b/test/mock/mock_osi_list.h
@@ -0,0 +1,278 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:19
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <base/logging.h>
+
+#include "check.h"
+#include "osi/include/allocator.h"
+#include "osi/include/list.h"
+#include "osi/include/osi.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace osi_list {
+
+// Shared state between mocked functions and tests
+// Name: list_append
+// Params: list_t* list, void* data
+// Return: bool
+struct list_append {
+  bool return_value{false};
+  std::function<bool(list_t* list, void* data)> body{
+      [this](list_t* list, void* data) { return return_value; }};
+  bool operator()(list_t* list, void* data) { return body(list, data); };
+};
+extern struct list_append list_append;
+
+// Name: list_back
+// Params: const list_t* list
+// Return: void*
+struct list_back {
+  void* return_value{};
+  std::function<void*(const list_t* list)> body{
+      [this](const list_t* list) { return return_value; }};
+  void* operator()(const list_t* list) { return body(list); };
+};
+extern struct list_back list_back;
+
+// Name: list_back_node
+// Params: const list_t* list
+// Return: list_node_t*
+struct list_back_node {
+  list_node_t* return_value{0};
+  std::function<list_node_t*(const list_t* list)> body{
+      [this](const list_t* list) { return return_value; }};
+  list_node_t* operator()(const list_t* list) { return body(list); };
+};
+extern struct list_back_node list_back_node;
+
+// Name: list_begin
+// Params: const list_t* list
+// Return: list_node_t*
+struct list_begin {
+  list_node_t* return_value{0};
+  std::function<list_node_t*(const list_t* list)> body{
+      [this](const list_t* list) { return return_value; }};
+  list_node_t* operator()(const list_t* list) { return body(list); };
+};
+extern struct list_begin list_begin;
+
+// Name: list_clear
+// Params: list_t* list
+// Return: void
+struct list_clear {
+  std::function<void(list_t* list)> body{[](list_t* list) {}};
+  void operator()(list_t* list) { body(list); };
+};
+extern struct list_clear list_clear;
+
+// Name: list_contains
+// Params: const list_t* list, const void* data
+// Return: bool
+struct list_contains {
+  bool return_value{false};
+  std::function<bool(const list_t* list, const void* data)> body{
+      [this](const list_t* list, const void* data) { return return_value; }};
+  bool operator()(const list_t* list, const void* data) {
+    return body(list, data);
+  };
+};
+extern struct list_contains list_contains;
+
+// Name: list_end
+// Params:  const list_t* list
+// Return: list_node_t*
+struct list_end {
+  list_node_t* return_value{0};
+  std::function<list_node_t*(const list_t* list)> body{
+      [this](const list_t* list) { return return_value; }};
+  list_node_t* operator()(const list_t* list) { return body(list); };
+};
+extern struct list_end list_end;
+
+// Name: list_foreach
+// Params: const list_t* list, list_iter_cb callback, void* context
+// Return: list_node_t*
+struct list_foreach {
+  list_node_t* return_value{0};
+  std::function<list_node_t*(const list_t* list, list_iter_cb callback,
+                             void* context)>
+      body{[this](const list_t* list, list_iter_cb callback, void* context) {
+        return return_value;
+      }};
+  list_node_t* operator()(const list_t* list, list_iter_cb callback,
+                          void* context) {
+    return body(list, callback, context);
+  };
+};
+extern struct list_foreach list_foreach;
+
+// Name: list_free
+// Params: list_t* list
+// Return: void
+struct list_free {
+  std::function<void(list_t* list)> body{[](list_t* list) {}};
+  void operator()(list_t* list) { body(list); };
+};
+extern struct list_free list_free;
+
+// Name: list_front
+// Params: const list_t* list
+// Return: void*
+struct list_front {
+  void* return_value{};
+  std::function<void*(const list_t* list)> body{
+      [this](const list_t* list) { return return_value; }};
+  void* operator()(const list_t* list) { return body(list); };
+};
+extern struct list_front list_front;
+
+// Name: list_insert_after
+// Params: list_t* list, list_node_t* prev_node, void* data
+// Return: bool
+struct list_insert_after {
+  bool return_value{false};
+  std::function<bool(list_t* list, list_node_t* prev_node, void* data)> body{
+      [this](list_t* list, list_node_t* prev_node, void* data) {
+        return return_value;
+      }};
+  bool operator()(list_t* list, list_node_t* prev_node, void* data) {
+    return body(list, prev_node, data);
+  };
+};
+extern struct list_insert_after list_insert_after;
+
+// Name: list_is_empty
+// Params: const list_t* list
+// Return: bool
+struct list_is_empty {
+  bool return_value{false};
+  std::function<bool(const list_t* list)> body{
+      [this](const list_t* list) { return return_value; }};
+  bool operator()(const list_t* list) { return body(list); };
+};
+extern struct list_is_empty list_is_empty;
+
+// Name: list_length
+// Params: const list_t* list
+// Return: size_t
+struct list_length {
+  size_t return_value{0};
+  std::function<size_t(const list_t* list)> body{
+      [this](const list_t* list) { return return_value; }};
+  size_t operator()(const list_t* list) { return body(list); };
+};
+extern struct list_length list_length;
+
+// Name: list_new
+// Params: list_free_cb callback
+// Return: list_t*
+struct list_new {
+  list_t* return_value{0};
+  std::function<list_t*(list_free_cb callback)> body{
+      [this](list_free_cb callback) { return return_value; }};
+  list_t* operator()(list_free_cb callback) { return body(callback); };
+};
+extern struct list_new list_new;
+
+// Name: list_new_internal
+// Params: list_free_cb callback, const allocator_t* zeroed_allocator
+// Return: list_t*
+struct list_new_internal {
+  list_t* return_value{0};
+  std::function<list_t*(list_free_cb callback,
+                        const allocator_t* zeroed_allocator)>
+      body{[this](list_free_cb callback, const allocator_t* zeroed_allocator) {
+        return return_value;
+      }};
+  list_t* operator()(list_free_cb callback,
+                     const allocator_t* zeroed_allocator) {
+    return body(callback, zeroed_allocator);
+  };
+};
+extern struct list_new_internal list_new_internal;
+
+// Name: list_next
+// Params: const list_node_t* node
+// Return: list_node_t*
+struct list_next {
+  list_node_t* return_value{0};
+  std::function<list_node_t*(const list_node_t* node)> body{
+      [this](const list_node_t* node) { return return_value; }};
+  list_node_t* operator()(const list_node_t* node) { return body(node); };
+};
+extern struct list_next list_next;
+
+// Name: list_node
+// Params: const list_node_t* node
+// Return: void*
+struct list_node {
+  void* return_value{};
+  std::function<void*(const list_node_t* node)> body{
+      [this](const list_node_t* node) { return return_value; }};
+  void* operator()(const list_node_t* node) { return body(node); };
+};
+extern struct list_node list_node;
+
+// Name: list_prepend
+// Params: list_t* list, void* data
+// Return: bool
+struct list_prepend {
+  bool return_value{false};
+  std::function<bool(list_t* list, void* data)> body{
+      [this](list_t* list, void* data) { return return_value; }};
+  bool operator()(list_t* list, void* data) { return body(list, data); };
+};
+extern struct list_prepend list_prepend;
+
+// Name: list_remove
+// Params: list_t* list, void* data
+// Return: bool
+struct list_remove {
+  bool return_value{false};
+  std::function<bool(list_t* list, void* data)> body{
+      [this](list_t* list, void* data) { return return_value; }};
+  bool operator()(list_t* list, void* data) { return body(list, data); };
+};
+extern struct list_remove list_remove;
+
+}  // namespace osi_list
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file
diff --git a/test/mock/mock_osi_properties.cc b/test/mock/mock_osi_properties.cc
new file mode 100644
index 0000000..393f4b8
--- /dev/null
+++ b/test/mock/mock_osi_properties.cc
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:4
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_osi_properties.h"
+
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace osi_properties {
+
+// Function state capture and return values, if needed
+struct osi_property_get osi_property_get;
+struct osi_property_get_bool osi_property_get_bool;
+struct osi_property_get_int32 osi_property_get_int32;
+struct osi_property_set osi_property_set;
+
+}  // namespace osi_properties
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+int osi_property_get(const char* key, char* value, const char* default_value) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_properties::osi_property_get(key, value,
+                                                      default_value);
+}
+bool osi_property_get_bool(const char* key, bool default_value) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_properties::osi_property_get_bool(key, default_value);
+}
+int32_t osi_property_get_int32(const char* key, int32_t default_value) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_properties::osi_property_get_int32(key, default_value);
+}
+int osi_property_set(const char* key, const char* value) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_properties::osi_property_set(key, value);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_osi_properties.h b/test/mock/mock_osi_properties.h
new file mode 100644
index 0000000..67f01e1
--- /dev/null
+++ b/test/mock/mock_osi_properties.h
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:4
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <cutils/properties.h>
+#include <string.h>
+
+#include "osi/include/properties.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace osi_properties {
+
+// Shared state between mocked functions and tests
+// Name: osi_property_get
+// Params: const char* key, char* value, const char* default_value
+// Return: int
+struct osi_property_get {
+  int return_value{0};
+  std::function<int(const char* key, char* value, const char* default_value)>
+      body{[this](const char* key, char* value, const char* default_value) {
+        return return_value;
+      }};
+  int operator()(const char* key, char* value, const char* default_value) {
+    return body(key, value, default_value);
+  };
+};
+extern struct osi_property_get osi_property_get;
+
+// Name: osi_property_get_bool
+// Params: const char* key, bool default_value
+// Return: bool
+struct osi_property_get_bool {
+  bool return_value{false};
+  std::function<bool(const char* key, bool default_value)> body{
+      [this](const char* key, bool default_value) { return return_value; }};
+  bool operator()(const char* key, bool default_value) {
+    return body(key, default_value);
+  };
+};
+extern struct osi_property_get_bool osi_property_get_bool;
+
+// Name: osi_property_get_int32
+// Params: const char* key, int32_t default_value
+// Return: int32_t
+struct osi_property_get_int32 {
+  int32_t return_value{0};
+  std::function<int32_t(const char* key, int32_t default_value)> body{
+      [this](const char* key, int32_t default_value) { return return_value; }};
+  int32_t operator()(const char* key, int32_t default_value) {
+    return body(key, default_value);
+  };
+};
+extern struct osi_property_get_int32 osi_property_get_int32;
+
+// Name: osi_property_set
+// Params: const char* key, const char* value
+// Return: int
+struct osi_property_set {
+  int return_value{0};
+  std::function<int(const char* key, const char* value)> body{
+      [this](const char* key, const char* value) { return return_value; }};
+  int operator()(const char* key, const char* value) {
+    return body(key, value);
+  };
+};
+extern struct osi_property_set osi_property_set;
+
+}  // namespace osi_properties
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file
diff --git a/test/mock/mock_osi_ringbuffer.cc b/test/mock/mock_osi_ringbuffer.cc
new file mode 100644
index 0000000..da9497c
--- /dev/null
+++ b/test/mock/mock_osi_ringbuffer.cc
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:8
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_osi_ringbuffer.h"
+
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace osi_ringbuffer {
+
+// Function state capture and return values, if needed
+struct ringbuffer_available ringbuffer_available;
+struct ringbuffer_delete ringbuffer_delete;
+struct ringbuffer_free ringbuffer_free;
+struct ringbuffer_init ringbuffer_init;
+struct ringbuffer_insert ringbuffer_insert;
+struct ringbuffer_peek ringbuffer_peek;
+struct ringbuffer_pop ringbuffer_pop;
+struct ringbuffer_size ringbuffer_size;
+
+}  // namespace osi_ringbuffer
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+size_t ringbuffer_available(const ringbuffer_t* rb) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_ringbuffer::ringbuffer_available(rb);
+}
+size_t ringbuffer_delete(ringbuffer_t* rb, size_t length) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_ringbuffer::ringbuffer_delete(rb, length);
+}
+void ringbuffer_free(ringbuffer_t* rb) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_ringbuffer::ringbuffer_free(rb);
+}
+ringbuffer_t* ringbuffer_init(const size_t size) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_ringbuffer::ringbuffer_init(size);
+}
+size_t ringbuffer_insert(ringbuffer_t* rb, const uint8_t* p, size_t length) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_ringbuffer::ringbuffer_insert(rb, p, length);
+}
+size_t ringbuffer_peek(const ringbuffer_t* rb, off_t offset, uint8_t* p,
+                       size_t length) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_ringbuffer::ringbuffer_peek(rb, offset, p, length);
+}
+size_t ringbuffer_pop(ringbuffer_t* rb, uint8_t* p, size_t length) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_ringbuffer::ringbuffer_pop(rb, p, length);
+}
+size_t ringbuffer_size(const ringbuffer_t* rb) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_ringbuffer::ringbuffer_size(rb);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_osi_ringbuffer.h b/test/mock/mock_osi_ringbuffer.h
new file mode 100644
index 0000000..2f0a538
--- /dev/null
+++ b/test/mock/mock_osi_ringbuffer.h
@@ -0,0 +1,156 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:8
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <base/logging.h>
+#include <stdlib.h>
+
+#include "check.h"
+#include "osi/include/allocator.h"
+#include "osi/include/ringbuffer.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace osi_ringbuffer {
+
+// Shared state between mocked functions and tests
+// Name: ringbuffer_available
+// Params: const ringbuffer_t* rb
+// Return: size_t
+struct ringbuffer_available {
+  size_t return_value{0};
+  std::function<size_t(const ringbuffer_t* rb)> body{
+      [this](const ringbuffer_t* rb) { return return_value; }};
+  size_t operator()(const ringbuffer_t* rb) { return body(rb); };
+};
+extern struct ringbuffer_available ringbuffer_available;
+
+// Name: ringbuffer_delete
+// Params: ringbuffer_t* rb, size_t length
+// Return: size_t
+struct ringbuffer_delete {
+  size_t return_value{0};
+  std::function<size_t(ringbuffer_t* rb, size_t length)> body{
+      [this](ringbuffer_t* rb, size_t length) { return return_value; }};
+  size_t operator()(ringbuffer_t* rb, size_t length) {
+    return body(rb, length);
+  };
+};
+extern struct ringbuffer_delete ringbuffer_delete;
+
+// Name: ringbuffer_free
+// Params: ringbuffer_t* rb
+// Return: void
+struct ringbuffer_free {
+  std::function<void(ringbuffer_t* rb)> body{[](ringbuffer_t* rb) {}};
+  void operator()(ringbuffer_t* rb) { body(rb); };
+};
+extern struct ringbuffer_free ringbuffer_free;
+
+// Name: ringbuffer_init
+// Params: const size_t size
+// Return: ringbuffer_t*
+struct ringbuffer_init {
+  ringbuffer_t* return_value{0};
+  std::function<ringbuffer_t*(const size_t size)> body{
+      [this](const size_t size) { return return_value; }};
+  ringbuffer_t* operator()(const size_t size) { return body(size); };
+};
+extern struct ringbuffer_init ringbuffer_init;
+
+// Name: ringbuffer_insert
+// Params: ringbuffer_t* rb, const uint8_t* p, size_t length
+// Return: size_t
+struct ringbuffer_insert {
+  size_t return_value{0};
+  std::function<size_t(ringbuffer_t* rb, const uint8_t* p, size_t length)> body{
+      [this](ringbuffer_t* rb, const uint8_t* p, size_t length) {
+        return return_value;
+      }};
+  size_t operator()(ringbuffer_t* rb, const uint8_t* p, size_t length) {
+    return body(rb, p, length);
+  };
+};
+extern struct ringbuffer_insert ringbuffer_insert;
+
+// Name: ringbuffer_peek
+// Params: const ringbuffer_t* rb, off_t offset, uint8_t* p, size_t length
+// Return: size_t
+struct ringbuffer_peek {
+  size_t return_value{0};
+  std::function<size_t(const ringbuffer_t* rb, off_t offset, uint8_t* p,
+                       size_t length)>
+      body{[this](const ringbuffer_t* rb, off_t offset, uint8_t* p,
+                  size_t length) { return return_value; }};
+  size_t operator()(const ringbuffer_t* rb, off_t offset, uint8_t* p,
+                    size_t length) {
+    return body(rb, offset, p, length);
+  };
+};
+extern struct ringbuffer_peek ringbuffer_peek;
+
+// Name: ringbuffer_pop
+// Params: ringbuffer_t* rb, uint8_t* p, size_t length
+// Return: size_t
+struct ringbuffer_pop {
+  size_t return_value{0};
+  std::function<size_t(ringbuffer_t* rb, uint8_t* p, size_t length)> body{
+      [this](ringbuffer_t* rb, uint8_t* p, size_t length) {
+        return return_value;
+      }};
+  size_t operator()(ringbuffer_t* rb, uint8_t* p, size_t length) {
+    return body(rb, p, length);
+  };
+};
+extern struct ringbuffer_pop ringbuffer_pop;
+
+// Name: ringbuffer_size
+// Params: const ringbuffer_t* rb
+// Return: size_t
+struct ringbuffer_size {
+  size_t return_value{0};
+  std::function<size_t(const ringbuffer_t* rb)> body{
+      [this](const ringbuffer_t* rb) { return return_value; }};
+  size_t operator()(const ringbuffer_t* rb) { return body(rb); };
+};
+extern struct ringbuffer_size ringbuffer_size;
+
+}  // namespace osi_ringbuffer
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file
diff --git a/test/mock/mock_osi_semaphore.cc b/test/mock/mock_osi_semaphore.cc
new file mode 100644
index 0000000..4a69c0e
--- /dev/null
+++ b/test/mock/mock_osi_semaphore.cc
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:6
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_osi_semaphore.h"
+
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace osi_semaphore {
+
+// Function state capture and return values, if needed
+struct semaphore_free semaphore_free;
+struct semaphore_get_fd semaphore_get_fd;
+struct semaphore_new semaphore_new;
+struct semaphore_post semaphore_post;
+struct semaphore_try_wait semaphore_try_wait;
+struct semaphore_wait semaphore_wait;
+
+}  // namespace osi_semaphore
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+void semaphore_free(semaphore_t* semaphore) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_semaphore::semaphore_free(semaphore);
+}
+int semaphore_get_fd(const semaphore_t* semaphore) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_semaphore::semaphore_get_fd(semaphore);
+}
+semaphore_t* semaphore_new(unsigned int value) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_semaphore::semaphore_new(value);
+}
+void semaphore_post(semaphore_t* semaphore) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_semaphore::semaphore_post(semaphore);
+}
+bool semaphore_try_wait(semaphore_t* semaphore) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_semaphore::semaphore_try_wait(semaphore);
+}
+void semaphore_wait(semaphore_t* semaphore) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_semaphore::semaphore_wait(semaphore);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_osi_semaphore.h b/test/mock/mock_osi_semaphore.h
new file mode 100644
index 0000000..ca862ea
--- /dev/null
+++ b/test/mock/mock_osi_semaphore.h
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:6
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <base/logging.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <malloc.h>
+#include <string.h>
+#include <sys/eventfd.h>
+#include <unistd.h>
+
+#include "check.h"
+#include "osi/include/allocator.h"
+#include "osi/include/log.h"
+#include "osi/include/osi.h"
+#include "osi/include/semaphore.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace osi_semaphore {
+
+// Shared state between mocked functions and tests
+// Name: semaphore_free
+// Params: semaphore_t* semaphore
+// Return: void
+struct semaphore_free {
+  std::function<void(semaphore_t* semaphore)> body{
+      [](semaphore_t* semaphore) {}};
+  void operator()(semaphore_t* semaphore) { body(semaphore); };
+};
+extern struct semaphore_free semaphore_free;
+
+// Name: semaphore_get_fd
+// Params: const semaphore_t* semaphore
+// Return: int
+struct semaphore_get_fd {
+  int return_value{0};
+  std::function<int(const semaphore_t* semaphore)> body{
+      [this](const semaphore_t* semaphore) { return return_value; }};
+  int operator()(const semaphore_t* semaphore) { return body(semaphore); };
+};
+extern struct semaphore_get_fd semaphore_get_fd;
+
+// Name: semaphore_new
+// Params: unsigned int value
+// Return: semaphore_t*
+struct semaphore_new {
+  semaphore_t* return_value{0};
+  std::function<semaphore_t*(unsigned int value)> body{
+      [this](unsigned int value) { return return_value; }};
+  semaphore_t* operator()(unsigned int value) { return body(value); };
+};
+extern struct semaphore_new semaphore_new;
+
+// Name: semaphore_post
+// Params: semaphore_t* semaphore
+// Return: void
+struct semaphore_post {
+  std::function<void(semaphore_t* semaphore)> body{
+      [](semaphore_t* semaphore) {}};
+  void operator()(semaphore_t* semaphore) { body(semaphore); };
+};
+extern struct semaphore_post semaphore_post;
+
+// Name: semaphore_try_wait
+// Params: semaphore_t* semaphore
+// Return: bool
+struct semaphore_try_wait {
+  bool return_value{false};
+  std::function<bool(semaphore_t* semaphore)> body{
+      [this](semaphore_t* semaphore) { return return_value; }};
+  bool operator()(semaphore_t* semaphore) { return body(semaphore); };
+};
+extern struct semaphore_try_wait semaphore_try_wait;
+
+// Name: semaphore_wait
+// Params: semaphore_t* semaphore
+// Return: void
+struct semaphore_wait {
+  std::function<void(semaphore_t* semaphore)> body{
+      [](semaphore_t* semaphore) {}};
+  void operator()(semaphore_t* semaphore) { body(semaphore); };
+};
+extern struct semaphore_wait semaphore_wait;
+
+}  // namespace osi_semaphore
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file
diff --git a/test/mock/mock_osi_socket.cc b/test/mock/mock_osi_socket.cc
new file mode 100644
index 0000000..541a3a3
--- /dev/null
+++ b/test/mock/mock_osi_socket.cc
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:11
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_osi_socket.h"
+
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace osi_socket {
+
+// Function state capture and return values, if needed
+struct socket_accept socket_accept;
+struct socket_bytes_available socket_bytes_available;
+struct socket_free socket_free;
+struct socket_listen socket_listen;
+struct socket_new socket_new;
+struct socket_new_from_fd socket_new_from_fd;
+struct socket_read socket_read;
+struct socket_register socket_register;
+struct socket_unregister socket_unregister;
+struct socket_write socket_write;
+struct socket_write_and_transfer_fd socket_write_and_transfer_fd;
+
+}  // namespace osi_socket
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+socket_t* socket_accept(const socket_t* socket) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_socket::socket_accept(socket);
+}
+ssize_t socket_bytes_available(const socket_t* socket) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_socket::socket_bytes_available(socket);
+}
+void socket_free(socket_t* socket) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_socket::socket_free(socket);
+}
+bool socket_listen(const socket_t* socket, port_t port) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_socket::socket_listen(socket, port);
+}
+socket_t* socket_new(void) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_socket::socket_new();
+}
+socket_t* socket_new_from_fd(int fd) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_socket::socket_new_from_fd(fd);
+}
+ssize_t socket_read(const socket_t* socket, void* buf, size_t count) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_socket::socket_read(socket, buf, count);
+}
+void socket_register(socket_t* socket, reactor_t* reactor, void* context,
+                     socket_cb read_cb, socket_cb write_cb) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_socket::socket_register(socket, reactor, context, read_cb,
+                                          write_cb);
+}
+void socket_unregister(socket_t* socket) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_socket::socket_unregister(socket);
+}
+ssize_t socket_write(const socket_t* socket, const void* buf, size_t count) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_socket::socket_write(socket, buf, count);
+}
+ssize_t socket_write_and_transfer_fd(const socket_t* socket, const void* buf,
+                                     size_t count, int fd) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_socket::socket_write_and_transfer_fd(socket, buf,
+                                                              count, fd);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_osi_socket.h b/test/mock/mock_osi_socket.h
new file mode 100644
index 0000000..5296b03
--- /dev/null
+++ b/test/mock/mock_osi_socket.h
@@ -0,0 +1,199 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:11
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <asm/ioctls.h>
+#include <base/logging.h>
+#include <errno.h>
+#include <netinet/in.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include "check.h"
+#include "osi/include/allocator.h"
+#include "osi/include/log.h"
+#include "osi/include/osi.h"
+#include "osi/include/reactor.h"
+#include "osi/include/socket.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace osi_socket {
+
+// Shared state between mocked functions and tests
+// Name: socket_accept
+// Params: const socket_t* socket
+// Return: socket_t*
+struct socket_accept {
+  socket_t* return_value{0};
+  std::function<socket_t*(const socket_t* socket)> body{
+      [this](const socket_t* socket) { return return_value; }};
+  socket_t* operator()(const socket_t* socket) { return body(socket); };
+};
+extern struct socket_accept socket_accept;
+
+// Name: socket_bytes_available
+// Params: const socket_t* socket
+// Return: ssize_t
+struct socket_bytes_available {
+  ssize_t return_value{0};
+  std::function<ssize_t(const socket_t* socket)> body{
+      [this](const socket_t* socket) { return return_value; }};
+  ssize_t operator()(const socket_t* socket) { return body(socket); };
+};
+extern struct socket_bytes_available socket_bytes_available;
+
+// Name: socket_free
+// Params: socket_t* socket
+// Return: void
+struct socket_free {
+  std::function<void(socket_t* socket)> body{[](socket_t* socket) {}};
+  void operator()(socket_t* socket) { body(socket); };
+};
+extern struct socket_free socket_free;
+
+// Name: socket_listen
+// Params: const socket_t* socket, port_t port
+// Return: bool
+struct socket_listen {
+  bool return_value{false};
+  std::function<bool(const socket_t* socket, port_t port)> body{
+      [this](const socket_t* socket, port_t port) { return return_value; }};
+  bool operator()(const socket_t* socket, port_t port) {
+    return body(socket, port);
+  };
+};
+extern struct socket_listen socket_listen;
+
+// Name: socket_new
+// Params: void
+// Return: socket_t*
+struct socket_new {
+  socket_t* return_value{0};
+  std::function<socket_t*(void)> body{[this](void) { return return_value; }};
+  socket_t* operator()(void) { return body(); };
+};
+extern struct socket_new socket_new;
+
+// Name: socket_new_from_fd
+// Params: int fd
+// Return: socket_t*
+struct socket_new_from_fd {
+  socket_t* return_value{0};
+  std::function<socket_t*(int fd)> body{
+      [this](int fd) { return return_value; }};
+  socket_t* operator()(int fd) { return body(fd); };
+};
+extern struct socket_new_from_fd socket_new_from_fd;
+
+// Name: socket_read
+// Params: const socket_t* socket, void* buf, size_t count
+// Return: ssize_t
+struct socket_read {
+  ssize_t return_value{0};
+  std::function<ssize_t(const socket_t* socket, void* buf, size_t count)> body{
+      [this](const socket_t* socket, void* buf, size_t count) {
+        return return_value;
+      }};
+  ssize_t operator()(const socket_t* socket, void* buf, size_t count) {
+    return body(socket, buf, count);
+  };
+};
+extern struct socket_read socket_read;
+
+// Name: socket_register
+// Params: socket_t* socket, reactor_t* reactor, void* context, socket_cb
+// read_cb, socket_cb write_cb Return: void
+struct socket_register {
+  std::function<void(socket_t* socket, reactor_t* reactor, void* context,
+                     socket_cb read_cb, socket_cb write_cb)>
+      body{[](socket_t* socket, reactor_t* reactor, void* context,
+              socket_cb read_cb, socket_cb write_cb) {}};
+  void operator()(socket_t* socket, reactor_t* reactor, void* context,
+                  socket_cb read_cb, socket_cb write_cb) {
+    body(socket, reactor, context, read_cb, write_cb);
+  };
+};
+extern struct socket_register socket_register;
+
+// Name: socket_unregister
+// Params: socket_t* socket
+// Return: void
+struct socket_unregister {
+  std::function<void(socket_t* socket)> body{[](socket_t* socket) {}};
+  void operator()(socket_t* socket) { body(socket); };
+};
+extern struct socket_unregister socket_unregister;
+
+// Name: socket_write
+// Params: const socket_t* socket, const void* buf, size_t count
+// Return: ssize_t
+struct socket_write {
+  ssize_t return_value{0};
+  std::function<ssize_t(const socket_t* socket, const void* buf, size_t count)>
+      body{[this](const socket_t* socket, const void* buf, size_t count) {
+        return return_value;
+      }};
+  ssize_t operator()(const socket_t* socket, const void* buf, size_t count) {
+    return body(socket, buf, count);
+  };
+};
+extern struct socket_write socket_write;
+
+// Name: socket_write_and_transfer_fd
+// Params: const socket_t* socket, const void* buf, size_t count, int fd
+// Return: ssize_t
+struct socket_write_and_transfer_fd {
+  ssize_t return_value{0};
+  std::function<ssize_t(const socket_t* socket, const void* buf, size_t count,
+                        int fd)>
+      body{[this](const socket_t* socket, const void* buf, size_t count,
+                  int fd) { return return_value; }};
+  ssize_t operator()(const socket_t* socket, const void* buf, size_t count,
+                     int fd) {
+    return body(socket, buf, count, fd);
+  };
+};
+extern struct socket_write_and_transfer_fd socket_write_and_transfer_fd;
+
+}  // namespace osi_socket
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file
diff --git a/test/mock/mock_osi_thread.cc b/test/mock/mock_osi_thread.cc
new file mode 100644
index 0000000..3b8ade1
--- /dev/null
+++ b/test/mock/mock_osi_thread.cc
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:11
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_osi_thread.h"
+
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace osi_thread {
+
+// Function state capture and return values, if needed
+struct thread_free thread_free;
+struct thread_get_reactor thread_get_reactor;
+struct thread_is_self thread_is_self;
+struct thread_join thread_join;
+struct thread_name thread_name;
+struct thread_new thread_new;
+struct thread_new_sized thread_new_sized;
+struct thread_post thread_post;
+struct thread_set_priority thread_set_priority;
+struct thread_set_rt_priority thread_set_rt_priority;
+struct thread_stop thread_stop;
+
+}  // namespace osi_thread
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+void thread_free(thread_t* thread) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_thread::thread_free(thread);
+}
+reactor_t* thread_get_reactor(const thread_t* thread) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_thread::thread_get_reactor(thread);
+}
+bool thread_is_self(const thread_t* thread) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_thread::thread_is_self(thread);
+}
+void thread_join(thread_t* thread) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_thread::thread_join(thread);
+}
+const char* thread_name(const thread_t* thread) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_thread::thread_name(thread);
+}
+thread_t* thread_new(const char* name) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_thread::thread_new(name);
+}
+thread_t* thread_new_sized(const char* name, size_t work_queue_capacity) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_thread::thread_new_sized(name, work_queue_capacity);
+}
+bool thread_post(thread_t* thread, thread_fn func, void* context) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_thread::thread_post(thread, func, context);
+}
+bool thread_set_priority(thread_t* thread, int priority) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_thread::thread_set_priority(thread, priority);
+}
+bool thread_set_rt_priority(thread_t* thread, int priority) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_thread::thread_set_rt_priority(thread, priority);
+}
+void thread_stop(thread_t* thread) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_thread::thread_stop(thread);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_osi_thread.h b/test/mock/mock_osi_thread.h
new file mode 100644
index 0000000..7bcab08
--- /dev/null
+++ b/test/mock/mock_osi_thread.h
@@ -0,0 +1,196 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:11
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <base/logging.h>
+#include <errno.h>
+#include <malloc.h>
+#include <pthread.h>
+#include <string.h>
+#include <sys/prctl.h>
+#include <sys/resource.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <atomic>
+
+#include "check.h"
+#include "osi/include/allocator.h"
+#include "osi/include/compat.h"
+#include "osi/include/fixed_queue.h"
+#include "osi/include/log.h"
+#include "osi/include/reactor.h"
+#include "osi/include/semaphore.h"
+#include "osi/include/thread.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace osi_thread {
+
+// Shared state between mocked functions and tests
+// Name: thread_free
+// Params: thread_t* thread
+// Return: void
+struct thread_free {
+  std::function<void(thread_t* thread)> body{[](thread_t* thread) {}};
+  void operator()(thread_t* thread) { body(thread); };
+};
+extern struct thread_free thread_free;
+
+// Name: thread_get_reactor
+// Params: const thread_t* thread
+// Return: reactor_t*
+struct thread_get_reactor {
+  reactor_t* return_value{0};
+  std::function<reactor_t*(const thread_t* thread)> body{
+      [this](const thread_t* thread) { return return_value; }};
+  reactor_t* operator()(const thread_t* thread) { return body(thread); };
+};
+extern struct thread_get_reactor thread_get_reactor;
+
+// Name: thread_is_self
+// Params: const thread_t* thread
+// Return: bool
+struct thread_is_self {
+  bool return_value{false};
+  std::function<bool(const thread_t* thread)> body{
+      [this](const thread_t* thread) { return return_value; }};
+  bool operator()(const thread_t* thread) { return body(thread); };
+};
+extern struct thread_is_self thread_is_self;
+
+// Name: thread_join
+// Params: thread_t* thread
+// Return: void
+struct thread_join {
+  std::function<void(thread_t* thread)> body{[](thread_t* thread) {}};
+  void operator()(thread_t* thread) { body(thread); };
+};
+extern struct thread_join thread_join;
+
+// Name: thread_name
+// Params: const thread_t* thread
+// Return: const char*
+struct thread_name {
+  const char* return_value{0};
+  std::function<const char*(const thread_t* thread)> body{
+      [this](const thread_t* thread) { return return_value; }};
+  const char* operator()(const thread_t* thread) { return body(thread); };
+};
+extern struct thread_name thread_name;
+
+// Name: thread_new
+// Params: const char* name
+// Return: thread_t*
+struct thread_new {
+  thread_t* return_value{0};
+  std::function<thread_t*(const char* name)> body{
+      [this](const char* name) { return return_value; }};
+  thread_t* operator()(const char* name) { return body(name); };
+};
+extern struct thread_new thread_new;
+
+// Name: thread_new_sized
+// Params: const char* name, size_t work_queue_capacity
+// Return: thread_t*
+struct thread_new_sized {
+  thread_t* return_value{0};
+  std::function<thread_t*(const char* name, size_t work_queue_capacity)> body{
+      [this](const char* name, size_t work_queue_capacity) {
+        return return_value;
+      }};
+  thread_t* operator()(const char* name, size_t work_queue_capacity) {
+    return body(name, work_queue_capacity);
+  };
+};
+extern struct thread_new_sized thread_new_sized;
+
+// Name: thread_post
+// Params: thread_t* thread, thread_fn func, void* context
+// Return: bool
+struct thread_post {
+  bool return_value{false};
+  std::function<bool(thread_t* thread, thread_fn func, void* context)> body{
+      [this](thread_t* thread, thread_fn func, void* context) {
+        return return_value;
+      }};
+  bool operator()(thread_t* thread, thread_fn func, void* context) {
+    return body(thread, func, context);
+  };
+};
+extern struct thread_post thread_post;
+
+// Name: thread_set_priority
+// Params: thread_t* thread, int priority
+// Return: bool
+struct thread_set_priority {
+  bool return_value{false};
+  std::function<bool(thread_t* thread, int priority)> body{
+      [this](thread_t* thread, int priority) { return return_value; }};
+  bool operator()(thread_t* thread, int priority) {
+    return body(thread, priority);
+  };
+};
+extern struct thread_set_priority thread_set_priority;
+
+// Name: thread_set_rt_priority
+// Params: thread_t* thread, int priority
+// Return: bool
+struct thread_set_rt_priority {
+  bool return_value{false};
+  std::function<bool(thread_t* thread, int priority)> body{
+      [this](thread_t* thread, int priority) { return return_value; }};
+  bool operator()(thread_t* thread, int priority) {
+    return body(thread, priority);
+  };
+};
+extern struct thread_set_rt_priority thread_set_rt_priority;
+
+// Name: thread_stop
+// Params: thread_t* thread
+// Return: void
+struct thread_stop {
+  std::function<void(thread_t* thread)> body{[](thread_t* thread) {}};
+  void operator()(thread_t* thread) { body(thread); };
+};
+extern struct thread_stop thread_stop;
+
+}  // namespace osi_thread
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file
diff --git a/test/mock/mock_osi_thread_scheduler.cc b/test/mock/mock_osi_thread_scheduler.cc
new file mode 100644
index 0000000..2efbb5b
--- /dev/null
+++ b/test/mock/mock_osi_thread_scheduler.cc
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:2
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_osi_thread_scheduler.h"
+
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace osi_thread_scheduler {
+
+// Function state capture and return values, if needed
+struct thread_scheduler_enable_real_time thread_scheduler_enable_real_time;
+struct thread_scheduler_get_priority_range thread_scheduler_get_priority_range;
+
+}  // namespace osi_thread_scheduler
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+bool thread_scheduler_enable_real_time(pid_t linux_tid) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_thread_scheduler::thread_scheduler_enable_real_time(
+      linux_tid);
+}
+bool thread_scheduler_get_priority_range(int& min, int& max) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_thread_scheduler::thread_scheduler_get_priority_range(
+      min, max);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_osi_thread_scheduler.h b/test/mock/mock_osi_thread_scheduler.h
new file mode 100644
index 0000000..da88a94
--- /dev/null
+++ b/test/mock/mock_osi_thread_scheduler.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:2
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace osi_thread_scheduler {
+
+// Shared state between mocked functions and tests
+// Name: osi_enable_real_time_scheduling
+// Params: pid_t linux_tid
+// Return: bool
+struct thread_scheduler_enable_real_time {
+  bool return_value{false};
+  std::function<bool(pid_t linux_tid)> body{
+      [this](pid_t linux_tid) { return return_value; }};
+  bool operator()(pid_t linux_tid) { return body(linux_tid); };
+};
+extern struct thread_scheduler_enable_real_time
+    thread_scheduler_enable_real_time;
+
+// Name: osi_fifo_scheduing_priority_range
+// Params: int& min, int& max
+// Return: bool
+struct thread_scheduler_get_priority_range {
+  bool return_value{false};
+  std::function<bool(int& min, int& max)> body{
+      [this](int& min, int& max) { return return_value; }};
+  bool operator()(int& min, int& max) { return body(min, max); };
+};
+extern struct thread_scheduler_get_priority_range
+    thread_scheduler_get_priority_range;
+
+}  // namespace osi_thread_scheduler
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
diff --git a/test/mock/mock_osi_wakelock.cc b/test/mock/mock_osi_wakelock.cc
new file mode 100644
index 0000000..6c359de
--- /dev/null
+++ b/test/mock/mock_osi_wakelock.cc
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:6
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_osi_wakelock.h"
+
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace osi_wakelock {
+
+// Function state capture and return values, if needed
+struct wakelock_acquire wakelock_acquire;
+struct wakelock_cleanup wakelock_cleanup;
+struct wakelock_debug_dump wakelock_debug_dump;
+struct wakelock_release wakelock_release;
+struct wakelock_set_os_callouts wakelock_set_os_callouts;
+struct wakelock_set_paths wakelock_set_paths;
+
+}  // namespace osi_wakelock
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+bool wakelock_acquire(void) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_wakelock::wakelock_acquire();
+}
+void wakelock_cleanup(void) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_wakelock::wakelock_cleanup();
+}
+void wakelock_debug_dump(int fd) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_wakelock::wakelock_debug_dump(fd);
+}
+bool wakelock_release(void) {
+  mock_function_count_map[__func__]++;
+  return test::mock::osi_wakelock::wakelock_release();
+}
+void wakelock_set_os_callouts(bt_os_callouts_t* callouts) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_wakelock::wakelock_set_os_callouts(callouts);
+}
+void wakelock_set_paths(const char* lock_path, const char* unlock_path) {
+  mock_function_count_map[__func__]++;
+  test::mock::osi_wakelock::wakelock_set_paths(lock_path, unlock_path);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_osi_wakelock.h b/test/mock/mock_osi_wakelock.h
new file mode 100644
index 0000000..80d0309
--- /dev/null
+++ b/test/mock/mock_osi_wakelock.h
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:6
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <errno.h>
+#include <fcntl.h>
+#include <hardware/bluetooth.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <pthread.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <mutex>
+#include <string>
+
+#include "base/logging.h"
+#include "check.h"
+#include "common/metrics.h"
+#include "osi/include/alarm.h"
+#include "osi/include/allocator.h"
+#include "osi/include/log.h"
+#include "osi/include/osi.h"
+#include "osi/include/thread.h"
+#include "osi/include/wakelock.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace osi_wakelock {
+
+// Shared state between mocked functions and tests
+// Name: wakelock_acquire
+// Params: void
+// Return: bool
+struct wakelock_acquire {
+  bool return_value{false};
+  std::function<bool(void)> body{[this](void) { return return_value; }};
+  bool operator()(void) { return body(); };
+};
+extern struct wakelock_acquire wakelock_acquire;
+
+// Name: wakelock_cleanup
+// Params: void
+// Return: void
+struct wakelock_cleanup {
+  std::function<void(void)> body{[](void) {}};
+  void operator()(void) { body(); };
+};
+extern struct wakelock_cleanup wakelock_cleanup;
+
+// Name: wakelock_debug_dump
+// Params: int fd
+// Return: void
+struct wakelock_debug_dump {
+  std::function<void(int fd)> body{[](int fd) {}};
+  void operator()(int fd) { body(fd); };
+};
+extern struct wakelock_debug_dump wakelock_debug_dump;
+
+// Name: wakelock_release
+// Params: void
+// Return: bool
+struct wakelock_release {
+  bool return_value{false};
+  std::function<bool(void)> body{[this](void) { return return_value; }};
+  bool operator()(void) { return body(); };
+};
+extern struct wakelock_release wakelock_release;
+
+// Name: wakelock_set_os_callouts
+// Params: bt_os_callouts_t* callouts
+// Return: void
+struct wakelock_set_os_callouts {
+  std::function<void(bt_os_callouts_t* callouts)> body{
+      [](bt_os_callouts_t* callouts) {}};
+  void operator()(bt_os_callouts_t* callouts) { body(callouts); };
+};
+extern struct wakelock_set_os_callouts wakelock_set_os_callouts;
+
+// Name: wakelock_set_paths
+// Params: const char* lock_path, const char* unlock_path
+// Return: void
+struct wakelock_set_paths {
+  std::function<void(const char* lock_path, const char* unlock_path)> body{
+      [](const char* lock_path, const char* unlock_path) {}};
+  void operator()(const char* lock_path, const char* unlock_path) {
+    body(lock_path, unlock_path);
+  };
+};
+extern struct wakelock_set_paths wakelock_set_paths;
+
+}  // namespace osi_wakelock
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file
diff --git a/test/mock/mock_stack_btm_devctl.cc b/test/mock/mock_stack_btm_devctl.cc
index ea3d41a..5aeab02 100644
--- a/test/mock/mock_stack_btm_devctl.cc
+++ b/test/mock/mock_stack_btm_devctl.cc
@@ -86,7 +86,7 @@
   mock_function_count_map[__func__]++;
   return BTM_SUCCESS;
 }
-tBTM_STATUS BTM_SetLocalDeviceName(char* p_name) {
+tBTM_STATUS BTM_SetLocalDeviceName(const char* p_name) {
   mock_function_count_map[__func__]++;
   return BTM_SUCCESS;
 }
diff --git a/test/mock/mock_utils_bt.cc b/test/mock/mock_utils_bt.cc
new file mode 100644
index 0000000..5b6bfc2
--- /dev/null
+++ b/test/mock/mock_utils_bt.cc
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:1
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Mock include file to share data between tests and mock
+#include "test/mock/mock_utils_bt.h"
+
+// Legacy module structure
+#if 0
+EXPORT_SYMBOL extern const module_t module_s = {.name = BT_UTILS_MODULE,
+                                                .init = nullptr,
+                                                .start_up = nullptr,
+                                                .shut_down = nullptr,
+                                                .clean_up = nullptr,
+                                                .dependencies = {nullptr}};
+#endif
+// Mocked internal structures, if any
+
+namespace test {
+namespace mock {
+namespace utils_bt {
+
+// Function state capture and return values, if needed
+struct raise_priority_a2dp raise_priority_a2dp;
+
+}  // namespace utils_bt
+}  // namespace mock
+}  // namespace test
+
+// Mocked functions, if any
+void raise_priority_a2dp(tHIGH_PRIORITY_TASK high_task) {
+  mock_function_count_map[__func__]++;
+  test::mock::utils_bt::raise_priority_a2dp(high_task);
+}
+// Mocked functions complete
+// END mockcify generation
diff --git a/test/mock/mock_utils_bt.h b/test/mock/mock_utils_bt.h
new file mode 100644
index 0000000..1b0b8a1
--- /dev/null
+++ b/test/mock/mock_utils_bt.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/*
+ * Generated mock file from original source file
+ *   Functions generated:1
+ *
+ *  mockcify.pl ver 0.3.0
+ */
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+extern std::map<std::string, int> mock_function_count_map;
+
+// Original included files, if any
+// NOTE: Since this is a mock file with mock definitions some number of
+//       include files may not be required.  The include-what-you-use
+//       still applies, but crafting proper inclusion is out of scope
+//       for this effort.  This compilation unit may compile as-is, or
+//       may need attention to prune from (or add to ) the inclusion set.
+#include <errno.h>
+#include <processgroup/sched_policy.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/resource.h>
+#include <unistd.h>
+
+#include <mutex>
+
+#include "bt_types.h"
+#include "bt_utils.h"
+#include "btcore/include/module.h"
+#include "osi/include/compat.h"
+#include "osi/include/log.h"
+#include "osi/include/properties.h"
+
+// Mocked compile conditionals, if any
+
+namespace test {
+namespace mock {
+namespace utils_bt {
+
+// Shared state between mocked functions and tests
+// Name: raise_priority_a2dp
+// Params: tHIGH_PRIORITY_TASK high_task
+// Return: void
+struct raise_priority_a2dp {
+  std::function<void(tHIGH_PRIORITY_TASK high_task)> body{
+      [](tHIGH_PRIORITY_TASK high_task) {}};
+  void operator()(tHIGH_PRIORITY_TASK high_task) { body(high_task); };
+};
+extern struct raise_priority_a2dp raise_priority_a2dp;
+
+}  // namespace utils_bt
+}  // namespace mock
+}  // namespace test
+
+// END mockcify generation
\ No newline at end of file