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

Commit b31cbd6b authored by Tom Cherry's avatar Tom Cherry
Browse files

logd: don't require chatty to pass CTS 

Remove a few tests that require logd to implement chatty to not
require chatty to pass CTS.  Note that these tests are already removed
in AOSP and won't be required in S.

Bug: 168100439
Test: these tests don't run
Merged-In: Ie12898617429a75b6caff92725aa7145650f8fc6
Change-Id: Ia81042a48e9675f2ad3ad75a10ec4d60c96ff712
parent 767fe151

logd/tests/logd_test.cpp

+0 −126
Original line number Diff line number Diff line
@@ -831,129 +831,3 @@ TEST(logd, getEventTag_newentry) { 
    GTEST_LOG_(INFO) << "This test does nothing.\n";

#endif

}
 


#ifdef __ANDROID__

static inline uint32_t get4LE(const uint8_t* src) {

  return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);

}



static inline uint32_t get4LE(const char* src) {

  return get4LE(reinterpret_cast<const uint8_t*>(src));

}

#endif



void __android_log_btwrite_multiple__helper(int count) {

#ifdef __ANDROID__

    log_time ts(CLOCK_MONOTONIC);

    usleep(100);

    log_time ts1(CLOCK_MONOTONIC);



    // We fork to create a unique pid for the submitted log messages

    // so that we do not collide with the other _multiple_ tests.



    pid_t pid = fork();



    if (pid == 0) {

        // child

        for (int i = count; i; --i) {

            ASSERT_LT(

                0, __android_log_btwrite(0, EVENT_TYPE_LONG, &ts, sizeof(ts)));

            usleep(100);

        }

        ASSERT_LT(0,

                  __android_log_btwrite(0, EVENT_TYPE_LONG, &ts1, sizeof(ts1)));

        usleep(1000000);



        _exit(0);

    }



    siginfo_t info = {};

    ASSERT_EQ(0, TEMP_FAILURE_RETRY(waitid(P_PID, pid, &info, WEXITED)));

    ASSERT_EQ(0, info.si_status);



    struct logger_list* logger_list;

    ASSERT_TRUE(nullptr !=

                (logger_list = android_logger_list_open(

                     LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK,

                     0, pid)));



    int expected_count = (count < 2) ? count : 2;

    int expected_chatty_count = (count <= 2) ? 0 : 1;

    int expected_identical_count = (count < 2) ? 0 : (count - 2);

    static const int expected_expire_count = 0;



    count = 0;

    int second_count = 0;

    int chatty_count = 0;

    int identical_count = 0;

    int expire_count = 0;



    for (;;) {

        log_msg log_msg;

        if (android_logger_list_read(logger_list, &log_msg) <= 0) break;



        if ((log_msg.entry.pid != pid) || (log_msg.entry.len < (4 + 1 + 8)) ||

            (log_msg.id() != LOG_ID_EVENTS))

            continue;



        char* eventData = log_msg.msg();

        if (!eventData) continue;



        uint32_t tag = get4LE(eventData);



        if ((eventData[4] == EVENT_TYPE_LONG) &&

            (log_msg.entry.len == (4 + 1 + 8))) {

            if (tag != 0) continue;



            log_time tx(eventData + 4 + 1);

            if (ts == tx) {

                ++count;

            } else if (ts1 == tx) {

                ++second_count;

            }

        } else if (eventData[4] == EVENT_TYPE_STRING) {

            if (tag != CHATTY_LOG_TAG) continue;

            ++chatty_count;

            // int len = get4LE(eventData + 4 + 1);

            log_msg.buf[LOGGER_ENTRY_MAX_LEN] = '\0';

            const char* cp;

            if ((cp = strstr(eventData + 4 + 1 + 4, " identical "))) {

                unsigned val = 0;

                sscanf(cp, " identical %u lines", &val);

                identical_count += val;

            } else if ((cp = strstr(eventData + 4 + 1 + 4, " expire "))) {

                unsigned val = 0;

                sscanf(cp, " expire %u lines", &val);

                expire_count += val;

            }

        }

    }



    android_logger_list_close(logger_list);



    EXPECT_EQ(expected_count, count);

    EXPECT_EQ(1, second_count);

    EXPECT_EQ(expected_chatty_count, chatty_count);

    EXPECT_EQ(expected_identical_count, identical_count);

    EXPECT_EQ(expected_expire_count, expire_count);

#else

    count = 0;

    GTEST_LOG_(INFO) << "This test does nothing.\n";

#endif

}



TEST(logd, multiple_test_1) {

    __android_log_btwrite_multiple__helper(1);

}



TEST(logd, multiple_test_2) {

    __android_log_btwrite_multiple__helper(2);

}



TEST(logd, multiple_test_3) {

    __android_log_btwrite_multiple__helper(3);

}



TEST(logd, multiple_test_10) {

    __android_log_btwrite_multiple__helper(10);

}