diff --git a/transport/Android.mk b/transport/Android.mk
index 8012835..8060f3b 100644
--- a/transport/Android.mk
+++ b/transport/Android.mk
@@ -58,3 +58,5 @@
 include $(BUILD_STATIC_JAVA_LIBRARY)
 
 endif # TARGET_BUILD_PDK not true
+
+include $(LOCAL_PATH)/base/1.0/vts/functional/Android.mk
diff --git a/transport/HidlPassthroughSupport.cpp b/transport/HidlPassthroughSupport.cpp
index b79d21c..e5eb164 100644
--- a/transport/HidlPassthroughSupport.cpp
+++ b/transport/HidlPassthroughSupport.cpp
@@ -25,30 +25,52 @@
 namespace hardware {
 namespace details {
 
+static sp<IBase> tryWrap(const std::string& descriptor, sp<IBase> iface) {
+    auto func = getBsConstructorMap().get(descriptor, nullptr);
+    if (!func) {
+        func = gBsConstructorMap.get(descriptor, nullptr);
+    }
+    if (func) {
+        return func(static_cast<void*>(iface.get()));
+    }
+    return nullptr;
+}
+
 sp<IBase> wrapPassthroughInternal(sp<IBase> iface) {
     if (iface == nullptr || iface->isRemote()) {
         // doesn't know how to handle it.
         return iface;
     }
-    std::string myDescriptor = getDescriptor(iface.get());
-    if (myDescriptor.empty()) {
-        // interfaceDescriptor fails
+
+    // Consider the case when an AOSP interface is extended by partners.
+    // Then the partner's HAL interface library is loaded only in the vndk
+    // linker namespace, but not in the default linker namespace, where
+    // this code runs. As a result, BsConstructorMap in the latter does not
+    // have the entry for the descriptor name.
+    //
+    // Therefore, we try to wrap using the descript names of the parent
+    // types along the interface chain, instead of always using the descriptor
+    // name of the current interface.
+    sp<IBase> base;
+    auto ret = iface->interfaceChain([&](const auto& types) {
+        for (const std::string& descriptor : types) {
+            base = tryWrap(descriptor, iface);
+            if (base != nullptr) {
+                break;  // wrap is successful. no need to lookup further.
+            }
+        }
+    });
+
+    if (!ret.isOk()) {
         return nullptr;
     }
-    auto func = getBsConstructorMap().get(myDescriptor, nullptr);
-    if (!func) {
-        func = gBsConstructorMap.get(myDescriptor, nullptr);
-        if (!func) {
-            return nullptr;
-        }
-    }
 
-    sp<IBase> base = func(static_cast<void*>(iface.get()));
-
-    // To ensure this is an instance of IType, we would normally
-    // call castFrom, but gBsConstructorMap guarantees that its
-    // result is of the appropriate type (not necessaryly BsType,
-    // but definitely a child of IType).
+    // It is ensured that if this function is called with an instance of IType
+    // then the corresponding descriptor would be in the BsConstructorMap.
+    // This is because referencing IType implies that the interface library
+    // defining the type has already been loaded into the current linker
+    // namespace, and thus the library should have added an entry into the
+    // BsConstructorMap while executing the library's constructor.
     return base;
 }
 
diff --git a/transport/ServiceManagement.cpp b/transport/ServiceManagement.cpp
index ef86f99..4bdeb6e 100644
--- a/transport/ServiceManagement.cpp
+++ b/transport/ServiceManagement.cpp
@@ -485,8 +485,7 @@
         // that thread, it will block forever because we hung up the one and only
         // binder thread on a condition variable that can only be notified by an
         // incoming binder call.
-        if (ProcessState::self()->getMaxThreads() <= 1 &&
-                IPCThreadState::self()->isLooperThread()) {
+        if (IPCThreadState::self()->isOnlyBinderThread()) {
             LOG(WARNING) << "Can't efficiently wait for " << mInterfaceName << "/"
                          << mInstanceName << ", because we are called from "
                          << "the only binder thread in this process.";
diff --git a/transport/base/1.0/vts/functional/Android.bp b/transport/base/1.0/vts/functional/Android.bp
new file mode 100644
index 0000000..f0bd45c
--- /dev/null
+++ b/transport/base/1.0/vts/functional/Android.bp
@@ -0,0 +1,34 @@
+// 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.
+
+
+cc_test {
+    name: "vts_ibase_test",
+    srcs: [
+        "vts_ibase_test.cpp",
+    ],
+    cflags: [
+        "-Wall",
+        "-Werror",
+    ],
+    shared_libs: [
+        "libbase",
+        "libhidlbase",
+        "libhidltransport",
+        "libhwbinder",
+        "liblog",
+        "libutils",
+    ],
+}
+
diff --git a/transport/base/1.0/vts/functional/Android.mk b/transport/base/1.0/vts/functional/Android.mk
new file mode 100644
index 0000000..61c6e31
--- /dev/null
+++ b/transport/base/1.0/vts/functional/Android.mk
@@ -0,0 +1,22 @@
+#
+# 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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := VtsHalBaseV1_0TargetTest
+-include test/vts/tools/build/Android.host_config.mk
diff --git a/transport/base/1.0/vts/functional/AndroidTest.xml b/transport/base/1.0/vts/functional/AndroidTest.xml
new file mode 100644
index 0000000..f2d5b1d
--- /dev/null
+++ b/transport/base/1.0/vts/functional/AndroidTest.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<configuration description="Config for VTS VtsHalBaseV1_0TargetTest test cases">
+    <option name="config-descriptor:metadata" key="plan" value="vts-treble" />
+    <multi_target_preparer class="com.android.tradefed.targetprep.VtsPythonVirtualenvPreparer" />
+    <test class="com.android.tradefed.testtype.VtsMultiDeviceTest">
+        <option name="test-module-name" value="VtsHalBaseV1_0TargetTest"/>
+        <option name="binary-test-working-directory" value="_32bit::/data/nativetest/" />
+        <option name="binary-test-working-directory" value="_64bit::/data/nativetest64/" />
+        <option name="binary-test-source" value="_32bit::DATA/nativetest/vts_ibase_test/vts_ibase_test" />
+        <option name="binary-test-source" value="_64bit::DATA/nativetest64/vts_ibase_test/vts_ibase_test" />
+        <option name="binary-test-type" value="gtest"/>
+        <option name="test-timeout" value="5m"/>
+    </test>
+</configuration>
diff --git a/transport/base/1.0/vts/functional/vts_ibase_test.cpp b/transport/base/1.0/vts/functional/vts_ibase_test.cpp
new file mode 100644
index 0000000..6d66042
--- /dev/null
+++ b/transport/base/1.0/vts/functional/vts_ibase_test.cpp
@@ -0,0 +1,171 @@
+/*
+ * 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 <functional>
+#include <map>
+#include <string>
+
+#include <android/hidl/base/1.0/IBase.h>
+#include <android/hidl/manager/1.0/IServiceManager.h>
+#include <gtest/gtest.h>
+#include <hidl/HidlBinderSupport.h>
+#include <hidl/ServiceManagement.h>
+
+using android::hardware::hidl_array;
+using android::hardware::hidl_death_recipient;
+using android::hardware::hidl_handle;
+using android::hardware::hidl_string;
+using android::hardware::hidl_vec;
+using android::hardware::IBinder;
+using android::hardware::toBinder;
+using android::hidl::base::V1_0::IBase;
+using android::hidl::manager::V1_0::IServiceManager;
+using android::sp;
+using android::wp;
+
+template <typename T>
+static inline ::testing::AssertionResult isOk(const ::android::hardware::Return<T>& ret) {
+    return ret.isOk() ? (::testing::AssertionSuccess() << ret.description())
+                      : (::testing::AssertionFailure() << ret.description());
+}
+#define ASSERT_OK(__ret__) ASSERT_TRUE(isOk(__ret__))
+#define EXPECT_OK(__ret__) EXPECT_TRUE(isOk(__ret__))
+
+struct Hal {
+    sp<IBase> service;
+    std::string name;  // space separated list of android.hidl.foo@1.0::IFoo/instance-name
+};
+
+class VtsHalBaseV1_0TargetTest : public ::testing::Test {
+   public:
+    virtual void SetUp() override {
+        default_manager_ = ::android::hardware::defaultServiceManager();
+
+        ASSERT_NE(default_manager_, nullptr)
+            << "Failed to get default service manager." << std::endl;
+
+        ASSERT_OK(default_manager_->list([&](const auto& list) {
+            for (const auto& name : list) {
+                const std::string strName = name;
+                auto loc = strName.find_first_of('/');
+                if (loc == std::string::npos) {
+                    ADD_FAILURE() << "Invalid FQName: " << strName;
+                    continue;
+                }
+                const std::string fqName = strName.substr(0, loc);
+                const std::string instance = strName.substr(loc + 1);
+
+                sp<IBase> service = default_manager_->get(fqName, instance);
+                if (service == nullptr) {
+                    ADD_FAILURE() << "Null service for " << name << " " << fqName << " "
+                                  << instance;
+                    continue;
+                }
+
+                sp<IBinder> binder = toBinder(service);
+                if (binder == nullptr) {
+                    ADD_FAILURE() << "Null binder for " << name;
+                    continue;
+                }
+
+                auto iter = all_hals_.find(binder);
+                if (iter != all_hals_.end()) {
+                    // include all the names this is registered as for error messages
+                    iter->second.name += " " + strName;
+                } else {
+                    all_hals_.insert(iter, {binder, Hal{service, strName}});
+                }
+            }
+        }));
+
+        ASSERT_FALSE(all_hals_.empty());  // sanity
+    }
+
+    void EachHal(const std::function<void(const Hal&)>& check) {
+        for (auto iter = all_hals_.begin(); iter != all_hals_.end(); ++iter) {
+            check(iter->second);
+        }
+    }
+
+    // default service manager
+    sp<IServiceManager> default_manager_;
+
+    // map from underlying instance to actual instance
+    //
+    // this prevents calling the same service twice since the same service
+    // will get registered multiple times for its entire inheritance
+    // hierarchy (or perhaps as different instance names)
+    std::map<sp<IBinder>, Hal> all_hals_;
+};
+
+TEST_F(VtsHalBaseV1_0TargetTest, CanPing) {
+    EachHal(
+        [&](const Hal& base) { EXPECT_OK(base.service->ping()) << "Cannot ping " << base.name; });
+}
+
+TEST_F(VtsHalBaseV1_0TargetTest, InterfaceChain) {
+    EachHal([&](const Hal& base) {
+        EXPECT_OK(base.service->interfaceChain([&](const auto& interfaceChain) {
+            // must include IBase + subclasses
+            EXPECT_GT(interfaceChain.size(), 1u) << "Invalid instance name " << base.name;
+        })) << base.name;
+    });
+}
+
+TEST_F(VtsHalBaseV1_0TargetTest, Descriptor) {
+    EachHal([&](const Hal& base) {
+        EXPECT_OK(base.service->interfaceDescriptor([&](const auto& descriptor) {
+            // must include IBase + subclasses
+            EXPECT_GT(descriptor.size(), 0u) << base.name;
+            EXPECT_NE(IBase::descriptor, descriptor) << base.name;
+        })) << base.name;
+    });
+}
+
+TEST_F(VtsHalBaseV1_0TargetTest, Death) {
+    struct HidlDeathRecipient : hidl_death_recipient {
+        virtual void serviceDied(uint64_t /* cookie */, const wp<IBase>& /* who */){};
+    };
+    sp<hidl_death_recipient> recipient = new HidlDeathRecipient;
+
+    EachHal([&](const Hal& base) {
+        EXPECT_OK(base.service->linkToDeath(recipient, 0 /* cookie */))
+            << "Register death recipient " << base.name;
+        EXPECT_OK(base.service->unlinkToDeath(recipient)) << "Unlink death recipient " << base.name;
+    });
+}
+
+TEST_F(VtsHalBaseV1_0TargetTest, Debug) {
+    EachHal([&](const Hal& base) {
+        // normally one is passed, but this is tested by dumpstate
+        EXPECT_OK(base.service->debug(hidl_handle(), {}))
+            << "Handle empty debug handle " << base.name;
+    });
+}
+
+TEST_F(VtsHalBaseV1_0TargetTest, HashChain) {
+    EachHal([&](const Hal& base) {
+        EXPECT_OK(base.service->getHashChain([&](const auto& hashChain) {
+            // must include IBase + subclasses
+            EXPECT_NE(0u, hashChain.size()) << "Invalid hash chain " << base.name;
+        })) << base.name;
+    });
+}
+
+int main(int argc, char** argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}