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

Commit 869c4e24 authored by Steven Moreland's avatar Steven Moreland
Browse files

libbinder: integration test for stability 

Due to the number of backends involved and amount of code
passing stability around, as well as prebuilts being used
and multiple build systems being introduced, validate
the stability of binder objects end to end.

Bug: 385355208
Test: atest binderStabilityTest
Change-Id: I25fb93b85740e8380a333cd2f05afc1a3c35ec5b
parent 06248774

libs/binder/TEST_MAPPING

+3 −0
Original line number Diff line number Diff line
@@ -36,6 +36,9 @@ 
    {

      "name": "binderStabilityTest"

    },

    {

      "name": "binderStabilityIntegrationTest"

    },

    {

      "name": "binderRpcWireProtocolTest"

    },

libs/binder/include/binder/Stability.h

+6 −2
Original line number Diff line number Diff line
@@ -20,6 +20,8 @@ 
#include <binder/IBinder.h>

#include <string>



class BinderStabilityIntegrationTest_ExpectedStabilityForItsPartition_Test;



namespace android {



class BpBinder;
@@ -127,6 +129,8 @@ private: 
    // through Parcel)

    friend ::android::ProcessState;



    friend ::BinderStabilityIntegrationTest_ExpectedStabilityForItsPartition_Test;



    static void tryMarkCompilationUnit(IBinder* binder);



    // Currently, we use int16_t for Level so that it can fit in BBinder.
@@ -156,11 +160,11 @@ private: 
                                                                uint32_t flags);



    // get stability information as encoded on the wire

    static int16_t getRepr(IBinder* binder);

    LIBBINDER_EXPORTED static int16_t getRepr(IBinder* binder);



    // whether a transaction on binder is allowed, if the transaction

    // is done from a context with a specific stability level

    static bool check(int16_t provided, Level required);

    LIBBINDER_EXPORTED static bool check(int16_t provided, Level required);



    static bool isDeclaredLevel(int32_t level);

    static std::string levelString(int32_t level);

libs/binder/tests/Android.bp

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

}



cc_test {

    name: "binderStabilityIntegrationTest",

    defaults: ["binder_test_defaults"],

    srcs: [

        "binderStabilityIntegrationTest.cpp",

    ],



    shared_libs: [

        "libbinder",

        "libutils",

    ],

    static_libs: [

        "libprocpartition",

    ],



    test_suites: [

        "general-tests",

        "vts",

    ],

    require_root: true,

}



cc_test {

    name: "binderAllocationLimits",

    defaults: ["binder_test_defaults"],

libs/binder/tests/binderStabilityIntegrationTest.cpp

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

 * Copyright (C) 2025 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 <binder/Binder.h>

#include <binder/IServiceManager.h>

#include <binder/Stability.h>

#include <gtest/gtest.h>

#include <procpartition/procpartition.h>



using namespace android;

using android::internal::Stability; // for testing only!

using android::procpartition::getPartition;

using android::procpartition::Partition;



class BinderStabilityIntegrationTest : public testing::Test,

                                       public ::testing::WithParamInterface<String16> {

public:

    virtual ~BinderStabilityIntegrationTest() {}

};



TEST_P(BinderStabilityIntegrationTest, ExpectedStabilityForItsPartition) {

    const String16& serviceName = GetParam();



    sp<IBinder> binder = defaultServiceManager()->checkService(serviceName);

    if (!binder) GTEST_SKIP() << "Could not get service, may have gone away.";



    pid_t pid;

    status_t res = binder->getDebugPid(&pid);

    if (res != OK) {

        GTEST_SKIP() << "Could not talk to service to get PID, res: " << statusToString(res);

    }



    Partition partition = getPartition(pid);



    Stability::Level level = Stability::Level::UNDECLARED;

    switch (partition) {

        case Partition::SYSTEM:

        case Partition::SYSTEM_EXT:

            level = Stability::Level::SYSTEM;

            break;

        case Partition::VENDOR:

        case Partition::ODM:

            level = Stability::Level::VENDOR;

            break;

        case Partition::UNKNOWN:

            GTEST_SKIP() << "Not sure of partition of process.";

            return;

        default:

            ADD_FAILURE() << "Unrecognized partition for service: " << partition;

            return;

    }



    ASSERT_TRUE(Stability::check(Stability::getRepr(binder.get()), level))

            << "Binder hosted on partition " << partition

            << " should have corresponding stability set.";

}



std::string PrintTestParam(

        const testing::TestParamInfo<BinderStabilityIntegrationTest::ParamType>& info) {

    std::string name = String8(info.param).c_str();

    for (size_t i = 0; i < name.size(); i++) {

        bool alnum = false;

        alnum |= (name[i] >= 'a' && name[i] <= 'z');

        alnum |= (name[i] >= 'A' && name[i] <= 'Z');

        alnum |= (name[i] >= '0' && name[i] <= '9');

        alnum |= (name[i] == '_');

        if (!alnum) name[i] = '_';

    }



    // index for uniqueness

    return std::to_string(info.index) + "__" + name;

}



INSTANTIATE_TEST_CASE_P(RegisteredServices, BinderStabilityIntegrationTest,

                        ::testing::ValuesIn(defaultServiceManager()->listServices()),

                        PrintTestParam);