Merge "Move IBufferHub-related test to VTS"

    return;

}

TEST_F(BufferHubBufferTest, AllocateAndFreeBuffer) {

    // TODO(b/116681016): directly test on BufferHubBuffer instead of the service.

    sp<IBufferHub> bufferHub = IBufferHub::getService();

    ASSERT_NE(nullptr, bufferHub.get());

    // Stride is an output, rfu0 and rfu1 are reserved data slot for future use.

    AHardwareBuffer_Desc aDesc = {kWidth, kHeight,        kLayerCount,  kFormat,

                                  kUsage, /*stride=*/0UL, /*rfu0=*/0UL, /*rfu1=*/0ULL};

    HardwareBufferDescription desc;

    memcpy(&desc, &aDesc, sizeof(HardwareBufferDescription));

    sp<IBufferClient> client;

    BufferHubStatus ret;

    IBufferHub::allocateBuffer_cb callback = [&](const auto& outClient, const auto& outStatus) {

        client = outClient;

        ret = outStatus;

    };

    EXPECT_TRUE(bufferHub->allocateBuffer(desc, kUserMetadataSize, callback).isOk());

    EXPECT_EQ(ret, BufferHubStatus::NO_ERROR);

    ASSERT_NE(nullptr, client.get());

    EXPECT_EQ(BufferHubStatus::NO_ERROR, client->close());

    EXPECT_EQ(BufferHubStatus::CLIENT_CLOSED, client->close());

}

TEST_F(BufferHubBufferTest, DuplicateFreedBuffer) {

    // TODO(b/116681016): directly test on BufferHubBuffer instead of the service.

    sp<IBufferHub> bufferHub = IBufferHub::getService();

    ASSERT_NE(nullptr, bufferHub.get());

    // Stride is an output, rfu0 and rfu1 are reserved data slot for future use.

    AHardwareBuffer_Desc aDesc = {kWidth, kHeight,        kLayerCount,  kFormat,

                                  kUsage, /*stride=*/0UL, /*rfu0=*/0UL, /*rfu1=*/0ULL};

    HardwareBufferDescription desc;

    memcpy(&desc, &aDesc, sizeof(HardwareBufferDescription));

    sp<IBufferClient> client;

    BufferHubStatus ret;

    IBufferHub::allocateBuffer_cb callback = [&](const auto& outClient, const auto& outStatus) {

        client = outClient;

        ret = outStatus;

    };

    EXPECT_TRUE(bufferHub->allocateBuffer(desc, kUserMetadataSize, callback).isOk());

    EXPECT_EQ(ret, BufferHubStatus::NO_ERROR);

    ASSERT_NE(nullptr, client.get());

    EXPECT_EQ(BufferHubStatus::NO_ERROR, client->close());

    hidl_handle token;

    IBufferClient::duplicate_cb dup_cb = [&](const auto& outToken, const auto& status) {

        token = outToken;

        ret = status;

    };

    EXPECT_TRUE(client->duplicate(dup_cb).isOk());

    EXPECT_EQ(ret, BufferHubStatus::CLIENT_CLOSED);

    EXPECT_EQ(token.getNativeHandle(), nullptr);

}

TEST_F(BufferHubBufferTest, DuplicateAndImportBuffer) {

    // TODO(b/116681016): directly test on BufferHubBuffer instead of the service.

    sp<IBufferHub> bufferhub = IBufferHub::getService();

    ASSERT_NE(nullptr, bufferhub.get());

    // Stride is an output, rfu0 and rfu1 are reserved data slot for future use.

    AHardwareBuffer_Desc aDesc = {kWidth, kHeight,        kLayerCount,  kFormat,

                                  kUsage, /*stride=*/0UL, /*rfu0=*/0UL, /*rfu1=*/0ULL};

    HardwareBufferDescription desc;

    memcpy(&desc, &aDesc, sizeof(HardwareBufferDescription));

    sp<IBufferClient> client;

    BufferHubStatus ret;

    IBufferHub::allocateBuffer_cb alloc_cb = [&](const auto& outClient, const auto& status) {

        client = outClient;

        ret = status;

    };

    ASSERT_TRUE(bufferhub->allocateBuffer(desc, kUserMetadataSize, alloc_cb).isOk());

    EXPECT_EQ(ret, BufferHubStatus::NO_ERROR);

    ASSERT_NE(nullptr, client.get());

    hidl_handle token;

    IBufferClient::duplicate_cb dup_cb = [&](const auto& outToken, const auto& status) {

        token = outToken;

        ret = status;

    };

    ASSERT_TRUE(client->duplicate(dup_cb).isOk());

    EXPECT_EQ(ret, BufferHubStatus::NO_ERROR);

    ASSERT_NE(token.getNativeHandle(), nullptr);

    EXPECT_EQ(token->numInts, 1);

    EXPECT_EQ(token->numFds, 0);

    sp<IBufferClient> client2;

    IBufferHub::importBuffer_cb import_cb = [&](const auto& outClient, const auto& status) {

        ret = status;

        client2 = outClient;

    };

    ASSERT_TRUE(bufferhub->importBuffer(token, import_cb).isOk());

    EXPECT_EQ(ret, BufferHubStatus::NO_ERROR);

    EXPECT_NE(nullptr, client2.get());

    // TODO(b/116681016): once BufferNode.id() is exposed via BufferHubBuffer, check origin.id =

    // improted.id here.

}

