diff --git a/include/hardware/ble_advertiser.h b/include/hardware/ble_advertiser.h
index 8abca00..02d553f 100644
--- a/include/hardware/ble_advertiser.h
+++ b/include/hardware/ble_advertiser.h
@@ -57,6 +57,9 @@
   /** Registers an advertiser with the stack */
   virtual void RegisterAdvertiser(IdStatusCallback) = 0;
 
+  using GetAddressCallback = base::Callback<void(uint8_t /* address_type*/, bt_bdaddr_t /*address*/)>;
+  virtual void GetOwnAddress(uint8_t advertiser_id, GetAddressCallback cb) = 0;
+
   /* Set the parameters as per spec, user manual specified values */
   virtual void SetParameters(uint8_t advertiser_id, AdvertiseParameters params,
                              ParametersCallback cb) = 0;
diff --git a/include/hardware/bt_gatt_client.h b/include/hardware/bt_gatt_client.h
index ec8dd16..33a6825 100644
--- a/include/hardware/bt_gatt_client.h
+++ b/include/hardware/bt_gatt_client.h
@@ -224,8 +224,13 @@
     bt_status_t (*search_service)(int conn_id, bt_uuid_t *filter_uuid );
 
     /** Read a characteristic on a remote device */
-    bt_status_t (*read_characteristic)( int conn_id, uint16_t handle,
-                    int auth_req );
+    bt_status_t (*read_characteristic)(int conn_id, uint16_t handle,
+                                       int auth_req);
+
+    /** Read a characteristic on a remote device */
+    bt_status_t (*read_using_characteristic_uuid)(
+        int conn_id, bt_uuid_t *uuid, uint16_t s_handle,
+        uint16_t e_handle, int auth_req);
 
     /** Write a remote characteristic */
     bt_status_t (*write_characteristic)(int conn_id, uint16_t handle,
diff --git a/modules/sensors/dynamic_sensor/ConnectionDetector.cpp b/modules/sensors/dynamic_sensor/ConnectionDetector.cpp
index 67a6f27..c51e912 100644
--- a/modules/sensors/dynamic_sensor/ConnectionDetector.cpp
+++ b/modules/sensors/dynamic_sensor/ConnectionDetector.cpp
@@ -105,30 +105,35 @@
 // FileConnectionDetector functions
 FileConnectionDetector::FileConnectionDetector (
         BaseDynamicSensorDaemon *d, const std::string &path, const std::string &regex)
-            : ConnectionDetector(d), Thread(false /*callCallJava*/), mPath(path), mRegex(regex) {
+            : ConnectionDetector(d), Thread(false /*callCallJava*/), mPath(path), mRegex(regex),
+              mLooper(new Looper(true /*allowNonCallback*/)), mInotifyFd(-1) {
+    if (mLooper == nullptr) {
+        return;
+    }
+
     mInotifyFd = ::inotify_init1(IN_NONBLOCK);
     if (mInotifyFd < 0) {
         ALOGE("Cannot init inotify");
         return;
     }
 
-    int wd = ::inotify_add_watch(mInotifyFd, path.c_str(), IN_CREATE | IN_DELETE | IN_MOVED_FROM);
-    if (wd < 0) {
+    int wd = ::inotify_add_watch(mInotifyFd, path.c_str(), IN_CREATE | IN_DELETE);
+    if (wd < 0 || !mLooper->addFd(mInotifyFd, POLL_IDENT, Looper::EVENT_INPUT, nullptr, nullptr)) {
         ::close(mInotifyFd);
         mInotifyFd = -1;
         ALOGE("Cannot setup watch on dir %s", path.c_str());
         return;
     }
 
-    mPollFd.fd = wd;
-    mPollFd.events = POLLIN;
-
+    // mLooper != null && mInotifyFd added to looper
     run("ddad_file");
 }
 
 FileConnectionDetector::~FileConnectionDetector() {
-    if (mInotifyFd) {
-        requestExitAndWait();
+    if (mInotifyFd > 0) {
+        requestExit();
+        mLooper->wake();
+        join();
         ::close(mInotifyFd);
     }
 }
@@ -153,63 +158,81 @@
     ::closedir(dirp);
 }
 
-bool FileConnectionDetector::threadLoop() {
-    struct {
-        struct inotify_event e;
-        uint8_t padding[NAME_MAX + 1];
-    } ev;
+void FileConnectionDetector::handleInotifyData(ssize_t len, const char *data) {
+    const char *dataEnd = data + len;
+    const struct inotify_event *ev;
 
-    processExistingFiles();
-
-    while (!Thread::exitPending()) {
-        int pollNum = ::poll(&mPollFd, 1, -1);
-        if (pollNum == -1) {
-           if (errno == EINTR)
-               continue;
-           ALOGE("inotify poll error: %s", ::strerror(errno));
+    // inotify adds paddings to guarantee the next read is aligned
+    for (; data < dataEnd; data += sizeof(struct inotify_event) + ev->len) {
+        ev = reinterpret_cast<const struct inotify_event*>(data);
+        if (ev->mask & IN_ISDIR) {
+            continue;
         }
 
-        if (pollNum > 0) {
-            if (! (mPollFd.revents & POLLIN)) {
-                continue;
+        const std::string name(ev->name);
+        if (matches(name)) {
+            if (ev->mask & IN_CREATE) {
+                mDaemon->onConnectionChange(getFullName(name), true /*connected*/);
             }
+            if (ev->mask & IN_DELETE) {
+                mDaemon->onConnectionChange(getFullName(name), false /*connected*/);
+            }
+        }
+    }
+}
 
-            /* Inotify events are available */
-            while (true) {
-                /* Read some events. */
-                ssize_t len = ::read(mInotifyFd, &ev, sizeof ev);
-                if (len == -1 && errno != EAGAIN) {
-                    ALOGE("read error: %s", ::strerror(errno));
-                    requestExit();
-                    break;
-                }
+bool FileConnectionDetector::readInotifyData() {
+    struct {
+        struct inotify_event ev;
+        char padding[NAME_MAX + 1];
+    } buffer;
 
-                /* If the nonblocking read() found no events to read, then
-                   it returns -1 with errno set to EAGAIN. In that case,
-                   we exit the loop. */
-                if (len <= 0) {
-                    break;
-                }
+    bool ret = true;
+    while (true) {
+        ssize_t len = ::read(mInotifyFd, &buffer, sizeof(buffer));
+        if (len == -1 && errno == EAGAIN) {
+            // no more data
+            break;
+        } else if (len > static_cast<ssize_t>(sizeof(struct inotify_event))) {
+            handleInotifyData(len, reinterpret_cast<char*>(&buffer));
+        } else if (len < 0) {
+            ALOGE("read error: %s", ::strerror(errno));
+            ret = false;
+            break;
+        } else {
+            // 0 <= len <= sizeof(struct inotify_event)
+            ALOGE("read return %zd, shorter than inotify_event size %zu",
+                  len, sizeof(struct inotify_event));
+            ret = false;
+            break;
+        }
+    }
+    return ret;
+}
 
-                if (ev.e.len && !(ev.e.mask & IN_ISDIR)) {
-                    const std::string name(ev.e.name);
-                    ALOGV("device %s state changed", name.c_str());
-                    if (matches(name)) {
-                        if (ev.e.mask & IN_CREATE) {
-                            mDaemon->onConnectionChange(getFullName(name), true /* connected*/);
-                        }
+bool FileConnectionDetector::threadLoop() {
+    Looper::setForThread(mLooper);
+    processExistingFiles();
+    while(!Thread::exitPending()) {
+        int ret = mLooper->pollOnce(-1);
 
-                        if (ev.e.mask & IN_DELETE || ev.e.mask & IN_MOVED_FROM) {
-                            mDaemon->onConnectionChange(getFullName(name), false /* connected*/);
-                        }
-                    }
-                }
+        if (ret != Looper::POLL_WAKE && ret != POLL_IDENT) {
+            ALOGE("Unexpected value %d from pollOnce, quit", ret);
+            requestExit();
+            break;
+        }
+
+        if (ret == POLL_IDENT) {
+            if (!readInotifyData()) {
+                requestExit();
             }
         }
     }
 
+    mLooper->removeFd(mInotifyFd);
     ALOGD("FileConnectionDetection thread exited");
     return false;
 }
+
 } // namespace SensorHalExt
 } // namespace android
diff --git a/modules/sensors/dynamic_sensor/ConnectionDetector.h b/modules/sensors/dynamic_sensor/ConnectionDetector.h
index 712d832..0ee1df2 100644
--- a/modules/sensors/dynamic_sensor/ConnectionDetector.h
+++ b/modules/sensors/dynamic_sensor/ConnectionDetector.h
@@ -19,6 +19,7 @@
 
 #include "BaseDynamicSensorDaemon.h"
 #include <utils/Thread.h>
+#include <utils/Looper.h>
 
 #include <regex>
 
@@ -62,17 +63,20 @@
             BaseDynamicSensorDaemon *d, const std::string &path, const std::string &regex);
     virtual ~FileConnectionDetector();
 private:
+    static constexpr int POLL_IDENT = 1;
     // implement virtual of Thread
     virtual bool threadLoop();
 
     bool matches(const std::string &name) const;
     void processExistingFiles() const;
+    void handleInotifyData(ssize_t len, const char *data);
+    bool readInotifyData();
     std::string getFullName(const std::string name) const;
 
     std::string mPath;
     std::regex mRegex;
+    sp<Looper> mLooper;
     int mInotifyFd;
-    struct pollfd mPollFd;
 };
 
 } // namespace SensorHalExt
diff --git a/modules/sensors/dynamic_sensor/HidRawSensorDevice.cpp b/modules/sensors/dynamic_sensor/HidRawSensorDevice.cpp
index 16e9060..8aa4cf9 100644
--- a/modules/sensors/dynamic_sensor/HidRawSensorDevice.cpp
+++ b/modules/sensors/dynamic_sensor/HidRawSensorDevice.cpp
@@ -37,7 +37,7 @@
 
 sp<HidRawSensorDevice> HidRawSensorDevice::create(const std::string &devName) {
     sp<HidRawSensorDevice> device(new HidRawSensorDevice(devName));
-    // remove +1 strong count added by constructor
+    // offset +1 strong count added by constructor
     device->decStrong(device.get());
 
     if (device->mValid) {
@@ -50,13 +50,15 @@
 HidRawSensorDevice::HidRawSensorDevice(const std::string &devName)
         : RefBase(), HidRawDevice(devName, sInterested),
           Thread(false /*canCallJava*/), mValid(false) {
-    if (!HidRawDevice::isValid()) {
-        return;
-    }
     // create HidRawSensor objects from digest
     // HidRawSensor object will take sp<HidRawSensorDevice> as parameter, so increment strong count
     // to prevent "this" being destructed.
     this->incStrong(this);
+
+    if (!HidRawDevice::isValid()) {
+        return;
+    }
+
     for (const auto &digest : mDigestVector) { // for each usage - vec<ReportPacket> pair
         uint32_t usage = static_cast<uint32_t>(digest.fullUsage);
         sp<HidRawSensor> s(new HidRawSensor(this, usage, digest.packets));
diff --git a/tests/camera2/Android.mk b/tests/camera2/Android.mk
deleted file mode 100644
index e4f9640..0000000
--- a/tests/camera2/Android.mk
+++ /dev/null
@@ -1,45 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= \
-	camera2_utils.cpp \
-	main.cpp \
-	CameraMetadataTests.cpp \
-	CameraModuleTests.cpp \
-	CameraStreamTests.cpp \
-	CameraFrameTests.cpp \
-	CameraBurstTests.cpp \
-	CameraMultiStreamTests.cpp\
-	ForkedTests.cpp \
-	TestForkerEventListener.cpp \
-	TestSettings.cpp \
-
-LOCAL_SHARED_LIBRARIES := \
-	liblog \
-	libutils \
-	libcutils \
-	libhardware \
-	libcamera_metadata \
-	libcameraservice \
-	libcamera_client \
-	libgui \
-	libsync \
-	libui \
-	libdl \
-	android.hardware.camera.device@3.2
-
-LOCAL_C_INCLUDES += \
-	system/media/camera/include \
-	system/media/private/camera/include \
-	frameworks/av/include/ \
-	frameworks/av/services/camera/libcameraservice \
-	frameworks/native/include \
-
-LOCAL_CFLAGS += -Wall -Wextra
-LOCAL_MODULE:= camera2_test
-LOCAL_MODULE_STEM_32 := camera2_test
-LOCAL_MODULE_STEM_64 := camera2_test64
-LOCAL_MULTILIB := both
-LOCAL_MODULE_TAGS := tests
-
-include $(BUILD_NATIVE_TEST)
diff --git a/tests/camera2/CameraBurstTests.cpp b/tests/camera2/CameraBurstTests.cpp
deleted file mode 100644
index 198c0c1..0000000
--- a/tests/camera2/CameraBurstTests.cpp
+++ /dev/null
@@ -1,731 +0,0 @@
-/*
- * Copyright (C) 2012 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 <gtest/gtest.h>
-#include <inttypes.h>
-
-#define LOG_TAG "CameraBurstTest"
-//#define LOG_NDEBUG 0
-#include <utils/Log.h>
-#include <utils/Timers.h>
-
-#include <cmath>
-
-#include "CameraStreamFixture.h"
-#include "TestExtensions.h"
-
-#define CAMERA_FRAME_TIMEOUT    1000000000LL //nsecs (1 secs)
-#define CAMERA_HEAP_COUNT       2 //HALBUG: 1 means registerBuffers fails
-#define CAMERA_BURST_DEBUGGING  0
-#define CAMERA_FRAME_BURST_COUNT 10
-
-/* constants for the exposure test */
-#define CAMERA_EXPOSURE_DOUBLE  2
-#define CAMERA_EXPOSURE_DOUBLING_THRESHOLD 1.0f
-#define CAMERA_EXPOSURE_DOUBLING_COUNT 4
-#define CAMERA_EXPOSURE_FORMAT CAMERA_STREAM_AUTO_CPU_FORMAT
-#define CAMERA_EXPOSURE_STARTING 100000 // 1/10ms, up to 51.2ms with 10 steps
-
-#define USEC 1000LL        // in ns
-#define MSEC 1000000LL     // in ns
-#define SEC  1000000000LL  // in ns
-
-#if CAMERA_BURST_DEBUGGING
-#define dout std::cout
-#else
-#define dout if (0) std::cout
-#endif
-
-#define WARN_UNLESS(condition) if(!(condition)) std::cerr << "Warning: "
-#define WARN_LE(exp, act) WARN_UNLESS((exp) <= (act))
-#define WARN_LT(exp, act) WARN_UNLESS((exp) < (act))
-#define WARN_GT(exp, act) WARN_UNLESS((exp) > (act))
-
-using namespace android;
-using namespace android::camera2;
-
-namespace android {
-namespace camera2 {
-namespace tests {
-
-static CameraStreamParams STREAM_PARAMETERS = {
-    /*mFormat*/     CAMERA_EXPOSURE_FORMAT,
-    /*mHeapCount*/  CAMERA_HEAP_COUNT
-};
-
-class CameraBurstTest
-    : public ::testing::Test,
-      public CameraStreamFixture {
-
-public:
-    CameraBurstTest() : CameraStreamFixture(STREAM_PARAMETERS) {
-        TEST_EXTENSION_FORKING_CONSTRUCTOR;
-
-        if (HasFatalFailure()) {
-            return;
-        }
-
-        CreateStream();
-    }
-
-    ~CameraBurstTest() {
-        TEST_EXTENSION_FORKING_DESTRUCTOR;
-
-        if (mDevice.get()) {
-            mDevice->waitUntilDrained();
-        }
-        DeleteStream();
-    }
-
-    virtual void SetUp() {
-        TEST_EXTENSION_FORKING_SET_UP;
-    }
-    virtual void TearDown() {
-        TEST_EXTENSION_FORKING_TEAR_DOWN;
-    }
-
-    /* this assumes the format is YUV420sp or flexible YUV */
-    long long TotalBrightness(const CpuConsumer::LockedBuffer& imgBuffer,
-                              int *underexposed,
-                              int *overexposed) const {
-
-        const uint8_t* buf = imgBuffer.data;
-        size_t stride = imgBuffer.stride;
-
-        /* iterate over the Y plane only */
-        long long acc = 0;
-
-        *underexposed = 0;
-        *overexposed = 0;
-
-        for (size_t y = 0; y < imgBuffer.height; ++y) {
-            for (size_t x = 0; x < imgBuffer.width; ++x) {
-                const uint8_t p = buf[y * stride + x];
-
-                if (p == 0) {
-                    if (underexposed) {
-                        ++*underexposed;
-                    }
-                    continue;
-                } else if (p == 255) {
-                    if (overexposed) {
-                        ++*overexposed;
-                    }
-                    continue;
-                }
-
-                acc += p;
-            }
-        }
-
-        return acc;
-    }
-
-    // Parses a comma-separated string list into a Vector
-    template<typename T>
-    void ParseList(const char *src, Vector<T> &list) {
-        std::istringstream s(src);
-        while (!s.eof()) {
-            char c = s.peek();
-            if (c == ',' || c == ' ') {
-                s.ignore(1, EOF);
-                continue;
-            }
-            T val;
-            s >> val;
-            list.push_back(val);
-        }
-    }
-
-};
-
-TEST_F(CameraBurstTest, ManualExposureControl) {
-
-    TEST_EXTENSION_FORKING_INIT;
-
-    // Range of valid exposure times, in nanoseconds
-    int64_t minExp, maxExp;
-    {
-        camera_metadata_ro_entry exposureTimeRange =
-            GetStaticEntry(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE);
-
-        ASSERT_EQ(2u, exposureTimeRange.count);
-        minExp = exposureTimeRange.data.i64[0];
-        maxExp = exposureTimeRange.data.i64[1];
-    }
-
-    dout << "Min exposure is " << minExp;
-    dout << " max exposure is " << maxExp << std::endl;
-
-    // Calculate some set of valid exposure times for each request
-    int64_t exposures[CAMERA_FRAME_BURST_COUNT];
-    exposures[0] = CAMERA_EXPOSURE_STARTING;
-    for (int i = 1; i < CAMERA_FRAME_BURST_COUNT; ++i) {
-        exposures[i] = exposures[i-1] * CAMERA_EXPOSURE_DOUBLE;
-    }
-    // Our calculated exposure times should be in [minExp, maxExp]
-    EXPECT_LE(minExp, exposures[0])
-        << "Minimum exposure range is too high, wanted at most "
-        << exposures[0] << "ns";
-    EXPECT_GE(maxExp, exposures[CAMERA_FRAME_BURST_COUNT-1])
-        << "Maximum exposure range is too low, wanted at least "
-        << exposures[CAMERA_FRAME_BURST_COUNT-1] << "ns";
-
-    // Create a preview request, turning off all 3A
-    CameraMetadata previewRequest;
-    ASSERT_EQ(OK, mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
-                                                &previewRequest));
-    {
-        Vector<int32_t> outputStreamIds;
-        outputStreamIds.push(mStreamId);
-        ASSERT_EQ(OK, previewRequest.update(ANDROID_REQUEST_OUTPUT_STREAMS,
-                                            outputStreamIds));
-
-        // Disable all 3A routines
-        uint8_t cmOff = static_cast<uint8_t>(ANDROID_CONTROL_MODE_OFF);
-        ASSERT_EQ(OK, previewRequest.update(ANDROID_CONTROL_MODE,
-                                            &cmOff, 1));
-
-        int requestId = 1;
-        ASSERT_EQ(OK, previewRequest.update(ANDROID_REQUEST_ID,
-                                            &requestId, 1));
-
-        if (CAMERA_BURST_DEBUGGING) {
-            int frameCount = 0;
-            ASSERT_EQ(OK, previewRequest.update(ANDROID_REQUEST_FRAME_COUNT,
-                                                &frameCount, 1));
-        }
-    }
-
-    if (CAMERA_BURST_DEBUGGING) {
-        previewRequest.dump(STDOUT_FILENO);
-    }
-
-    // Submit capture requests
-    for (int i = 0; i < CAMERA_FRAME_BURST_COUNT; ++i) {
-        CameraMetadata tmpRequest = previewRequest;
-        ASSERT_EQ(OK, tmpRequest.update(ANDROID_SENSOR_EXPOSURE_TIME,
-                                        &exposures[i], 1));
-        ALOGV("Submitting capture request %d with exposure %" PRId64, i,
-            exposures[i]);
-        dout << "Capture request " << i << " exposure is "
-             << (exposures[i]/1e6f) << std::endl;
-        ASSERT_EQ(OK, mDevice->capture(tmpRequest));
-    }
-
-    dout << "Buffer dimensions " << mWidth << "x" << mHeight << std::endl;
-
-    float brightnesses[CAMERA_FRAME_BURST_COUNT];
-    // Get each frame (metadata) and then the buffer. Calculate brightness.
-    for (int i = 0; i < CAMERA_FRAME_BURST_COUNT; ++i) {
-        ALOGV("Reading capture request %d with exposure %" PRId64, i, exposures[i]);
-        ASSERT_EQ(OK, mDevice->waitForNextFrame(CAMERA_FRAME_TIMEOUT));
-        ALOGV("Reading capture request-1 %d", i);
-        CaptureResult result;
-        ASSERT_EQ(OK, mDevice->getNextResult(&result));
-        ALOGV("Reading capture request-2 %d", i);
-
-        ASSERT_EQ(OK, mFrameListener->waitForFrame(CAMERA_FRAME_TIMEOUT));
-        ALOGV("We got the frame now");
-
-        CpuConsumer::LockedBuffer imgBuffer;
-        ASSERT_EQ(OK, mCpuConsumer->lockNextBuffer(&imgBuffer));
-
-        int underexposed, overexposed;
-        long long brightness = TotalBrightness(imgBuffer, &underexposed,
-                                               &overexposed);
-        float avgBrightness = brightness * 1.0f /
-                              (mWidth * mHeight - (underexposed + overexposed));
-        ALOGV("Total brightness for frame %d was %lld (underexposed %d, "
-              "overexposed %d), avg %f", i, brightness, underexposed,
-              overexposed, avgBrightness);
-        dout << "Average brightness (frame " << i << ") was " << avgBrightness
-             << " (underexposed " << underexposed << ", overexposed "
-             << overexposed << ")" << std::endl;
-
-        ASSERT_EQ(OK, mCpuConsumer->unlockBuffer(imgBuffer));
-
-        brightnesses[i] = avgBrightness;
-    }
-
-    // Calculate max consecutive frame exposure doubling
-    float prev = brightnesses[0];
-    int doubling_count = 1;
-    int max_doubling_count = 0;
-    for (int i = 1; i < CAMERA_FRAME_BURST_COUNT; ++i) {
-        if (fabs(brightnesses[i] - prev*CAMERA_EXPOSURE_DOUBLE)
-            <= CAMERA_EXPOSURE_DOUBLING_THRESHOLD) {
-            doubling_count++;
-        }
-        else {
-            max_doubling_count = std::max(max_doubling_count, doubling_count);
-            doubling_count = 1;
-        }
-        prev = brightnesses[i];
-    }
-
-    dout << "max doubling count: " << max_doubling_count << std::endl;
-
-    /**
-     * Make this check warning only, since the brightness calculation is not reliable
-     * and we have separate test to cover this case. Plus it is pretty subtle to make
-     * it right without complicating the test too much.
-     */
-    WARN_LE(CAMERA_EXPOSURE_DOUBLING_COUNT, max_doubling_count)
-            << "average brightness should double at least "
-            << CAMERA_EXPOSURE_DOUBLING_COUNT
-            << " times over each consecutive frame as the exposure is doubled"
-            << std::endl;
-}
-
-/**
- * This test varies exposure time, frame duration, and sensitivity for a
- * burst of captures. It picks values by default, but the selection can be
- * overridden with the environment variables
- *   CAMERA2_TEST_VARIABLE_BURST_EXPOSURE_TIMES
- *   CAMERA2_TEST_VARIABLE_BURST_FRAME_DURATIONS
- *   CAMERA2_TEST_VARIABLE_BURST_SENSITIVITIES
- * which must all be a list of comma-separated values, and each list must be
- * the same length.  In addition, if the environment variable
- *   CAMERA2_TEST_VARIABLE_BURST_DUMP_FRAMES
- * is set to 1, then the YUV buffers are dumped into files named
- *   "camera2_test_variable_burst_frame_NNN.yuv"
- *
- * For example:
- *   $ setenv CAMERA2_TEST_VARIABLE_BURST_EXPOSURE_TIMES 10000000,20000000
- *   $ setenv CAMERA2_TEST_VARIABLE_BURST_FRAME_DURATIONS 40000000,40000000
- *   $ setenv CAMERA2_TEST_VARIABLE_BURST_SENSITIVITIES 200,100
- *   $ setenv CAMERA2_TEST_VARIABLE_BURST_DUMP_FRAMES 1
- *   $ /data/nativetest/camera2_test/camera2_test --gtest_filter="*VariableBurst"
- */
-TEST_F(CameraBurstTest, VariableBurst) {
-
-    TEST_EXTENSION_FORKING_INIT;
-
-    // Bounds for checking frame duration is within range
-    const nsecs_t DURATION_UPPER_BOUND = 10 * MSEC;
-    const nsecs_t DURATION_LOWER_BOUND = 20 * MSEC;
-
-    // Threshold for considering two captures to have equivalent exposure value,
-    // as a ratio of the smaller EV to the larger EV.
-    const float   EV_MATCH_BOUND = 0.95;
-    // Bound for two captures with equivalent exp values to have the same
-    // measured brightness, in 0-255 luminance.
-    const float   BRIGHTNESS_MATCH_BOUND = 5;
-
-    // Environment variables to look for to override test settings
-    const char *expEnv         = "CAMERA2_TEST_VARIABLE_BURST_EXPOSURE_TIMES";
-    const char *durationEnv    = "CAMERA2_TEST_VARIABLE_BURST_FRAME_DURATIONS";
-    const char *sensitivityEnv = "CAMERA2_TEST_VARIABLE_BURST_SENSITIVITIES";
-    const char *dumpFrameEnv   = "CAMERA2_TEST_VARIABLE_BURST_DUMP_FRAMES";
-
-    // Range of valid exposure times, in nanoseconds
-    int64_t minExp = 0, maxExp = 0;
-    // List of valid sensor sensitivities
-    Vector<int32_t> sensitivities;
-    // Range of valid frame durations, in nanoseconds
-    int64_t minDuration = 0, maxDuration = 0;
-
-    {
-        camera_metadata_ro_entry exposureTimeRange =
-            GetStaticEntry(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE);
-
-        EXPECT_EQ(2u, exposureTimeRange.count) << "Bad exposure time range tag."
-                "Using default values";
-        if (exposureTimeRange.count == 2) {
-            minExp = exposureTimeRange.data.i64[0];
-            maxExp = exposureTimeRange.data.i64[1];
-        }
-
-        EXPECT_LT(0, minExp) << "Minimum exposure time is 0";
-        EXPECT_LT(0, maxExp) << "Maximum exposure time is 0";
-        EXPECT_LE(minExp, maxExp) << "Minimum exposure is greater than maximum";
-
-        if (minExp == 0) {
-            minExp = 1 * MSEC; // Fallback minimum exposure time
-        }
-
-        if (maxExp == 0) {
-            maxExp = 10 * SEC; // Fallback maximum exposure time
-        }
-    }
-
-    camera_metadata_ro_entry hardwareLevel =
-        GetStaticEntry(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL);
-    ASSERT_EQ(1u, hardwareLevel.count);
-    uint8_t level = hardwareLevel.data.u8[0];
-    ASSERT_GE(level, ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED);
-    ASSERT_LE(level, ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL);
-    if (level == ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED) {
-        const ::testing::TestInfo* const test_info =
-            ::testing::UnitTest::GetInstance()->current_test_info();
-        std::cerr << "Skipping test "
-                  << test_info->test_case_name() << "."
-                  << test_info->name()
-                  << " because HAL hardware supported level is limited "
-                  << std::endl;
-        return;
-    }
-
-    dout << "Stream size is " << mWidth << " x " << mHeight << std::endl;
-    dout << "Valid exposure range is: " <<
-            minExp << " - " << maxExp << " ns " << std::endl;
-
-    {
-        camera_metadata_ro_entry sensivityRange =
-            GetStaticEntry(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE);
-        EXPECT_EQ(2u, sensivityRange.count) << "No sensitivity range listed."
-                "Falling back to default set.";
-        int32_t minSensitivity = 100;
-        int32_t maxSensitivity = 800;
-        if (sensivityRange.count == 2) {
-            ASSERT_GT(sensivityRange.data.i32[0], 0);
-            ASSERT_GT(sensivityRange.data.i32[1], 0);
-            minSensitivity = sensivityRange.data.i32[0];
-            maxSensitivity = sensivityRange.data.i32[1];
-        }
-        int32_t count = (maxSensitivity - minSensitivity + 99) / 100;
-        sensitivities.push_back(minSensitivity);
-        for (int i = 1; i < count; i++) {
-            sensitivities.push_back(minSensitivity + i * 100);
-        }
-        sensitivities.push_back(maxSensitivity);
-    }
-
-    dout << "Available sensitivities: ";
-    for (size_t i = 0; i < sensitivities.size(); i++) {
-        dout << sensitivities[i] << " ";
-    }
-    dout << std::endl;
-
-    {
-        if (getDeviceVersion() < CAMERA_DEVICE_API_VERSION_3_2) {
-            camera_metadata_ro_entry availableProcessedSizes =
-                    GetStaticEntry(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
-
-            camera_metadata_ro_entry availableProcessedMinFrameDurations =
-                    GetStaticEntry(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS);
-
-            EXPECT_EQ(availableProcessedSizes.count,
-                    availableProcessedMinFrameDurations.count * 2) <<
-                    "The number of minimum frame durations doesn't match the number of "
-                    "available sizes. Using fallback values";
-
-            if (availableProcessedSizes.count ==
-                    availableProcessedMinFrameDurations.count * 2) {
-                bool gotSize = false;
-                for (size_t i = 0; i < availableProcessedSizes.count; i += 2) {
-                    if (availableProcessedSizes.data.i32[i] == mWidth &&
-                            availableProcessedSizes.data.i32[i+1] == mHeight) {
-                        gotSize = true;
-                        minDuration = availableProcessedMinFrameDurations.data.i64[i/2];
-                    }
-                }
-                EXPECT_TRUE(gotSize) << "Can't find stream size in list of "
-                        "available sizes: " << mWidth << ", " << mHeight;
-            }
-            if (minDuration == 0) {
-                minDuration = 1 * SEC / 30; // Fall back to 30 fps as minimum duration
-            }
-        } else {
-            minDuration = getMinFrameDurationFor(
-                    HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, mWidth, mHeight);
-        }
-        ASSERT_LT(0, minDuration);
-
-        camera_metadata_ro_entry maxFrameDuration =
-                GetStaticEntry(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION);
-
-        EXPECT_EQ(1u, maxFrameDuration.count) << "No valid maximum frame duration";
-
-        if (maxFrameDuration.count == 1) {
-            maxDuration = maxFrameDuration.data.i64[0];
-        }
-
-        EXPECT_GT(maxDuration, 0) << "Max duration is 0 or not given, using fallback";
-
-        if (maxDuration == 0) {
-            maxDuration = 10 * SEC; // Fall back to 10 seconds as max duration
-        }
-
-    }
-    dout << "Available frame duration range for configured stream size: "
-         << minDuration << " - " << maxDuration << " ns" << std::endl;
-
-    // Get environment variables if set
-    const char *expVal = getenv(expEnv);
-    const char *durationVal = getenv(durationEnv);
-    const char *sensitivityVal = getenv(sensitivityEnv);
-
-    bool gotExp = (expVal != NULL);
-    bool gotDuration = (durationVal != NULL);
-    bool gotSensitivity = (sensitivityVal != NULL);
-
-    // All or none must be provided if using override envs
-    ASSERT_TRUE( (gotDuration && gotExp && gotSensitivity) ||
-            (!gotDuration && !gotExp && !gotSensitivity) ) <<
-            "Incomplete set of environment variable overrides provided";
-
-    Vector<int64_t> expList, durationList;
-    Vector<int32_t> sensitivityList;
-    if (gotExp) {
-        ParseList(expVal, expList);
-        ParseList(durationVal, durationList);
-        ParseList(sensitivityVal, sensitivityList);
-
-        ASSERT_TRUE(
-            (expList.size() == durationList.size()) &&
-            (durationList.size() == sensitivityList.size())) <<
-                "Mismatched sizes in env lists, or parse error";
-
-        dout << "Using burst list from environment with " << expList.size() <<
-                " captures" << std::endl;
-    } else {
-        // Create a default set of controls based on the available ranges
-
-        int64_t e;
-        int64_t d;
-        int32_t s;
-
-        // Exposure ramp
-
-        e = minExp;
-        d = minDuration;
-        s = sensitivities[0];
-        while (e < maxExp) {
-            expList.push_back(e);
-            durationList.push_back(d);
-            sensitivityList.push_back(s);
-            e = e * 2;
-        }
-        e = maxExp;
-        expList.push_back(e);
-        durationList.push_back(d);
-        sensitivityList.push_back(s);
-
-        // Duration ramp
-
-        e = 30 * MSEC;
-        d = minDuration;
-        s = sensitivities[0];
-        while (d < maxDuration) {
-            // make sure exposure <= frame duration
-            expList.push_back(e > d ? d : e);
-            durationList.push_back(d);
-            sensitivityList.push_back(s);
-            d = d * 2;
-        }
-
-        // Sensitivity ramp
-
-        e = 30 * MSEC;
-        d = 30 * MSEC;
-        d = d > minDuration ? d : minDuration;
-        for (size_t i = 0; i < sensitivities.size(); i++) {
-            expList.push_back(e);
-            durationList.push_back(d);
-            sensitivityList.push_back(sensitivities[i]);
-        }
-
-        // Constant-EV ramp, duration == exposure
-
-        e = 30 * MSEC; // at ISO 100
-        for (size_t i = 0; i < sensitivities.size(); i++) {
-            int64_t e_adj = e * 100 / sensitivities[i];
-            expList.push_back(e_adj);
-            durationList.push_back(e_adj > minDuration ? e_adj : minDuration);
-            sensitivityList.push_back(sensitivities[i]);
-        }
-
-        dout << "Default burst sequence created with " << expList.size() <<
-                " entries" << std::endl;
-    }
-
-    // Validate the list, but warn only
-    for (size_t i = 0; i < expList.size(); i++) {
-        EXPECT_GE(maxExp, expList[i])
-                << "Capture " << i << " exposure too long: " << expList[i];
-        EXPECT_LE(minExp, expList[i])
-                << "Capture " << i << " exposure too short: " << expList[i];
-        EXPECT_GE(maxDuration, durationList[i])
-                << "Capture " << i << " duration too long: " << durationList[i];
-        EXPECT_LE(minDuration, durationList[i])
-                 << "Capture " << i << " duration too short: "  << durationList[i];
-        bool validSensitivity = false;
-        for (size_t j = 0; j < sensitivities.size(); j++) {
-            if (sensitivityList[i] == sensitivities[j]) {
-                validSensitivity = true;
-                break;
-            }
-        }
-        EXPECT_TRUE(validSensitivity)
-                << "Capture " << i << " sensitivity not in list: " << sensitivityList[i];
-    }
-
-    // Check if debug yuv dumps are requested
-
-    bool dumpFrames = false;
-    {
-        const char *frameDumpVal = getenv(dumpFrameEnv);
-        if (frameDumpVal != NULL) {
-            if (frameDumpVal[0] == '1') dumpFrames = true;
-        }
-    }
-
-    dout << "Dumping YUV frames " <<
-            (dumpFrames ? "enabled, not checking timing" : "disabled") << std::endl;
-
-    // Create a base preview request, turning off all 3A
-    CameraMetadata previewRequest;
-    ASSERT_EQ(OK, mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
-                                                &previewRequest));
-    {
-        Vector<int32_t> outputStreamIds;
-        outputStreamIds.push(mStreamId);
-        ASSERT_EQ(OK, previewRequest.update(ANDROID_REQUEST_OUTPUT_STREAMS,
-                                            outputStreamIds));
-
-        // Disable all 3A routines
-        uint8_t cmOff = static_cast<uint8_t>(ANDROID_CONTROL_MODE_OFF);
-        ASSERT_EQ(OK, previewRequest.update(ANDROID_CONTROL_MODE,
-                                            &cmOff, 1));
-
-        int requestId = 1;
-        ASSERT_EQ(OK, previewRequest.update(ANDROID_REQUEST_ID,
-                                            &requestId, 1));
-    }
-
-    // Submit capture requests
-
-    for (size_t i = 0; i < expList.size(); ++i) {
-        CameraMetadata tmpRequest = previewRequest;
-        ASSERT_EQ(OK, tmpRequest.update(ANDROID_SENSOR_EXPOSURE_TIME,
-                                        &expList[i], 1));
-        ASSERT_EQ(OK, tmpRequest.update(ANDROID_SENSOR_FRAME_DURATION,
-                                        &durationList[i], 1));
-        ASSERT_EQ(OK, tmpRequest.update(ANDROID_SENSOR_SENSITIVITY,
-                                        &sensitivityList[i], 1));
-        ALOGV("Submitting capture %zu with exposure %" PRId64 ", frame duration %" PRId64 ", sensitivity %d",
-                i, expList[i], durationList[i], sensitivityList[i]);
-        dout << "Capture request " << i <<
-                ": exposure is " << (expList[i]/1e6f) << " ms" <<
-                ", frame duration is " << (durationList[i]/1e6f) << " ms" <<
-                ", sensitivity is " << sensitivityList[i] <<
-                std::endl;
-        ASSERT_EQ(OK, mDevice->capture(tmpRequest));
-    }
-
-    Vector<float> brightnesses;
-    Vector<nsecs_t> captureTimes;
-    brightnesses.setCapacity(expList.size());
-    captureTimes.setCapacity(expList.size());
-
-    // Get each frame (metadata) and then the buffer. Calculate brightness.
-    for (size_t i = 0; i < expList.size(); ++i) {
-
-        ALOGV("Reading request %zu", i);
-        dout << "Waiting for capture " << i << ": " <<
-                " exposure " << (expList[i]/1e6f) << " ms," <<
-                " frame duration " << (durationList[i]/1e6f) << " ms," <<
-                " sensitivity " << sensitivityList[i] <<
-                std::endl;
-
-        // Set wait limit based on expected frame duration, or minimum timeout
-        int64_t waitLimit = CAMERA_FRAME_TIMEOUT;
-        if (expList[i] * 2 > waitLimit) waitLimit = expList[i] * 2;
-        if (durationList[i] * 2 > waitLimit) waitLimit = durationList[i] * 2;
-
-        ASSERT_EQ(OK, mDevice->waitForNextFrame(waitLimit));
-        ALOGV("Reading capture request-1 %zu", i);
-        CaptureResult result;
-        ASSERT_EQ(OK, mDevice->getNextResult(&result));
-        ALOGV("Reading capture request-2 %zu", i);
-
-        ASSERT_EQ(OK, mFrameListener->waitForFrame(CAMERA_FRAME_TIMEOUT));
-        ALOGV("We got the frame now");
-
-        captureTimes.push_back(systemTime());
-
-        CpuConsumer::LockedBuffer imgBuffer;
-        ASSERT_EQ(OK, mCpuConsumer->lockNextBuffer(&imgBuffer));
-
-        int underexposed, overexposed;
-        float avgBrightness = 0;
-        long long brightness = TotalBrightness(imgBuffer, &underexposed,
-                                               &overexposed);
-        int numValidPixels = mWidth * mHeight - (underexposed + overexposed);
-        if (numValidPixels != 0) {
-            avgBrightness = brightness * 1.0f / numValidPixels;
-        } else if (underexposed < overexposed) {
-            avgBrightness = 255;
-        }
-
-        ALOGV("Total brightness for frame %zu was %lld (underexposed %d, "
-              "overexposed %d), avg %f", i, brightness, underexposed,
-              overexposed, avgBrightness);
-        dout << "Average brightness (frame " << i << ") was " << avgBrightness
-             << " (underexposed " << underexposed << ", overexposed "
-             << overexposed << ")" << std::endl;
-        brightnesses.push_back(avgBrightness);
-
-        if (i != 0) {
-            float prevEv = static_cast<float>(expList[i - 1]) * sensitivityList[i - 1];
-            float currentEv = static_cast<float>(expList[i]) * sensitivityList[i];
-            float evRatio = (prevEv > currentEv) ? (currentEv / prevEv) :
-                    (prevEv / currentEv);
-            if ( evRatio > EV_MATCH_BOUND ) {
-                WARN_LT(fabs(brightnesses[i] - brightnesses[i - 1]),
-                        BRIGHTNESS_MATCH_BOUND) <<
-                        "Capture brightness different from previous, even though "
-                        "they have the same EV value. Ev now: " << currentEv <<
-                        ", previous: " << prevEv << ". Brightness now: " <<
-                        brightnesses[i] << ", previous: " << brightnesses[i-1] <<
-                        std::endl;
-            }
-            // Only check timing if not saving to disk, since that slows things
-            // down substantially
-            if (!dumpFrames) {
-                nsecs_t timeDelta = captureTimes[i] - captureTimes[i-1];
-                nsecs_t expectedDelta = expList[i] > durationList[i] ?
-                        expList[i] : durationList[i];
-                WARN_LT(timeDelta, expectedDelta + DURATION_UPPER_BOUND) <<
-                        "Capture took " << timeDelta << " ns to receive, but expected"
-                        " frame duration was " << expectedDelta << " ns." <<
-                        std::endl;
-                WARN_GT(timeDelta, expectedDelta - DURATION_LOWER_BOUND) <<
-                        "Capture took " << timeDelta << " ns to receive, but expected"
-                        " frame duration was " << expectedDelta << " ns." <<
-                        std::endl;
-                dout << "Time delta from previous frame: " << timeDelta / 1e6 <<
-                        " ms.  Expected " << expectedDelta / 1e6 << " ms" << std::endl;
-            }
-        }
-
-        if (dumpFrames) {
-            String8 dumpName =
-                    String8::format("/data/local/tmp/camera2_test_variable_burst_frame_%03zu.yuv", i);
-            dout << "  Writing YUV dump to " << dumpName << std::endl;
-            DumpYuvToFile(dumpName, imgBuffer);
-        }
-
-        ASSERT_EQ(OK, mCpuConsumer->unlockBuffer(imgBuffer));
-    }
-
-}
-
-}
-}
-}
diff --git a/tests/camera2/CameraFrameTests.cpp b/tests/camera2/CameraFrameTests.cpp
deleted file mode 100644
index 3c5abf7..0000000
--- a/tests/camera2/CameraFrameTests.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Copyright (C) 2012 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 <gtest/gtest.h>
-
-#define LOG_TAG "CameraFrameTest"
-//#define LOG_NDEBUG 0
-#include <utils/Log.h>
-
-#include "hardware/hardware.h"
-#include "hardware/camera2.h"
-
-#include <common/CameraDeviceBase.h>
-#include <utils/StrongPointer.h>
-#include <gui/CpuConsumer.h>
-#include <gui/Surface.h>
-
-#include <unistd.h>
-
-#include "CameraStreamFixture.h"
-#include "TestExtensions.h"
-
-#define CAMERA_FRAME_TIMEOUT    1000000000 //nsecs (1 secs)
-#define CAMERA_HEAP_COUNT       2 //HALBUG: 1 means registerBuffers fails
-#define CAMERA_FRAME_DEBUGGING  0
-
-using namespace android;
-using namespace android::camera2;
-
-namespace android {
-namespace camera2 {
-namespace tests {
-
-static CameraStreamParams STREAM_PARAMETERS = {
-    /*mFormat*/     CAMERA_STREAM_AUTO_CPU_FORMAT,
-    /*mHeapCount*/  CAMERA_HEAP_COUNT
-};
-
-class CameraFrameTest
-    : public ::testing::TestWithParam<int>,
-      public CameraStreamFixture {
-
-public:
-    CameraFrameTest() : CameraStreamFixture(STREAM_PARAMETERS) {
-        TEST_EXTENSION_FORKING_CONSTRUCTOR;
-
-        if (!HasFatalFailure()) {
-            CreateStream();
-        }
-    }
-
-    ~CameraFrameTest() {
-        TEST_EXTENSION_FORKING_DESTRUCTOR;
-
-        if (mDevice.get()) {
-            mDevice->waitUntilDrained();
-        }
-    }
-
-    virtual void SetUp() {
-        TEST_EXTENSION_FORKING_SET_UP;
-    }
-    virtual void TearDown() {
-        TEST_EXTENSION_FORKING_TEAR_DOWN;
-    }
-
-protected:
-
-};
-
-TEST_P(CameraFrameTest, GetFrame) {
-
-    TEST_EXTENSION_FORKING_INIT;
-
-    /* Submit a PREVIEW type request, then wait until we get the frame back */
-    CameraMetadata previewRequest;
-    ASSERT_EQ(OK, mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
-                                                &previewRequest));
-    {
-        Vector<int32_t> outputStreamIds;
-        outputStreamIds.push(mStreamId);
-        ASSERT_EQ(OK, previewRequest.update(ANDROID_REQUEST_OUTPUT_STREAMS,
-                                            outputStreamIds));
-        if (CAMERA_FRAME_DEBUGGING) {
-            int frameCount = 0;
-            ASSERT_EQ(OK, previewRequest.update(ANDROID_REQUEST_FRAME_COUNT,
-                                                &frameCount, 1));
-        }
-    }
-
-    if (CAMERA_FRAME_DEBUGGING) {
-        previewRequest.dump(STDOUT_FILENO);
-    }
-
-    for (int i = 0; i < GetParam(); ++i) {
-        ALOGV("Submitting capture request %d", i);
-        CameraMetadata tmpRequest = previewRequest;
-        ASSERT_EQ(OK, mDevice->capture(tmpRequest));
-    }
-
-    for (int i = 0; i < GetParam(); ++i) {
-        ALOGV("Reading capture request %d", i);
-        ASSERT_EQ(OK, mDevice->waitForNextFrame(CAMERA_FRAME_TIMEOUT));
-
-        CaptureResult result;
-        ASSERT_EQ(OK, mDevice->getNextResult(&result));
-
-        // wait for buffer to be available
-        ASSERT_EQ(OK, mFrameListener->waitForFrame(CAMERA_FRAME_TIMEOUT));
-        ALOGV("We got the frame now");
-
-        // mark buffer consumed so producer can re-dequeue it
-        CpuConsumer::LockedBuffer imgBuffer;
-        ASSERT_EQ(OK, mCpuConsumer->lockNextBuffer(&imgBuffer));
-        ASSERT_EQ(OK, mCpuConsumer->unlockBuffer(imgBuffer));
-    }
-
-}
-
-//FIXME: dont hardcode stream params, and also test multistream
-INSTANTIATE_TEST_CASE_P(FrameParameterCombinations, CameraFrameTest,
-    testing::Range(1, 10));
-
-
-}
-}
-}
diff --git a/tests/camera2/CameraMetadataTests.cpp b/tests/camera2/CameraMetadataTests.cpp
deleted file mode 100644
index da5b748..0000000
--- a/tests/camera2/CameraMetadataTests.cpp
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
- * Copyright (C) 2012 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.
- */
-
-#define LOG_NDEBUG 0
-#define LOG_TAG "CameraMetadataTestFunctional"
-#include "cutils/log.h"
-#include "cutils/properties.h"
-#include "utils/Errors.h"
-
-#include "gtest/gtest.h"
-#include "system/camera_metadata.h"
-#include "hardware/hardware.h"
-#include "hardware/camera2.h"
-
-#include "common/CameraDeviceBase.h"
-#include "utils/StrongPointer.h"
-
-#include <gui/CpuConsumer.h>
-#include <gui/Surface.h>
-
-#include <string>
-
-#include "CameraStreamFixture.h"
-#include "TestExtensions.h"
-
-namespace android {
-namespace camera2 {
-namespace tests {
-
-//FIXME: dont hardcode
-static CameraStreamParams METADATA_STREAM_PARAMETERS = {
-    /*mFormat*/     HAL_PIXEL_FORMAT_YCrCb_420_SP,
-    /*mHeapCount*/  2
-};
-
-class CameraMetadataTest
-    : public ::testing::Test,
-      public CameraStreamFixture {
-
-public:
-    CameraMetadataTest()
-    : CameraStreamFixture(METADATA_STREAM_PARAMETERS) {
-        TEST_EXTENSION_FORKING_CONSTRUCTOR;
-    }
-
-    ~CameraMetadataTest() {
-        TEST_EXTENSION_FORKING_DESTRUCTOR;
-    }
-
-    int GetTypeFromTag(uint32_t tag) const {
-        return get_camera_metadata_tag_type(tag);
-    }
-
-    int GetTypeFromStaticTag(uint32_t tag) const {
-        const CameraMetadata& staticInfo = mDevice->info();
-        camera_metadata_ro_entry entry = staticInfo.find(tag);
-        return entry.type;
-    }
-
-    int GetEntryCountFromStaticTag(uint32_t tag) const {
-        const CameraMetadata& staticInfo = mDevice->info();
-        camera_metadata_ro_entry entry = staticInfo.find(tag);
-        return entry.count;
-    }
-
-    bool HasElementInArrayFromStaticTag(uint32_t tag, int32_t element) const {
-        const CameraMetadata& staticInfo = mDevice->info();
-        camera_metadata_ro_entry entry = staticInfo.find(tag);
-        for (size_t i = 0; i < entry.count; ++i) {
-            if (entry.data.i32[i] == element)
-                return true;
-        }
-        return false;
-    }
-
-protected:
-
-};
-
-TEST_F(CameraMetadataTest, types) {
-
-    TEST_EXTENSION_FORKING_INIT;
-
-    //FIXME: set this up in an external file of some sort (xml?)
-    {
-        char value[PROPERTY_VALUE_MAX];
-        property_get("ro.build.id", value, "");
-        std::string str_value(value);
-
-        if (str_value == "manta")
-        {
-            EXPECT_EQ(TYPE_BYTE,
-                GetTypeFromStaticTag(ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO));
-            EXPECT_EQ(TYPE_BYTE,
-                GetTypeFromStaticTag(ANDROID_QUIRKS_USE_ZSL_FORMAT));
-            EXPECT_EQ(TYPE_BYTE,
-                GetTypeFromStaticTag(ANDROID_QUIRKS_METERING_CROP_REGION));
-        }
-    }
-
-    /*
-    TODO:
-    go through all static metadata and make sure all fields we expect
-    that are there, ARE there.
-
-    dont worry about the type as its enforced by the metadata api
-    we can probably check the range validity though
-    */
-
-    if (0) {
-        camera_metadata_ro_entry entry;
-        EXPECT_EQ(TYPE_BYTE,     entry.type);
-        EXPECT_EQ(TYPE_INT32,    entry.type);
-        EXPECT_EQ(TYPE_FLOAT,    entry.type);
-        EXPECT_EQ(TYPE_INT64,    entry.type);
-        EXPECT_EQ(TYPE_DOUBLE,   entry.type);
-        EXPECT_EQ(TYPE_RATIONAL, entry.type);
-    }
-}
-
-TEST_F(CameraMetadataTest, RequiredFormats) {
-    TEST_EXTENSION_FORKING_INIT;
-
-    EXPECT_TRUE(
-        HasElementInArrayFromStaticTag(ANDROID_SCALER_AVAILABLE_FORMATS,
-                                       HAL_PIXEL_FORMAT_BLOB)); // JPEG
-
-    if (getDeviceVersion() < CAMERA_DEVICE_API_VERSION_3_0) {
-        // HAL2 can support either flexible YUV or YV12 + NV21
-        if (!HasElementInArrayFromStaticTag(ANDROID_SCALER_AVAILABLE_FORMATS,
-                        HAL_PIXEL_FORMAT_YCbCr_420_888)) {
-
-            EXPECT_TRUE(
-                HasElementInArrayFromStaticTag(ANDROID_SCALER_AVAILABLE_FORMATS,
-                        HAL_PIXEL_FORMAT_YCrCb_420_SP)); // NV21
-
-            EXPECT_TRUE(
-                HasElementInArrayFromStaticTag(ANDROID_SCALER_AVAILABLE_FORMATS,
-                        HAL_PIXEL_FORMAT_YV12));
-        }
-    } else {
-        // HAL3 must support flexible YUV
-        EXPECT_TRUE(HasElementInArrayFromStaticTag(ANDROID_SCALER_AVAILABLE_FORMATS,
-                        HAL_PIXEL_FORMAT_YCbCr_420_888));
-    }
-
-}
-
-TEST_F(CameraMetadataTest, SaneResolutions) {
-    TEST_EXTENSION_FORKING_INIT;
-
-    if (getDeviceVersion() < CAMERA_DEVICE_API_VERSION_3_2) {
-        // Iff there are listed raw resolutions, the format should be available
-        int rawResolutionsCount =
-                GetEntryCountFromStaticTag(ANDROID_SCALER_AVAILABLE_RAW_SIZES);
-        if (rawResolutionsCount > 0) {
-            EXPECT_TRUE(
-                HasElementInArrayFromStaticTag(ANDROID_SCALER_AVAILABLE_FORMATS,
-                        HAL_PIXEL_FORMAT_RAW16));
-        }
-
-        // Required processed sizes.
-        int processedSizeCount =
-               GetEntryCountFromStaticTag(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
-        EXPECT_NE(0, processedSizeCount);
-        EXPECT_EQ(0, processedSizeCount % 2); // multiple of 2 (w,h)
-
-        // Required JPEG sizes
-        int jpegSizeCount =
-                GetEntryCountFromStaticTag(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
-        EXPECT_NE(0, jpegSizeCount);
-        EXPECT_EQ(0, jpegSizeCount % 2); // multiple of 2 (w,h)
-    } else {
-        int strmConfigCount =
-                GetEntryCountFromStaticTag(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
-        EXPECT_NE(0, strmConfigCount);
-        EXPECT_EQ(0, strmConfigCount % 4); // multiple of 4 (format,w,h,output?)
-    }
-
-}
-
-}
-}
-}
diff --git a/tests/camera2/CameraModuleFixture.h b/tests/camera2/CameraModuleFixture.h
deleted file mode 100644
index b0d49e2..0000000
--- a/tests/camera2/CameraModuleFixture.h
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
- * Copyright (C) 2012 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_HAL_CAMERA2_TESTS_MODULE_FIXTURE__
-#define __ANDROID_HAL_CAMERA2_TESTS_MODULE_FIXTURE__
-
-#include <gtest/gtest.h>
-
-#include "hardware/hardware.h"
-#include "hardware/camera2.h"
-
-#include <common/CameraModule.h>
-#include <device3/Camera3Device.h>
-
-#include "camera2_utils.h"
-#include "TestExtensions.h"
-
-namespace android {
-namespace camera2 {
-namespace tests {
-
-template <bool InfoQuirk = false>
-struct CameraModuleFixture {
-
-    explicit CameraModuleFixture(int CameraID = -1) {
-        TEST_EXTENSION_FORKING_CONSTRUCTOR;
-
-        mCameraID = CameraID;
-    }
-
-    ~CameraModuleFixture() {
-        TEST_EXTENSION_FORKING_DESTRUCTOR;
-    }
-
-    camera_metadata_ro_entry GetStaticEntry(uint32_t tag) const {
-        const CameraMetadata& staticInfo = mDevice->info();
-        camera_metadata_ro_entry entry = staticInfo.find(tag);
-        return entry;
-    }
-
-    void SetUp() {
-        TEST_EXTENSION_FORKING_SET_UP;
-
-        camera_module_t *rawModule;
-        ASSERT_LE(0, hw_get_module(CAMERA_HARDWARE_MODULE_ID,
-            (const hw_module_t **)&rawModule)) << "Could not load camera module";
-        ASSERT_NE((void*)0, rawModule);
-        mModule = new CameraModule(rawModule);
-
-        mNumberOfCameras = mModule->getNumberOfCameras();
-        ASSERT_LE(0, mNumberOfCameras);
-
-        ASSERT_LE(
-            CAMERA_MODULE_API_VERSION_2_0, mModule->getModuleApiVersion())
-            << "Wrong module API version";
-
-        /* For using this fixture in other tests only */
-        SetUpMixin();
-    }
-
-    void TearDown() {
-        TEST_EXTENSION_FORKING_TEAR_DOWN;
-
-        TearDownMixin();
-
-        /* important: device must be destructed before closing module,
-           since it calls back into HAL */
-        mDevice.clear();
-
-        if (!TEST_EXTENSION_FORKING_ENABLED) {
-            ASSERT_EQ(0, HWModuleHelpers::closeModule(mModule->getDso()))
-                << "Failed to close camera HAL module";
-        }
-        delete mModule;
-    }
-
-    void CreateCamera(int cameraID, /*out*/ sp<CameraDeviceBase> *device) {
-        struct camera_info info;
-        ASSERT_EQ(OK, mModule->getCameraInfo(cameraID, &info));
-
-        ASSERT_GE((int)info.device_version, CAMERA_DEVICE_API_VERSION_3_0) <<
-                "Device version too old for camera " << cameraID << ". Version: " <<
-                info.device_version;
-        switch(info.device_version) {
-            case CAMERA_DEVICE_API_VERSION_3_0:
-            case CAMERA_DEVICE_API_VERSION_3_1:
-            case CAMERA_DEVICE_API_VERSION_3_2:
-                *device = new Camera3Device(String8::format("%d", cameraID));
-                break;
-            default:
-                device->clear();
-                FAIL() << "Device version unknown for camera " << cameraID << ". Version: " <<
-                       info.device_version;
-        }
-
-    }
-
-    int getDeviceVersion() {
-        return getDeviceVersion(mCameraID);
-    }
-
-    int getDeviceVersion(int cameraId, status_t* status = NULL) {
-        camera_info info;
-        status_t res;
-        res = mModule->getCameraInfo(cameraId, &info);
-        if (status != NULL) *status = res;
-
-        return info.device_version;
-    }
-
-private:
-
-    void SetUpMixin() {
-        /* For using this fixture in other tests only */
-        if (mCameraID != -1) {
-            EXPECT_LE(0, mCameraID);
-            EXPECT_LT(mCameraID, mNumberOfCameras);
-
-            /* HALBUG (Exynos5); crashes if we skip calling get_camera_info
-               before initializing. Need info anyway now. */
-
-            CreateCamera(mCameraID, &mDevice);
-
-            ASSERT_TRUE(mDevice != NULL) << "Failed to open device " << mCameraID;
-            ASSERT_EQ(OK, mDevice->initialize(mModule))
-                << "Failed to initialize device " << mCameraID;
-        }
-    }
-
-    void TearDownMixin() {
-
-    }
-
-protected:
-    int mNumberOfCameras;
-    CameraModule *mModule;
-    sp<CameraDeviceBase> mDevice;
-
-private:
-    int mCameraID;
-};
-
-
-}
-}
-}
-
-#endif
diff --git a/tests/camera2/CameraModuleTests.cpp b/tests/camera2/CameraModuleTests.cpp
deleted file mode 100644
index 2b6c757..0000000
--- a/tests/camera2/CameraModuleTests.cpp
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Copyright (C) 2012 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 <gtest/gtest.h>
-
-#define LOG_TAG "CameraModuleTest"
-#define LOG_NDEBUG 0
-#include <utils/Log.h>
-#include <utils/StrongPointer.h>
-#include <common/CameraDeviceBase.h>
-
-#include "hardware/hardware.h"
-#include "hardware/camera2.h"
-
-#include "CameraModuleFixture.h"
-
-namespace android {
-namespace camera2 {
-namespace tests {
-
-class CameraModuleTest : public ::testing::Test,
-                                  public CameraModuleFixture<> {
-
-public:
-    CameraModuleTest() {
-        CameraModuleFixture::SetUp();
-    }
-
-    ~CameraModuleTest() {
-        CameraModuleFixture::TearDown();
-    }
-
-    status_t initializeDevice(int cameraId) {
-
-        // ignore HAL1s. count as test pass
-        status_t stat;
-        if (isDeviceVersionHal2(cameraId, &stat) && stat == OK) {
-            stat = mDevice->initialize(mModule);
-        }
-
-        return stat;
-    }
-
-    bool isDeviceVersionHal2(int cameraId, status_t* status) {
-        return getDeviceVersion(cameraId, status)
-               >= CAMERA_DEVICE_API_VERSION_2_0;
-    }
-};
-
-TEST_F(CameraModuleTest, LoadModule) {
-
-    TEST_EXTENSION_FORKING_INIT;
-
-    status_t stat;
-    for (int i = 0; i < mNumberOfCameras; ++i) {
-        if (isDeviceVersionHal2(i, &stat) && stat == OK) {
-            CreateCamera(i, &mDevice);
-            ASSERT_EQ(OK, initializeDevice(i))
-                << "Failed to initialize device " << i;
-            mDevice.clear();
-        } else {
-            const ::testing::TestInfo* const test_info =
-                ::testing::UnitTest::GetInstance()->current_test_info();
-            std::cerr << "Skipping test "
-                      << test_info->test_case_name() << "."
-                      << test_info->name()
-                      << " because HAL device version is V1"
-                      << std::endl;
-        }
-    }
-
-}
-
-TEST_F(CameraModuleTest, LoadModuleBadIndices) {
-
-    TEST_EXTENSION_FORKING_INIT;
-
-    int idx[] = { -1, mNumberOfCameras, mNumberOfCameras + 1 };
-    hw_device_t *device = NULL;
-
-    for (unsigned i = 0; i < sizeof(idx)/sizeof(idx[0]); ++i) {
-        String8 deviceName = String8::format("%d", idx[i]);
-        status_t res = mModule->open(deviceName, &device);
-        EXPECT_NE(OK, res);
-        EXPECT_EQ(-ENODEV, res)
-            << "Incorrect error code when trying to open camera with invalid id "
-            << deviceName;
-    }
-}
-
-TEST_F(CameraModuleTest, GetCameraInfo) {
-
-    TEST_EXTENSION_FORKING_INIT;
-
-    for (int i = 0; i < mNumberOfCameras; ++i) {
-        struct camera_info info;
-        ASSERT_EQ(OK, mModule->getCameraInfo(i, &info));
-    }
-
-}
-
-TEST_F(CameraModuleTest, GetCameraInfoBadIndices) {
-
-    TEST_EXTENSION_FORKING_INIT;
-
-    int idx[] = { -1, mNumberOfCameras, mNumberOfCameras + 1 };
-    for (unsigned i = 0; i < sizeof(idx)/sizeof(idx[0]); ++i) {
-        struct camera_info info;
-        EXPECT_NE(OK, mModule->getCameraInfo(idx[i], &info));
-        EXPECT_EQ(-EINVAL, mModule->getCameraInfo(idx[i], &info))
-            << "Incorrect error code for get_camera_info idx= "
-            << idx[i];
-    }
-}
-
-/**
- * TODO: Additional test to add: open two cameras at once.
- *       (is allowed to fail, at least for now, but should not blow up)
- *     - open same device multiple times
- *     - close same device multiple times
- */
-
-
-
-
-}
-}
-}
diff --git a/tests/camera2/CameraMultiStreamTests.cpp b/tests/camera2/CameraMultiStreamTests.cpp
deleted file mode 100644
index f4aeab7..0000000
--- a/tests/camera2/CameraMultiStreamTests.cpp
+++ /dev/null
@@ -1,713 +0,0 @@
-/*
- * Copyright (C) 2013 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 <inttypes.h>
-#define LOG_TAG "CameraMultiStreamTest"
-//#define LOG_NDEBUG 0
-#include "CameraStreamFixture.h"
-#include "TestExtensions.h"
-
-#include <gtest/gtest.h>
-#include <utils/Log.h>
-#include <utils/StrongPointer.h>
-#include <common/CameraDeviceBase.h>
-#include <hardware/hardware.h>
-#include <hardware/camera2.h>
-#include <gui/SurfaceComposerClient.h>
-#include <gui/Surface.h>
-
-#define DEFAULT_FRAME_DURATION 33000000LL // 33ms
-#define CAMERA_HEAP_COUNT       1
-#define CAMERA_EXPOSURE_FORMAT CAMERA_STREAM_AUTO_CPU_FORMAT
-#define CAMERA_DISPLAY_FORMAT HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED
-#define CAMERA_MULTI_STREAM_DEBUGGING  0
-#define CAMERA_FRAME_TIMEOUT    1000000000LL // nsecs (1 secs)
-#define PREVIEW_RENDERING_TIME_INTERVAL 200000 // in unit of us, 200ms
-// 1% tolerance margin for exposure sanity check against metadata
-#define TOLERANCE_MARGIN_METADATA 0.01
-// 5% tolerance margin for exposure sanity check against capture times
-#define TOLERANCE_MARGIN_CAPTURE 0.05
-/* constants for display */
-#define DISPLAY_BUFFER_HEIGHT 1024
-#define DISPLAY_BUFFER_WIDTH 1024
-#define DISPLAY_BUFFER_FORMAT PIXEL_FORMAT_RGB_888
-
-// This test intends to test large preview size but less than 1080p.
-#define PREVIEW_WIDTH_CAP   1920
-#define PREVIEW_HEIGHT_CAP  1080
-// This test intends to test small metering burst size that is less than 640x480
-#define METERING_WIDTH_CAP  640
-#define METERING_HEIGHT_CAP 480
-
-#define EXP_WAIT_MULTIPLIER 2
-
-namespace android {
-namespace camera2 {
-namespace tests {
-
-static const CameraStreamParams DEFAULT_STREAM_PARAMETERS = {
-    /*mFormat*/     CAMERA_EXPOSURE_FORMAT,
-    /*mHeapCount*/  CAMERA_HEAP_COUNT
-};
-
-static const CameraStreamParams DISPLAY_STREAM_PARAMETERS = {
-    /*mFormat*/     CAMERA_DISPLAY_FORMAT,
-    /*mHeapCount*/  CAMERA_HEAP_COUNT
-};
-
-class CameraMultiStreamTest
-    : public ::testing::Test,
-      public CameraStreamFixture {
-
-public:
-    CameraMultiStreamTest() : CameraStreamFixture(DEFAULT_STREAM_PARAMETERS) {
-        TEST_EXTENSION_FORKING_CONSTRUCTOR;
-
-        if (HasFatalFailure()) {
-            return;
-        }
-        /**
-         * Don't create default stream, each test is in charge of creating
-         * its own streams.
-         */
-    }
-
-    ~CameraMultiStreamTest() {
-        TEST_EXTENSION_FORKING_DESTRUCTOR;
-    }
-
-    sp<SurfaceComposerClient> mComposerClient;
-    sp<SurfaceControl> mSurfaceControl;
-
-    void CreateOnScreenSurface(sp<Surface>& surface) {
-        mComposerClient = new SurfaceComposerClient;
-        ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
-
-        mSurfaceControl = mComposerClient->createSurface(
-                String8("CameraMultiStreamTest StreamingImage Surface"),
-                DISPLAY_BUFFER_HEIGHT, DISPLAY_BUFFER_WIDTH,
-                DISPLAY_BUFFER_FORMAT, 0);
-
-        ASSERT_NE((void*)NULL, mSurfaceControl.get());
-        ASSERT_TRUE(mSurfaceControl->isValid());
-
-        SurfaceComposerClient::openGlobalTransaction();
-        ASSERT_EQ(NO_ERROR, mSurfaceControl->setLayer(0x7FFFFFFF));
-        ASSERT_EQ(NO_ERROR, mSurfaceControl->show());
-        SurfaceComposerClient::closeGlobalTransaction();
-
-        surface = mSurfaceControl->getSurface();
-
-        ASSERT_NE((void*)NULL, surface.get());
-    }
-
-    struct Size {
-        int32_t width;
-        int32_t height;
-    };
-
-    // Select minimal size by number of pixels.
-    void GetMinSize(const int32_t* data, size_t count,
-            Size* min, int32_t* idx) {
-        ASSERT_NE((int32_t*)NULL, data);
-        int32_t minIdx = 0;
-        int32_t minSize = INT_MAX, tempSize;
-        for (size_t i = 0; i < count; i+=2) {
-            tempSize = data[i] * data[i+1];
-            if (minSize > tempSize) {
-                minSize = tempSize;
-                minIdx = i;
-            }
-        }
-        min->width = data[minIdx];
-        min->height = data[minIdx + 1];
-        *idx = minIdx;
-    }
-
-    // Select maximal size by number of pixels.
-    void GetMaxSize(const int32_t* data, size_t count,
-            Size* max, int32_t* idx) {
-        ASSERT_NE((int32_t*)NULL, data);
-        int32_t maxIdx = 0;
-        int32_t maxSize = INT_MIN, tempSize;
-        for (size_t i = 0; i < count; i+=2) {
-            tempSize = data[i] * data[i+1];
-            if (maxSize < tempSize) {
-                maxSize = tempSize;
-                maxIdx = i;
-            }
-        }
-        max->width = data[maxIdx];
-        max->height = data[maxIdx + 1];
-        *idx = maxIdx;
-    }
-
-    // Cap size by number of pixels.
-    Size CapSize(Size cap, Size input) {
-        if (input.width * input.height > cap.width * cap.height) {
-            return cap;
-        }
-        return input;
-    }
-
-    struct CameraStream : public RefBase {
-
-    public:
-        /**
-         * Only initialize the variables here, do the ASSERT check in
-         * SetUp function. To make this stream useful, the SetUp must
-         * be called before using it.
-         */
-        CameraStream(
-                int width,
-                int height,
-                const sp<CameraDeviceBase>& device,
-                CameraStreamParams param, sp<Surface> surface,
-                bool useCpuConsumer)
-            : mDevice(device),
-              mWidth(width),
-              mHeight(height) {
-            mFormat = param.mFormat;
-            if (useCpuConsumer) {
-                sp<IGraphicBufferProducer> producer;
-                sp<IGraphicBufferConsumer> consumer;
-                BufferQueue::createBufferQueue(&producer, &consumer);
-                mCpuConsumer = new CpuConsumer(consumer, param.mHeapCount);
-                mCpuConsumer->setName(String8(
-                        "CameraMultiStreamTest::mCpuConsumer"));
-                mSurface = new Surface(producer);
-            } else {
-                // Render the stream to screen.
-                mCpuConsumer = NULL;
-                mSurface = surface;
-            }
-
-            mFrameListener = new FrameListener();
-            if (mCpuConsumer != 0) {
-                mCpuConsumer->setFrameAvailableListener(mFrameListener);
-            }
-        }
-
-        /**
-         * Finally create camera stream, and do the ASSERT check, since we
-         * can not do it in ctor.
-         */
-        void SetUp() {
-            ASSERT_EQ(OK,
-                mDevice->createStream(mSurface,
-                    mWidth, mHeight, mFormat, HAL_DATASPACE_UNKNOWN,
-                    CAMERA3_STREAM_ROTATION_0, &mStreamId));
-
-            ASSERT_NE(-1, mStreamId);
-        }
-
-        int GetStreamId() { return mStreamId; }
-        sp<CpuConsumer> GetConsumer() { return mCpuConsumer; }
-        sp<FrameListener> GetFrameListener() { return mFrameListener; }
-
-    protected:
-        ~CameraStream() {
-            if (mDevice.get()) {
-                mDevice->waitUntilDrained();
-                mDevice->deleteStream(mStreamId);
-            }
-            // Clear producer before consumer.
-            mSurface.clear();
-            mCpuConsumer.clear();
-        }
-
-    private:
-        sp<FrameListener>       mFrameListener;
-        sp<CpuConsumer>         mCpuConsumer;
-        sp<Surface>             mSurface;
-        sp<CameraDeviceBase>    mDevice;
-        int                     mStreamId;
-        int                     mWidth;
-        int                     mHeight;
-        int                     mFormat;
-    };
-
-    int64_t GetExposureValue(const CameraMetadata& metaData) {
-        camera_metadata_ro_entry_t entry =
-                metaData.find(ANDROID_SENSOR_EXPOSURE_TIME);
-        EXPECT_EQ(1u, entry.count);
-        if (entry.count == 1) {
-            return entry.data.i64[0];
-        }
-        return -1;
-    }
-
-    int32_t GetSensitivity(const CameraMetadata& metaData) {
-        camera_metadata_ro_entry_t entry =
-                metaData.find(ANDROID_SENSOR_SENSITIVITY);
-        EXPECT_EQ(1u, entry.count);
-        if (entry.count == 1) {
-            return entry.data.i32[0];
-        }
-        return -1;
-    }
-
-    int64_t GetFrameDuration(const CameraMetadata& metaData) {
-        camera_metadata_ro_entry_t entry =
-                metaData.find(ANDROID_SENSOR_FRAME_DURATION);
-        EXPECT_EQ(1u, entry.count);
-        if (entry.count == 1) {
-            return entry.data.i64[0];
-        }
-        return -1;
-    }
-
-    void CreateRequests(CameraMetadata& previewRequest,
-            CameraMetadata& meteringRequest,
-            CameraMetadata& captureRequest,
-            int previewStreamId,
-            int meteringStreamId,
-            int captureStreamId) {
-        int32_t requestId = 0;
-        Vector<int32_t> previewStreamIds;
-        previewStreamIds.push(previewStreamId);
-        ASSERT_EQ(OK, mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
-                &previewRequest));
-        ASSERT_EQ(OK, previewRequest.update(ANDROID_REQUEST_OUTPUT_STREAMS,
-                previewStreamIds));
-        ASSERT_EQ(OK, previewRequest.update(ANDROID_REQUEST_ID,
-                &requestId, 1));
-
-        // Create metering request, manual settings
-        // Manual control: Disable 3A, noise reduction, edge sharping
-        uint8_t cmOff = static_cast<uint8_t>(ANDROID_CONTROL_MODE_OFF);
-        uint8_t nrOff = static_cast<uint8_t>(ANDROID_NOISE_REDUCTION_MODE_OFF);
-        uint8_t sharpOff = static_cast<uint8_t>(ANDROID_EDGE_MODE_OFF);
-        Vector<int32_t> meteringStreamIds;
-        meteringStreamIds.push(meteringStreamId);
-        ASSERT_EQ(OK, mDevice->createDefaultRequest(
-                CAMERA2_TEMPLATE_PREVIEW,
-                &meteringRequest));
-        ASSERT_EQ(OK, meteringRequest.update(
-                ANDROID_REQUEST_OUTPUT_STREAMS,
-                meteringStreamIds));
-        ASSERT_EQ(OK, meteringRequest.update(
-                ANDROID_CONTROL_MODE,
-                &cmOff, 1));
-        ASSERT_EQ(OK, meteringRequest.update(
-                ANDROID_NOISE_REDUCTION_MODE,
-                &nrOff, 1));
-        ASSERT_EQ(OK, meteringRequest.update(
-                ANDROID_EDGE_MODE,
-                &sharpOff, 1));
-
-        // Create capture request, manual settings
-        Vector<int32_t> captureStreamIds;
-        captureStreamIds.push(captureStreamId);
-        ASSERT_EQ(OK, mDevice->createDefaultRequest(
-                CAMERA2_TEMPLATE_PREVIEW,
-                &captureRequest));
-        ASSERT_EQ(OK, captureRequest.update(
-                ANDROID_REQUEST_OUTPUT_STREAMS,
-                captureStreamIds));
-        ASSERT_EQ(OK, captureRequest.update(
-                ANDROID_CONTROL_MODE,
-                &cmOff, 1));
-        ASSERT_EQ(OK, captureRequest.update(
-                ANDROID_NOISE_REDUCTION_MODE,
-                &nrOff, 1));
-        ASSERT_EQ(OK, captureRequest.update(
-                ANDROID_EDGE_MODE,
-                &sharpOff, 1));
-    }
-
-    sp<CameraStream> CreateStream(
-            int width,
-            int height,
-            const sp<CameraDeviceBase>& device,
-            CameraStreamParams param = DEFAULT_STREAM_PARAMETERS,
-            const sp<Surface>& surface = NULL,
-            bool useCpuConsumer = true) {
-        param.mFormat = MapAutoFormat(param.mFormat);
-        return new CameraStream(width, height, device,
-                param, surface, useCpuConsumer);
-    }
-
-    void CaptureBurst(CameraMetadata& request, size_t requestCount,
-            const Vector<int64_t>& exposures,
-            const Vector<int32_t>& sensitivities,
-            const sp<CameraStream>& stream,
-            int64_t minFrameDuration,
-            int32_t* requestIdStart) {
-        ASSERT_EQ(OK, request.update(ANDROID_SENSOR_FRAME_DURATION,
-                &minFrameDuration, 1));
-        // Submit a series of requests with the specified exposure/gain values.
-        int32_t targetRequestId = *requestIdStart;
-        for (size_t i = 0; i < requestCount; i++) {
-            ASSERT_EQ(OK, request.update(ANDROID_REQUEST_ID, requestIdStart, 1));
-            ASSERT_EQ(OK, request.update(ANDROID_SENSOR_EXPOSURE_TIME, &exposures[i], 1));
-            ASSERT_EQ(OK, request.update(ANDROID_SENSOR_SENSITIVITY, &sensitivities[i], 1));
-            ASSERT_EQ(OK, mDevice->capture(request));
-            ALOGV("Submitting request with: id %d with exposure %" PRId64 ", sensitivity %d",
-                    *requestIdStart, exposures[i], sensitivities[i]);
-            if (CAMERA_MULTI_STREAM_DEBUGGING) {
-                request.dump(STDOUT_FILENO);
-            }
-            (*requestIdStart)++;
-        }
-        // Get capture burst results.
-        Vector<nsecs_t> captureBurstTimes;
-        sp<CpuConsumer> consumer = stream->GetConsumer();
-        sp<FrameListener> listener = stream->GetFrameListener();
-
-        // Set wait limit based on expected frame duration.
-        int64_t waitLimit = CAMERA_FRAME_TIMEOUT;
-        for (size_t i = 0; i < requestCount; i++) {
-            ALOGV("Reading request result %zu", i);
-
-            /**
-             * Raise the timeout to be at least twice as long as the exposure
-             * time. to avoid a false positive when the timeout is too short.
-             */
-            if ((exposures[i] * EXP_WAIT_MULTIPLIER) > waitLimit) {
-                waitLimit = exposures[i] * EXP_WAIT_MULTIPLIER;
-            }
-
-            CaptureResult result;
-            CameraMetadata frameMetadata;
-            int32_t resultRequestId;
-            do {
-                ASSERT_EQ(OK, mDevice->waitForNextFrame(waitLimit));
-                ASSERT_EQ(OK, mDevice->getNextResult(&result));
-                frameMetadata = result.mMetadata;
-
-                camera_metadata_entry_t resultEntry = frameMetadata.find(ANDROID_REQUEST_ID);
-                ASSERT_EQ(1u, resultEntry.count);
-                resultRequestId = resultEntry.data.i32[0];
-                if (CAMERA_MULTI_STREAM_DEBUGGING) {
-                    std::cout << "capture result req id: " << resultRequestId << std::endl;
-                }
-            } while (resultRequestId != targetRequestId);
-            targetRequestId++;
-            ALOGV("Got capture burst result for request %zu", i);
-
-            // Validate capture result
-            if (CAMERA_MULTI_STREAM_DEBUGGING) {
-                frameMetadata.dump(STDOUT_FILENO);
-            }
-
-            // TODO: Need revisit it to figure out an accurate margin.
-            int64_t resultExposure = GetExposureValue(frameMetadata);
-            int32_t resultSensitivity = GetSensitivity(frameMetadata);
-            EXPECT_LE(sensitivities[i] * (1.0 - TOLERANCE_MARGIN_METADATA), resultSensitivity);
-            EXPECT_GE(sensitivities[i] * (1.0 + TOLERANCE_MARGIN_METADATA), resultSensitivity);
-            EXPECT_LE(exposures[i] * (1.0 - TOLERANCE_MARGIN_METADATA), resultExposure);
-            EXPECT_GE(exposures[i] * (1.0 + TOLERANCE_MARGIN_METADATA), resultExposure);
-
-            ASSERT_EQ(OK, listener->waitForFrame(waitLimit));
-            captureBurstTimes.push_back(systemTime());
-            CpuConsumer::LockedBuffer imgBuffer;
-            ASSERT_EQ(OK, consumer->lockNextBuffer(&imgBuffer));
-            ALOGV("Got capture buffer for request %zu", i);
-
-            /**
-             * TODO: Validate capture buffer. Current brightness calculation
-             * is too slow, it also doesn't account for saturation effects,
-             * which is quite common since we are going over a significant
-             * range of EVs. we need figure out some reliable way to validate
-             * buffer data.
-             */
-
-            ASSERT_EQ(OK, consumer->unlockBuffer(imgBuffer));
-            if (i > 0) {
-                nsecs_t timeDelta =
-                        captureBurstTimes[i] - captureBurstTimes[i-1];
-                EXPECT_GE(timeDelta * ( 1 + TOLERANCE_MARGIN_CAPTURE), exposures[i]);
-            }
-        }
-    }
-
-    /**
-     * Intentionally shadow default CreateStream function from base class,
-     * because we don't want any test in this class to use the default
-     * stream creation function.
-     */
-    void CreateStream() {
-    }
-};
-
-/**
- * This test adds multiple stream use case test, basically, test 3
- * streams:
- *
- * 1. Preview stream, with large size that is no bigger than 1080p
- * we render this stream to display and vary the exposure time for
- * for certain amount of time for visualization purpose.
- *
- * 2. Metering stream, with small size that is no bigger than VGA size.
- * a burst is issued for different exposure times and analog gains
- * (or analog gain implemented sensitivities) then check if the capture
- * result metadata matches the request.
- *
- * 3. Capture stream, this is basically similar as meterting stream, but
- * has large size, which is the largest supported JPEG capture size.
- *
- * This multiple stream test is to test if HAL supports:
- *
- * 1. Multiple streams like above, HAL should support at least 3 streams
- * concurrently: one preview stream, 2 other YUV stream.
- *
- * 2. Manual control(gain/exposure) of mutiple burst capture.
- */
-// Disable this test for now, as we need cleanup the usage of the deprecated tag quite a bit.
-TEST_F(CameraMultiStreamTest, DISABLED_MultiBurst) {
-
-    TEST_EXTENSION_FORKING_INIT;
-
-    const int32_t* implDefData;
-    size_t implDefCount;
-    const int32_t* jpegData;
-    size_t jpegCount;
-    if (getDeviceVersion() < CAMERA_DEVICE_API_VERSION_3_2) {
-        camera_metadata_ro_entry availableProcessedSizes =
-            GetStaticEntry(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
-        ASSERT_EQ(0u, availableProcessedSizes.count % 2);
-        ASSERT_GE(availableProcessedSizes.count, 2u);
-        camera_metadata_ro_entry availableProcessedMinFrameDurations =
-            GetStaticEntry(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS);
-        EXPECT_EQ(availableProcessedSizes.count,
-            availableProcessedMinFrameDurations.count * 2);
-
-        camera_metadata_ro_entry availableJpegSizes =
-            GetStaticEntry(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
-        ASSERT_EQ(0u, availableJpegSizes.count % 2);
-        ASSERT_GE(availableJpegSizes.count, 2u);
-        implDefData = availableProcessedSizes.data.i32;
-        implDefCount = availableProcessedSizes.count;
-        jpegData = availableJpegSizes.data.i32;
-        jpegCount = availableJpegSizes.count;
-    } else {
-        getResolutionList(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, &implDefData, &implDefCount);
-        ASSERT_NE(0u, implDefCount)
-            << "Missing implementation defined sizes";
-        ASSERT_EQ(0u, implDefCount % 2);
-        ASSERT_GE(implDefCount, 2u);
-
-        getResolutionList(HAL_PIXEL_FORMAT_BLOB, &jpegData, &jpegCount);
-        ASSERT_EQ(0u, jpegCount % 2);
-        ASSERT_GE(jpegCount, 2u);
-    }
-
-    camera_metadata_ro_entry hardwareLevel =
-        GetStaticEntry(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL);
-    ASSERT_EQ(1u, hardwareLevel.count);
-    uint8_t level = hardwareLevel.data.u8[0];
-    ASSERT_GE(level, ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED);
-    ASSERT_LE(level, ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL);
-    if (level == ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED) {
-        const ::testing::TestInfo* const test_info =
-            ::testing::UnitTest::GetInstance()->current_test_info();
-        std::cerr << "Skipping test "
-                  << test_info->test_case_name() << "."
-                  << test_info->name()
-                  << " because HAL hardware supported level is limited "
-                  << std::endl;
-        return;
-    }
-
-    // Find the right sizes for preview, metering, and capture streams
-    int64_t minFrameDuration = DEFAULT_FRAME_DURATION;
-    Size processedMinSize = {0, 0}, processedMaxSize = {0, 0};
-    Size jpegMaxSize = {0, 0};
-
-    int32_t minIdx, maxIdx;
-    GetMinSize(implDefData, implDefCount, &processedMinSize, &minIdx);
-    GetMaxSize(implDefData, implDefCount, &processedMaxSize, &maxIdx);
-    ALOGV("Found processed max size: %dx%d, min size = %dx%d",
-            processedMaxSize.width, processedMaxSize.height,
-            processedMinSize.width, processedMinSize.height);
-
-    if (getDeviceVersion() < CAMERA_DEVICE_API_VERSION_3_2) {
-        camera_metadata_ro_entry availableProcessedMinFrameDurations =
-            GetStaticEntry(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS);
-        minFrameDuration =
-            availableProcessedMinFrameDurations.data.i64[maxIdx / 2];
-    } else {
-        minFrameDuration = getMinFrameDurationFor(
-                HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED,
-                processedMaxSize.width, processedMaxSize.height);
-    }
-
-    EXPECT_GT(minFrameDuration, 0);
-
-    if (minFrameDuration <= 0) {
-        minFrameDuration = DEFAULT_FRAME_DURATION;
-    }
-
-    ALOGV("targeted minimal frame duration is: %" PRId64 "ns", minFrameDuration);
-
-    GetMaxSize(jpegData, jpegCount, &jpegMaxSize, &maxIdx);
-    ALOGV("Found Jpeg size max idx = %d", maxIdx);
-
-    // Max Jpeg size should be available in processed sizes. Use it for
-    // YUV capture anyway.
-    EXPECT_EQ(processedMaxSize.width, jpegMaxSize.width);
-    EXPECT_EQ(processedMaxSize.height, jpegMaxSize.height);
-
-    // Cap preview size.
-    Size previewLimit = { PREVIEW_WIDTH_CAP, PREVIEW_HEIGHT_CAP };
-    // FIXME: need make sure the previewLimit is supported by HAL.
-    Size previewSize = CapSize(previewLimit, processedMaxSize);
-    // Cap Metering size.
-    Size meteringLimit = { METERING_WIDTH_CAP, METERING_HEIGHT_CAP };
-    // Cap metering size to VGA (VGA is mandatory by CDD)
-    Size meteringSize = CapSize(meteringLimit, processedMinSize);
-    // Capture stream should be the max size of jpeg sizes.
-    ALOGV("preview size: %dx%d, metering size: %dx%d, capture size: %dx%d",
-            previewSize.width, previewSize.height,
-            meteringSize.width, meteringSize.height,
-            jpegMaxSize.width, jpegMaxSize.height);
-
-    // Create streams
-    // Preview stream: small resolution, render on the screen.
-    sp<CameraStream> previewStream;
-    {
-        sp<Surface> surface;
-        ASSERT_NO_FATAL_FAILURE(CreateOnScreenSurface(/*out*/surface));
-        previewStream = CreateStream(
-                previewSize.width,
-                previewSize.height,
-                mDevice,
-                DISPLAY_STREAM_PARAMETERS,
-                surface,
-                false);
-        ASSERT_NE((void*)NULL, previewStream.get());
-        ASSERT_NO_FATAL_FAILURE(previewStream->SetUp());
-    }
-    // Metering burst stream: small resolution yuv stream
-    sp<CameraStream> meteringStream =
-            CreateStream(
-                    meteringSize.width,
-                    meteringSize.height,
-                    mDevice);
-    ASSERT_NE((void*)NULL, meteringStream.get());
-    ASSERT_NO_FATAL_FAILURE(meteringStream->SetUp());
-    // Capture burst stream: full resolution yuv stream
-    sp<CameraStream> captureStream =
-            CreateStream(
-                    jpegMaxSize.width,
-                    jpegMaxSize.height,
-                    mDevice);
-    ASSERT_NE((void*)NULL, captureStream.get());
-    ASSERT_NO_FATAL_FAILURE(captureStream->SetUp());
-
-    // Create Preview request.
-    CameraMetadata previewRequest, meteringRequest, captureRequest;
-    ASSERT_NO_FATAL_FAILURE(CreateRequests(previewRequest, meteringRequest,
-            captureRequest, previewStream->GetStreamId(),
-            meteringStream->GetStreamId(), captureStream->GetStreamId()));
-
-    // Start preview
-    if (CAMERA_MULTI_STREAM_DEBUGGING) {
-        previewRequest.dump(STDOUT_FILENO);
-    }
-
-    // Generate exposure and sensitivity lists
-    camera_metadata_ro_entry exposureTimeRange =
-        GetStaticEntry(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE);
-    ASSERT_EQ(exposureTimeRange.count, 2u);
-    int64_t minExp = exposureTimeRange.data.i64[0];
-    int64_t maxExp = exposureTimeRange.data.i64[1];
-    ASSERT_GT(maxExp, minExp);
-
-    camera_metadata_ro_entry sensivityRange =
-        GetStaticEntry(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE);
-    ASSERT_EQ(2u, sensivityRange.count);
-    int32_t minSensitivity = sensivityRange.data.i32[0];
-    int32_t maxSensitivity = sensivityRange.data.i32[1];
-    camera_metadata_ro_entry maxAnalogSenEntry =
-            GetStaticEntry(ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY);
-    EXPECT_EQ(1u, maxAnalogSenEntry.count);
-    int32_t maxAnalogSensitivity = maxAnalogSenEntry.data.i32[0];
-    EXPECT_LE(maxAnalogSensitivity, maxSensitivity);
-    // Only test the sensitivity implemented by analog gain.
-    if (maxAnalogSensitivity > maxSensitivity) {
-        // Fallback to maxSensitity
-        maxAnalogSensitivity = maxSensitivity;
-    }
-
-    // sensitivity list, only include the sensitivities that are implemented
-    // purely by analog gain if possible.
-    Vector<int32_t> sensitivities;
-    Vector<int64_t> exposures;
-    size_t count = (maxAnalogSensitivity - minSensitivity + 99) / 100;
-    sensitivities.push_back(minSensitivity);
-    for (size_t i = 1; i < count; i++) {
-        sensitivities.push_back(minSensitivity + i * 100);
-    }
-    sensitivities.push_back(maxAnalogSensitivity);
-    ALOGV("Sensitivity Range: min=%d, max=%d", minSensitivity,
-            maxAnalogSensitivity);
-    int64_t exp = minExp;
-    while (exp < maxExp) {
-        exposures.push_back(exp);
-        exp *= 2;
-    }
-    // Sweep the exposure value for preview, just for visual inspection purpose.
-    uint8_t cmOff = static_cast<uint8_t>(ANDROID_CONTROL_MODE_OFF);
-    for (size_t i = 0; i < exposures.size(); i++) {
-        ASSERT_EQ(OK, previewRequest.update(
-                ANDROID_CONTROL_MODE,
-                &cmOff, 1));
-        ASSERT_EQ(OK, previewRequest.update(
-                ANDROID_SENSOR_EXPOSURE_TIME,
-                &exposures[i], 1));
-        ALOGV("Submitting preview request %zu with exposure %" PRId64,
-                i, exposures[i]);
-
-        ASSERT_EQ(OK, mDevice->setStreamingRequest(previewRequest));
-
-        // Let preview run 200ms on screen for each exposure time.
-        usleep(PREVIEW_RENDERING_TIME_INTERVAL);
-    }
-
-    size_t requestCount = sensitivities.size();
-    if (requestCount > exposures.size()) {
-        requestCount = exposures.size();
-    }
-
-    // To maintain the request id uniqueness (preview request id is 0), make burst capture start
-    // request id 1 here.
-    int32_t requestIdStart = 1;
-    /**
-     * Submit metering request, set default frame duration to minimal possible
-     * value, we want the capture to run as fast as possible. HAL should adjust
-     * the frame duration to minimal necessary value to support the requested
-     * exposure value if exposure is larger than frame duration.
-     */
-    CaptureBurst(meteringRequest, requestCount, exposures, sensitivities,
-            meteringStream, minFrameDuration, &requestIdStart);
-
-    /**
-     * Submit capture request, set default frame duration to minimal possible
-     * value, we want the capture to run as fast as possible. HAL should adjust
-     * the frame duration to minimal necessary value to support the requested
-     * exposure value if exposure is larger than frame duration.
-     */
-    CaptureBurst(captureRequest, requestCount, exposures, sensitivities,
-            captureStream, minFrameDuration, &requestIdStart);
-
-    ASSERT_EQ(OK, mDevice->clearStreamingRequest());
-}
-
-}
-}
-}
diff --git a/tests/camera2/CameraStreamFixture.h b/tests/camera2/CameraStreamFixture.h
deleted file mode 100644
index 92ff05b..0000000
--- a/tests/camera2/CameraStreamFixture.h
+++ /dev/null
@@ -1,377 +0,0 @@
-/*
- * Copyright (C) 2012 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_HAL_CAMERA2_TESTS_STREAM_FIXTURE__
-#define __ANDROID_HAL_CAMERA2_TESTS_STREAM_FIXTURE__
-
-#include <gtest/gtest.h>
-#include <iostream>
-#include <fstream>
-
-#include <gui/CpuConsumer.h>
-#include <gui/Surface.h>
-#include <utils/Condition.h>
-#include <utils/Mutex.h>
-#include <system/camera_metadata.h>
-
-#include "CameraModuleFixture.h"
-#include "TestExtensions.h"
-
-#define ALIGN(x, mask) ( ((x) + (mask) - 1) & ~((mask) - 1) )
-
-namespace android {
-namespace camera2 {
-namespace tests {
-
-// Format specifier for picking the best format for CPU reading the given device
-// version
-#define CAMERA_STREAM_AUTO_CPU_FORMAT (-1)
-
-struct CameraStreamParams;
-
-void PrintTo(const CameraStreamParams& p, ::std::ostream* os);
-
-struct CameraStreamParams {
-    int mFormat;
-    int mHeapCount;
-
-};
-
-inline ::std::ostream& operator<<(::std::ostream& os, const CameraStreamParams &p) {
-    PrintTo(p, &os);
-    return os;
-}
-
-inline void PrintTo(const CameraStreamParams& p, ::std::ostream* os) {
-    char fmt[100];
-    camera_metadata_enum_snprint(
-        ANDROID_SCALER_AVAILABLE_FORMATS, p.mFormat, fmt, sizeof(fmt));
-
-    *os <<  "{ ";
-    *os <<  "Format: 0x"  << std::hex << p.mFormat    << ", ";
-    *os <<  "Format name: " << fmt << ", ";
-    *os <<  "HeapCount: " <<             p.mHeapCount;
-    *os << " }";
-}
-
-class CameraStreamFixture
-    : public CameraModuleFixture</*InfoQuirk*/true> {
-
-public:
-    explicit CameraStreamFixture(CameraStreamParams p)
-    : CameraModuleFixture(TestSettings::DeviceId()) {
-        TEST_EXTENSION_FORKING_CONSTRUCTOR;
-
-        mParam = p;
-
-        SetUp();
-    }
-
-    ~CameraStreamFixture() {
-        TEST_EXTENSION_FORKING_DESTRUCTOR;
-
-        TearDown();
-    }
-
-private:
-
-    void SetUp() {
-        TEST_EXTENSION_FORKING_SET_UP;
-
-        CameraModuleFixture::SetUp();
-
-        sp<CameraDeviceBase> device = mDevice;
-
-        /* use an arbitrary w,h */
-        if (getDeviceVersion() < CAMERA_DEVICE_API_VERSION_3_2) {
-            const int tag = ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES;
-
-            const CameraMetadata& staticInfo = device->info();
-            camera_metadata_ro_entry entry = staticInfo.find(tag);
-            ASSERT_NE(0u, entry.count)
-                << "Missing tag android.scaler.availableProcessedSizes";
-
-            ASSERT_LE(2u, entry.count);
-            /* this seems like it would always be the smallest w,h
-               but we actually make no contract that it's sorted asc */
-            mWidth = entry.data.i32[0];
-            mHeight = entry.data.i32[1];
-        } else {
-            buildOutputResolutions();
-            const int32_t *implDefResolutions = NULL;
-            size_t   implDefResolutionsCount;
-
-            int format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
-
-            getResolutionList(format,
-                    &implDefResolutions, &implDefResolutionsCount);
-            ASSERT_NE(0u, implDefResolutionsCount)
-                << "Missing implementation defined sizes";
-            mWidth = implDefResolutions[0];
-            mHeight = implDefResolutions[1];
-        }
-    }
-    void TearDown() {
-        TEST_EXTENSION_FORKING_TEAR_DOWN;
-
-        // important: shut down HAL before releasing streams
-        CameraModuleFixture::TearDown();
-
-        deleteOutputResolutions();
-        mSurface.clear();
-        mCpuConsumer.clear();
-        mFrameListener.clear();
-    }
-
-protected:
-
-    int64_t getMinFrameDurationFor(int32_t format, int32_t width, int32_t height) {
-        int64_t minFrameDuration = -1L;
-        const int tag = ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS;
-        sp<CameraDeviceBase> device = mDevice;
-        const CameraMetadata& staticInfo = device->info();
-        camera_metadata_ro_entry_t availableMinDurations = staticInfo.find(tag);
-        for (uint32_t i = 0; i < availableMinDurations.count; i += 4) {
-            if (format == availableMinDurations.data.i64[i] &&
-                    width == availableMinDurations.data.i64[i + 1] &&
-                    height == availableMinDurations.data.i64[i + 2]) {
-                minFrameDuration = availableMinDurations.data.i64[i + 3];
-                break;
-            }
-        }
-        return minFrameDuration;
-    }
-
-    void buildOutputResolutions() {
-        if (getDeviceVersion() < CAMERA_DEVICE_API_VERSION_3_2) {
-            return;
-        }
-        if (mOutputResolutions.isEmpty()) {
-            const int tag = ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS;
-            const CameraMetadata& staticInfo = mDevice->info();
-            camera_metadata_ro_entry_t availableStrmConfigs = staticInfo.find(tag);
-            ASSERT_EQ(0u, availableStrmConfigs.count % 4);
-            for (uint32_t i = 0; i < availableStrmConfigs.count; i += 4) {
-                int32_t format = availableStrmConfigs.data.i32[i];
-                int32_t width = availableStrmConfigs.data.i32[i + 1];
-                int32_t height = availableStrmConfigs.data.i32[i + 2];
-                int32_t inOrOut = availableStrmConfigs.data.i32[i + 3];
-                if (inOrOut == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT) {
-                    int index = mOutputResolutions.indexOfKey(format);
-                    if (index < 0) {
-                        index = mOutputResolutions.add(format, new Vector<int32_t>());
-                        ASSERT_TRUE(index >= 0);
-                    }
-                    Vector<int32_t> *resolutions = mOutputResolutions.editValueAt(index);
-                    resolutions->add(width);
-                    resolutions->add(height);
-                }
-            }
-        }
-    }
-
-    void getResolutionList(int32_t format,
-            const int32_t **list,
-            size_t *count) {
-        ALOGV("Getting resolutions for format %x", format);
-        if (getDeviceVersion() < CAMERA_DEVICE_API_VERSION_3_2) {
-            return;
-        }
-        int index = mOutputResolutions.indexOfKey(format);
-        ASSERT_TRUE(index >= 0);
-        Vector<int32_t>* resolutions = mOutputResolutions.valueAt(index);
-        *list = resolutions->array();
-        *count = resolutions->size();
-    }
-
-    void deleteOutputResolutions() {
-        for (uint32_t i = 0; i < mOutputResolutions.size(); i++) {
-            Vector<int32_t>* resolutions = mOutputResolutions.editValueAt(i);
-            delete resolutions;
-        }
-        mOutputResolutions.clear();
-    }
-
-    struct FrameListener : public ConsumerBase::FrameAvailableListener {
-
-        FrameListener() {
-            mPendingFrames = 0;
-        }
-
-        // CpuConsumer::FrameAvailableListener implementation
-        virtual void onFrameAvailable(const BufferItem& /* item */) {
-            ALOGV("Frame now available (start)");
-
-            Mutex::Autolock lock(mMutex);
-            mPendingFrames++;
-            mCondition.signal();
-
-            ALOGV("Frame now available (end)");
-        }
-
-        status_t waitForFrame(nsecs_t timeout) {
-            status_t res;
-            Mutex::Autolock lock(mMutex);
-            while (mPendingFrames == 0) {
-                res = mCondition.waitRelative(mMutex, timeout);
-                if (res != OK) return res;
-            }
-            mPendingFrames--;
-            return OK;
-        }
-
-    private:
-        Mutex mMutex;
-        Condition mCondition;
-        int mPendingFrames;
-    };
-
-    void CreateStream() {
-        sp<CameraDeviceBase> device = mDevice;
-        CameraStreamParams p = mParam;
-
-        sp<IGraphicBufferProducer> producer;
-        sp<IGraphicBufferConsumer> consumer;
-        BufferQueue::createBufferQueue(&producer, &consumer);
-        mCpuConsumer = new CpuConsumer(consumer, p.mHeapCount);
-        mCpuConsumer->setName(String8("CameraStreamTest::mCpuConsumer"));
-
-        mSurface = new Surface(producer);
-
-        int format = MapAutoFormat(p.mFormat);
-
-        ASSERT_EQ(OK,
-            device->createStream(mSurface,
-                mWidth, mHeight, format,
-                HAL_DATASPACE_UNKNOWN,
-                CAMERA3_STREAM_ROTATION_0,
-                &mStreamId));
-
-        ASSERT_NE(-1, mStreamId);
-
-        // do not make 'this' a FrameListener or the lifetime policy will clash
-        mFrameListener = new FrameListener();
-        mCpuConsumer->setFrameAvailableListener(mFrameListener);
-    }
-
-    void DeleteStream() {
-        ASSERT_EQ(OK, mDevice->deleteStream(mStreamId));
-    }
-
-    int MapAutoFormat(int format) {
-        if (format == CAMERA_STREAM_AUTO_CPU_FORMAT) {
-            if (getDeviceVersion() >= CAMERA_DEVICE_API_VERSION_3_0) {
-                format = HAL_PIXEL_FORMAT_YCbCr_420_888;
-            } else {
-                format = HAL_PIXEL_FORMAT_YCrCb_420_SP;
-            }
-        }
-        return format;
-    }
-
-    void DumpYuvToFile(const String8 &fileName, const CpuConsumer::LockedBuffer &img) {
-        uint8_t *dataCb, *dataCr;
-        uint32_t stride;
-        uint32_t chromaStride;
-        uint32_t chromaStep;
-
-        switch (img.format) {
-            case HAL_PIXEL_FORMAT_YCbCr_420_888:
-                stride = img.stride;
-                chromaStride = img.chromaStride;
-                chromaStep = img.chromaStep;
-                dataCb = img.dataCb;
-                dataCr = img.dataCr;
-                break;
-            case HAL_PIXEL_FORMAT_YCrCb_420_SP:
-                stride = img.width;
-                chromaStride = img.width;
-                chromaStep = 2;
-                dataCr = img.data + img.width * img.height;
-                dataCb = dataCr + 1;
-                break;
-            case HAL_PIXEL_FORMAT_YV12:
-                stride = img.stride;
-                chromaStride = ALIGN(img.width / 2, 16);
-                chromaStep = 1;
-                dataCr = img.data + img.stride * img.height;
-                dataCb = dataCr + chromaStride * img.height/2;
-                break;
-            default:
-                ALOGE("Unknown format %d, not dumping", img.format);
-                return;
-        }
-
-        // Write Y
-        FILE *yuvFile = fopen(fileName.string(), "w");
-
-        size_t bytes;
-
-        for (size_t y = 0; y < img.height; ++y) {
-            bytes = fwrite(
-                reinterpret_cast<const char*>(img.data + stride * y),
-                1, img.width, yuvFile);
-            if (bytes != img.width) {
-                ALOGE("Unable to write to file %s", fileName.string());
-                fclose(yuvFile);
-                return;
-            }
-        }
-
-        // Write Cb/Cr
-        uint8_t *src = dataCb;
-        for (int c = 0; c < 2; ++c) {
-            for (size_t y = 0; y < img.height / 2; ++y) {
-                uint8_t *px = src + y * chromaStride;
-                if (chromaStep != 1) {
-                    for (size_t x = 0; x < img.width / 2; ++x) {
-                        fputc(*px, yuvFile);
-                        px += chromaStep;
-                    }
-                } else {
-                    bytes = fwrite(reinterpret_cast<const char*>(px),
-                            1, img.width / 2, yuvFile);
-                    if (bytes != img.width / 2) {
-                        ALOGE("Unable to write to file %s", fileName.string());
-                        fclose(yuvFile);
-                        return;
-                    }
-                }
-            }
-            src = dataCr;
-        }
-        fclose(yuvFile);
-    }
-
-    int mWidth;
-    int mHeight;
-
-    int mStreamId;
-
-    android::sp<FrameListener>       mFrameListener;
-    android::sp<CpuConsumer>         mCpuConsumer;
-    android::sp<Surface>             mSurface;
-    KeyedVector<int32_t, Vector<int32_t>* > mOutputResolutions;
-
-private:
-    CameraStreamParams mParam;
-};
-
-}
-}
-}
-
-#endif
diff --git a/tests/camera2/CameraStreamTests.cpp b/tests/camera2/CameraStreamTests.cpp
deleted file mode 100644
index de9ae8a..0000000
--- a/tests/camera2/CameraStreamTests.cpp
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * Copyright (C) 2012 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 <iostream>
-#include <iomanip>
-#include <gtest/gtest.h>
-
-#define LOG_TAG "CameraStreamTest"
-#define LOG_NDEBUG 0
-#include <utils/Log.h>
-
-#include "hardware/hardware.h"
-#include "hardware/camera2.h"
-
-#include <utils/StrongPointer.h>
-#include <gui/CpuConsumer.h>
-#include <gui/Surface.h>
-
-#include "CameraStreamFixture.h"
-#include "TestExtensions.h"
-
-using namespace android;
-using namespace android::camera2;
-
-namespace android {
-namespace camera2 {
-namespace tests {
-
-class CameraStreamTest
-    : public ::testing::TestWithParam<CameraStreamParams>,
-      public CameraStreamFixture {
-
-public:
-    CameraStreamTest() : CameraStreamFixture(GetParam()) {
-        TEST_EXTENSION_FORKING_CONSTRUCTOR;
-    }
-
-    ~CameraStreamTest() {
-        TEST_EXTENSION_FORKING_DESTRUCTOR;
-    }
-
-    virtual void SetUp() {
-        TEST_EXTENSION_FORKING_SET_UP;
-    }
-    virtual void TearDown() {
-        TEST_EXTENSION_FORKING_TEAR_DOWN;
-    }
-
-protected:
-
-};
-
-TEST_P(CameraStreamTest, CreateStream) {
-
-    TEST_EXTENSION_FORKING_INIT;
-
-    /** Make sure the format requested is supported. PASS this test if it's not
-      * not supported.
-      *
-      * TODO: would be nice of not running this test in the first place
-      *       somehow.
-      */
-    {
-        camera_metadata_ro_entry availableFormats =
-            GetStaticEntry(ANDROID_SCALER_AVAILABLE_FORMATS);
-
-        bool hasFormat = false;
-        for (size_t i = 0; i < availableFormats.count; ++i) {
-            if (availableFormats.data.i32[i] == GetParam().mFormat) {
-                hasFormat = true;
-                break;
-            }
-        }
-
-        if (!hasFormat) {
-            const ::testing::TestInfo* const test_info =
-                ::testing::UnitTest::GetInstance()->current_test_info();
-            std::cerr << "Skipping test "
-                      << test_info->test_case_name() << "."
-                      << test_info->name()
-                      << " because the format was not available: "
-                      << GetParam() << std::endl;
-            return;
-        }
-    }
-
-    ASSERT_NO_FATAL_FAILURE(CreateStream());
-    ASSERT_NO_FATAL_FAILURE(DeleteStream());
-}
-
-//TODO: use a combinatoric generator
-static CameraStreamParams TestParameters[] = {
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED,
-        /*mHeapCount*/ 1
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED,
-        /*mHeapCount*/ 2
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED,
-        /*mHeapCount*/ 3
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_YCrCb_420_SP, // NV21
-        /*mHeapCount*/ 1
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_YCrCb_420_SP,
-        /*mHeapCount*/ 2
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_YCrCb_420_SP,
-        /*mHeapCount*/ 3
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_YV12,
-        /*mHeapCount*/ 1
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_YV12,
-        /*mHeapCount*/ 2
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_YV12,
-        /*mHeapCount*/ 3
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_Y8,
-        /*mHeapCount*/ 1
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_Y8,
-        /*mHeapCount*/ 2
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_Y8,
-        /*mHeapCount*/ 3
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_Y16,
-        /*mHeapCount*/ 1
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_Y16,
-        /*mHeapCount*/ 2
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_Y16,
-        /*mHeapCount*/ 3
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_RAW16,
-        /*mHeapCount*/ 1
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_RAW16,
-        /*mHeapCount*/ 2
-    },
-    {
-        /*mFormat*/    HAL_PIXEL_FORMAT_RAW16,
-        /*mHeapCount*/ 3
-    },
-};
-
-INSTANTIATE_TEST_CASE_P(StreamParameterCombinations, CameraStreamTest,
-    testing::ValuesIn(TestParameters));
-
-
-}
-}
-}
diff --git a/tests/camera2/ForkedTests.cpp b/tests/camera2/ForkedTests.cpp
deleted file mode 100644
index 39599da..0000000
--- a/tests/camera2/ForkedTests.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (C) 2012 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 <gtest/gtest.h>
-
-#include <stdlib.h>
-
-#include "TestExtensions.h"
-
-namespace android {
-namespace camera2 {
-namespace tests {
-
-// Intentionally disabled since 2 of these tests are supposed to fail
-class DISABLED_ForkedTest : public ::testing::Test {
-
-    virtual void SetUp() {
-        TEST_EXTENSION_FORKING_SET_UP;
-    }
-
-    virtual void TearDown() {
-        TEST_EXTENSION_FORKING_TEAR_DOWN;
-    }
-};
-
-// intentionally fail
-TEST_F(DISABLED_ForkedTest, FailCrash) {
-    TEST_EXTENSION_FORKING_INIT;
-    abort();
-}
-
-TEST_F(DISABLED_ForkedTest, SucceedNormal) {
-    TEST_EXTENSION_FORKING_INIT;
-
-    EXPECT_TRUE(true);
-}
-
-// intentionally fail
-TEST_F(DISABLED_ForkedTest, FailNormal) {
-    TEST_EXTENSION_FORKING_INIT;
-
-    EXPECT_TRUE(false);
-}
-
-}
-}
-}
-
diff --git a/tests/camera2/TestExtensions.h b/tests/camera2/TestExtensions.h
deleted file mode 100644
index 2af587d..0000000
--- a/tests/camera2/TestExtensions.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (C) 2012 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_HAL_CAMERA2_TESTS_EXTENSIONS__
-#define __ANDROID_HAL_CAMERA2_TESTS_EXTENSIONS__
-
-#include "TestForkerEventListener.h"
-#include "TestSettings.h"
-
-// Use at the beginning of each Test::SetUp() impl
-#define TEST_EXTENSION_FORKING_SET_UP                                       \
-    do {                                                                    \
-        if (TEST_EXTENSION_FORKING_ENABLED) {                               \
-            if (!TestForkerEventListener::mIsForked) {                      \
-                return;                                                     \
-            }                                                               \
-        }                                                                   \
-    } while (false)                                                         \
-
-// Use at the beginning of each Test::TearDown() impl
-#define TEST_EXTENSION_FORKING_TEAR_DOWN   TEST_EXTENSION_FORKING_SET_UP
-
-// Use at the beginning of each Test::Test constructor
-#define TEST_EXTENSION_FORKING_CONSTRUCTOR TEST_EXTENSION_FORKING_SET_UP
-
-// Use at the beginning of each Test::~Test destructor
-#define TEST_EXTENSION_FORKING_DESTRUCTOR  TEST_EXTENSION_FORKING_TEAR_DOWN
-
-// Use at the beginning of each test body, e.g. TEST(x,y), TEST_F(x,y), etc
-#define TEST_EXTENSION_FORKING_INIT                                         \
-    do {                                                                    \
-        TEST_EXTENSION_FORKING_SET_UP;                                      \
-        if (HasFatalFailure()) return;                                      \
-    } while(false)                                                          \
-
-// Are we running each test by forking it?
-#define TEST_EXTENSION_FORKING_ENABLED                                      \
-    (android::camera2::tests::TestSettings::ForkingEnabled())
-
-
-
-#endif
-
diff --git a/tests/camera2/TestForkerEventListener.cpp b/tests/camera2/TestForkerEventListener.cpp
deleted file mode 100644
index 9416db2..0000000
--- a/tests/camera2/TestForkerEventListener.cpp
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (C) 2012 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 <unistd.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <string.h>
-
-#include <gtest/gtest.h>
-
-#include "TestForkerEventListener.h"
-#include "TestExtensions.h"
-
-#define DEBUG_TEST_FORKER_EVENT_LISTENER 0
-
-#define RETURN_CODE_PASSED 0
-#define RETURN_CODE_FAILED 1
-
-namespace android {
-namespace camera2 {
-namespace tests {
-
-bool TestForkerEventListener::mIsForked         = false;
-
-TestForkerEventListener::TestForkerEventListener() {
-    mIsForked = false;
-    mHasSucceeded = true;
-    mTermSignal = 0;
-}
-
-// Called before a test starts.
-void TestForkerEventListener::OnTestStart(const ::testing::TestInfo&) {
-
-    if (!TEST_EXTENSION_FORKING_ENABLED) {
-        return;
-    }
-
-    pid_t childPid = fork();
-    if (childPid != 0) {
-        int status;
-        waitpid(childPid, &status, /*options*/0);
-
-        // terminated normally?
-        mHasSucceeded = WIFEXITED(status);
-        // terminate with return code 0 = test passed, 1 = test failed
-        if (mHasSucceeded) {
-          mHasSucceeded = WEXITSTATUS(status) == RETURN_CODE_PASSED;
-        } else if (WIFSIGNALED(status)) {
-          mTermSignal = WTERMSIG(status);
-        }
-
-        /* the test is then skipped by inserting the various
-        TEST_EXTENSION_ macros in TestExtensions.h */
-
-    } else {
-        mIsForked = true;
-    }
-}
-
-// Called after a failed assertion or a SUCCEED() invocation.
-void TestForkerEventListener::OnTestPartResult(
-    const ::testing::TestPartResult& test_part_result) {
-
-    if (DEBUG_TEST_FORKER_EVENT_LISTENER) {
-        printf("%s in %s:%d\n%s\n",
-             test_part_result.failed() ? "*** Failure" : "Success",
-             test_part_result.file_name(),
-             test_part_result.line_number(),
-             test_part_result.summary());
-    }
-}
-
-// Called after a test ends.
-void TestForkerEventListener::OnTestEnd(const ::testing::TestInfo& test_info) {
-
-    if (!TEST_EXTENSION_FORKING_ENABLED) {
-        return;
-    }
-
-    if (mIsForked) {
-        exit(test_info.result()->Passed()
-            ? RETURN_CODE_PASSED : RETURN_CODE_FAILED);
-    } else if (!mHasSucceeded && mTermSignal != 0) {
-
-      printf("*** Test %s.%s crashed with signal = %s\n",
-             test_info.test_case_name(), test_info.name(),
-             strsignal(mTermSignal));
-    }
-
-    //TODO: overload the default event listener to suppress this message
-    // dynamically (e.g. by skipping OnTestPartResult after OnTestEnd )
-
-    // trigger a test failure if the child has failed
-    if (!mHasSucceeded) {
-        ADD_FAILURE();
-    }
-    mTermSignal = 0;
-}
-
-
-}
-}
-}
-
diff --git a/tests/camera2/TestForkerEventListener.h b/tests/camera2/TestForkerEventListener.h
deleted file mode 100644
index 347a06b..0000000
--- a/tests/camera2/TestForkerEventListener.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (C) 2012 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_HAL_CAMERA2_TESTS_FORKER_EVENT_LISTENER__
-#define __ANDROID_HAL_CAMERA2_TESTS_FORKER_EVENT_LISTENER__
-
-#include <gtest/gtest.h>
-
-namespace android {
-namespace camera2 {
-namespace tests {
-
-// Fork before each test runs.
-class TestForkerEventListener : public ::testing::EmptyTestEventListener {
-
-public:
-
-    TestForkerEventListener();
-
-private:
-
-    // Called before a test starts.
-    virtual void OnTestStart(const ::testing::TestInfo& test_info);
-
-    // Called after a failed assertion or a SUCCEED() invocation.
-    virtual void OnTestPartResult(
-        const ::testing::TestPartResult& test_part_result);
-
-    // Called after a test ends.
-    virtual void OnTestEnd(const ::testing::TestInfo& test_info);
-
-    bool mHasSucceeded;
-    int mTermSignal;
-
-public:
-    // do not read directly. use TEST_EXTENSION macros instead
-    static bool mIsForked;
-};
-
-}
-}
-}
-
-#endif
diff --git a/tests/camera2/TestSettings.cpp b/tests/camera2/TestSettings.cpp
deleted file mode 100644
index f07adc8..0000000
--- a/tests/camera2/TestSettings.cpp
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- * Copyright (C) 2012 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 <cstdlib>
-#include <getopt.h>
-#include <cstring>
-#include <iostream>
-
-#include "TestSettings.h"
-
-#include "TestForkerEventListener.h"
-
-namespace android {
-namespace camera2 {
-namespace tests {
-
-bool TestSettings::mForkingDisabled     = false;
-int  TestSettings::mDeviceId            = 0;
-char* const* TestSettings::mArgv;
-
-// --forking-disabled, false by default
-bool TestSettings::ForkingDisabled() {
-    return mForkingDisabled;
-}
-
-// reverse of --forking-disabled (not a flag), true by default
-bool TestSettings::ForkingEnabled() {
-    return !ForkingDisabled();
-}
-
-// --device-id, 0 by default
-int TestSettings::DeviceId() {
-    return mDeviceId;
-}
-
-// returns false if usage should be printed and we should exit early
-bool TestSettings::ParseArgs(int argc, char* const argv[])
-{
-    {
-        char *env = getenv("CAMERA2_TEST_FORKING_DISABLED");
-        if (env) {
-            mForkingDisabled = atoi(env);
-        }
-
-        env = getenv("CAMERA2_TEST_DEVICE_ID");
-        if (env) {
-            mDeviceId = atoi(env);
-        }
-    }
-
-    bool printHelp = false;
-    bool unknownArgs = false;
-
-    opterr = 0; // do not print errors for unknown arguments
-    while (true) {
-        int c;
-        int option_index = 0;
-
-        static struct option long_options[] = {
-            /* name              has_arg          flag val */
-            {"forking-disabled", optional_argument, 0,  0  },
-            {"device-id",        required_argument, 0,  0  },
-            {"help",             no_argument,       0, 'h' },
-            {0,                  0,                 0,  0  }
-        };
-
-        // Note: '+' in optstring means do not mutate argv
-        c = getopt_long(argc, argv, "+h", long_options, &option_index);
-
-        if (c == -1) { // All arguments exhausted
-            break;
-        }
-        if (c == '?') { // Argument not in option lists
-            const char *arg = argv[optind-1];
-            // Anything beginning with gtest_ will get handled by gtest
-            if (strstr(arg, "--gtest_") != arg) {
-                std::cerr << "Unknown argument: " << arg << std::endl;
-                unknownArgs = true;
-            }
-            continue;
-        }
-
-        switch (c) {
-        case 0: // long option
-            switch (option_index) {
-            case 0: {
-                const char *arg = optarg ?: "1";
-                mForkingDisabled = atoi(arg);
-                break;
-            }
-            case 1: {
-                mDeviceId = atoi(optarg);
-                break;
-            }
-            default:
-                std::cerr << "Unknown long option: " << option_index << std::endl;
-                break;
-            }
-            break; // case 0
-        case 'h': // help
-            printHelp = true;
-            break;
-        default: // case '?'
-            std::cerr << "Unknown option: " << optarg << std::endl;
-        }
-    }
-
-    if (unknownArgs) {
-        std::cerr << std::endl;
-    }
-
-    mArgv = argv;
-
-    if (printHelp || unknownArgs) {
-        return false;
-    }
-
-    std::cerr << "Forking Disabled: "
-              << (mForkingDisabled ? "yes" : "no") << std::endl;
-
-    std::cerr << "Device ID: " << mDeviceId << std::endl;
-
-    return true;
-}
-
-// print usage/help list of commands (non-gtest)
-void TestSettings::PrintUsage() {
-    std::cerr << "Usage: " << mArgv[0] << " [OPTIONS]" << std::endl;
-    std::cerr << std::endl;
-
-    std::cerr << "Main modes of operation:"
-              << std::endl;
-    std::cerr << "   --forking-disabled[=1]  don't fork process before "
-              << std::endl
-              << "                           running a new test."
-              << std::endl
-              << "                           (default enabled)"
-              << std::endl;
-    std::cerr << "   --device-id=ID          specify a different camera ID"
-              << std::endl
-              << "                           (default 0)"
-              << std::endl;
-
-    std::cerr << "   -h, --help              print this help listing"
-              << std::endl;
-
-
-    std::cerr << std::endl;
-}
-
-}
-}
-}
-
diff --git a/tests/camera2/TestSettings.h b/tests/camera2/TestSettings.h
deleted file mode 100644
index 6164de5..0000000
--- a/tests/camera2/TestSettings.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-:qa
- * Copyright (C) 2012 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_HAL_CAMERA2_TESTS_SETTINGS__
-#define __ANDROID_HAL_CAMERA2_TESTS_SETTINGS__
-
-namespace android {
-namespace camera2 {
-namespace tests {
-
-class TestSettings {
-
-public:
-    // --forking-disabled, false by default
-    static bool ForkingDisabled();
-
-    // reverse of --forking-disabled (not a flag), true by default
-    static bool ForkingEnabled();
-
-    // --device-id, 0 by default
-    static int DeviceId();
-
-    // returns false if usage should be printed and we should exit early
-    static bool ParseArgs(int argc, char* const argv[]);
-
-    // print usage/help list of commands (non-gtest)
-    static void PrintUsage();
-
-private:
-    TestSettings();
-    ~TestSettings();
-
-    static bool mForkingDisabled;
-    static int  mDeviceId;
-    static char* const* mArgv;
-};
-
-}
-}
-}
-
-#endif
diff --git a/tests/camera2/camera2_utils.cpp b/tests/camera2/camera2_utils.cpp
deleted file mode 100644
index dab0ae9..0000000
--- a/tests/camera2/camera2_utils.cpp
+++ /dev/null
@@ -1,609 +0,0 @@
-/*
- * Copyright (C) 2012 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.
- */
-
-// Utility classes for camera2 HAL testing
-
-#define LOG_TAG "Camera2_test_utils"
-#define LOG_NDEBUG 0
-
-#include "utils/Log.h"
-#include "camera2_utils.h"
-#include <dlfcn.h>
-
-namespace android {
-namespace camera2 {
-namespace tests {
-
-/**
- * MetadataQueue
- */
-
-MetadataQueue::MetadataQueue():
-            mDevice(NULL),
-            mFrameCount(0),
-            mCount(0),
-            mStreamSlotCount(0),
-            mSignalConsumer(true)
-{
-    camera2_request_queue_src_ops::dequeue_request = consumer_dequeue;
-    camera2_request_queue_src_ops::request_count = consumer_buffer_count;
-    camera2_request_queue_src_ops::free_request = consumer_free;
-
-    camera2_frame_queue_dst_ops::dequeue_frame = producer_dequeue;
-    camera2_frame_queue_dst_ops::cancel_frame = producer_cancel;
-    camera2_frame_queue_dst_ops::enqueue_frame = producer_enqueue;
-}
-
-MetadataQueue::~MetadataQueue() {
-    freeBuffers(mEntries.begin(), mEntries.end());
-    freeBuffers(mStreamSlot.begin(), mStreamSlot.end());
-}
-
-// Interface to camera2 HAL as consumer (input requests/reprocessing)
-const camera2_request_queue_src_ops_t* MetadataQueue::getToConsumerInterface() {
-    return static_cast<camera2_request_queue_src_ops_t*>(this);
-}
-
-void MetadataQueue::setFromConsumerInterface(camera2_device_t *d) {
-    mDevice = d;
-}
-
-const camera2_frame_queue_dst_ops_t* MetadataQueue::getToProducerInterface() {
-    return static_cast<camera2_frame_queue_dst_ops_t*>(this);
-}
-
-// Real interfaces
-status_t MetadataQueue::enqueue(camera_metadata_t *buf) {
-    Mutex::Autolock l(mMutex);
-
-    mCount++;
-    mEntries.push_back(buf);
-    notEmpty.signal();
-
-    if (mSignalConsumer && mDevice != NULL) {
-        mSignalConsumer = false;
-
-        mMutex.unlock();
-        ALOGV("%s: Signaling consumer", __FUNCTION__);
-        mDevice->ops->notify_request_queue_not_empty(mDevice);
-        mMutex.lock();
-    }
-    return OK;
-}
-
-int MetadataQueue::getBufferCount() {
-    Mutex::Autolock l(mMutex);
-    if (mStreamSlotCount > 0) {
-        return CAMERA2_REQUEST_QUEUE_IS_BOTTOMLESS;
-    }
-    return mCount;
-}
-
-status_t MetadataQueue::dequeue(camera_metadata_t **buf, bool incrementCount) {
-    Mutex::Autolock l(mMutex);
-
-    if (mCount == 0) {
-        if (mStreamSlotCount == 0) {
-            ALOGV("%s: Empty", __FUNCTION__);
-            *buf = NULL;
-            mSignalConsumer = true;
-            return OK;
-        }
-        ALOGV("%s: Streaming %d frames to queue", __FUNCTION__,
-              mStreamSlotCount);
-
-        for (List<camera_metadata_t*>::iterator slotEntry = mStreamSlot.begin();
-                slotEntry != mStreamSlot.end();
-                slotEntry++ ) {
-            size_t entries = get_camera_metadata_entry_count(*slotEntry);
-            size_t dataBytes = get_camera_metadata_data_count(*slotEntry);
-
-            camera_metadata_t *copy = allocate_camera_metadata(entries, dataBytes);
-            append_camera_metadata(copy, *slotEntry);
-            mEntries.push_back(copy);
-        }
-        mCount = mStreamSlotCount;
-    }
-    ALOGV("MetadataQueue: deque (%d buffers)", mCount);
-    camera_metadata_t *b = *(mEntries.begin());
-    mEntries.erase(mEntries.begin());
-
-    if (incrementCount) {
-        add_camera_metadata_entry(b,
-                ANDROID_REQUEST_FRAME_COUNT,
-                (void**)&mFrameCount, 1);
-        mFrameCount++;
-    }
-
-    *buf = b;
-    mCount--;
-
-    return OK;
-}
-
-status_t MetadataQueue::waitForBuffer(nsecs_t timeout) {
-    Mutex::Autolock l(mMutex);
-    status_t res;
-    while (mCount == 0) {
-        res = notEmpty.waitRelative(mMutex,timeout);
-        if (res != OK) return res;
-    }
-    return OK;
-}
-
-status_t MetadataQueue::setStreamSlot(camera_metadata_t *buf) {
-    if (buf == NULL) {
-        freeBuffers(mStreamSlot.begin(), mStreamSlot.end());
-        mStreamSlotCount = 0;
-        return OK;
-    }
-    if (mStreamSlotCount > 1) {
-        List<camera_metadata_t*>::iterator deleter = ++mStreamSlot.begin();
-        freeBuffers(++mStreamSlot.begin(), mStreamSlot.end());
-        mStreamSlotCount = 1;
-    }
-    if (mStreamSlotCount == 1) {
-        free_camera_metadata( *(mStreamSlot.begin()) );
-        *(mStreamSlot.begin()) = buf;
-    } else {
-        mStreamSlot.push_front(buf);
-        mStreamSlotCount = 1;
-    }
-    return OK;
-}
-
-status_t MetadataQueue::setStreamSlot(const List<camera_metadata_t*> &bufs) {
-    if (mStreamSlotCount > 0) {
-        freeBuffers(mStreamSlot.begin(), mStreamSlot.end());
-    }
-    mStreamSlot = bufs;
-    mStreamSlotCount = mStreamSlot.size();
-
-    return OK;
-}
-
-status_t MetadataQueue::freeBuffers(List<camera_metadata_t*>::iterator start,
-                                    const List<camera_metadata_t*>::iterator& end) {
-    while (start != end) {
-        free_camera_metadata(*start);
-        start = mStreamSlot.erase(start);
-    }
-    return OK;
-}
-
-MetadataQueue* MetadataQueue::getInstance(
-        const camera2_request_queue_src_ops_t *q) {
-    const MetadataQueue* cmq = static_cast<const MetadataQueue*>(q);
-    return const_cast<MetadataQueue*>(cmq);
-}
-
-MetadataQueue* MetadataQueue::getInstance(
-        const camera2_frame_queue_dst_ops_t *q) {
-    const MetadataQueue* cmq = static_cast<const MetadataQueue*>(q);
-    return const_cast<MetadataQueue*>(cmq);
-}
-
-int MetadataQueue::consumer_buffer_count(
-        const camera2_request_queue_src_ops_t *q) {
-    MetadataQueue *queue = getInstance(q);
-    return queue->getBufferCount();
-}
-
-int MetadataQueue::consumer_dequeue(const camera2_request_queue_src_ops_t *q,
-        camera_metadata_t **buffer) {
-    MetadataQueue *queue = getInstance(q);
-    return queue->dequeue(buffer, true);
-}
-
-int MetadataQueue::consumer_free(const camera2_request_queue_src_ops_t * /* q */,
-        camera_metadata_t *old_buffer) {
-    free_camera_metadata(old_buffer);
-    return OK;
-}
-
-int MetadataQueue::producer_dequeue(const camera2_frame_queue_dst_ops_t * /* q */,
-        size_t entries, size_t bytes,
-        camera_metadata_t **buffer) {
-    camera_metadata_t *new_buffer =
-            allocate_camera_metadata(entries, bytes);
-    if (new_buffer == NULL) return NO_MEMORY;
-    *buffer = new_buffer;
-        return OK;
-}
-
-int MetadataQueue::producer_cancel(const camera2_frame_queue_dst_ops_t * /* q */,
-        camera_metadata_t *old_buffer) {
-    free_camera_metadata(old_buffer);
-    return OK;
-}
-
-int MetadataQueue::producer_enqueue(const camera2_frame_queue_dst_ops_t *q,
-        camera_metadata_t *filled_buffer) {
-    MetadataQueue *queue = getInstance(q);
-    return queue->enqueue(filled_buffer);
-}
-
-/**
- * NotifierListener
- */
-
-NotifierListener::NotifierListener() {
-}
-
-status_t NotifierListener::getNotificationsFrom(camera2_device *dev) {
-    if (!dev) return BAD_VALUE;
-    status_t err;
-    err = dev->ops->set_notify_callback(dev,
-            notify_callback_dispatch,
-            (void*)this);
-    return err;
-}
-
-status_t NotifierListener::getNextNotification(int32_t *msg_type,
-        int32_t *ext1,
-        int32_t *ext2,
-        int32_t *ext3) {
-    Mutex::Autolock l(mMutex);
-    if (mNotifications.size() == 0) return BAD_VALUE;
-    return getNextNotificationLocked(msg_type, ext1, ext2, ext3);
-}
-
-status_t NotifierListener::waitForNotification(int32_t *msg_type,
-        int32_t *ext1,
-        int32_t *ext2,
-        int32_t *ext3) {
-    Mutex::Autolock l(mMutex);
-    while (mNotifications.size() == 0) {
-        mNewNotification.wait(mMutex);
-    }
-    return getNextNotificationLocked(msg_type, ext1, ext2, ext3);
-}
-
-int NotifierListener::numNotifications() {
-    Mutex::Autolock l(mMutex);
-    return mNotifications.size();
-}
-
-status_t NotifierListener::getNextNotificationLocked(int32_t *msg_type,
-        int32_t *ext1,
-        int32_t *ext2,
-        int32_t *ext3) {
-    *msg_type = mNotifications.begin()->msg_type;
-    *ext1 = mNotifications.begin()->ext1;
-    *ext2 = mNotifications.begin()->ext2;
-    *ext3 = mNotifications.begin()->ext3;
-    mNotifications.erase(mNotifications.begin());
-    return OK;
-}
-
-void NotifierListener::onNotify(int32_t msg_type,
-        int32_t ext1,
-        int32_t ext2,
-        int32_t ext3) {
-    Mutex::Autolock l(mMutex);
-    mNotifications.push_back(Notification(msg_type, ext1, ext2, ext3));
-    mNewNotification.signal();
-}
-
-void NotifierListener::notify_callback_dispatch(int32_t msg_type,
-        int32_t ext1,
-        int32_t ext2,
-        int32_t ext3,
-        void *user) {
-    NotifierListener *me = reinterpret_cast<NotifierListener*>(user);
-    me->onNotify(msg_type, ext1, ext2, ext3);
-}
-
-/**
- * StreamAdapter
- */
-
-#ifndef container_of
-#define container_of(ptr, type, member) \
-    (type *)((char*)(ptr) - offsetof(type, member))
-#endif
-
-StreamAdapter::StreamAdapter(sp<IGraphicBufferProducer> consumer):
-        mState(UNINITIALIZED), mDevice(NULL),
-        mId(-1),
-        mWidth(0), mHeight(0), mFormat(0)
-{
-    mConsumerInterface = new Surface(consumer);
-    camera2_stream_ops::dequeue_buffer = dequeue_buffer;
-    camera2_stream_ops::enqueue_buffer = enqueue_buffer;
-    camera2_stream_ops::cancel_buffer = cancel_buffer;
-    camera2_stream_ops::set_crop = set_crop;
-}
-
-StreamAdapter::~StreamAdapter() {
-    disconnect();
-}
-
-status_t StreamAdapter::connectToDevice(camera2_device_t *d,
-        uint32_t width, uint32_t height, int format) {
-    if (mState != UNINITIALIZED) return INVALID_OPERATION;
-    if (d == NULL) {
-        ALOGE("%s: Null device passed to stream adapter", __FUNCTION__);
-        return BAD_VALUE;
-    }
-
-    status_t res;
-
-    mWidth = width;
-    mHeight = height;
-    mFormat = format;
-
-    // Allocate device-side stream interface
-
-    uint32_t id;
-    uint32_t formatActual; // ignored
-    uint32_t usage;
-    uint32_t maxBuffers = 2;
-    res = d->ops->allocate_stream(d,
-            mWidth, mHeight, mFormat, getStreamOps(),
-            &id, &formatActual, &usage, &maxBuffers);
-    if (res != OK) {
-        ALOGE("%s: Device stream allocation failed: %s (%d)",
-                __FUNCTION__, strerror(-res), res);
-        mState = UNINITIALIZED;
-        return res;
-    }
-    mDevice = d;
-
-    mId = id;
-    mUsage = usage;
-    mMaxProducerBuffers = maxBuffers;
-
-    // Configure consumer-side ANativeWindow interface
-
-    res = native_window_api_connect(mConsumerInterface.get(),
-            NATIVE_WINDOW_API_CAMERA);
-    if (res != OK) {
-        ALOGE("%s: Unable to connect to native window for stream %d",
-                __FUNCTION__, mId);
-        mState = ALLOCATED;
-        return res;
-    }
-
-    res = native_window_set_usage(mConsumerInterface.get(), mUsage);
-    if (res != OK) {
-        ALOGE("%s: Unable to configure usage %08x for stream %d",
-                __FUNCTION__, mUsage, mId);
-        mState = CONNECTED;
-        return res;
-    }
-
-    res = native_window_set_buffers_dimensions(mConsumerInterface.get(),
-            mWidth, mHeight);
-    if (res != OK) {
-        ALOGE("%s: Unable to configure buffer dimensions"
-                " %d x %d for stream %d",
-                __FUNCTION__, mWidth, mHeight, mId);
-        mState = CONNECTED;
-        return res;
-    }
-    res = native_window_set_buffers_format(mConsumerInterface.get(),
-            mFormat);
-    if (res != OK) {
-        ALOGE("%s: Unable to configure buffer format"
-                " 0x%x for stream %d",
-                __FUNCTION__, mFormat, mId);
-        mState = CONNECTED;
-        return res;
-    }
-
-    int maxConsumerBuffers;
-    res = mConsumerInterface->query(mConsumerInterface.get(),
-            NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &maxConsumerBuffers);
-    if (res != OK) {
-        ALOGE("%s: Unable to query consumer undequeued"
-                " buffer count for stream %d", __FUNCTION__, mId);
-        mState = CONNECTED;
-        return res;
-    }
-    mMaxConsumerBuffers = maxConsumerBuffers;
-
-    ALOGV("%s: Producer wants %d buffers, consumer wants %d", __FUNCTION__,
-            mMaxProducerBuffers, mMaxConsumerBuffers);
-
-    int totalBuffers = mMaxConsumerBuffers + mMaxProducerBuffers;
-
-    res = native_window_set_buffer_count(mConsumerInterface.get(),
-            totalBuffers);
-    if (res != OK) {
-        ALOGE("%s: Unable to set buffer count for stream %d",
-                __FUNCTION__, mId);
-        mState = CONNECTED;
-        return res;
-    }
-
-    // Register allocated buffers with HAL device
-    buffer_handle_t *buffers = new buffer_handle_t[totalBuffers];
-    ANativeWindowBuffer **anwBuffers = new ANativeWindowBuffer*[totalBuffers];
-    int bufferIdx = 0;
-    for (; bufferIdx < totalBuffers; bufferIdx++) {
-        res = native_window_dequeue_buffer_and_wait(mConsumerInterface.get(),
-                &anwBuffers[bufferIdx]);
-        if (res != OK) {
-            ALOGE("%s: Unable to dequeue buffer %d for initial registration for"
-                    "stream %d", __FUNCTION__, bufferIdx, mId);
-            mState = CONNECTED;
-            goto cleanUpBuffers;
-        }
-        buffers[bufferIdx] = anwBuffers[bufferIdx]->handle;
-    }
-
-    res = mDevice->ops->register_stream_buffers(mDevice,
-            mId,
-            totalBuffers,
-            buffers);
-    if (res != OK) {
-        ALOGE("%s: Unable to register buffers with HAL device for stream %d",
-                __FUNCTION__, mId);
-        mState = CONNECTED;
-    } else {
-        mState = ACTIVE;
-    }
-
-cleanUpBuffers:
-    for (int i = 0; i < bufferIdx; i++) {
-        res = mConsumerInterface->cancelBuffer(mConsumerInterface.get(),
-                anwBuffers[i], -1);
-    }
-    delete[] anwBuffers;
-    delete[] buffers;
-
-    return res;
-}
-
-status_t StreamAdapter::disconnect() {
-    status_t res;
-    if (mState >= ALLOCATED) {
-        res = mDevice->ops->release_stream(mDevice, mId);
-        if (res != OK) {
-            ALOGE("%s: Unable to release stream %d",
-                    __FUNCTION__, mId);
-            return res;
-        }
-    }
-    if (mState >= CONNECTED) {
-        res = native_window_api_disconnect(mConsumerInterface.get(),
-                NATIVE_WINDOW_API_CAMERA);
-        if (res != OK) {
-            ALOGE("%s: Unable to disconnect stream %d from native window",
-                    __FUNCTION__, mId);
-            return res;
-        }
-    }
-    mId = -1;
-    mState = DISCONNECTED;
-    return OK;
-}
-
-int StreamAdapter::getId() {
-    return mId;
-}
-
-const camera2_stream_ops *StreamAdapter::getStreamOps() {
-    return static_cast<camera2_stream_ops *>(this);
-}
-
-ANativeWindow* StreamAdapter::toANW(const camera2_stream_ops_t *w) {
-    return static_cast<const StreamAdapter*>(w)->mConsumerInterface.get();
-}
-
-int StreamAdapter::dequeue_buffer(const camera2_stream_ops_t *w,
-        buffer_handle_t** buffer) {
-    int res;
-    int state = static_cast<const StreamAdapter*>(w)->mState;
-    if (state != ACTIVE) {
-        ALOGE("%s: Called when in bad state: %d", __FUNCTION__, state);
-        return INVALID_OPERATION;
-    }
-
-    ANativeWindow *a = toANW(w);
-    ANativeWindowBuffer* anb;
-    res = native_window_dequeue_buffer_and_wait(a, &anb);
-    if (res != OK) return res;
-
-    *buffer = &(anb->handle);
-
-    return res;
-}
-
-int StreamAdapter::enqueue_buffer(const camera2_stream_ops_t* w,
-        int64_t timestamp,
-        buffer_handle_t* buffer) {
-    int state = static_cast<const StreamAdapter*>(w)->mState;
-    if (state != ACTIVE) {
-        ALOGE("%s: Called when in bad state: %d", __FUNCTION__, state);
-        return INVALID_OPERATION;
-    }
-    ANativeWindow *a = toANW(w);
-    status_t err;
-    err = native_window_set_buffers_timestamp(a, timestamp);
-    if (err != OK) return err;
-    return a->queueBuffer(a,
-            container_of(buffer, ANativeWindowBuffer, handle), -1);
-}
-
-int StreamAdapter::cancel_buffer(const camera2_stream_ops_t* w,
-        buffer_handle_t* buffer) {
-    int state = static_cast<const StreamAdapter*>(w)->mState;
-    if (state != ACTIVE) {
-        ALOGE("%s: Called when in bad state: %d", __FUNCTION__, state);
-        return INVALID_OPERATION;
-    }
-    ANativeWindow *a = toANW(w);
-    return a->cancelBuffer(a,
-            container_of(buffer, ANativeWindowBuffer, handle), -1);
-}
-
-int StreamAdapter::set_crop(const camera2_stream_ops_t* w,
-        int left, int top, int right, int bottom) {
-    int state = static_cast<const StreamAdapter*>(w)->mState;
-    if (state != ACTIVE) {
-        ALOGE("%s: Called when in bad state: %d", __FUNCTION__, state);
-        return INVALID_OPERATION;
-    }
-    ANativeWindow *a = toANW(w);
-    android_native_rect_t crop = { left, top, right, bottom };
-    return native_window_set_crop(a, &crop);
-}
-
-/**
- * FrameWaiter
- */
-
-FrameWaiter::FrameWaiter():
-        mPendingFrames(0) {
-}
-
-status_t FrameWaiter::waitForFrame(nsecs_t timeout) {
-    status_t res;
-    Mutex::Autolock lock(mMutex);
-    while (mPendingFrames == 0) {
-        res = mCondition.waitRelative(mMutex, timeout);
-        if (res != OK) return res;
-    }
-    mPendingFrames--;
-    return OK;
-}
-
-void FrameWaiter::onFrameAvailable(const BufferItem& /* item */) {
-    Mutex::Autolock lock(mMutex);
-    mPendingFrames++;
-    mCondition.signal();
-}
-
-int HWModuleHelpers::closeModule(void *dso) {
-    int status;
-    if (!dso) {
-        return -EINVAL;
-    }
-
-    status = dlclose(dso);
-    if (status != 0) {
-        char const *err_str = dlerror();
-        ALOGE("%s dlclose failed, error: %s", __func__, err_str ?: "unknown");
-    }
-
-    return status;
-}
-
-} // namespace tests
-} // namespace camera2
-} // namespace android
diff --git a/tests/camera2/camera2_utils.h b/tests/camera2/camera2_utils.h
deleted file mode 100644
index 274ee76..0000000
--- a/tests/camera2/camera2_utils.h
+++ /dev/null
@@ -1,250 +0,0 @@
-/*
- * Copyright (C) 2012 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_HAL_CAMERA2_TESTS_UTILS__
-#define __ANDROID_HAL_CAMERA2_TESTS_UTILS__
-
-// Utility classes for camera2 HAL testing
-
-#include <system/camera_metadata.h>
-#include <hardware/camera2.h>
-
-#include <gui/Surface.h>
-#include <gui/CpuConsumer.h>
-
-#include <utils/List.h>
-#include <utils/Mutex.h>
-#include <utils/Condition.h>
-
-namespace android {
-namespace camera2 {
-namespace tests {
-
-/**
- * Queue class for both sending requests to a camera2 device, and for receiving
- * frames from a camera2 device.
- */
-class MetadataQueue: public camera2_request_queue_src_ops_t,
-                    public camera2_frame_queue_dst_ops_t {
-  public:
-    MetadataQueue();
-    ~MetadataQueue();
-
-    // Interface to camera2 HAL device, either for requests (device is consumer)
-    // or for frames (device is producer)
-    const camera2_request_queue_src_ops_t*   getToConsumerInterface();
-    void setFromConsumerInterface(camera2_device_t *d);
-
-    const camera2_frame_queue_dst_ops_t* getToProducerInterface();
-
-    // Real interfaces. On enqueue, queue takes ownership of buffer pointer
-    // On dequeue, user takes ownership of buffer pointer.
-    status_t enqueue(camera_metadata_t *buf);
-    status_t dequeue(camera_metadata_t **buf, bool incrementCount = true);
-    int      getBufferCount();
-    status_t waitForBuffer(nsecs_t timeout);
-
-    // Set repeating buffer(s); if the queue is empty on a dequeue call, the
-    // queue copies the contents of the stream slot into the queue, and then
-    // dequeues the first new entry.
-    status_t setStreamSlot(camera_metadata_t *buf);
-    status_t setStreamSlot(const List<camera_metadata_t*> &bufs);
-
-  private:
-    status_t freeBuffers(List<camera_metadata_t*>::iterator start,
-                         const List<camera_metadata_t*>::iterator& end);
-
-    camera2_device_t *mDevice;
-
-    Mutex mMutex;
-    Condition notEmpty;
-
-    int mFrameCount;
-
-    int mCount;
-    List<camera_metadata_t*> mEntries;
-    int mStreamSlotCount;
-    List<camera_metadata_t*> mStreamSlot;
-
-    bool mSignalConsumer;
-
-    static MetadataQueue* getInstance(const camera2_frame_queue_dst_ops_t *q);
-    static MetadataQueue* getInstance(const camera2_request_queue_src_ops_t *q);
-
-    static int consumer_buffer_count(const camera2_request_queue_src_ops_t *q);
-
-    static int consumer_dequeue(const camera2_request_queue_src_ops_t *q,
-            camera_metadata_t **buffer);
-
-    static int consumer_free(const camera2_request_queue_src_ops_t *q,
-            camera_metadata_t *old_buffer);
-
-    static int producer_dequeue(const camera2_frame_queue_dst_ops_t *q,
-            size_t entries, size_t bytes,
-            camera_metadata_t **buffer);
-
-    static int producer_cancel(const camera2_frame_queue_dst_ops_t *q,
-            camera_metadata_t *old_buffer);
-
-    static int producer_enqueue(const camera2_frame_queue_dst_ops_t *q,
-            camera_metadata_t *filled_buffer);
-
-};
-
-/**
- * Basic class to receive and queue up notifications from the camera device
- */
-
-class NotifierListener {
-  public:
-
-    NotifierListener();
-
-    status_t getNotificationsFrom(camera2_device *dev);
-
-    status_t getNextNotification(int32_t *msg_type, int32_t *ext1,
-            int32_t *ext2, int32_t *ext3);
-
-    status_t waitForNotification(int32_t *msg_type, int32_t *ext1,
-            int32_t *ext2, int32_t *ext3);
-
-    int numNotifications();
-
-  private:
-
-    status_t getNextNotificationLocked(int32_t *msg_type,
-            int32_t *ext1, int32_t *ext2, int32_t *ext3);
-
-    struct Notification {
-        Notification(int32_t type, int32_t e1, int32_t e2, int32_t e3):
-                msg_type(type),
-                ext1(e1),
-                ext2(e2),
-                ext3(e3)
-        {}
-
-        int32_t msg_type;
-        int32_t ext1;
-        int32_t ext2;
-        int32_t ext3;
-    };
-
-    List<Notification> mNotifications;
-
-    Mutex mMutex;
-    Condition mNewNotification;
-
-    void onNotify(int32_t msg_type,
-            int32_t ext1,
-            int32_t ext2,
-            int32_t ext3);
-
-    static void notify_callback_dispatch(int32_t msg_type,
-            int32_t ext1,
-            int32_t ext2,
-            int32_t ext3,
-            void *user);
-
-};
-
-/**
- * Adapter from an IGraphicBufferProducer interface to camera2 device stream ops.
- * Also takes care of allocating/deallocating stream in device interface
- */
-class StreamAdapter: public camera2_stream_ops {
-  public:
-    explicit StreamAdapter(sp<IGraphicBufferProducer> consumer);
-
-    ~StreamAdapter();
-
-    status_t connectToDevice(camera2_device_t *d,
-            uint32_t width, uint32_t height, int format);
-
-    status_t disconnect();
-
-    // Get stream ID. Only valid after a successful connectToDevice call.
-    int      getId();
-
-  private:
-    enum {
-        ERROR = -1,
-        DISCONNECTED = 0,
-        UNINITIALIZED,
-        ALLOCATED,
-        CONNECTED,
-        ACTIVE
-    } mState;
-
-    sp<ANativeWindow> mConsumerInterface;
-    camera2_device_t *mDevice;
-
-    uint32_t mId;
-    uint32_t mWidth;
-    uint32_t mHeight;
-    uint32_t mFormat;
-    uint32_t mUsage;
-    uint32_t mMaxProducerBuffers;
-    uint32_t mMaxConsumerBuffers;
-
-    const camera2_stream_ops *getStreamOps();
-
-    static ANativeWindow* toANW(const camera2_stream_ops_t *w);
-
-    static int dequeue_buffer(const camera2_stream_ops_t *w,
-            buffer_handle_t** buffer);
-
-    static int enqueue_buffer(const camera2_stream_ops_t* w,
-            int64_t timestamp,
-            buffer_handle_t* buffer);
-
-    static int cancel_buffer(const camera2_stream_ops_t* w,
-            buffer_handle_t* buffer);
-
-    static int set_crop(const camera2_stream_ops_t* w,
-            int left, int top, int right, int bottom);
-
-};
-
-/**
- * Simple class to wait on the CpuConsumer to have a frame available
- */
-class FrameWaiter : public CpuConsumer::FrameAvailableListener {
-  public:
-    FrameWaiter();
-
-    /**
-     * Wait for max timeout nanoseconds for a new frame. Returns
-     * OK if a frame is available, TIMED_OUT if the timeout was reached.
-     */
-    status_t waitForFrame(nsecs_t timeout);
-
-    virtual void onFrameAvailable(const BufferItem& item);
-
-    int mPendingFrames;
-    Mutex mMutex;
-    Condition mCondition;
-};
-
-struct HWModuleHelpers {
-    /* attempt to unload the library with dlclose */
-    static int closeModule(void* dso);
-};
-
-}
-}
-}
-
-#endif
diff --git a/tests/camera2/main.cpp b/tests/camera2/main.cpp
deleted file mode 100644
index e0ebbe9..0000000
--- a/tests/camera2/main.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright (C) 2012 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 <gtest/gtest.h>
-#include "TestForkerEventListener.h"
-#include "TestSettings.h"
-
-using android::camera2::tests::TestForkerEventListener;
-using android::camera2::tests::TestSettings;
-
-int main(int argc, char **argv) {
-
-    bool printUsage = !TestSettings::ParseArgs(argc, argv);
-
-    ::testing::InitGoogleTest(&argc, argv);
-
-    if (printUsage) {
-        TestSettings::PrintUsage();
-        return 0;
-    }
-
-    // Gets hold of the event listener list.
-    ::testing::TestEventListeners& listeners =
-        ::testing::UnitTest::GetInstance()->listeners();
-    // Adds a listener to the end.  Google Test takes the ownership.
-    listeners.Append(new TestForkerEventListener());
-
-    int ret = RUN_ALL_TESTS();
-
-    return ret;
-}