diff --git a/broadcastradio/1.1/vts/functional/Android.bp b/broadcastradio/1.1/vts/functional/Android.bp
index c136019..6e5c84c 100644
--- a/broadcastradio/1.1/vts/functional/Android.bp
+++ b/broadcastradio/1.1/vts/functional/Android.bp
@@ -31,7 +31,8 @@
     ],
     static_libs: [
         "VtsHalHidlTargetTestBase",
-        "broadcastradio-vts-call-barrier",
+        "android.hardware.broadcastradio@1.1-utils-lib",
+        "android.hardware.broadcastradio@1.1-vts-utils-lib",
         "libgmock",
     ],
     cflags: [
@@ -40,16 +41,3 @@
         "-g",
     ],
 }
-
-cc_library_static {
-    name: "broadcastradio-vts-call-barrier",
-    srcs: [
-        "call-barrier.cpp",
-    ],
-    export_include_dirs: ["."],
-    cflags: [
-        "-Wall",
-        "-Wextra",
-        "-Werror",
-    ],
-}
diff --git a/broadcastradio/1.1/vts/functional/VtsHalBroadcastradioV1_1TargetTest.cpp b/broadcastradio/1.1/vts/functional/VtsHalBroadcastradioV1_1TargetTest.cpp
index d20452b..c6bc344 100644
--- a/broadcastradio/1.1/vts/functional/VtsHalBroadcastradioV1_1TargetTest.cpp
+++ b/broadcastradio/1.1/vts/functional/VtsHalBroadcastradioV1_1TargetTest.cpp
@@ -17,8 +17,15 @@
 #define LOG_TAG "broadcastradio.vts"
 
 #include <VtsHalHidlTargetTestBase.h>
+#include <android/hardware/broadcastradio/1.1/IBroadcastRadio.h>
+#include <android/hardware/broadcastradio/1.1/IBroadcastRadioFactory.h>
+#include <android/hardware/broadcastradio/1.1/ITuner.h>
+#include <android/hardware/broadcastradio/1.1/ITunerCallback.h>
+#include <android/hardware/broadcastradio/1.1/types.h>
 #include <android-base/logging.h>
-#include <call-barrier.h>
+#include <broadcastradio-utils/Utils.h>
+#include <broadcastradio-vts-utils/call-barrier.h>
+#include <broadcastradio-vts-utils/mock-timeout.h>
 #include <cutils/native_handle.h>
 #include <cutils/properties.h>
 #include <gmock/gmock.h>
@@ -27,14 +34,6 @@
 
 #include <chrono>
 
