Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ad8db511 authored by Andrew Scull's avatar Andrew Scull Committed by android-build-merger
Browse files

Merge "OemLock functional VTS test." into oc-dr1-dev

am: 831af8d8

Change-Id: I97484727d9a5e103a00320bdc5dfce0adcf84b15
parents 73d517be 831af8d8
Loading
Loading
Loading
Loading
+36 −0
Original line number Diff line number Diff line
//
// Copyright (C) 2016 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

cc_test {
    name: "VtsHalOemLockV1_0TargetTest",
    defaults: ["hidl_defaults"],
    srcs: ["VtsHalOemLockV1_0TargetTest.cpp"],
    shared_libs: [
        "libbase",
        "liblog",
        "libcutils",
        "libhidlbase",
        "libhidltransport",
        "libnativehelper",
        "libutils",
        "android.hardware.oemlock@1.0",
    ],
    static_libs: ["VtsHalHidlTargetTestBase"],
    cflags: [
        "-O0",
        "-g",
    ],
}
+189 −0
Original line number Diff line number Diff line
/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <android/hardware/oemlock/1.0/IOemLock.h>

#include <VtsHalHidlTargetTestBase.h>

using ::android::hardware::oemlock::V1_0::IOemLock;
using ::android::hardware::oemlock::V1_0::OemLockStatus;
using ::android::hardware::oemlock::V1_0::OemLockSecureStatus;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::sp;

struct OemLockHidlTest : public ::testing::VtsHalHidlTargetTestBase {
    virtual void SetUp() override {
        oemlock = ::testing::VtsHalHidlTargetTestBase::getService<IOemLock>();
        ASSERT_NE(oemlock, nullptr);
    }

    virtual void TearDown() override {}

    sp<IOemLock> oemlock;
};

/*
 * Check the name can be retrieved
 */
TEST_F(OemLockHidlTest, GetName) {
    std::string name;
    OemLockStatus status;

    bool callbackCalled = false;
    const auto ret = oemlock->getName([&](OemLockStatus s, hidl_string n) {
        callbackCalled = true;
        status = s;
        name = n.c_str();
    });

    ASSERT_TRUE(ret.isOk());
    ASSERT_TRUE(callbackCalled);
    EXPECT_EQ(status, OemLockStatus::OK);
    // Any value acceptable
};

/*
 * Check the unlock allowed by device state can be queried
 */
TEST_F(OemLockHidlTest, QueryUnlockAllowedByDevice) {
    bool allowed;
    OemLockStatus status;

    bool callbackCalled = false;
    const auto ret = oemlock->isOemUnlockAllowedByDevice([&](OemLockStatus s, bool a) {
        callbackCalled = true;
        status = s;
        allowed = a;
    });

    ASSERT_TRUE(ret.isOk());
    ASSERT_TRUE(callbackCalled);
    EXPECT_EQ(status, OemLockStatus::OK);
    // Any value acceptable
}

/*
 * Check unlock allowed by device state can be toggled
 */
TEST_F(OemLockHidlTest, AllowedByDeviceCanBeToggled) {
    bool allowed;
    OemLockStatus status;

    auto getAllowedCallback = [&](OemLockStatus s, bool a) {
        status = s;
        allowed = a;
    };

    // Get the original state so it can be restored
    const auto get_ret = oemlock->isOemUnlockAllowedByDevice(getAllowedCallback);
    ASSERT_TRUE(get_ret.isOk());
    ASSERT_EQ(status, OemLockStatus::OK);
    const bool originallyAllowed = allowed;

    // Toggle the state
    const auto set_ret = oemlock->setOemUnlockAllowedByDevice(!originallyAllowed);
    ASSERT_TRUE(set_ret.isOk());
    ASSERT_EQ(set_ret, OemLockStatus::OK);
    const auto check_set_ret = oemlock->isOemUnlockAllowedByDevice(getAllowedCallback);
    ASSERT_TRUE(check_set_ret.isOk());
    ASSERT_EQ(status, OemLockStatus::OK);
    ASSERT_EQ(allowed, !originallyAllowed);

    // Restore the state
    const auto restore_ret = oemlock->setOemUnlockAllowedByDevice(originallyAllowed);
    ASSERT_TRUE(restore_ret.isOk());
    ASSERT_EQ(restore_ret, OemLockStatus::OK);
    const auto check_restore_ret = oemlock->isOemUnlockAllowedByDevice(getAllowedCallback);
    ASSERT_TRUE(check_restore_ret.isOk());
    ASSERT_EQ(status, OemLockStatus::OK);
    ASSERT_EQ(allowed, originallyAllowed);
};

