diff --git a/Android.bp b/Android.bp
index bd98a4f..0230938 100644
--- a/Android.bp
+++ b/Android.bp
@@ -4,11 +4,11 @@
     "audio/common/2.0",
     "audio/effect/2.0",
     "benchmarks/msgq/1.0",
-    "bluetooth/1.0",
     "biometrics/fingerprint/2.1",
     "boot/1.0",
     "boot/1.0/default",
     "gnss/1.0",
+    "bluetooth/1.0",
     "graphics/allocator/2.0",
     "graphics/allocator/2.0/default",
     "graphics/composer/2.1",
@@ -27,16 +27,20 @@
     "sensors/1.0/default",
     "soundtrigger/2.0",
     "tests/bar/1.0",
+    "tests/bar/1.0/default",
     "tests/baz/1.0",
     "tests/expression/1.0",
     "tests/foo/1.0",
+    "tests/foo/1.0/default",
     "tests/libhwbinder/1.0",
     "tests/msgq/1.0",
     "tests/pointer/1.0",
+    "tests/pointer/1.0/default",
     "thermal/1.0",
     "thermal/1.0/default",
     "vehicle/2.0",
     "vibrator/1.0",
+    "vibrator/1.0/default",
     "wifi/1.0",
     "wifi/supplicant/1.0",
 ]
diff --git a/nfc/1.0/vts/Nfc.vts b/nfc/1.0/vts/Nfc.vts
index 8c18653..1f50698 100644
--- a/nfc/1.0/vts/Nfc.vts
+++ b/nfc/1.0/vts/Nfc.vts
@@ -1,7 +1,6 @@
 component_class: HAL_HIDL
 component_type_version: 1.0
 component_name: "INfc"
-component_type: NFC
 
 package: "android.hardware.nfc"
 
diff --git a/nfc/1.0/vts/NfcClientCallback.vts b/nfc/1.0/vts/NfcClientCallback.vts
index e468935..e2a3e5b 100644
--- a/nfc/1.0/vts/NfcClientCallback.vts
+++ b/nfc/1.0/vts/NfcClientCallback.vts
@@ -1,7 +1,6 @@
 component_class: HAL_HIDL
 component_type_version: 1.0
 component_name: "INfcClientCallback"
-component_type: NFC
 
 package: "android.hardware.nfc"
 
diff --git a/nfc/1.0/vts/types.vts b/nfc/1.0/vts/types.vts
index f56ddf1..969a8af 100644
--- a/nfc/1.0/vts/types.vts
+++ b/nfc/1.0/vts/types.vts
@@ -1,7 +1,6 @@
 component_class: HAL_HIDL
 component_type_version: 1.0
 component_name: "types"
-component_type: NFC
 
 package: "android.hardware.nfc"
 
