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

Commit 392f44fc authored by Jooyung Han's avatar Jooyung Han
Browse files

Add libbinder_ndk_unit_test_host 

A new test module for host-based unit tests of libbinder_ndk. For now,
it has a couple of tests from libbinder_ndk_unit_test that were
disabled.

Bug: 300548972
Test: atest --host libbinder_ndk_unit_test_host
Change-Id: I99a3354b0e0fa6ee3391ca820b36dbdef226022d
parent 748848b7

libs/binder/ndk/tests/Android.bp

+22 −0
Original line number Diff line number Diff line
@@ -80,6 +80,28 @@ cc_test { 
    require_root: true,

}



cc_test_host {

    name: "libbinder_ndk_unit_test_host",

    defaults: ["test_libbinder_ndk_defaults"],

    srcs: ["libbinder_ndk_unit_test_host.cpp"],

    test_suites: [

        "general-tests",

    ],

    test_options: {

        unit_test: true,

    },

    static_libs: [

        "libbase",

        "libbinder_ndk",

        "libbinder",

        "libcutils",

        "libfakeservicemanager",

        "libgmock",

        "liblog",

        "libutils",

    ],

}



cc_test {

    name: "binderVendorDoubleLoadTest",

    vendor: true,

libs/binder/ndk/tests/libbinder_ndk_unit_test.cpp

+0 −17
Original line number Diff line number Diff line
@@ -39,7 +39,6 @@ 
#include <condition_variable>

#include <iostream>

#include <mutex>

#include <optional>

#include <thread>



#include "android/binder_ibinder.h"
@@ -433,22 +432,6 @@ TEST(NdkBinder, GetLazyService) { 
    EXPECT_EQ(STATUS_OK, AIBinder_ping(binder.get()));

}



// TEST(NdkBinder, IsUpdatable) {

//     bool isUpdatable =

//     AServiceManager_isUpdatableViaApex("android.hardware.light.ILights/default");

//     EXPECT_EQ(isUpdatable, true);

// }

//

// TEST(NdkBinder, GetUpdatableViaApex) {

//     std::optional<std::string> updatableViaApex;

//     AServiceManager_getUpdatableApexName(

//             "android.hardware.light.ILights/default", &updatableViaApex,

//             [](const char* apexName, void* context) {

//                 *static_cast<std::optional<std::string>*>(context) = apexName;

//             });

//     EXPECT_NE(updatableViaApex, std::nullopt) << *updatableViaApex;

// }



// This is too slow

TEST(NdkBinder, CheckLazyServiceShutDown) {

    ndk::SpAIBinder binder(AServiceManager_waitForService(kLazyBinderNdkUnitTestService));

libs/binder/ndk/tests/libbinder_ndk_unit_test_host.cpp

0 → 100644
+104 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2023 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/binder_manager.h>

#include <binder/IServiceManager.h>

#include <gmock/gmock.h>

#include <gtest/gtest.h>

#include <utils/String16.h>

#include <utils/String8.h>

#include <utils/StrongPointer.h>



#include <optional>



#include "fakeservicemanager/FakeServiceManager.h"



using android::FakeServiceManager;

using android::setDefaultServiceManager;

using android::sp;

using android::String16;

using android::String8;

using testing::_;

using testing::Eq;

using testing::Mock;

using testing::NiceMock;

using testing::Optional;

using testing::Return;



struct MockServiceManager : FakeServiceManager {

    MOCK_METHOD1(updatableViaApex, std::optional<String16>(const String16&));

};



struct AServiceManager : testing::Test {

    static sp<MockServiceManager> mockSM;



    static void InitMock() {

        mockSM = new NiceMock<MockServiceManager>;

        setDefaultServiceManager(mockSM);

    }



    void TearDown() override { Mock::VerifyAndClear(mockSM.get()); }



    void ExpectUpdatableViaApexReturns(std::optional<String16> apexName) {

        EXPECT_CALL(*mockSM, updatableViaApex(_)).WillRepeatedly(Return(apexName));

    }

};



sp<MockServiceManager> AServiceManager::mockSM;



TEST_F(AServiceManager, isUpdatableViaApex) {

    auto apexFoo = String16("com.android.hardware.foo");

    ExpectUpdatableViaApexReturns(apexFoo);



    bool isUpdatable = AServiceManager_isUpdatableViaApex("android.hardware.foo.IFoo/default");

    EXPECT_EQ(isUpdatable, true);

}



TEST_F(AServiceManager, isUpdatableViaApex_Not) {

    ExpectUpdatableViaApexReturns(std::nullopt);



    bool isUpdatable = AServiceManager_isUpdatableViaApex("android.hardware.foo.IFoo/default");

    EXPECT_EQ(isUpdatable, false);

}



void getUpdatableApexNameCallback(const char* apexName, void* context) {

    *(static_cast<std::optional<std::string>*>(context)) = apexName;

}



TEST_F(AServiceManager, getUpdatableApexName) {

    auto apexFoo = String16("com.android.hardware.foo");

    ExpectUpdatableViaApexReturns(apexFoo);



    std::optional<std::string> result;

    AServiceManager_getUpdatableApexName("android.hardware.foo.IFoo/default", &result,

                                         getUpdatableApexNameCallback);

    EXPECT_THAT(result, Optional(std::string(String8(apexFoo))));

}



TEST_F(AServiceManager, getUpdatableApexName_Null) {

    ExpectUpdatableViaApexReturns(std::nullopt);



    std::optional<std::string> result;

    AServiceManager_getUpdatableApexName("android.hardware.foo.IFoo/default", &result,

                                         getUpdatableApexNameCallback);

    EXPECT_THAT(result, Eq(std::nullopt));

}



int main(int argc, char* argv[]) {

    ::testing::InitGoogleTest(&argc, argv);

    AServiceManager::InitMock();

    return RUN_ALL_TESTS();

}