binderLibTest: epoch->uptime

#include <input/BlockingQueue.h>

#include <processgroup/processgroup.h>

#include <utils/Flattenable.h>

#include <utils/SystemClock.h>

#include <linux/sched.h>

#include <sys/epoll.h>

    EXPECT_TRUE(reply.readBool());

}

size_t epochMillis() {

    using std::chrono::duration_cast;

    using std::chrono::milliseconds;

    using std::chrono::seconds;

    using std::chrono::system_clock;

    return duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();

}

TEST_F(BinderLibTest, HangingServices) {

    Parcel data, reply;

    sp<IBinder> server = addServer();

    data.writeInt32(delay);

    // b/266537959 - must take before taking lock, since countdown is started in the remote

    // process there.

    size_t epochMsBefore = epochMillis();

    int64_t timeBefore = uptimeMillis();

    EXPECT_THAT(server->transact(BINDER_LIB_TEST_PROCESS_TEMPORARY_LOCK, data, &reply), NO_ERROR);

    std::vector<std::thread> ts;

    for (size_t i = 0; i < kKernelThreads + 1; i++) {

    for (auto &t : ts) {

        t.join();

    }

    size_t epochMsAfter = epochMillis();

    int64_t timeAfter = uptimeMillis();

    // deadlock occurred and threads only finished after 1s passed.

    EXPECT_GE(epochMsAfter, epochMsBefore + delay);

    EXPECT_GE(timeAfter, timeBefore + delay);

}

TEST_F(BinderLibTest, BinderProxyCount) {