// nullptr must not crash the service

TEST_F(BufferHubBufferTest, ImportNullToken) {

    // TODO(b/116681016): directly test on BufferHubBuffer instead of the service.

    sp<IBufferHub> bufferhub = IBufferHub::getService();

    ASSERT_NE(nullptr, bufferhub.get());

    hidl_handle nullToken;

    sp<IBufferClient> client;

    BufferHubStatus ret;

    IBufferHub::importBuffer_cb import_cb = [&](const auto& outClient, const auto& status) {

        client = outClient;

        ret = status;

    };

    ASSERT_TRUE(bufferhub->importBuffer(nullToken, import_cb).isOk());

    EXPECT_EQ(ret, BufferHubStatus::INVALID_TOKEN);

    EXPECT_EQ(nullptr, client.get());

}

// This test has a very little chance to fail (number of existing tokens / 2 ^ 32)

TEST_F(BufferHubBufferTest, ImportInvalidToken) {

    // TODO(b/116681016): directly test on BufferHubBuffer instead of the service.

    sp<IBufferHub> bufferhub = IBufferHub::getService();

    ASSERT_NE(nullptr, bufferhub.get());

    native_handle_t* tokenHandle = native_handle_create(/*numFds=*/0, /*numInts=*/1);

    tokenHandle->data[0] = 0;

    hidl_handle invalidToken(tokenHandle);

    sp<IBufferClient> client;

    BufferHubStatus ret;

    IBufferHub::importBuffer_cb import_cb = [&](const auto& outClient, const auto& status) {

        client = outClient;

        ret = status;

    };

    ASSERT_TRUE(bufferhub->importBuffer(invalidToken, import_cb).isOk());

    EXPECT_EQ(ret, BufferHubStatus::INVALID_TOKEN);

    EXPECT_EQ(nullptr, client.get());

    native_handle_delete(tokenHandle);

}

TEST_F(BufferHubBufferTest, ImportFreedBuffer) {

    // TODO(b/116681016): directly test on BufferHubBuffer instead of the service.

    sp<IBufferHub> bufferhub = IBufferHub::getService();

    ASSERT_NE(nullptr, bufferhub.get());

    // Stride is an output, rfu0 and rfu1 are reserved data slot for future use.

    AHardwareBuffer_Desc aDesc = {kWidth, kHeight,        kLayerCount,  kFormat,

                                  kUsage, /*stride=*/0UL, /*rfu0=*/0UL, /*rfu1=*/0ULL};

    HardwareBufferDescription desc;

    memcpy(&desc, &aDesc, sizeof(HardwareBufferDescription));

    sp<IBufferClient> client;

    BufferHubStatus ret;

    IBufferHub::allocateBuffer_cb alloc_cb = [&](const auto& outClient, const auto& status) {

        client = outClient;

        ret = status;

    };

    ASSERT_TRUE(bufferhub->allocateBuffer(desc, kUserMetadataSize, alloc_cb).isOk());

    EXPECT_EQ(ret, BufferHubStatus::NO_ERROR);

    ASSERT_NE(nullptr, client.get());

    hidl_handle token;

    IBufferClient::duplicate_cb dup_cb = [&](const auto& outToken, const auto& status) {

        token = outToken;

        ret = status;

    };

    ASSERT_TRUE(client->duplicate(dup_cb).isOk());

    EXPECT_EQ(ret, BufferHubStatus::NO_ERROR);

    ASSERT_NE(token.getNativeHandle(), nullptr);

    EXPECT_EQ(token->numInts, 1);

    EXPECT_EQ(token->numFds, 0);

    // Close the client. Now the token should be invalid.

    client->close();

    sp<IBufferClient> client2;

    IBufferHub::importBuffer_cb import_cb = [&](const auto& outClient, const auto& status) {

        client2 = outClient;

        ret = status;

    };

    EXPECT_TRUE(bufferhub->importBuffer(token, import_cb).isOk());

    EXPECT_EQ(ret, BufferHubStatus::INVALID_TOKEN);

    EXPECT_EQ(nullptr, client2.get());

}

TEST_F(BufferHubBufferStateTransitionTest, GainBuffer_fromReleasedState) {

    ASSERT_TRUE(IsBufferReleased(b1->buffer_state()));