Move dead submodules in-tree

Signed-off-by: swurl <swurl@swurl.xyz>

1 files changed, 432 insertions, 0 deletions

diff --git a/externals/oboe/tests/testStreamClosedMethods.cpp b/externals/oboe/tests/testStreamClosedMethods.cpp
new file mode 100644
index 0000000000..62b08596ca
--- /dev/null
+++ b/externals/oboe/tests/testStreamClosedMethods.cpp
@@ -0,0 +1,432 @@
+/*
+ * Copyright 2018 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 <oboe/Oboe.h>
+
+using namespace oboe;
+
+class MyCallback : public AudioStreamDataCallback {
+public:
+    DataCallbackResult onAudioReady(AudioStream *oboeStream, void *audioData, int32_t numFrames) override {
+        return DataCallbackResult::Continue;
+    }
+};
+
+class StreamClosedReturnValues : public ::testing::Test {
+
+protected:
+
+    bool openStream() {
+        Result r = mBuilder.openStream(mStream);
+        EXPECT_EQ(r, Result::OK) << "Failed to open stream " << convertToText(r);
+        return (r == Result::OK);
+    }
+
+    bool releaseStream() {
+        Result r = mStream->release();
+        if (getSdkVersion() > __ANDROID_API_R__ && mBuilder.getAudioApi() != AudioApi::OpenSLES) {
+            EXPECT_EQ(r, Result::OK) << "Failed to release stream. " << convertToText(r);
+            return (r == Result::OK);
+        } else {
+            EXPECT_EQ(r, Result::ErrorUnimplemented) << "Did not get  ErrorUnimplemented" << convertToText(r);
+            return (r == Result::ErrorUnimplemented);
+        }
+    }
+
+    bool closeStream() {
+        Result r = mStream->close();
+        EXPECT_EQ(r, Result::OK) << "Failed to close stream. " << convertToText(r);
+        return (r == Result::OK);
+    }
+
+    bool openAndCloseStream() {
+        if (!openStream() || !closeStream())
+            return false;
+        StreamState s = mStream->getState();
+        EXPECT_EQ(s, StreamState::Closed) << "Stream state " << convertToText(mStream->getState());
+        return (s == StreamState::Closed);
+    }
+
+    static int64_t getNanoseconds() {
+        struct timespec time;
+        int result = clock_gettime(CLOCK_MONOTONIC, &time);
+        if (result < 0) {
+            return result;
+        }
+        return (time.tv_sec * (int64_t)1e9) + time.tv_nsec;
+    }
+
+	// ASSERT_* requires a void return type.
+    void measureCloseTime(int32_t delayMillis) {
+        ASSERT_TRUE(openStream());
+        mStream->setDelayBeforeCloseMillis(delayMillis);
+        ASSERT_EQ(delayMillis, mStream->getDelayBeforeCloseMillis());
+        // Measure time it takes to close.
+        int64_t startTimeMillis = getNanoseconds() / 1e6;
+        ASSERT_TRUE(closeStream());
+        int64_t stopTimeMillis = getNanoseconds() / 1e6;
+        int32_t elapsedTimeMillis = (int32_t)(stopTimeMillis - startTimeMillis);
+        ASSERT_GE(elapsedTimeMillis, delayMillis);
+    }
+
+    void testDelayBeforeClose() {
+        const int32_t delayMillis = 500;
+        measureCloseTime(delayMillis);
+    }
+
+    AudioStreamBuilder mBuilder;
+    std::shared_ptr<AudioStream> mStream;
+
+};
+
+TEST_F(StreamClosedReturnValues, GetChannelCountReturnsLastKnownValue){
+
+    mBuilder.setChannelCount(2);
+    ASSERT_TRUE(openAndCloseStream());
+    ASSERT_EQ(mStream->getChannelCount(), 2);
+}
+
+TEST_F(StreamClosedReturnValues, GetDirectionReturnsLastKnownValue){
+
+    // Note that when testing on the emulator setting the direction to Input will result in ErrorInternal when
+    // opening the stream
+    mBuilder.setDirection(Direction::Input);
+    ASSERT_TRUE(openAndCloseStream());
+    ASSERT_EQ(mStream->getDirection(), Direction::Input);
+}
+
+TEST_F(StreamClosedReturnValues, GetSampleRateReturnsLastKnownValue){
+
+    mBuilder.setSampleRate(8000);
+    ASSERT_TRUE(openAndCloseStream());
+    ASSERT_EQ(mStream->getSampleRate(), 8000);
+}
+
+TEST_F(StreamClosedReturnValues, GetFramesPerCallbackReturnsLastKnownValue) {
+
+    mBuilder.setFramesPerCallback(192);
+    ASSERT_TRUE(openAndCloseStream());
+    ASSERT_EQ(mStream->getFramesPerCallback(), 192);
+}
+
+TEST_F(StreamClosedReturnValues, GetFormatReturnsLastKnownValue) {
+
+    mBuilder.setFormat(AudioFormat::I16);
+    ASSERT_TRUE(openAndCloseStream());
+    ASSERT_EQ(mStream->getFormat(), AudioFormat::I16);
+}
+
+TEST_F(StreamClosedReturnValues, GetBufferSizeInFramesReturnsLastKnownValue) {
+
+    ASSERT_TRUE(openStream());
+    int32_t bufferSize = mStream->getBufferSizeInFrames();
+    ASSERT_TRUE(closeStream());
+    ASSERT_EQ(mStream->getBufferSizeInFrames(), bufferSize);
+}
+
+TEST_F(StreamClosedReturnValues, GetBufferCapacityInFramesReturnsLastKnownValue) {
+
+    ASSERT_TRUE(openStream());
+    int32_t bufferCapacity = mStream->getBufferCapacityInFrames();
+    ASSERT_TRUE(closeStream());
+    ASSERT_EQ(mStream->getBufferCapacityInFrames(), bufferCapacity);
+}
+
+TEST_F(StreamClosedReturnValues, GetSharingModeReturnsLastKnownValue) {
+
+    ASSERT_TRUE(openStream());
+    SharingMode s = mStream->getSharingMode();
+    ASSERT_TRUE(closeStream());
+    ASSERT_EQ(mStream->getSharingMode(), s);
+}
+
+TEST_F(StreamClosedReturnValues, GetPerformanceModeReturnsLastKnownValue) {
+
+    ASSERT_TRUE(openStream());
+    PerformanceMode p = mStream->getPerformanceMode();
+    ASSERT_TRUE(closeStream());
+    ASSERT_EQ(mStream->getPerformanceMode(), p);
+}
+
+TEST_F(StreamClosedReturnValues, GetDeviceIdReturnsLastKnownValue) {
+
+    ASSERT_TRUE(openStream());
+    int32_t d = mStream->getDeviceId();
+    ASSERT_TRUE(closeStream());
+    ASSERT_EQ(mStream->getDeviceId(), d);
+}
+
+TEST_F(StreamClosedReturnValues, GetDataCallbackReturnsLastKnownValue) {
+
+    AudioStreamDataCallback *callback = new MyCallback();
+    mBuilder.setDataCallback(callback);
+    ASSERT_TRUE(openAndCloseStream());
+
+    AudioStreamDataCallback *callback2 = mStream->getDataCallback();
+    ASSERT_EQ(callback, callback2);
+}
+
+TEST_F(StreamClosedReturnValues, GetUsageReturnsLastKnownValue){
+    ASSERT_TRUE(openStream());
+    Usage u = mStream->getUsage();
+    ASSERT_TRUE(closeStream());
+    ASSERT_EQ(mStream->getUsage(), u);
+}
+
+TEST_F(StreamClosedReturnValues, GetContentTypeReturnsLastKnownValue){
+    ASSERT_TRUE(openStream());
+    ContentType c = mStream->getContentType();
+    ASSERT_TRUE(closeStream());
+    ASSERT_EQ(mStream->getContentType(), c);
+}
+
+TEST_F(StreamClosedReturnValues, GetInputPresetReturnsLastKnownValue){
+    ASSERT_TRUE(openStream());
+    auto i = mStream->getInputPreset();
+    ASSERT_TRUE(closeStream());
+    ASSERT_EQ(mStream->getInputPreset(), i);
+}
+
+TEST_F(StreamClosedReturnValues, GetSessionIdReturnsLastKnownValue){
+    ASSERT_TRUE(openStream());
+    auto s = mStream->getSessionId();
+    ASSERT_TRUE(closeStream());
+    ASSERT_EQ(mStream->getSessionId(), s);
+}
+
+TEST_F(StreamClosedReturnValues, StreamStateIsClosed){
+    ASSERT_TRUE(openAndCloseStream());
+    ASSERT_EQ(mStream->getState(), StreamState::Closed);
+}
+
+TEST_F(StreamClosedReturnValues, GetXRunCountReturnsLastKnownValue){
+
+    ASSERT_TRUE(openStream());
+    if (mStream->isXRunCountSupported()){
+        auto i = mStream->getXRunCount();
+        ASSERT_EQ(mStream->getXRunCount(), i);
+    }
+    ASSERT_TRUE(closeStream());
+}
+
+TEST_F(StreamClosedReturnValues, GetFramesPerBurstReturnsLastKnownValue){
+
+    ASSERT_TRUE(openStream());
+    auto f = mStream->getFramesPerBurst();
+    ASSERT_TRUE(closeStream());
+    ASSERT_EQ(mStream->getFramesPerBurst(), f);
+}
+
+TEST_F(StreamClosedReturnValues, GetBytesPerFrameReturnsLastKnownValue){
+    ASSERT_TRUE(openStream());
+    auto f = mStream->getBytesPerFrame();
+    ASSERT_TRUE(closeStream());
+    ASSERT_EQ(mStream->getBytesPerFrame(), f);
+}
+
+TEST_F(StreamClosedReturnValues, GetBytesPerSampleReturnsLastKnownValue){
+    ASSERT_TRUE(openStream());
+    auto f = mStream->getBytesPerSample();
+    ASSERT_TRUE(closeStream());
+    ASSERT_EQ(mStream->getBytesPerSample(), f);
+}
+
+TEST_F(StreamClosedReturnValues, GetFramesWrittenReturnsLastKnownValue){
+    mBuilder.setFormat(AudioFormat::I16);
+    mBuilder.setChannelCount(1);
+    ASSERT_TRUE(openStream());
+    ASSERT_EQ(mStream->setBufferSizeInFrames(mStream->getBufferCapacityInFrames()), Result::OK);
+    mStream->start();
+
+    int16_t buffer[4] = { 1, 2, 3, 4 };
+    Result r = mStream->write(&buffer, 4, 0);
+    if (r != Result::OK) {
+        FAIL() << "Could not write to audio stream";
+    }
+
+    auto f = mStream->getFramesWritten();
+    ASSERT_EQ(f, 4);
+
+    ASSERT_TRUE(closeStream());
+    ASSERT_EQ(mStream->getFramesWritten(), f);
+}
+
+TEST_F(StreamClosedReturnValues, GetFramesReadReturnsLastKnownValue) {
+
+    mBuilder.setDirection(Direction::Input);
+    mBuilder.setFormat(AudioFormat::I16);
+    mBuilder.setChannelCount(1);
+
+    ASSERT_TRUE(openStream());
+    mStream->start();
+
+    int16_t buffer[192];
+    auto r = mStream->read(&buffer, 192, 1000 * kNanosPerMillisecond);
+    ASSERT_EQ(r.value(), 192);
+
+    auto f = mStream->getFramesRead();
+    ASSERT_EQ(f, 192);
+
+    ASSERT_TRUE(closeStream());
+    ASSERT_EQ(mStream->getFramesRead(), f);
+}
+
+TEST_F(StreamClosedReturnValues, GetTimestampReturnsErrorClosedIfSupported){
+
+    ASSERT_TRUE(openStream());
+
+    int64_t framePosition;
+    int64_t presentationTime;
+
+    auto r = mStream->getTimestamp(CLOCK_MONOTONIC, &framePosition, &presentationTime);
+    bool isTimestampSupported = (r == Result::OK);
+
+    ASSERT_TRUE(closeStream());
+
+    if (isTimestampSupported){
+        ASSERT_EQ(mStream->getTimestamp(CLOCK_MONOTONIC, &framePosition, &presentationTime), Result::ErrorClosed);
+    }
+}
+
+TEST_F(StreamClosedReturnValues, GetAudioApiReturnsLastKnownValue){
+    ASSERT_TRUE(openStream());
+    AudioApi a = mStream->getAudioApi();
+    ASSERT_TRUE(closeStream());
+    ASSERT_EQ(mStream->getAudioApi(), a);
+}
+
+TEST_F(StreamClosedReturnValues, GetUsesAAudioReturnsLastKnownValue){
+    ASSERT_TRUE(openStream());
+    bool a = mStream->usesAAudio();
+    ASSERT_TRUE(closeStream());
+    ASSERT_EQ(mStream->usesAAudio(), a);
+}
+
+TEST_F(StreamClosedReturnValues, StreamStateControlsReturnClosed){
+
+    ASSERT_TRUE(openAndCloseStream());
+    Result r = mStream->close();
+    EXPECT_EQ(r, Result::ErrorClosed) << convertToText(r);
+    r = mStream->start();
+    EXPECT_EQ(r, Result::ErrorClosed) << convertToText(r);
+    EXPECT_EQ(mStream->pause(), Result::ErrorClosed);
+    EXPECT_EQ(mStream->flush(), Result::ErrorClosed);
+    EXPECT_EQ(mStream->stop(), Result::ErrorClosed);
+    EXPECT_EQ(mStream->requestStart(), Result::ErrorClosed);
+    EXPECT_EQ(mStream->requestPause(), Result::ErrorClosed);
+    EXPECT_EQ(mStream->requestFlush(), Result::ErrorClosed);
+    EXPECT_EQ(mStream->requestStop(), Result::ErrorClosed);
+}
+
+TEST_F(StreamClosedReturnValues, WaitForStateChangeReturnsClosed){
+
+    ASSERT_TRUE(openAndCloseStream());
+    StreamState next;
+    Result r = mStream->waitForStateChange(StreamState::Open, &next, 0);
+    EXPECT_TRUE(r == Result::OK || r == Result::ErrorClosed) << convertToText(r);
+}
+
+TEST_F(StreamClosedReturnValues, SetBufferSizeInFramesReturnsClosed){
+
+    ASSERT_TRUE(openAndCloseStream());
+    auto r = mStream->setBufferSizeInFrames(192);
+    ASSERT_EQ(r.error(), Result::ErrorClosed);
+}
+
+TEST_F(StreamClosedReturnValues, CalculateLatencyInMillisReturnsClosedIfSupported){
+
+    ASSERT_TRUE(openAndCloseStream());
+
+    if (mStream->getAudioApi() == AudioApi::AAudio){
+        auto r = mStream->calculateLatencyMillis();
+        ASSERT_EQ(r.error(), Result::ErrorInvalidState);
+    }
+}
+
+TEST_F(StreamClosedReturnValues, ReadReturnsClosed){
+
+    ASSERT_TRUE(openAndCloseStream());
+
+    int buffer[8]{0};
+    auto r = mStream->read(buffer, 1, 0);
+    ASSERT_EQ(r.error(), Result::ErrorClosed);
+}
+
+TEST_F(StreamClosedReturnValues, WriteReturnsClosed){
+
+    ASSERT_TRUE(openAndCloseStream());
+
+    int buffer[8]{0};
+    auto r = mStream->write(buffer, 1, 0);
+    ASSERT_EQ(r.error(), Result::ErrorClosed);
+}
+
+TEST_F(StreamClosedReturnValues, DelayBeforeCloseInput){
+    if (AudioStreamBuilder::isAAudioRecommended()) {
+        mBuilder.setDirection(Direction::Input);
+        testDelayBeforeClose();
+    }
+}
+
+TEST_F(StreamClosedReturnValues, DelayBeforeCloseOutput){
+    if (AudioStreamBuilder::isAAudioRecommended()) {
+        mBuilder.setDirection(Direction::Output);
+        testDelayBeforeClose();
+    }
+}
+
+TEST_F(StreamClosedReturnValues, DelayBeforeCloseInputOpenSL){
+    mBuilder.setAudioApi(AudioApi::OpenSLES);
+    mBuilder.setDirection(Direction::Input);
+    testDelayBeforeClose();
+}
+
+TEST_F(StreamClosedReturnValues, DelayBeforeCloseOutputOpenSL){
+    mBuilder.setAudioApi(AudioApi::OpenSLES);
+    mBuilder.setDirection(Direction::Output);
+    testDelayBeforeClose();
+}
+
+TEST_F(StreamClosedReturnValues, TestReleaseInput){
+    mBuilder.setDirection(Direction::Input);
+    ASSERT_TRUE(openStream());
+    ASSERT_TRUE(releaseStream());
+    ASSERT_TRUE(closeStream());
+}
+
+TEST_F(StreamClosedReturnValues, TestReleaseInputOpenSLES){
+    mBuilder.setAudioApi(AudioApi::OpenSLES);
+    mBuilder.setDirection(Direction::Input);
+    ASSERT_TRUE(openStream());
+    ASSERT_TRUE(releaseStream());
+    ASSERT_TRUE(closeStream());
+}
+
+TEST_F(StreamClosedReturnValues, TestReleaseOutput){
+    mBuilder.setDirection(Direction::Output);
+    ASSERT_TRUE(openStream());
+    ASSERT_TRUE(releaseStream());
+    ASSERT_TRUE(closeStream());
+}
+
+TEST_F(StreamClosedReturnValues, TestReleaseOutputOpenSLES){
+    mBuilder.setAudioApi(AudioApi::OpenSLES);
+    mBuilder.setDirection(Direction::Output);
+    ASSERT_TRUE(openStream());
+    ASSERT_TRUE(releaseStream());
+    ASSERT_TRUE(closeStream());
+}