/*
 * Check the unlock allowed by device state can be queried
 */
TEST_F(OemLockHidlTest, QueryUnlockAllowedByCarrier) {
    bool allowed;
    OemLockStatus status;

    bool callbackCalled = false;
    const auto ret = oemlock->isOemUnlockAllowedByCarrier([&](OemLockStatus s, bool a) {
        callbackCalled = true;
        status = s;
        allowed = a;
    });

    ASSERT_TRUE(ret.isOk());
    ASSERT_TRUE(callbackCalled);
    EXPECT_EQ(status, OemLockStatus::OK);
    // Any value acceptable
}

/*
 * Attempt to check unlock allowed by carrier can be toggled
 *
 * The implementation may involve a signature which cannot be tested here. That
 * is a valid implementation so the test will pass. If there is no signature
 * required, the test will toggle the value.
 */
TEST_F(OemLockHidlTest, CarrierUnlock) {
    const hidl_vec<uint8_t> noSignature = {};
    bool allowed;
    OemLockStatus status;

    auto getAllowedCallback = [&](OemLockStatus s, bool a) {
        status = s;
        allowed = a;
    };

    // Get the original state so it can be restored
    const auto get_ret = oemlock->isOemUnlockAllowedByCarrier(getAllowedCallback);
    ASSERT_TRUE(get_ret.isOk());
    ASSERT_EQ(status, OemLockStatus::OK);
    const bool originallyAllowed = allowed;

    if (originallyAllowed) {
        // Only applied to locked devices
        return;
    }

    // Toggle the state
    const auto set_ret = oemlock->setOemUnlockAllowedByCarrier(!originallyAllowed, noSignature);
    ASSERT_TRUE(set_ret.isOk());
    ASSERT_NE(set_ret, OemLockSecureStatus::FAILED);
    const auto check_set_ret = oemlock->isOemUnlockAllowedByCarrier(getAllowedCallback);
    ASSERT_TRUE(check_set_ret.isOk());
    ASSERT_EQ(status, OemLockStatus::OK);

    if (set_ret == OemLockSecureStatus::INVALID_SIGNATURE) {
        // Signature is required so we cannot toggle the value in the test, but this is allowed
        ASSERT_EQ(allowed, originallyAllowed);
        return;
    }

    ASSERT_EQ(set_ret, OemLockSecureStatus::OK);
    ASSERT_EQ(allowed, !originallyAllowed);

    // Restore the state
    const auto restore_ret = oemlock->setOemUnlockAllowedByCarrier(originallyAllowed, noSignature);
    ASSERT_TRUE(restore_ret.isOk());
    ASSERT_EQ(restore_ret, OemLockSecureStatus::OK);
    const auto check_restore_ret = oemlock->isOemUnlockAllowedByCarrier(getAllowedCallback);
    ASSERT_TRUE(check_restore_ret.isOk());
    ASSERT_EQ(status, OemLockStatus::OK);
    ASSERT_EQ(allowed, originallyAllowed);
};
+1 −0
Original line number Diff line number Diff line
// This is an autogenerated file, do not edit.
subdirs = [
    "1.0",
    "1.0/vts/functional",
]