-#include <android/hardware/broadcastradio/1.1/IBroadcastRadio.h>
-#include <android/hardware/broadcastradio/1.1/IBroadcastRadioFactory.h>
-#include <android/hardware/broadcastradio/1.1/ITuner.h>
-#include <android/hardware/broadcastradio/1.1/ITunerCallback.h>
-#include <android/hardware/broadcastradio/1.1/types.h>
-
-#include "mock-timeout.h"
-
 namespace android {
 namespace hardware {
 namespace broadcastradio {
@@ -57,6 +56,9 @@
 using V1_0::MetadataKey;
 using V1_0::MetadataType;
 
+using std::chrono::steady_clock;
+using std::this_thread::sleep_for;
+
 static constexpr auto kConfigTimeout = 10s;
 static constexpr auto kConnectModuleTimeout = 1s;
 static constexpr auto kTuneTimeout = 30s;
@@ -91,10 +93,8 @@
     virtual void SetUp() override;
     virtual void TearDown() override;
 
-    // TODO(b/36864490): check all bands for good test conditions (ie. FM is more likely to have
-    // any stations on the list, so don't pick AM blindly).
-    bool openTuner(unsigned band);
-    const BandConfig& getBand(unsigned idx);
+    bool openTuner();
+    bool nextBand();
     bool getProgramList(std::function<void(const hidl_vec<ProgramInfo>& list)> cb);
 
     Class radioClass;
@@ -105,9 +105,33 @@
     sp<TunerCallbackMock> mCallback = new TunerCallbackMock();
 
    private:
+    const BandConfig& getBand(unsigned idx);
+
+    unsigned currentBandIndex = 0;
     hidl_vec<BandConfig> mBands;
 };
 
+/**
+ * Clears strong pointer and waits until the object gets destroyed.
+ *
+ * @param ptr The pointer to get cleared.
+ * @param timeout Time to wait for other references.
+ */
+template <typename T>
+static void clearAndWait(sp<T>& ptr, std::chrono::milliseconds timeout) {
+    wp<T> wptr = ptr;
+    ptr.clear();
+    auto limit = steady_clock::now() + timeout;
+    while (wptr.promote() != nullptr) {
+        constexpr auto step = 10ms;
+        if (steady_clock::now() + step > limit) {
+            FAIL() << "Pointer was not released within timeout";
+            break;
+        }
+        sleep_for(step);
+    }
+}
+
 void BroadcastRadioHalTest::SetUp() {
     radioClass = GetParam();
 
@@ -153,10 +177,10 @@
 void BroadcastRadioHalTest::TearDown() {
     mTuner.clear();
     mRadioModule.clear();
-    // TODO(b/36864490): wait (with timeout) until mCallback has only one reference
+    clearAndWait(mCallback, 1s);
 }
 
-bool BroadcastRadioHalTest::openTuner(unsigned band) {
+bool BroadcastRadioHalTest::openTuner() {
     EXPECT_EQ(nullptr, mTuner.get());
 
     if (radioClass == Class::AM_FM) {
@@ -169,7 +193,8 @@
         if (result != Result::OK) return;
         mTuner = ITuner::castFrom(tuner);
     };
-    auto hidlResult = mRadioModule->openTuner(getBand(band), true, mCallback, openCb);
+    currentBandIndex = 0;
+    auto hidlResult = mRadioModule->openTuner(getBand(0), true, mCallback, openCb);
 
     EXPECT_TRUE(hidlResult.isOk());
     EXPECT_EQ(Result::OK, halResult);
@@ -210,6 +235,21 @@
     return band;
 }
 
+bool BroadcastRadioHalTest::nextBand() {
+    if (currentBandIndex + 1 >= mBands.size()) return false;
+    currentBandIndex++;
+
+    BandConfig bandCb;
+    EXPECT_TIMEOUT_CALL(*mCallback, configChange, Result::OK, _)
+        .WillOnce(DoAll(SaveArg<1>(&bandCb), testing::Return(ByMove(Void()))));
+    auto hidlResult = mTuner->setConfiguration(getBand(currentBandIndex));
+    EXPECT_EQ(Result::OK, hidlResult);
+    EXPECT_TIMEOUT_CALL_WAIT(*mCallback, configChange, kConfigTimeout);
+    EXPECT_EQ(getBand(currentBandIndex), bandCb);
+
+    return true;
+}
+
 bool BroadcastRadioHalTest::getProgramList(
     std::function<void(const hidl_vec<ProgramInfo>& list)> cb) {
     ProgramListResult getListResult = ProgramListResult::NOT_INITIALIZED;
@@ -244,11 +284,7 @@
         EXPECT_EQ(ProgramListResult::OK, getListResult);
     }
 
-    if (isListEmpty) {
-        printSkipped("Program list is empty.");
-        return false;
-    }
-    return true;
+    return !isListEmpty;
 }
 
 /**
@@ -263,13 +299,13 @@
  */
 TEST_P(BroadcastRadioHalTest, OpenTunerTwice) {
     if (skipped) return;
-    ASSERT_TRUE(openTuner(0));
 
-    Result halResult = Result::NOT_INITIALIZED;
-    auto openCb = [&](Result result, const sp<V1_0::ITuner>&) { halResult = result; };
-    auto hidlResult = mRadioModule->openTuner(getBand(0), true, mCallback, openCb);
-    ASSERT_TRUE(hidlResult.isOk());
-    ASSERT_EQ(Result::OK, halResult);
+    ASSERT_TRUE(openTuner());
+
+    auto secondTuner = mTuner;
+    mTuner.clear();
+
+    ASSERT_TRUE(openTuner());
 }
 
 /**
@@ -283,17 +319,25 @@
  */
 TEST_P(BroadcastRadioHalTest, TuneFromProgramList) {
     if (skipped) return;
-    ASSERT_TRUE(openTuner(0));
+    ASSERT_TRUE(openTuner());
 
     ProgramInfo firstProgram;
-    auto getCb = [&](const hidl_vec<ProgramInfo>& list) {
-        // don't copy the whole list out, it might be heavy
-        firstProgram = list[0];
-    };
-    if (!getProgramList(getCb)) return;
+    bool foundAny = false;
+    do {
+        auto getCb = [&](const hidl_vec<ProgramInfo>& list) {
+            // don't copy the whole list out, it might be heavy
+            firstProgram = list[0];
+        };
+        if (getProgramList(getCb)) foundAny = true;
+    } while (nextBand());
+    if (HasFailure()) return;
+    if (!foundAny) {
+        printSkipped("Program list is empty.");
+        return;
+    }
 
     ProgramSelector selCb;
-    EXPECT_CALL(*mCallback, tuneComplete(_, _));
+    EXPECT_CALL(*mCallback, tuneComplete(_, _)).Times(0);
     EXPECT_TIMEOUT_CALL(*mCallback, tuneComplete_1_1, Result::OK, _)
         .WillOnce(DoAll(SaveArg<1>(&selCb), testing::Return(ByMove(Void()))));
     auto tuneResult = mTuner->tune_1_1(firstProgram.selector);
@@ -304,7 +348,7 @@
 
 TEST_P(BroadcastRadioHalTest, CancelAnnouncement) {
     if (skipped) return;
-    ASSERT_TRUE(openTuner(0));
+    ASSERT_TRUE(openTuner());
 
     auto hidlResult = mTuner->cancelAnnouncement();
     EXPECT_EQ(Result::OK, hidlResult);
@@ -336,23 +380,24 @@
  */
 TEST_P(BroadcastRadioHalTest, OobImagesOnly) {
     if (skipped) return;
-    ASSERT_TRUE(openTuner(0));
+    ASSERT_TRUE(openTuner());
 
     std::vector<int> imageIds;
 
-    ProgramInfo firstProgram;
-    auto getCb = [&](const hidl_vec<ProgramInfo>& list) {
-        for (auto&& program : list) {
-            for (auto&& entry : program.base.metadata) {
-                EXPECT_NE(MetadataType::RAW, entry.type);
-                if (entry.key != MetadataKey::ICON && entry.key != MetadataKey::ART) continue;
-                EXPECT_NE(0, entry.intValue);
-                EXPECT_EQ(0u, entry.rawValue.size());
-                if (entry.intValue != 0) imageIds.push_back(entry.intValue);
+    do {
+        auto getCb = [&](const hidl_vec<ProgramInfo>& list) {
+            for (auto&& program : list) {
+                for (auto&& entry : program.base.metadata) {
+                    EXPECT_NE(MetadataType::RAW, entry.type);
+                    if (entry.key != MetadataKey::ICON && entry.key != MetadataKey::ART) continue;
+                    EXPECT_NE(0, entry.intValue);
+                    EXPECT_EQ(0u, entry.rawValue.size());
+                    if (entry.intValue != 0) imageIds.push_back(entry.intValue);
+                }
             }
-        }
-    };
-    if (!getProgramList(getCb)) return;
+        };
+        getProgramList(getCb);
+    } while (nextBand());
 
     if (imageIds.size() == 0) {
         printSkipped("No images found");
diff --git a/broadcastradio/1.1/vts/functional/call-barrier.cpp b/broadcastradio/1.1/vts/functional/call-barrier.cpp
deleted file mode 100644
index fede297..0000000
--- a/broadcastradio/1.1/vts/functional/call-barrier.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (C) 2017 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 "call-barrier.h"
-
-namespace android {
-namespace hardware {
-namespace broadcastradio {
-namespace vts {
-
-using std::lock_guard;
-using std::mutex;
-using std::unique_lock;
-
-void CallBarrier::call() {
-    lock_guard<mutex> lk(mMut);
-    mWasCalled = true;
-    mCond.notify_all();
-}
-
-bool CallBarrier::waitForCall(std::chrono::milliseconds timeout) {
-    unique_lock<mutex> lk(mMut);
-
-    if (mWasCalled) return true;
-
-    auto status = mCond.wait_for(lk, timeout);
-    return status == std::cv_status::no_timeout;
-}
-
-}  // namespace vts
-}  // namespace broadcastradio
-}  // namespace hardware
-}  // namespace android
diff --git a/broadcastradio/1.1/vts/functional/call-barrier.h b/broadcastradio/1.1/vts/functional/call-barrier.h
deleted file mode 100644
index 462396a..0000000
--- a/broadcastradio/1.1/vts/functional/call-barrier.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (C) 2017 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.
- */
-#ifndef ANDROID_HARDWARE_BROADCASTRADIO_V1_1_CALL_BARRIER
-#define ANDROID_HARDWARE_BROADCASTRADIO_V1_1_CALL_BARRIER
-
-#include <chrono>
-#include <thread>
-
-namespace android {
-namespace hardware {
-namespace broadcastradio {
-namespace vts {
-
-/**
- * A barrier for thread synchronization, where one should wait for another to
- * reach a specific point in execution.
- */
-class CallBarrier {
-   public:
-    /**
-     * Notify the other thread it may continue execution.
-     *
-     * This may be called before the other thread starts waiting on the barrier.
-     */
-    void call();
-
-    /**
-     * Wait for the other thread to reach call() execution point.
-     *
-     * @param timeout a maximum time to wait.
-     * @returns {@code false} if timed out, {@code true} otherwise.
-     */
-    bool waitForCall(std::chrono::milliseconds timeout);
-
-   private:
-    bool mWasCalled = false;
-    std::mutex mMut;
-    std::condition_variable mCond;
-};
-
-}  // namespace vts
-}  // namespace broadcastradio
-}  // namespace hardware
-}  // namespace android
-
-#endif  // ANDROID_HARDWARE_BROADCASTRADIO_V1_1_CALL_BARRIER
diff --git a/broadcastradio/1.1/vts/functional/mock-timeout.h b/broadcastradio/1.1/vts/functional/mock-timeout.h
deleted file mode 100644
index fa1114f..0000000
--- a/broadcastradio/1.1/vts/functional/mock-timeout.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (C) 2017 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.
- */
-#ifndef ANDROID_HARDWARE_BROADCASTRADIO_V1_1_MOCK_TIMEOUT
-#define ANDROID_HARDWARE_BROADCASTRADIO_V1_1_MOCK_TIMEOUT
-
-#include <gmock/gmock.h>
-#include <thread>
-
-/**
- * Common helper objects for gmock timeout extension.
- *
- * INTERNAL IMPLEMENTATION - don't use in user code.
- */
-#define EGMOCK_TIMEOUT_METHOD_DEF_(Method, ...) \
-    std::atomic<bool> egmock_called_##Method;   \
-    std::mutex egmock_mut_##Method;             \
-    std::condition_variable egmock_cond_##Method;
-
-/**
- * Common method body for gmock timeout extension.
- *
- * INTERNAL IMPLEMENTATION - don't use in user code.
- */
-#define EGMOCK_TIMEOUT_METHOD_BODY_(Method, ...)             \
-    auto ret = egmock_##Method(__VA_ARGS__);                 \
-    {                                                        \
-        std::lock_guard<std::mutex> lk(egmock_mut_##Method); \
-        egmock_called_##Method = true;                       \
-        egmock_cond_##Method.notify_all();                   \
-    }                                                        \
-    return ret;
-
-/**
- * Gmock MOCK_METHOD1 timeout-capable extension.
- */
-#define MOCK_TIMEOUT_METHOD1(Method, ...)                                                 \
-    MOCK_METHOD1(egmock_##Method, __VA_ARGS__);                                           \
-    EGMOCK_TIMEOUT_METHOD_DEF_(Method);                                                   \
-    virtual GMOCK_RESULT_(, __VA_ARGS__) Method(GMOCK_ARG_(, 1, __VA_ARGS__) egmock_a1) { \
-        EGMOCK_TIMEOUT_METHOD_BODY_(Method, egmock_a1);                                   \
-    }
-
-/**
- * Gmock MOCK_METHOD2 timeout-capable extension.
- */
-#define MOCK_TIMEOUT_METHOD2(Method, ...)                                                        \
-    MOCK_METHOD2(egmock_##Method, __VA_ARGS__);                                                  \
-    EGMOCK_TIMEOUT_METHOD_DEF_(Method);                                                          \
-    virtual GMOCK_RESULT_(, __VA_ARGS__)                                                         \
-        Method(GMOCK_ARG_(, 1, __VA_ARGS__) egmock_a1, GMOCK_ARG_(, 2, __VA_ARGS__) egmock_a2) { \
-        EGMOCK_TIMEOUT_METHOD_BODY_(Method, egmock_a1, egmock_a2);                               \
-    }
-
-/**
- * Gmock EXPECT_CALL timeout-capable extension.
- *
- * It has slightly different syntax from the original macro, to make method name accessible.
- * So, instead of typing
- *     EXPECT_CALL(account, charge(100, Currency::USD));
- * you need to inline arguments
- *     EXPECT_TIMEOUT_CALL(account, charge, 100, Currency::USD);
- */
-#define EXPECT_TIMEOUT_CALL(obj, Method, ...) \
-    (obj).egmock_called_##Method = false;     \
-    EXPECT_CALL(obj, egmock_##Method(__VA_ARGS__))
-
-/**
- * Waits for an earlier EXPECT_TIMEOUT_CALL to execute.
- *
- * It does not fully support special constraints of the EXPECT_CALL clause, just proceeds when the
- * first call to a given method comes. For example, in the following code:
- *     EXPECT_TIMEOUT_CALL(account, charge, 100, _);
- *     account.charge(50, Currency::USD);
- *     EXPECT_TIMEOUT_CALL_WAIT(account, charge, 500ms);
- * the wait clause will just continue, as the charge method was called.
- *
- * @param obj object for a call
- * @param Method the method to wait for
- * @param timeout the maximum time for waiting
- */
-#define EXPECT_TIMEOUT_CALL_WAIT(obj, Method, timeout)                      \
-    {                                                                       \
-        std::unique_lock<std::mutex> lk((obj).egmock_mut_##Method);         \
-        if (!(obj).egmock_called_##Method) {                                \
-            auto status = (obj).egmock_cond_##Method.wait_for(lk, timeout); \
-            EXPECT_EQ(std::cv_status::no_timeout, status);                  \
-        }                                                                   \
-    }
-
-#endif  // ANDROID_HARDWARE_BROADCASTRADIO_V1_1_MOCK_TIMEOUT