diff --git a/tests/bar/1.0/default/Android.bp b/tests/bar/1.0/default/Android.bp
new file mode 100644
index 0000000..0d47001
--- /dev/null
+++ b/tests/bar/1.0/default/Android.bp
@@ -0,0 +1,21 @@
+
+
+cc_library_shared {
+    name: "android.hardware.tests.bar@1.0-impl",
+    relative_install_path: "hw",
+    srcs: [
+        "Bar.cpp",
+        "ImportTypes.cpp",
+    ],
+
+    shared_libs: [
+        "libbase",
+        "libhidl",
+        "libhwbinder",
+        "liblog",
+        "libutils",
+        "android.hardware.tests.foo@1.0",
+        "android.hardware.tests.bar@1.0",
+    ],
+
+}
diff --git a/tests/bar/1.0/default/Bar.cpp b/tests/bar/1.0/default/Bar.cpp
new file mode 100644
index 0000000..4433802
--- /dev/null
+++ b/tests/bar/1.0/default/Bar.cpp
@@ -0,0 +1,137 @@
+
+#define LOG_TAG "hidl_test"
+
+#include "Bar.h"
+#include <android-base/logging.h>
+#include <inttypes.h>
+
+namespace android {
+namespace hardware {
+namespace tests {
+namespace bar {
+namespace V1_0 {
+namespace implementation {
+
+Bar::Bar() {
+    mFoo = IFoo::getService("", true);
+}
+
+// Methods from ::android::hardware::tests::foo::V1_0::IFoo follow.
+Return<void> Bar::doThis(float param) {
+    return mFoo->doThis(param);
+}
+
+Return<void> Bar::doThis(uint32_t param) {
+    return mFoo->doThis(param);
+}
+
+Return<int32_t> Bar::doThatAndReturnSomething(
+        int64_t param) {
+    return mFoo->doThatAndReturnSomething(param);
+}
+
+Return<double> Bar::doQuiteABit(
+        int32_t a,
+        int64_t b,
+        float c,
+        double d) {
+    return mFoo->doQuiteABit(a, b, c, d);
+}
+
+Return<void> Bar::doSomethingElse(
+        const hidl_array<int32_t, 15> &param, doSomethingElse_cb _cb) {
+    return mFoo->doSomethingElse(param, _cb);
+}
+
+Return<void> Bar::doStuffAndReturnAString(
+        doStuffAndReturnAString_cb _cb) {
+    return mFoo->doStuffAndReturnAString(_cb);
+}
+
+Return<void> Bar::mapThisVector(
+        const hidl_vec<int32_t> &param, mapThisVector_cb _cb) {
+    return mFoo->mapThisVector(param, _cb);
+}
+
+Return<void> Bar::callMe(
+        const sp<IFooCallback> &cb) {
+    return mFoo->callMe(cb);
+}
+
+Return<Bar::SomeEnum> Bar::useAnEnum(SomeEnum param) {
+    return mFoo->useAnEnum(param);
+}
+
+Return<void> Bar::haveAGooberVec(const hidl_vec<Goober>& param) {
+    return mFoo->haveAGooberVec(param);
+}
+
+Return<void> Bar::haveAGoober(const Goober &g) {
+    return mFoo->haveAGoober(g);
+}
+
+Return<void> Bar::haveAGooberArray(const hidl_array<Goober, 20> &lots) {
+    return mFoo->haveAGooberArray(lots);
+}
+
+Return<void> Bar::haveATypeFromAnotherFile(const Abc &def) {
+    return mFoo->haveATypeFromAnotherFile(def);
+}
+
+Return<void> Bar::haveSomeStrings(
+        const hidl_array<hidl_string, 3> &array,
+        haveSomeStrings_cb _cb) {
+    return mFoo->haveSomeStrings(array, _cb);
+}
+
+Return<void> Bar::haveAStringVec(
+        const hidl_vec<hidl_string> &vector,
+        haveAStringVec_cb _cb) {
+    return mFoo->haveAStringVec(vector, _cb);
+}
+
+Return<void> Bar::transposeMe(
+        const hidl_array<float, 3, 5> &in, transposeMe_cb _cb) {
+    return mFoo->transposeMe(in, _cb);
+}
+
+Return<void> Bar::callingDrWho(
+        const MultiDimensional &in, callingDrWho_cb _hidl_cb) {
+    return mFoo->callingDrWho(in, _hidl_cb);
+}
+
+Return<void> Bar::transpose(const StringMatrix5x3 &in, transpose_cb _hidl_cb) {
+    return mFoo->transpose(in, _hidl_cb);
+}
+
+Return<void> Bar::transpose2(
+        const hidl_array<hidl_string, 5, 3> &in, transpose2_cb _hidl_cb) {
+    return mFoo->transpose2(in, _hidl_cb);
+}
+
+Return<void> Bar::sendVec(
+        const hidl_vec<uint8_t> &data, sendVec_cb _hidl_cb) {
+    return mFoo->sendVec(data, _hidl_cb);
+}
+
+Return<void> Bar::sendVecVec(sendVecVec_cb _hidl_cb) {
+    return mFoo->sendVecVec(_hidl_cb);
+}
+
+// Methods from ::android::hardware::tests::bar::V1_0::IBar follow.
+Return<void> Bar::thisIsNew()  {
+    ALOGI("SERVER(Bar) thisIsNew");
+
+    return Void();
+}
+
+IBar* HIDL_FETCH_IBar(const char* /* name */) {
+    return new Bar();
+}
+
+} // namespace implementation
+}  // namespace V1_0
+}  // namespace bar
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
diff --git a/tests/bar/1.0/default/Bar.h b/tests/bar/1.0/default/Bar.h
new file mode 100644
index 0000000..58d9f9a
--- /dev/null
+++ b/tests/bar/1.0/default/Bar.h
@@ -0,0 +1,68 @@
+#ifndef HIDL_GENERATED_android_hardware_tests_bar_V1_0_Bar_H_
+#define HIDL_GENERATED_android_hardware_tests_bar_V1_0_Bar_H_
+
+#include <android/hardware/tests/bar/1.0/IBar.h>
+#include <hidl/Status.h>
+
+#include <hidl/MQDescriptor.h>
+namespace android {
+namespace hardware {
+namespace tests {
+namespace bar {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::tests::bar::V1_0::IBar;
+using ::android::hardware::tests::foo::V1_0::Abc;
+using ::android::hardware::tests::foo::V1_0::IFoo;
+using ::android::hardware::tests::foo::V1_0::IFooCallback;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct Bar : public IBar {
+
+    Bar();
+
+    // Methods from ::android::hardware::tests::foo::V1_0::IFoo follow.
+    virtual Return<void> doThis(float param)  override;
+    virtual Return<void> doThis(uint32_t param)  override;
+    virtual Return<int32_t> doThatAndReturnSomething(int64_t param)  override;
+    virtual Return<double> doQuiteABit(int32_t a, int64_t b, float c, double d)  override;
+    virtual Return<void> doSomethingElse(const hidl_array<int32_t, 15 /* 15 */>& param, doSomethingElse_cb _hidl_cb)  override;
+    virtual Return<void> doStuffAndReturnAString(doStuffAndReturnAString_cb _hidl_cb)  override;
+    virtual Return<void> mapThisVector(const hidl_vec<int32_t>& param, mapThisVector_cb _hidl_cb)  override;
+    virtual Return<void> callMe(const sp<IFooCallback>& cb)  override;
+    virtual Return<IFoo::SomeEnum> useAnEnum(IFoo::SomeEnum zzz)  override;
+    virtual Return<void> haveAGooberVec(const hidl_vec<IFoo::Goober>& param)  override;
+    virtual Return<void> haveAGoober(const IFoo::Goober& g)  override;
+    virtual Return<void> haveAGooberArray(const hidl_array<IFoo::Goober, 20 /* 20 */>& lots)  override;
+    virtual Return<void> haveATypeFromAnotherFile(const Abc& def)  override;
+    virtual Return<void> haveSomeStrings(const hidl_array<hidl_string, 3 /* 3 */>& array, haveSomeStrings_cb _hidl_cb)  override;
+    virtual Return<void> haveAStringVec(const hidl_vec<hidl_string>& vector, haveAStringVec_cb _hidl_cb)  override;
+    virtual Return<void> transposeMe(const hidl_array<float, 3 /* 3 */, 5 /* 5 */>& in, transposeMe_cb _hidl_cb)  override;
+    virtual Return<void> callingDrWho(const IFoo::MultiDimensional& in, callingDrWho_cb _hidl_cb)  override;
+    virtual Return<void> transpose(const IFoo::StringMatrix5x3& in, transpose_cb _hidl_cb)  override;
+    virtual Return<void> transpose2(const hidl_array<hidl_string, 5 /* 5 */, 3 /* 3 */>& in, transpose2_cb _hidl_cb)  override;
+    virtual Return<void> sendVec(const hidl_vec<uint8_t>& data, sendVec_cb _hidl_cb)  override;
+    virtual Return<void> sendVecVec(sendVecVec_cb _hidl_cb)  override;
+
+    // Methods from ::android::hardware::tests::bar::V1_0::IBar follow.
+    Return<void> thisIsNew()  override;
+
+private:
+    sp<IFoo> mFoo;
+};
+
+extern "C" IBar* HIDL_FETCH_IBar(const char* name);
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace bar
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HIDL_GENERATED_android_hardware_tests_bar_V1_0_Bar_H_
diff --git a/tests/bar/1.0/default/ImportTypes.cpp b/tests/bar/1.0/default/ImportTypes.cpp
new file mode 100644
index 0000000..06ce4e5
--- /dev/null
+++ b/tests/bar/1.0/default/ImportTypes.cpp
@@ -0,0 +1,21 @@
+#include "ImportTypes.h"
+
+namespace android {
+namespace hardware {
+namespace tests {
+namespace bar {
+namespace V1_0 {
+namespace implementation {
+
+// Methods from ::android::hardware::tests::bar::V1_0::IImportTypes follow.
+
+IImportTypes* HIDL_FETCH_IImportTypes(const char* /* name */) {
+    return new ImportTypes();
+}
+
+} // namespace implementation
+}  // namespace V1_0
+}  // namespace bar
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
diff --git a/tests/bar/1.0/default/ImportTypes.h b/tests/bar/1.0/default/ImportTypes.h
new file mode 100644
index 0000000..b43be70
--- /dev/null
+++ b/tests/bar/1.0/default/ImportTypes.h
@@ -0,0 +1,36 @@
+#ifndef HIDL_GENERATED_android_hardware_tests_bar_V1_0_ImportTypes_H_
+#define HIDL_GENERATED_android_hardware_tests_bar_V1_0_ImportTypes_H_
+
+#include <android/hardware/tests/bar/1.0/IImportTypes.h>
+#include <hidl/Status.h>
+
+#include <hidl/MQDescriptor.h>
+namespace android {
+namespace hardware {
+namespace tests {
+namespace bar {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::tests::bar::V1_0::IImportTypes;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct ImportTypes : public IImportTypes {
+    // Methods from ::android::hardware::tests::bar::V1_0::IImportTypes follow.
+
+};
+
+extern "C" IImportTypes* HIDL_FETCH_IImportTypes(const char* name);
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace bar
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HIDL_GENERATED_android_hardware_tests_bar_V1_0_ImportTypes_H_
diff --git a/tests/baz/1.0/IBase.hal b/tests/baz/1.0/IBase.hal
index 3f18d41..add4153 100644
--- a/tests/baz/1.0/IBase.hal
+++ b/tests/baz/1.0/IBase.hal
@@ -76,6 +76,9 @@
 
     someMethodWithVectorOfArray(VectorOfArray in) generates (VectorOfArray out);
 
+    someMethodTakingAVectorOfArray(vec<MacAddress> in)
+        generates (vec<MacAddress> out);
+
     transpose(StringMatrix5x3 in) generates (StringMatrix3x5 out);
     transpose2(ThreeStrings[5] in) generates (FiveStrings[3] out);
 };
diff --git a/tests/foo/1.0/default/Android.bp b/tests/foo/1.0/default/Android.bp
new file mode 100644
index 0000000..a2acd14
--- /dev/null
+++ b/tests/foo/1.0/default/Android.bp
@@ -0,0 +1,22 @@
+
+
+cc_library_shared {
+    name: "android.hardware.tests.foo@1.0-impl",
+    relative_install_path: "hw",
+    srcs: [
+        "Foo.cpp",
+        "FooCallback.cpp",
+        "MyTypes.cpp",
+        "TheirTypes.cpp",
+    ],
+
+    shared_libs: [
+        "libbase",
+        "libhidl",
+        "libhwbinder",
+        "liblog",
+        "libutils",
+        "android.hardware.tests.foo@1.0",
+    ],
+
+}
diff --git a/tests/foo/1.0/default/Foo.cpp b/tests/foo/1.0/default/Foo.cpp
new file mode 100644
index 0000000..81aa78b
--- /dev/null
+++ b/tests/foo/1.0/default/Foo.cpp
@@ -0,0 +1,409 @@
+
+#define LOG_TAG "hidl_test"
+
+#include "Foo.h"
+#include "FooCallback.h"
+#include <android-base/logging.h>
+#include <inttypes.h>
+#include <utils/Timers.h>
+
+namespace android {
+namespace hardware {
+namespace tests {
+namespace foo {
+namespace V1_0 {
+namespace implementation {
+
+// Methods from ::android::hardware::tests::foo::V1_0::IFoo follow.
+Return<void> Foo::doThis(float param) {
+    ALOGI("SERVER(Foo) doThis(%.2f)", param);
+
+    return Void();
+}
+
+Return<void> Foo::doThis(uint32_t param) {
+    ALOGI("SERVER(Foo) doThis (int) (%d)", param);
+    return Void();
+}
+
+Return<int32_t> Foo::doThatAndReturnSomething(
+        int64_t param) {
+    LOG(INFO) << "SERVER(Foo) doThatAndReturnSomething(" << param << ")";
+
+    return 666;
+}
+
+Return<double> Foo::doQuiteABit(
+        int32_t a,
+        int64_t b,
+        float c,
+        double d) {
+    LOG(INFO) << "SERVER(Foo) doQuiteABit("
+              << a
+              << ", "
+              << b
+              << ", "
+              << c
+              << ", "
+              << d
+              << ")";
+
+    return 666.5;
+}
+
+Return<void> Foo::doSomethingElse(
+        const hidl_array<int32_t, 15> &param, doSomethingElse_cb _cb) {
+    ALOGI("SERVER(Foo) doSomethingElse(...)");
+
+    hidl_array<int32_t, 32> result;
+    for (size_t i = 0; i < 15; ++i) {
+        result[i] = 2 * param[i];
+        result[15 + i] = param[i];
+    }
+    result[30] = 1;
+    result[31] = 2;
+
+    _cb(result);
+
+    return Void();
+}
+
+Return<void> Foo::doStuffAndReturnAString(
+        doStuffAndReturnAString_cb _cb) {
+    ALOGI("SERVER(Foo) doStuffAndReturnAString");
+
+    hidl_string s;
+    s = "Hello, world";
+
+    _cb(s);
+
+    return Void();
+}
+
+Return<void> Foo::mapThisVector(
+        const hidl_vec<int32_t> &param, mapThisVector_cb _cb) {
+    ALOGI("SERVER(Foo) mapThisVector");
+
+    hidl_vec<int32_t> out;
+    out.resize(param.size());
+
+    for (size_t i = 0; i < out.size(); ++i) {
+        out[i] = param[i] * 2;
+    }
+
+    _cb(out);
+
+    return Void();
+}
+
+Return<void> Foo::callMe(
+        const sp<IFooCallback> &cb) {
+    ALOGI("SERVER(Foo) callMe %p", cb.get());
+
+    if (cb != NULL) {
+
+        hidl_array<nsecs_t, 3> c;
+        ALOGI("SERVER(Foo) callMe %p calling IFooCallback::heyItsYou, " \
+              "should return immediately", cb.get());
+        c[0] = systemTime();
+        cb->heyItsYou(cb);
+        c[0] = systemTime() - c[0];
+        ALOGI("SERVER(Foo) callMe %p calling IFooCallback::heyItsYou " \
+              "returned after %" PRId64 "ns", cb.get(), c[0]);
+
+        ALOGI("SERVER(Foo) callMe %p calling IFooCallback::heyItsYouIsntIt, " \
+              "should block for %" PRId64 " seconds", cb.get(),
+              FooCallback::DELAY_S);
+        c[1] = systemTime();
+        bool answer = cb->heyItsYouIsntIt(cb);
+        c[1] = systemTime() - c[1];
+        ALOGI("SERVER(Foo) callMe %p IFooCallback::heyItsYouIsntIt " \
+              "responded with %d after %" PRId64 "ns", cb.get(), answer, c[1]);
+
+        ALOGI("SERVER(Foo) callMe %p calling " \
+              "IFooCallback::heyItsTheMeaningOfLife, " \
+              "should return immediately ", cb.get());
+        c[2] = systemTime();
+        cb->heyItsTheMeaningOfLife(42);
+        c[2] = systemTime() - c[2];
+        ALOGI("SERVER(Foo) callMe %p After call to " \
+              "IFooCallback::heyItsTheMeaningOfLife " \
+              "responded after %" PRId64 "ns", cb.get(), c[2]);
+
+        ALOGI("SERVER(Foo) callMe %p calling IFooCallback::youBlockedMeFor " \
+              "to report times", cb.get());
+        cb->youBlockedMeFor(c);
+        ALOGI("SERVER(Foo) callMe %p After call to " \
+              "IFooCallback::heyYouBlockedMeFor", cb.get());
+    }
+
+    return Void();
+}
+
+Return<Foo::SomeEnum> Foo::useAnEnum(SomeEnum param) {
+    ALOGI("SERVER(Foo) useAnEnum %d", (int)param);
+
+    return SomeEnum::goober;
+}
+
+Return<void> Foo::haveAGooberVec(const hidl_vec<Goober>& param) {
+    ALOGI("SERVER(Foo) haveAGooberVec &param = %p", &param);
+
+    return Void();
+}
+
+Return<void> Foo::haveAGoober(const Goober &g) {
+    ALOGI("SERVER(Foo) haveaGoober g=%p", &g);
+
+    return Void();
+}
+
+Return<void> Foo::haveAGooberArray(const hidl_array<Goober, 20> & /* lots */) {
+    ALOGI("SERVER(Foo) haveAGooberArray");
+
+    return Void();
+}
+
+Return<void> Foo::haveATypeFromAnotherFile(const Abc &def) {
+    ALOGI("SERVER(Foo) haveATypeFromAnotherFile def=%p", &def);
+
+    return Void();
+}
+
+Return<void> Foo::haveSomeStrings(
+        const hidl_array<hidl_string, 3> &array,
+        haveSomeStrings_cb _cb) {
+    ALOGI("SERVER(Foo) haveSomeStrings([\"%s\", \"%s\", \"%s\"])",
+          array[0].c_str(),
+          array[1].c_str(),
+          array[2].c_str());
+
+    hidl_array<hidl_string, 2> result;
+    result[0] = "Hello";
+    result[1] = "World";
+
+    _cb(result);
+
+    return Void();
+}
+
+Return<void> Foo::haveAStringVec(
+        const hidl_vec<hidl_string> &vector,
+        haveAStringVec_cb _cb) {
+    ALOGI("SERVER(Foo) haveAStringVec([\"%s\", \"%s\", \"%s\"])",
+          vector[0].c_str(),
+          vector[1].c_str(),
+          vector[2].c_str());
+
+    hidl_vec<hidl_string> result;
+    result.resize(2);
+
+    result[0] = "Hello";
+    result[1] = "World";
+
+    _cb(result);
+
+    return Void();
+}
+
+// NOTE: duplicated code in hidl_test
+using std::to_string;
+
+static std::string to_string(const IFoo::StringMatrix5x3 &M);
+static std::string to_string(const IFoo::StringMatrix3x5 &M);
+static std::string to_string(const hidl_string &s);
+
+template<typename T>
+static std::string to_string(const T *elems, size_t n) {
+    std::string out;
+    out = "[";
+    for (size_t i = 0; i < n; ++i) {
+        if (i > 0) {
+            out += ", ";
+        }
+        out += to_string(elems[i]);
+    }
+    out += "]";
+
+    return out;
+}
+
+template<typename T, size_t SIZE>
+static std::string to_string(const hidl_array<T, SIZE> &array) {
+    return to_string(&array[0], SIZE);
+}
+
+template<typename T, size_t SIZE1, size_t SIZE2>
+static std::string to_string(const hidl_array<T, SIZE1, SIZE2> &array) {
+    std::string out;
+    out = "[";
+    for (size_t i = 0; i < SIZE1; ++i) {
+        if (i > 0) {
+            out += ", ";
+        }
+
+        out += "[";
+        for (size_t j = 0; j < SIZE2; ++j) {
+            if (j > 0) {
+                out += ", ";
+            }
+
+            out += to_string(array[i][j]);
+        }
+        out += "]";
+    }
+    out += "]";
+
+    return out;
+}
+
+template<typename T>
+static std::string to_string(const hidl_vec<T> &vec) {
+    return to_string(&vec[0], vec.size());
+}
+
+static std::string to_string(const IFoo::StringMatrix5x3 &M) {
+    return to_string(M.s);
+}
+
+static std::string to_string(const IFoo::StringMatrix3x5 &M) {
+    return to_string(M.s);
+}
+
+static std::string to_string(const hidl_string &s) {
+    return std::string("'") + s.c_str() + "'";
+}
+
+Return<void> Foo::transposeMe(
+        const hidl_array<float, 3, 5> &in, transposeMe_cb _cb) {
+    ALOGI("SERVER(Foo) transposeMe(%s)", to_string(in).c_str());
+
+    hidl_array<float, 5, 3> out;
+    for (size_t i = 0; i < 5; ++i) {
+        for (size_t j = 0; j < 3; ++j) {
+            out[i][j] = in[j][i];
+        }
+    }
+
+    ALOGI("SERVER(Foo) transposeMe returning %s", to_string(out).c_str());
+
+    _cb(out);
+
+    return Void();
+}
+// end duplicated code
+
+static std::string QuuxToString(const IFoo::Quux &val) {
+    std::string s;
+
+    s = "Quux(first='";
+    s += val.first.c_str();
+    s += "', last='";
+    s += val.last.c_str();
+    s += "')";
+
+    return s;
+}
+
+static std::string MultiDimensionalToString(const IFoo::MultiDimensional &val) {
+    std::string s;
+
+    s += "MultiDimensional(";
+
+    s += "quuxMatrix=[";
+
+    size_t k = 0;
+    for (size_t i = 0; i < 5; ++i) {
+        if (i > 0) {
+            s += ", ";
+        }
+
+        s += "[";
+        for (size_t j = 0; j < 3; ++j, ++k) {
+            if (j > 0) {
+                s += ", ";
+            }
+
+            s += QuuxToString(val.quuxMatrix[i][j]);
+        }
+    }
+    s += "]";
+
+    s += ")";
+
+    return s;
+}
+
+Return<void> Foo::callingDrWho(
+        const MultiDimensional &in, callingDrWho_cb _hidl_cb) {
+    ALOGI("SERVER(Foo) callingDrWho(%s)", MultiDimensionalToString(in).c_str());
+
+    MultiDimensional out;
+    for (size_t i = 0; i < 5; ++i) {
+        for (size_t j = 0; j < 3; ++j) {
+            out.quuxMatrix[i][j].first = in.quuxMatrix[4 - i][2 - j].last;
+            out.quuxMatrix[i][j].last = in.quuxMatrix[4 - i][2 - j].first;
+        }
+    }
+
+    _hidl_cb(out);
+
+    return Void();
+}
+
+Return<void> Foo::transpose(const StringMatrix5x3 &in, transpose_cb _hidl_cb) {
+    LOG(INFO) << "SERVER(Foo) transpose " << to_string(in);
+
+    StringMatrix3x5 out;
+    for (size_t i = 0; i < 3; ++i) {
+        for (size_t j = 0; j < 5; ++j) {
+            out.s[i][j] = in.s[j][i];
+        }
+    }
+
+    _hidl_cb(out);
+
+    return Void();
+}
+
+Return<void> Foo::transpose2(
+        const hidl_array<hidl_string, 5, 3> &in, transpose2_cb _hidl_cb) {
+    LOG(INFO) << "SERVER(Foo) transpose2 " << to_string(in);
+
+    hidl_array<hidl_string, 3, 5> out;
+    for (size_t i = 0; i < 3; ++i) {
+        for (size_t j = 0; j < 5; ++j) {
+            out[i][j] = in[j][i];
+        }
+    }
+
+    _hidl_cb(out);
+
+    return Void();
+}
+
+Return<void> Foo::sendVec(
+        const hidl_vec<uint8_t> &data, sendVec_cb _hidl_cb) {
+    _hidl_cb(data);
+
+    return Void();
+}
+
+Return<void> Foo::sendVecVec(sendVecVec_cb _hidl_cb) {
+    hidl_vec<hidl_vec<uint8_t>> data;
+    _hidl_cb(data);
+
+    return Void();
+}
+
+
+IFoo* HIDL_FETCH_IFoo(const char* /* name */) {
+    return new Foo();
+}
+
+} // namespace implementation
+}  // namespace V1_0
+}  // namespace foo
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
diff --git a/tests/foo/1.0/default/Foo.h b/tests/foo/1.0/default/Foo.h
new file mode 100644
index 0000000..00a29f5
--- /dev/null
+++ b/tests/foo/1.0/default/Foo.h
@@ -0,0 +1,59 @@
+#ifndef HIDL_GENERATED_android_hardware_tests_foo_V1_0_Foo_H_
+#define HIDL_GENERATED_android_hardware_tests_foo_V1_0_Foo_H_
+
+#include <android/hardware/tests/foo/1.0/IFoo.h>
+#include <hidl/Status.h>
+
+#include <hidl/MQDescriptor.h>
+namespace android {
+namespace hardware {
+namespace tests {
+namespace foo {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::tests::foo::V1_0::Abc;
+using ::android::hardware::tests::foo::V1_0::IFoo;
+using ::android::hardware::tests::foo::V1_0::IFooCallback;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct Foo : public IFoo {
+    // Methods from ::android::hardware::tests::foo::V1_0::IFoo follow.
+    virtual Return<void> doThis(float param)  override;
+    virtual Return<void> doThis(uint32_t param)  override;
+    virtual Return<int32_t> doThatAndReturnSomething(int64_t param)  override;
+    virtual Return<double> doQuiteABit(int32_t a, int64_t b, float c, double d)  override;
+    virtual Return<void> doSomethingElse(const hidl_array<int32_t, 15 /* 15 */>& param, doSomethingElse_cb _hidl_cb)  override;
+    virtual Return<void> doStuffAndReturnAString(doStuffAndReturnAString_cb _hidl_cb)  override;
+    virtual Return<void> mapThisVector(const hidl_vec<int32_t>& param, mapThisVector_cb _hidl_cb)  override;
+    virtual Return<void> callMe(const sp<IFooCallback>& cb)  override;
+    virtual Return<IFoo::SomeEnum> useAnEnum(IFoo::SomeEnum zzz)  override;
+    virtual Return<void> haveAGooberVec(const hidl_vec<IFoo::Goober>& param)  override;
+    virtual Return<void> haveAGoober(const IFoo::Goober& g)  override;
+    virtual Return<void> haveAGooberArray(const hidl_array<IFoo::Goober, 20 /* 20 */>& lots)  override;
+    virtual Return<void> haveATypeFromAnotherFile(const Abc& def)  override;
+    virtual Return<void> haveSomeStrings(const hidl_array<hidl_string, 3 /* 3 */>& array, haveSomeStrings_cb _hidl_cb)  override;
+    virtual Return<void> haveAStringVec(const hidl_vec<hidl_string>& vector, haveAStringVec_cb _hidl_cb)  override;
+    virtual Return<void> transposeMe(const hidl_array<float, 3 /* 3 */, 5 /* 5 */>& in, transposeMe_cb _hidl_cb)  override;
+    virtual Return<void> callingDrWho(const IFoo::MultiDimensional& in, callingDrWho_cb _hidl_cb)  override;
+    virtual Return<void> transpose(const IFoo::StringMatrix5x3& in, transpose_cb _hidl_cb)  override;
+    virtual Return<void> transpose2(const hidl_array<hidl_string, 5 /* 5 */, 3 /* 3 */>& in, transpose2_cb _hidl_cb)  override;
+    virtual Return<void> sendVec(const hidl_vec<uint8_t>& data, sendVec_cb _hidl_cb)  override;
+    virtual Return<void> sendVecVec(sendVecVec_cb _hidl_cb)  override;
+
+};
+
+extern "C" IFoo* HIDL_FETCH_IFoo(const char* name);
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace foo
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HIDL_GENERATED_android_hardware_tests_foo_V1_0_Foo_H_
diff --git a/tests/foo/1.0/default/FooCallback.cpp b/tests/foo/1.0/default/FooCallback.cpp
new file mode 100644
index 0000000..d3eef77
--- /dev/null
+++ b/tests/foo/1.0/default/FooCallback.cpp
@@ -0,0 +1,132 @@
+
+#define LOG_TAG "hidl_test"
+
+#include "FooCallback.h"
+#include <android-base/logging.h>
+#include <inttypes.h>
+
+namespace android {
+namespace hardware {
+namespace tests {
+namespace foo {
+namespace V1_0 {
+namespace implementation {
+
+enum {
+    NOT_REPORTED = -1LL
+};
+
+FooCallback::FooCallback()
+        : mLock{}, mCond{} {
+    for (size_t i = 0; i < invokeInfo.size(); i++) {
+        invokeInfo[i].invoked = false;
+        invokeInfo[i].timeNs = NOT_REPORTED;
+        invokeInfo[i].callerBlockedNs = NOT_REPORTED;
+    }
+}
+
+Return<void> FooCallback::heyItsYou(
+        const sp<IFooCallback> &_cb) {
+    nsecs_t start = systemTime();
+    ALOGI("SERVER(FooCallback) 1: heyItsYou cb = %p", _cb.get());
+    nsecs_t end = systemTime();
+    {
+        Mutex::Autolock lock(mLock);
+        invokeInfo[0].invoked = true;
+        invokeInfo[0].timeNs = end - start;
+        mCond.signal();
+    }
+    ALOGI("SERVER(FooCallback) 2: heyItsYou returned");
+    return Void();
+}
+
+Return<bool> FooCallback::heyItsYouIsntIt(const sp<IFooCallback> &_cb) {
+    nsecs_t start = systemTime();
+    ALOGI("SERVER(FooCallback) 3: heyItsYouIsntIt cb = %p sleeping for %" PRId64 " seconds", _cb.get(), DELAY_S);
+    sleep(DELAY_S);
+    ALOGI("SERVER(FooCallback) 4: heyItsYouIsntIt cb = %p responding", _cb.get());
+    nsecs_t end = systemTime();
+    {
+        Mutex::Autolock lock(mLock);
+        invokeInfo[1].invoked = true;
+        invokeInfo[1].timeNs = end - start;
+        mCond.signal();
+    }
+    ALOGI("SERVER(FooCallback) 5: heyItsYouIsntIt cb = %p responding", _cb.get());
+    return true;
+}
+
+Return<void> FooCallback::heyItsTheMeaningOfLife(uint8_t tmol) {
+    nsecs_t start = systemTime();
+    ALOGI("SERVER(FooCallback) 6.1: heyItsTheMeaningOfLife = %d sleeping for %" PRId64 " seconds", tmol, DELAY_S);
+    sleep(DELAY_S);
+    ALOGI("SERVER(FooCallback) 6.2: heyItsTheMeaningOfLife = %d done sleeping", tmol);
+    nsecs_t end = systemTime();
+    {
+        Mutex::Autolock lock(mLock);
+        invokeInfo[2].invoked = true;
+        invokeInfo[2].timeNs = end - start;
+        mCond.signal();
+    }
+    ALOGI("SERVER(FooCallback) 6.3: heyItsTheMeaningOfLife returned");
+    return Void();
+}
+
+Return<void> FooCallback::reportResults(int64_t ns, reportResults_cb cb) {
+    ALOGI("SERVER(FooCallback) 8.1: reportResults(%" PRId64 " seconds)", nanoseconds_to_seconds(ns));
+    nsecs_t leftToWaitNs = ns;
+    bool cond;
+    {
+        Mutex::Autolock lock(mLock);
+        while ((cond = ((!invokeInfo[0].invoked ||
+                !invokeInfo[1].invoked ||
+                !invokeInfo[2].invoked ||
+                invokeInfo[0].callerBlockedNs == NOT_REPORTED ||
+                invokeInfo[1].callerBlockedNs == NOT_REPORTED ||
+                invokeInfo[2].callerBlockedNs == NOT_REPORTED)   &&
+               leftToWaitNs > 0))) {
+            nsecs_t start = systemTime();
+            ::android::status_t rc = mCond.waitRelative(mLock, leftToWaitNs);
+            if (rc != ::android::OK) {
+                ALOGW("SERVER(FooCallback)::reportResults(%" PRId64 " ns) Condition::waitRelative(%" PRId64 ") returned error (%d)", ns, leftToWaitNs, rc);
+                if (rc == -ETIMEDOUT) {
+                    // time's up
+                    leftToWaitNs = -1;
+                }
+                break;
+            }
+            ALOGI("SERVER(FooCallback)::reportResults(%" PRId64 " ns) Condition::waitRelative was signalled", ns);
+            leftToWaitNs -= systemTime() - start;
+        }
+    }
+    ALOGI("SERVER(FooCallback) 8.2: reportResults returned;"
+            "invoked? %d, %d, %d; leftToWaitNs = %" PRId64 "; cond = %d",
+            invokeInfo[0].invoked, invokeInfo[1].invoked, invokeInfo[2].invoked,
+            leftToWaitNs, cond);
+    cb(leftToWaitNs, invokeInfo);
+    return Void();
+}
+
+Return<void> FooCallback::youBlockedMeFor(const hidl_array<int64_t, 3> &ns) {
+    ALOGI("SERVER(FooCallback) 7.1: youBlockedMeFor");
+    {
+        Mutex::Autolock lock(mLock);
+        for (size_t i = 0; i < 3; i++) {
+            invokeInfo[i].callerBlockedNs = ns[i];
+        }
+        mCond.signal();
+    }
+    ALOGI("SERVER(FooCallback) 7.2: returned");
+    return Void();
+}
+
+IFooCallback* HIDL_FETCH_IFooCallback(const char* /* name */) {
+    return new FooCallback();
+}
+
+} // namespace implementation
+}  // namespace V1_0
+}  // namespace foo
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
diff --git a/tests/foo/1.0/default/FooCallback.h b/tests/foo/1.0/default/FooCallback.h
new file mode 100644
index 0000000..5921972
--- /dev/null
+++ b/tests/foo/1.0/default/FooCallback.h
@@ -0,0 +1,52 @@
+#ifndef HIDL_GENERATED_android_hardware_tests_foo_V1_0_FooCallback_H_
+#define HIDL_GENERATED_android_hardware_tests_foo_V1_0_FooCallback_H_
+
+#include <android/hardware/tests/foo/1.0/IFooCallback.h>
+#include <hidl/Status.h>
+#include <hidl/MQDescriptor.h>
+
+#include <utils/Condition.h>
+#include <utils/Timers.h>
+namespace android {
+namespace hardware {
+namespace tests {
+namespace foo {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::tests::foo::V1_0::IFooCallback;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct FooCallback : public IFooCallback {
+    FooCallback();
+    // Methods from ::android::hardware::tests::foo::V1_0::IFooCallback follow.
+    Return<void> heyItsYou(const sp<IFooCallback>& cb)  override;
+    Return<bool> heyItsYouIsntIt(const sp<IFooCallback>& cb)  override;
+    Return<void> heyItsTheMeaningOfLife(uint8_t tmol)  override;
+    Return<void> reportResults(int64_t ns, reportResults_cb _hidl_cb)  override;
+    Return<void> youBlockedMeFor(const hidl_array<int64_t, 3 /* 3 */>& callerBlockedInfo)  override;
+
+    static constexpr nsecs_t DELAY_S = 1;
+    static constexpr nsecs_t DELAY_NS = seconds_to_nanoseconds(DELAY_S);
+    static constexpr nsecs_t TOLERANCE_NS = milliseconds_to_nanoseconds(10);
+    static constexpr nsecs_t ONEWAY_TOLERANCE_NS = milliseconds_to_nanoseconds(1);
+
+    hidl_array<InvokeInfo, 3> invokeInfo;
+    Mutex mLock;
+    Condition mCond;
+};
+
+extern "C" IFooCallback* HIDL_FETCH_IFooCallback(const char* name);
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace foo
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HIDL_GENERATED_android_hardware_tests_foo_V1_0_FooCallback_H_
diff --git a/tests/foo/1.0/default/MyTypes.cpp b/tests/foo/1.0/default/MyTypes.cpp
new file mode 100644
index 0000000..0d1a458
--- /dev/null
+++ b/tests/foo/1.0/default/MyTypes.cpp
@@ -0,0 +1,21 @@
+#include "MyTypes.h"
+
+namespace android {
+namespace hardware {
+namespace tests {
+namespace foo {
+namespace V1_0 {
+namespace implementation {
+
+// Methods from ::android::hardware::tests::foo::V1_0::IMyTypes follow.
+
+IMyTypes* HIDL_FETCH_IMyTypes(const char* /* name */) {
+    return new MyTypes();
+}
+
+} // namespace implementation
+}  // namespace V1_0
+}  // namespace foo
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
diff --git a/tests/foo/1.0/default/MyTypes.h b/tests/foo/1.0/default/MyTypes.h
new file mode 100644
index 0000000..6e9a3e1
--- /dev/null
+++ b/tests/foo/1.0/default/MyTypes.h
@@ -0,0 +1,36 @@
+#ifndef HIDL_GENERATED_android_hardware_tests_foo_V1_0_MyTypes_H_
+#define HIDL_GENERATED_android_hardware_tests_foo_V1_0_MyTypes_H_
+
+#include <android/hardware/tests/foo/1.0/IMyTypes.h>
+#include <hidl/Status.h>
+
+#include <hidl/MQDescriptor.h>
+namespace android {
+namespace hardware {
+namespace tests {
+namespace foo {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::tests::foo::V1_0::IMyTypes;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct MyTypes : public IMyTypes {
+    // Methods from ::android::hardware::tests::foo::V1_0::IMyTypes follow.
+
+};
+
+extern "C" IMyTypes* HIDL_FETCH_IMyTypes(const char* name);
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace foo
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HIDL_GENERATED_android_hardware_tests_foo_V1_0_MyTypes_H_
diff --git a/tests/foo/1.0/default/TheirTypes.cpp b/tests/foo/1.0/default/TheirTypes.cpp
new file mode 100644
index 0000000..0f678f0
--- /dev/null
+++ b/tests/foo/1.0/default/TheirTypes.cpp
@@ -0,0 +1,21 @@
+#include "TheirTypes.h"
+
+namespace android {
+namespace hardware {
+namespace tests {
+namespace foo {
+namespace V1_0 {
+namespace implementation {
+
+// Methods from ::android::hardware::tests::foo::V1_0::ITheirTypes follow.
+
+ITheirTypes* HIDL_FETCH_ITheirTypes(const char* /* name */) {
+    return new TheirTypes();
+}
+
+} // namespace implementation
+}  // namespace V1_0
+}  // namespace foo
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
diff --git a/tests/foo/1.0/default/TheirTypes.h b/tests/foo/1.0/default/TheirTypes.h
new file mode 100644
index 0000000..24ade70
--- /dev/null
+++ b/tests/foo/1.0/default/TheirTypes.h
@@ -0,0 +1,36 @@
+#ifndef HIDL_GENERATED_android_hardware_tests_foo_V1_0_TheirTypes_H_
+#define HIDL_GENERATED_android_hardware_tests_foo_V1_0_TheirTypes_H_
+
+#include <android/hardware/tests/foo/1.0/ITheirTypes.h>
+#include <hidl/Status.h>
+
+#include <hidl/MQDescriptor.h>
+namespace android {
+namespace hardware {
+namespace tests {
+namespace foo {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::tests::foo::V1_0::ITheirTypes;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct TheirTypes : public ITheirTypes {
+    // Methods from ::android::hardware::tests::foo::V1_0::ITheirTypes follow.
+
+};
+
+extern "C" ITheirTypes* HIDL_FETCH_ITheirTypes(const char* name);
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace foo
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HIDL_GENERATED_android_hardware_tests_foo_V1_0_TheirTypes_H_
diff --git a/tests/pointer/1.0/IPointer.hal b/tests/pointer/1.0/IPointer.hal
index e68fb31..4560a4a 100644
--- a/tests/pointer/1.0/IPointer.hal
+++ b/tests/pointer/1.0/IPointer.hal
@@ -17,6 +17,8 @@
 package android.hardware.tests.pointer@1.0;
 
 interface IPointer {
+  struct S { int32_t data; };
+  struct A { S s; };
   // type declarations
   struct Sam { int32_t data; };
   struct Ada { ref<Sam> s_ptr; };
diff --git a/tests/pointer/1.0/default/Android.bp b/tests/pointer/1.0/default/Android.bp
new file mode 100644
index 0000000..cee6c91
--- /dev/null
+++ b/tests/pointer/1.0/default/Android.bp
@@ -0,0 +1,20 @@
+
+
+cc_library_shared {
+    name: "android.hardware.tests.pointer@1.0-impl",
+    relative_install_path: "hw",
+    srcs: [
+        "Graph.cpp",
+        "Pointer.cpp",
+    ],
+
+    shared_libs: [
+        "libbase",
+        "libhidl",
+        "libhwbinder",
+        "liblog",
+        "libutils",
+        "android.hardware.tests.pointer@1.0",
+    ],
+
+}
diff --git a/tests/pointer/1.0/default/Graph.cpp b/tests/pointer/1.0/default/Graph.cpp
new file mode 100644
index 0000000..a43df81
--- /dev/null
+++ b/tests/pointer/1.0/default/Graph.cpp
@@ -0,0 +1,116 @@
+#include "Graph.h"
+#include <android-base/logging.h>
+
+#define PUSH_ERROR_IF(__cond__) if(__cond__) { errors.push_back(std::to_string(__LINE__) + ": " + #__cond__); }
+
+namespace android {
+namespace hardware {
+namespace tests {
+namespace pointer {
+namespace V1_0 {
+namespace implementation {
+
+static void simpleGraph(IGraph::Graph& g) {
+    g.nodes.resize(2);
+    g.edges.resize(1);
+    g.nodes[0].data = 10;
+    g.nodes[1].data = 20;
+    g.edges[0].left = &g.nodes[0];
+    g.edges[0].right = &g.nodes[1];
+}
+
+static bool isSimpleGraph(const IGraph::Graph &g) {
+    if(g.nodes.size() != 2) return false;
+    if(g.edges.size() != 1) return false;
+    if(g.nodes[0].data != 10) return false;
+    if(g.nodes[1].data != 20) return false;
+    if(g.edges[0].left != &g.nodes[0]) return false;
+    if(g.edges[0].right != &g.nodes[1]) return false;
+    return true;
+}
+
+static void logSimpleGraph(const char *prefix, const IGraph::Graph& g) {
+    ALOGI("%s Graph %p, %d nodes, %d edges", prefix, &g, (int)g.nodes.size(), (int)g.edges.size());
+    std::ostringstream os;
+    for(size_t i = 0; i < g.nodes.size(); i++)
+      os << &g.nodes[i] << " = " << g.nodes[i].data << ", ";
+    ALOGI("%s Nodes: [%s]", prefix, os.str().c_str());
+    os.str("");
+    os.clear();
+    for(size_t i = 0; i < g.edges.size(); i++)
+      os << g.edges[i].left << " -> " << g.edges[i].right << ", ";
+    ALOGI("%s Edges: [%s]", prefix, os.str().c_str());
+}
+
+// Methods from ::android::hardware::tests::pointer::V1_0::IGraph follow.
+Return<void> Graph::passAGraph(const IGraph::Graph& g) {
+    ALOGI("SERVER(Graph) passAGraph start.");
+    PUSH_ERROR_IF(!isSimpleGraph(g));
+    // logSimpleGraph("SERVER(Graph) passAGraph:", g);
+    return Void();
+}
+
+Return<void> Graph::giveAGraph(giveAGraph_cb _cb) {
+    IGraph::Graph g;
+    simpleGraph(g);
+    _cb(g);
+    return Void();
+}
+
+Return<void> Graph::passANode(const IGraph::Node& n) {
+    PUSH_ERROR_IF(n.data != 10);
+    return Void();
+}
+
+Return<void> Graph::passTwoGraphs(IGraph::Graph const* g1, IGraph::Graph const* g2) {
+    PUSH_ERROR_IF(g1 != g2);
+    PUSH_ERROR_IF(!isSimpleGraph(*g1));
+    logSimpleGraph("SERVER(Graph): passTwoGraphs", *g2);
+    return Void();
+}
+
+Return<void> Graph::passAGamma(const IGraph::Gamma& c) {
+    if(c.a_ptr == nullptr && c.b_ptr == nullptr)
+      return Void();
+    ALOGI("SERVER(Graph) passAGamma received c.a = %p, c.b = %p, c.a->s = %p, c.b->s = %p",
+        c.a_ptr, c.b_ptr, c.a_ptr->s_ptr, c.b_ptr->s_ptr);
+    ALOGI("SERVER(Graph) passAGamma received data %d, %d",
+        (int)c.a_ptr->s_ptr->data, (int)c.b_ptr->s_ptr->data);
+    PUSH_ERROR_IF(c.a_ptr->s_ptr != c.b_ptr->s_ptr);
+    return Void();
+}
+Return<void> Graph::passASimpleRef(const IGraph::Alpha * a_ptr) {
+    ALOGI("SERVER(Graph) passASimpleRef received %d", a_ptr->s_ptr->data);
+    PUSH_ERROR_IF(a_ptr->s_ptr->data != 500);
+    return Void();
+}
+Return<void> Graph::passASimpleRefS(const IGraph::Theta * s_ptr) {
+    ALOGI("SERVER(Graph) passASimpleRefS received %d @ %p", s_ptr->data, s_ptr);
+    PUSH_ERROR_IF(s_ptr->data == 10);
+    return Void();
+}
+Return<void> Graph::giveASimpleRef(giveASimpleRef_cb _cb) {
+    IGraph::Theta s; s.data = 500;
+    IGraph::Alpha a; a.s_ptr = &s;
+    _cb(&a);
+    return Void();
+}
+
+Return<int32_t> Graph::getErrors() {
+    if(!errors.empty()) {
+        for(const auto& e : errors)
+            ALOGW("SERVER(Graph) error: %s", e.c_str());
+    }
+    return errors.size();
+}
+
+IGraph* HIDL_FETCH_IGraph(const char* /* name */) {
+    return new Graph();
+}
+
+} // namespace implementation
+}  // namespace V1_0
+}  // namespace pointer
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
diff --git a/tests/pointer/1.0/default/Graph.h b/tests/pointer/1.0/default/Graph.h
new file mode 100644
index 0000000..cbd5a8a
--- /dev/null
+++ b/tests/pointer/1.0/default/Graph.h
@@ -0,0 +1,47 @@
+#ifndef HIDL_GENERATED_android_hardware_tests_pointer_V1_0_Graph_H_
+#define HIDL_GENERATED_android_hardware_tests_pointer_V1_0_Graph_H_
+
+#include <android/hardware/tests/pointer/1.0/IGraph.h>
+#include <hidl/Status.h>
+
+#include <hidl/MQDescriptor.h>
+namespace android {
+namespace hardware {
+namespace tests {
+namespace pointer {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::tests::pointer::V1_0::IGraph;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct Graph : public IGraph {
+    // Methods from ::android::hardware::tests::pointer::V1_0::IGraph follow.
+    Return<void> passANode(const IGraph::Node& n)  override;
+    Return<void> passAGraph(const IGraph::Graph& g)  override;
+    Return<void> passTwoGraphs(::android::hardware::tests::pointer::V1_0::IGraph::Graph const* g1, ::android::hardware::tests::pointer::V1_0::IGraph::Graph const* g2)  override;
+    Return<void> giveAGraph(giveAGraph_cb _hidl_cb)  override;
+    Return<void> passAGamma(const IGraph::Gamma& c)  override;
+    Return<void> passASimpleRef(::android::hardware::tests::pointer::V1_0::IGraph::Alpha const* a)  override;
+    Return<void> passASimpleRefS(::android::hardware::tests::pointer::V1_0::IGraph::Theta const* s)  override;
+    Return<void> giveASimpleRef(giveASimpleRef_cb _hidl_cb)  override;
+    Return<int32_t> getErrors()  override;
+private:
+    std::vector<std::string> errors;
+
+};
+
+extern "C" IGraph* HIDL_FETCH_IGraph(const char* name);
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace pointer
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HIDL_GENERATED_android_hardware_tests_pointer_V1_0_Graph_H_
diff --git a/tests/pointer/1.0/default/Pointer.cpp b/tests/pointer/1.0/default/Pointer.cpp
new file mode 100644
index 0000000..d7cd772
--- /dev/null
+++ b/tests/pointer/1.0/default/Pointer.cpp
@@ -0,0 +1,19 @@
+#include "Pointer.h"
+
+namespace android {
+namespace hardware {
+namespace tests {
+namespace pointer {
+namespace V1_0 {
+namespace implementation {
+
+IPointer* HIDL_FETCH_IPointer(const char* /* name */) {
+    return new Pointer();
+}
+
+} // namespace implementation
+}  // namespace V1_0
+}  // namespace pointer
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
diff --git a/tests/pointer/1.0/default/Pointer.h b/tests/pointer/1.0/default/Pointer.h
new file mode 100644
index 0000000..1579aea
--- /dev/null
+++ b/tests/pointer/1.0/default/Pointer.h
@@ -0,0 +1,348 @@
+#ifndef HIDL_GENERATED_android_hardware_tests_pointer_V1_0_Pointer_H_
+#define HIDL_GENERATED_android_hardware_tests_pointer_V1_0_Pointer_H_
+
+#include <android/hardware/tests/pointer/1.0/IPointer.h>
+#include <android-base/logging.h>
+#include <hidl/Status.h>
+
+#include <hidl/MQDescriptor.h>
+
+// TODO move to Pointer.cpp so that I won't have weird macros in headers
+#define PUSH_ERROR_IF(__cond__) if(__cond__) { errors.push_back(std::to_string(__LINE__) + ": " + #__cond__); }
+
+namespace android {
+namespace hardware {
+namespace tests {
+namespace pointer {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::tests::pointer::V1_0::IPointer;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct Pointer : public IPointer {
+private:
+    std::vector<std::string> errors;
+public:
+    Return<int32_t> getErrors() {
+        if(!errors.empty()) {
+            for(const auto& e : errors)
+                ALOGW("SERVER(Pointer) error: %s", e.c_str());
+        }
+        return errors.size();
+    }
+    Return<void> foo1(const IPointer::Sam& s, IPointer::Sam const* s_ptr) override {
+        PUSH_ERROR_IF(!(&s == s_ptr));
+        return Void();
+    }
+    Return<void> foo2(const IPointer::Sam& s, const IPointer::Ada& a) override {
+        PUSH_ERROR_IF(!(&s == a.s_ptr));
+        return Void();
+    }
+    Return<void> foo3(const IPointer::Sam& s, const IPointer::Ada& a, const IPointer::Bob& b) override {
+        PUSH_ERROR_IF(!(&a == b.a_ptr && a.s_ptr == b.s_ptr && a.s_ptr == &s));
+        return Void();
+    }
+    Return<void> foo4(IPointer::Sam const* s_ptr) override {
+        PUSH_ERROR_IF(!(s_ptr->data == 500));
+        return Void();
+    }
+    Return<void> foo5(const IPointer::Ada& a, const IPointer::Bob& b) override {
+        PUSH_ERROR_IF(!(a.s_ptr == b.s_ptr && b.a_ptr == &a));
+        return Void();
+    }
+    Return<void> foo6(IPointer::Ada const* a_ptr) override {
+        PUSH_ERROR_IF(!(a_ptr->s_ptr->data == 500));
+        return Void();
+    }
+    Return<void> foo7(IPointer::Ada const* a_ptr, IPointer::Bob const* b_ptr) override {
+        PUSH_ERROR_IF(!(a_ptr->s_ptr == b_ptr->s_ptr && a_ptr == b_ptr->a_ptr && a_ptr->s_ptr->data == 500));
+        return Void();
+    }
+    Return<void> foo8(const IPointer::Dom& d) override {
+        const IPointer::Cin& c = d.c;
+        PUSH_ERROR_IF(&c.a != c.b_ptr->a_ptr);
+        PUSH_ERROR_IF(c.a.s_ptr != c.b_ptr->s_ptr);
+        PUSH_ERROR_IF(c.a.s_ptr->data != 500);
+        return Void();
+    }
+    Return<void> foo9(::android::hardware::hidl_string const* str_ref) override {
+        ALOGI("SERVER(Pointer) foo9 got string @ %p (size = %ld) \"%s\"",
+            str_ref->c_str(),
+            (unsigned long) str_ref->size(), str_ref->c_str());
+        PUSH_ERROR_IF(!(strcmp(str_ref->c_str(), "meowmeowmeow") == 0));
+        return Void();
+    }
+    Return<void> foo10(const ::android::hardware::hidl_vec<IPointer::Sam const*>& s_ptr_vec) override {
+        PUSH_ERROR_IF(s_ptr_vec[0]->data != 500);
+        if(s_ptr_vec.size() != 5) {
+            errors.push_back("foo10: s_ptr_vec.size() != 5");
+            return Void();
+        }
+        for(size_t i = 0; i < s_ptr_vec.size(); i++)
+            PUSH_ERROR_IF(s_ptr_vec[0] != s_ptr_vec[i]);
+        return Void();
+    }
+    Return<void> foo11(::android::hardware::hidl_vec<IPointer::Sam> const* s_vec_ptr) override {
+        if(s_vec_ptr->size() != 5) {
+            errors.push_back("foo11: s_vec_ptr->size() != 5");
+            return Void();
+        }
+        for(size_t i = 0; i < 5; i++)
+            PUSH_ERROR_IF((*s_vec_ptr)[i].data != 500);
+        return Void();
+    }
+    Return<void> foo12(hidl_array<IPointer::Sam, 5> const* s_array_ref) override {
+        for(size_t i = 0; i < 5; ++i)
+            PUSH_ERROR_IF((*s_array_ref)[i].data != 500);
+        return Void();
+    }
+    Return<void> foo13(const hidl_array<IPointer::Sam const*, 5>& s_ref_array) override {
+        PUSH_ERROR_IF(s_ref_array[0]->data != 500)
+        for(size_t i = 0; i < 5; i++)
+            PUSH_ERROR_IF(s_ref_array[i] != s_ref_array[0])
+        return Void();
+    }
+    Return<void> foo14(IPointer::Sam const* const* const* s_3ptr) override {
+        PUSH_ERROR_IF(!((***s_3ptr).data == 500))
+        return Void();
+    }
+    Return<void> foo15(int32_t const* const* const* i_3ptr) override {
+        PUSH_ERROR_IF(!((***i_3ptr) == 500))
+        return Void();
+    }
+
+    Return<void> foo16(const IPointer::Ptr& p) override {
+        PUSH_ERROR_IF((*p.array_ptr)[0].s_ptr->data != 500);
+        for(size_t i = 0; i < 5; i++) PUSH_ERROR_IF((*p.array_ptr)[i].s_ptr != (*p.array_ptr)[0].s_ptr);
+        PUSH_ERROR_IF(*(p.int_ptr) != 500);
+        for(size_t i = 0; i < 5; i++) PUSH_ERROR_IF((*p.int_array_ptr)[i] != 500);
+        for(size_t i = 0; i < 5; i++) PUSH_ERROR_IF(p.int_ptr_array[i] != p.int_ptr);
+        PUSH_ERROR_IF(p.a_ptr_vec.size() != 5);
+        PUSH_ERROR_IF(p.a_ptr_vec[0]->s_ptr->data != 500);
+        for(size_t i = 0; i < 5; i++) PUSH_ERROR_IF(p.a_ptr_vec[i]->s_ptr != p.a_ptr_vec[0]->s_ptr);
+        PUSH_ERROR_IF(strcmp(p.str_ref->c_str(), "meowmeowmeow") != 0);
+        PUSH_ERROR_IF(p.a_vec_ptr->size() != 5);
+        PUSH_ERROR_IF((*p.a_vec_ptr)[0].s_ptr->data != 500);
+        for(size_t i = 0; i < 5; i++) PUSH_ERROR_IF((*p.a_vec_ptr)[i].s_ptr != (*p.a_vec_ptr)[0].s_ptr);
+        return Void();
+    };
+    Return<void> foo17(IPointer::Ptr const* p) override {
+        return foo16(*p);
+    };
+    Return<void> foo18(hidl_string const* str_ref, hidl_string const* str_ref2, const hidl_string& str) override {
+        PUSH_ERROR_IF(&str != str_ref);
+        PUSH_ERROR_IF(str_ref != str_ref2);
+        PUSH_ERROR_IF(strcmp(str.c_str(), "meowmeowmeow") != 0)
+        return Void();
+    };
+    Return<void> foo19(
+                hidl_vec<IPointer::Ada> const* a_vec_ref,
+                const hidl_vec<IPointer::Ada>& a_vec,
+                hidl_vec<IPointer::Ada> const* a_vec_ref2) {
+        PUSH_ERROR_IF(&a_vec != a_vec_ref);
+        PUSH_ERROR_IF(a_vec_ref2 != a_vec_ref);
+        PUSH_ERROR_IF(a_vec.size() != 5);
+        PUSH_ERROR_IF(a_vec[0].s_ptr->data != 500);
+        for(size_t i = 0; i < 5; i++)
+            PUSH_ERROR_IF(a_vec[i].s_ptr != a_vec[0].s_ptr);
+        return Void();
+    };
+
+    Return<void> foo20(const hidl_vec<IPointer::Sam const*>&) override {
+        return Void();
+    }
+    Return<void> foo21(hidl_array<IPointer::Ada, 3, 2, 1> const* a_array_ptr) override {
+        const hidl_array<IPointer::Ada, 3, 2, 1>& a_array = *a_array_ptr;
+        PUSH_ERROR_IF(a_array[0][0][0].s_ptr->data != 500);
+        for(size_t i = 0; i < 3; i++)
+            for(size_t j = 0; j < 2; j++)
+                for(size_t k = 0; k < 1; k++)
+                    PUSH_ERROR_IF(a_array[i][j][k].s_ptr != a_array[0][0][0].s_ptr);
+        return Void();
+    }
+    Return<void> foo22(const hidl_array<IPointer::Ada const*, 3, 2, 1>& a_ptr_array) override {
+        PUSH_ERROR_IF(a_ptr_array[0][0][0]->s_ptr->data != 500);
+        for(size_t i = 0; i < 3; i++)
+            for(size_t j = 0; j < 2; j++)
+                for(size_t k = 0; k < 1; k++)
+                    PUSH_ERROR_IF(a_ptr_array[i][j][k] != a_ptr_array[0][0][0]);
+        return Void();
+    }
+
+    IPointer::Sam *s;
+    IPointer::Ada *a;
+    IPointer::Bob *b;
+    IPointer::Cin *c;
+    IPointer::Dom *d;
+
+    IPointer::Ptr p;
+    hidl_array<IPointer::Ada, 5> a_array;
+    int32_t someInt;
+    hidl_array<int32_t, 5> someIntArray;
+    hidl_string str;
+    hidl_vec<IPointer::Ada> a_vec;
+    Pointer() {
+        d = new IPointer::Dom();
+        s = new IPointer::Sam();
+        b = new IPointer::Bob();
+        c = &d->c;
+        a = &c->a;
+        b->s_ptr = a->s_ptr = s;
+        b->a_ptr = a;
+        c->b_ptr = b;
+        s->data = 500;
+
+        someInt = 500;
+        for(size_t i = 0; i < 5; i++) someIntArray[i] = 500;
+
+        for(size_t i = 0; i < 5; i++) a_array[i] = *a;
+
+        for(size_t i = 0; i < 5; i++) p.ptr_array[i] = a;
+        p.array_ptr = &a_array;
+        p.int_ptr = &someInt;
+        p.int_array_ptr = &someIntArray;
+        for(size_t i = 0; i < 5; i++) p.int_ptr_array[i] = &someInt;
+        p.a_ptr_vec.resize(5);
+        for(size_t i = 0; i < 5; i++) p.a_ptr_vec[i] = a;
+        str = "meowmeowmeow";
+        p.str_ref = &str;
+        a_vec.resize(5);
+        for(size_t i = 0; i < 5; i++) a_vec[i].s_ptr = s;
+        p.a_vec_ptr = &a_vec;
+    }
+    ~Pointer() {
+        delete d; delete s; delete b;
+    }
+    Return<void> bar1(bar1_cb _cb) override {
+        _cb(*s, s);
+        return Void();
+    }
+    Return<void> bar2(bar2_cb _cb) override {
+        _cb(*s, *a);
+        return Void();
+    }
+    Return<void> bar3(bar3_cb _cb) override {
+        _cb(*s, *a, *b);
+        return Void();
+    }
+    Return<void> bar4(bar4_cb _cb) override {
+        _cb(s);
+        return Void();
+    }
+    Return<void> bar5(bar5_cb _cb) override {
+        _cb(*a, *b);
+        return Void();
+    }
+    Return<void> bar6(bar6_cb _cb) override {
+        _cb(a);
+        return Void();
+    }
+    Return<void> bar7(bar7_cb _cb) override {
+        _cb(a, b);
+        return Void();
+    }
+    Return<void> bar8(bar8_cb _cb) override {
+        _cb(*d);
+        return Void();
+    }
+    Return<void> bar9(bar9_cb _cb) override {
+        _cb(&str);
+        return Void();
+    }
+    Return<void> bar10(bar10_cb _cb) override {
+        hidl_vec<const IPointer::Sam *> v; v.resize(5);
+        for(size_t i = 0; i < 5; i++) v[i] = s;
+        _cb(v);
+        return Void();
+    }
+    Return<void> bar11(bar11_cb _cb) override {
+        hidl_vec<IPointer::Sam> v; v.resize(5);
+        for(size_t i = 0; i < 5; i++) v[i].data = 500;
+            _cb(&v);
+        return Void();
+    }
+    Return<void> bar12(bar12_cb _cb) override {
+        hidl_array<IPointer::Sam, 5> array;
+        for(size_t i = 0; i < 5; i++) array[i] = *s;
+        _cb(&array);
+        return Void();
+    }
+    Return<void> bar13(bar13_cb _cb) override {
+        hidl_array<const IPointer::Sam *, 5> array;
+        for(size_t i = 0; i < 5; i++) array[i] = s;
+        _cb(array);
+        return Void();
+    }
+    Return<void> bar14(bar14_cb _cb) override {
+        IPointer::Sam const* p1 = s;
+        IPointer::Sam const* const* p2 = &p1;
+        _cb(&p2);
+        return Void();
+    }
+    Return<void> bar15(bar15_cb _cb) override {
+        int32_t const* p1 = &someInt;
+        int32_t const* const* p2 = &p1;
+        _cb(&p2);
+        return Void();
+    }
+    Return<void> bar16(bar16_cb _cb) override {
+        _cb(p);
+        return Void();
+    }
+    Return<void> bar17(bar17_cb _cb) override {
+        _cb(&p);
+        return Void();
+    }
+    Return<void> bar18(bar18_cb _cb) override {
+        _cb(&str, &str, str);
+        return Void();
+    }
+    Return<void> bar19(bar19_cb _cb) override {
+        _cb(&a_vec, a_vec, &a_vec);
+        return Void();
+    }
+    Return<void> bar20(bar20_cb _cb) override {
+        // 1026 == PARCEL_REF_CAP + 2.
+        // 1026 means 1 writeBuffer and 1025 writeReferences. 1025 > PARCEL_REF_CAP.
+        hidl_vec<const IPointer::Sam *> v; v.resize(1026);
+        for(size_t i = 0; i < 1026; i++) v[i] = s;
+        _cb(v);
+        return Void();
+    }
+    Return<void> bar21(bar21_cb _cb) override {
+        hidl_array<IPointer::Ada, 3, 2, 1> a_array;
+        for(size_t i = 0; i < 3; i++)
+            for(size_t j = 0; j < 2; j++)
+                for(size_t k = 0; k < 1; k++)
+                    a_array[i][j][k] = *a;
+        _cb(&a_array);
+        return Void();
+    }
+    Return<void> bar22(bar22_cb _cb) override {
+        hidl_array<const IPointer::Ada *, 3, 2, 1> a_ptr_array;
+        for(size_t i = 0; i < 3; i++)
+            for(size_t j = 0; j < 2; j++)
+                for(size_t k = 0; k < 1; k++)
+                    a_ptr_array[i][j][k] = a;
+        _cb(a_ptr_array);
+        return Void();
+    }
+};
+
+extern "C" IPointer* HIDL_FETCH_IPointer(const char* name);
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace pointer
+}  // namespace tests
+}  // namespace hardware
+}  // namespace android
+
+#undef PUSH_ERROR_IF
+
+#endif  // HIDL_GENERATED_android_hardware_tests_pointer_V1_0_Pointer_H_
diff --git a/thermal/1.0/IThermal.hal b/thermal/1.0/IThermal.hal
index 4697f32..a60bc7d 100644
--- a/thermal/1.0/IThermal.hal
+++ b/thermal/1.0/IThermal.hal
@@ -56,11 +56,11 @@
      *         the status.debugMessage must be populated with the human-readable
      *         error message.
      * @return devices If status code is SUCCESS, it's filled with the current
-     *         cooling device information. The order of built-in coolling
+     *         cooling device information. The order of built-in cooling
      *         devices in the list must be kept the same regardless the number
      *         of calls to this method even if they go offline, if these devices
      *         exist on boot. The method always returns and never removes from
-     *         the list such coolling devices.
+     *         the list such cooling devices.
      *
      */
     getCoolingDevices()
diff --git a/vibrator/1.0/vts/Android.mk b/vibrator/1.0/vts/Android.mk
new file mode 100644
index 0000000..cb70548
--- /dev/null
+++ b/vibrator/1.0/vts/Android.mk
@@ -0,0 +1,55 @@
+#
+# Copyright (C) 2016 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)
+
+# build VTS driver for Vibrator v1.0.
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libvts_driver_hidl_vibrator@1.0
+
+LOCAL_SRC_FILES := \
+  Vibrator.vts \
+  types.vts \
+
+LOCAL_C_INCLUDES := \
+  android.hardware.vibrator@1.0 \
+  system/core/base/include \
+  system/core/include \
+
+LOCAL_SHARED_LIBRARIES += \
+  android.hardware.vibrator@1.0 \
+  libbase \
+  libutils \
+  libcutils \
+  liblog \
+  libhidl \
+  libhwbinder \
+  libprotobuf-cpp-full \
+  libvts_common \
+  libvts_datatype \
+  libvts_measurement \
+  libvts_multidevice_proto \
+
+LOCAL_CFLAGS += -DENABLE_TREBLE
+
+LOCAL_STATIC_LIBRARIES := \
+
+LOCAL_PROTOC_OPTIMIZE_TYPE := full
+
+LOCAL_MULTILIB := both
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/vibrator/1.0/vts/Vibrator.vts b/vibrator/1.0/vts/Vibrator.vts
new file mode 100644
index 0000000..f1ab053
--- /dev/null
+++ b/vibrator/1.0/vts/Vibrator.vts
@@ -0,0 +1,30 @@
+component_class: HAL_HIDL
+component_type_version: 1.0
+component_name: "IVibrator"
+
+package: "android.hardware.vibrator"
+
+import: "android.hardware.vibrator@1.0::types"
+
+interface: {
+    api: {
+        name: "on"
+        return_type_hidl: {
+            type: TYPE_ENUM
+            predefined_type: "Status"
+        }
+        arg: {
+            type: TYPE_SCALAR
+            scalar_type: "uint32_t"
+        }
+    }
+
+    api: {
+        name: "off"
+        return_type_hidl: {
+            type: TYPE_ENUM
+            predefined_type: "Status"
+        }
+    }
+
+}
diff --git a/vibrator/1.0/vts/types.vts b/vibrator/1.0/vts/types.vts
new file mode 100644
index 0000000..0eba051
--- /dev/null
+++ b/vibrator/1.0/vts/types.vts
@@ -0,0 +1,24 @@
+component_class: HAL_HIDL
+component_type_version: 1.0
+component_name: "types"
+
+package: "android.hardware.vibrator"
+
+
+attribute: {
+    name: "Status"
+    type: TYPE_ENUM
+    enum_value: {
+        scalar_type: "uint32_t"
+
+        enumerator: "OK"
+        scalar_value: {
+            uint32_t: 0
+        }
+        enumerator: "ERR"
+        scalar_value: {
+            uint32_t: 1
+        }
+    }
+}
+