自学教程：C++ GTEST_LOG_函数代码示例

unsigned int TestClient::GetPcRegisterId() {  if (m_pc_register != UINT_MAX)    return m_pc_register;  for (unsigned int register_id = 0;; register_id++) {    std::string message = formatv("qRegisterInfo{0:x-}", register_id).str();    std::string response;    if (!SendMessage(message, response)) {      GTEST_LOG_(ERROR) << "Unable to query register ID for PC register.";      return UINT_MAX;    }    auto elements_or_error = SplitPairList("GetPcRegisterId", response);    if (auto split_error = elements_or_error.takeError()) {      GTEST_LOG_(ERROR) << "GetPcRegisterId: Error splitting response: "                        << response;      return UINT_MAX;    }    auto elements = *elements_or_error;    if (elements["alt-name"] == "pc" || elements["generic"] == "pc") {      m_pc_register = register_id;      break;    }  }  return m_pc_register;}

static bool check_unique(const std::string& config, const std::string& prefix) {    int retval = false;    std::string data;    if (!android::base::ReadFileToString(config, &data)) return retval;    const fs_path_config_from_file* pc =        reinterpret_cast<const fs_path_config_from_file*>(data.c_str());    size_t len = data.size();    std::vector<const char*> paths_tmp;    size_t entry_number = 0;    while (len > 0) {        uint16_t host_len = (len >= endof(pc, len)) ? pc->len : INT16_MAX;        if (host_len > len) {            GTEST_LOG_(WARNING) << config << ": truncated at entry " << entry_number << " ("                                << host_len << " > " << len << ")";            const std::string unknown("?");            GTEST_LOG_(WARNING)                << config << ": entry[" << entry_number << "]={ "                << "len=" << ((len >= endof(pc, len))                                  ? android::base::StringPrintf("%" PRIu16, pc->len)                                  : unknown)                << ", mode=" << ((len >= endof(pc, mode))                                     ? android::base::StringPrintf("0%" PRIo16, pc->mode)                                     : unknown)                << ", uid=" << ((len >= endof(pc, uid))                                    ? android::base::StringPrintf("%" PRIu16, pc->uid)                                    : unknown)                << ", gid=" << ((len >= endof(pc, gid))                                    ? android::base::StringPrintf("%" PRIu16, pc->gid)                                    : unknown)                << ", capabilities="                << ((len >= endof(pc, capabilities))                        ? android::base::StringPrintf("0x%" PRIx64, pc->capabilities)                        : unknown)                << ", prefix="                << ((len >= offsetof(fs_path_config_from_file, prefix))                        ? android::base::StringPrintf(                              "/"%.*s...", (int)(len - offsetof(fs_path_config_from_file, prefix)),                              pc->prefix)                        : unknown)                << " }";            retval = true;            break;        }        paths_tmp.push_back(pc->prefix);        pc = reinterpret_cast<const fs_path_config_from_file*>(reinterpret_cast<const char*>(pc) +                                                               host_len);        len -= host_len;        ++entry_number;    }    return check_unique(paths_tmp, config, prefix) || retval;}

bool TestClient::SendMessage(StringRef message, std::string &response_string,                             PacketResult expected_result) {  StringExtractorGDBRemote response;  GTEST_LOG_(INFO) << "Send Packet: " << message.str();  PacketResult result = SendPacketAndWaitForResponse(message, response, false);  response.GetEscapedBinaryData(response_string);  GTEST_LOG_(INFO) << "Read Packet: " << response_string;  if (result != expected_result) {    GTEST_LOG_(ERROR) << FormatFailedResult(message, result);    return false;  }  return true;}

TEST_F(DlExtRelroSharingTest, VerifyMemorySaving) {  if (geteuid() != 0) {    GTEST_LOG_(INFO) << "This test must be run as root./n";    return;  }  TemporaryFile tf; // Use tf to get an unique filename.  ASSERT_NOERROR(close(tf.fd));  ASSERT_NO_FATAL_FAILURE(CreateRelroFile(LIBNAME, tf.filename));  int pipefd[2];  ASSERT_NOERROR(pipe(pipefd));  size_t without_sharing, with_sharing;  ASSERT_NO_FATAL_FAILURE(SpawnChildrenAndMeasurePss(LIBNAME, false, &without_sharing));  ASSERT_NO_FATAL_FAILURE(SpawnChildrenAndMeasurePss(LIBNAME, true, &with_sharing));  // We expect the sharing to save at least 10% of the total PSS. In practice  // it saves 40%+ for this test.  size_t expected_size = without_sharing - (without_sharing/10);  EXPECT_LT(with_sharing, expected_size);  // Use destructor of tf to close and unlink the file.  tf.fd = extinfo_.relro_fd;}

// Starts capturing an output stream (stdout/stderr).void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) {  if (*stream != NULL) {    GTEST_LOG_(FATAL) << "Only one " << stream_name                      << " capturer can exist at a time.";  }  *stream = new CapturedStream(fd);}

TEST(getauxval, unexpected_values) {#if defined(GETAUXVAL_CAN_COMPILE)    ASSERT_EQ((unsigned long int) 0, getauxval(0xdeadbeef));#else    GTEST_LOG_(INFO) << "This test does nothing./n";#endif}

TEST(STDIO_TEST, fseek_ftell_unseekable) {#if defined(__BIONIC__) // glibc has fopencookie instead.  auto read_fn = [](void*, char*, int) { return -1; };  FILE* fp = funopen(nullptr, read_fn, nullptr, nullptr, nullptr);  ASSERT_TRUE(fp != nullptr);  // Check that ftell balks on an unseekable FILE*.  errno = 0;  ASSERT_EQ(-1, ftell(fp));  ASSERT_EQ(ESPIPE, errno);  // SEEK_CUR is rewritten as SEEK_SET internally...  errno = 0;  ASSERT_EQ(-1, fseek(fp, 0, SEEK_CUR));  ASSERT_EQ(ESPIPE, errno);  // ...so it's worth testing the direct seek path too.  errno = 0;  ASSERT_EQ(-1, fseek(fp, 0, SEEK_SET));  ASSERT_EQ(ESPIPE, errno);  fclose(fp);#else  GTEST_LOG_(INFO) << "glibc uses fopencookie instead./n";#endif}

TEST(pthread, pthread_setname_np__too_long) {#if defined(__BIONIC__) // Not all build servers have a new enough glibc? TODO: remove when they're on gprecise.  ASSERT_EQ(ERANGE, pthread_setname_np(pthread_self(), "this name is far too long for linux"));#else // __BIONIC__  GTEST_LOG_(INFO) << "This test does nothing./n";#endif // __BIONIC__}

bool TestClient::SetInferior(llvm::ArrayRef<std::string> inferior_args) {  std::stringstream command;  command << "A";  for (size_t i = 0; i < inferior_args.size(); i++) {    if (i > 0)      command << ',';    std::string hex_encoded = toHex(inferior_args[i]);    command << hex_encoded.size() << ',' << i << ',' << hex_encoded;  }  if (!SendMessage(command.str()))    return false;  if (!SendMessage("qLaunchSuccess"))    return false;  std::string response;  if (!SendMessage("qProcessInfo", response))    return false;  auto create_or_error = ProcessInfo::Create(response);  if (auto create_error = create_or_error.takeError()) {    GTEST_LOG_(ERROR) << toString(std::move(create_error));    return false;  }  m_process_info = *create_or_error;  return true;}

TEST(properties, wait) {#if defined(__BIONIC__)    LocalPropertyTestState pa;    ASSERT_TRUE(pa.valid);    unsigned int serial;    prop_info *pi;    pthread_t t;    int flag = 0;    ASSERT_EQ(0, __system_property_add("property", 8, "value1", 6));    serial = __system_property_wait_any(0);    pi = (prop_info *)__system_property_find("property");    ASSERT_NE((prop_info *)NULL, pi);    __system_property_update(pi, "value2", 6);    serial = __system_property_wait_any(serial);    ASSERT_EQ(0, pthread_create(&t, NULL, PropertyWaitHelperFn, &flag));    ASSERT_EQ(flag, 0);    serial = __system_property_wait_any(serial);    ASSERT_EQ(flag, 1);    void* result;    ASSERT_EQ(0, pthread_join(t, &result));#else // __BIONIC__    GTEST_LOG_(INFO) << "This test does nothing./n";#endif // __BIONIC__}

TEST(pthread, pthread_types_allow_four_bytes_alignment) {#if defined(__BIONIC__)  // For binary compatibility with old version, we need to allow 4-byte aligned data for pthread types.  StrictAlignmentAllocator allocator;  pthread_mutex_t* mutex = reinterpret_cast<pthread_mutex_t*>(                             allocator.allocate(sizeof(pthread_mutex_t), 4));  ASSERT_EQ(0, pthread_mutex_init(mutex, NULL));  ASSERT_EQ(0, pthread_mutex_lock(mutex));  ASSERT_EQ(0, pthread_mutex_unlock(mutex));  ASSERT_EQ(0, pthread_mutex_destroy(mutex));  pthread_cond_t* cond = reinterpret_cast<pthread_cond_t*>(                           allocator.allocate(sizeof(pthread_cond_t), 4));  ASSERT_EQ(0, pthread_cond_init(cond, NULL));  ASSERT_EQ(0, pthread_cond_signal(cond));  ASSERT_EQ(0, pthread_cond_broadcast(cond));  ASSERT_EQ(0, pthread_cond_destroy(cond));  pthread_rwlock_t* rwlock = reinterpret_cast<pthread_rwlock_t*>(                               allocator.allocate(sizeof(pthread_rwlock_t), 4));  ASSERT_EQ(0, pthread_rwlock_init(rwlock, NULL));  ASSERT_EQ(0, pthread_rwlock_rdlock(rwlock));  ASSERT_EQ(0, pthread_rwlock_unlock(rwlock));  ASSERT_EQ(0, pthread_rwlock_wrlock(rwlock));  ASSERT_EQ(0, pthread_rwlock_unlock(rwlock));  ASSERT_EQ(0, pthread_rwlock_destroy(rwlock));#else  GTEST_LOG_(INFO) << "This test tests bionic implementation details.";#endif}

TEST(signal, sys_signame) {#if defined(__BIONIC__)  ASSERT_TRUE(sys_signame[0] == NULL);  ASSERT_STREQ("HUP", sys_signame[SIGHUP]);#else  GTEST_LOG_(INFO) << "This test does nothing./n";#endif}

TEST(math, __isnormall) {#if defined(__BIONIC__)  ASSERT_TRUE(__isnormall(123.0L));  ASSERT_FALSE(__isnormall(ldouble_subnormal()));#else // __BIONIC__  GTEST_LOG_(INFO) << "glibc doesn't have __isnormall./n";#endif // __BIONIC__}

TEST(math, __isfinitel) {#if defined(__BIONIC__)  ASSERT_TRUE(__isfinitel(123.0f));  ASSERT_FALSE(__isfinitel(HUGE_VALL));#else // __BIONIC__  GTEST_LOG_(INFO) << "This test does nothing./n";#endif // __BIONIC__}

bool TestClient::StartDebugger() {  const ArchSpec &arch_spec = HostInfo::GetArchitecture();  Args args;  args.AppendArgument(LLDB_SERVER);  args.AppendArgument("gdbserver");  args.AppendArgument("--log-channels=gdb-remote packets");  args.AppendArgument("--reverse-connect");  std::string log_file_name = GenerateLogFileName(arch_spec);  if (log_file_name.size()) {    args.AppendArgument("--log-file=" + log_file_name);  }  Status error;  TCPSocket listen_socket(true, false);  error = listen_socket.Listen("127.0.0.1:0", 5);  if (error.Fail()) {    GTEST_LOG_(ERROR) << "Unable to open listen socket.";    return false;  }  char connect_remote_address[64];  snprintf(connect_remote_address, sizeof(connect_remote_address),           "localhost:%u", listen_socket.GetLocalPortNumber());  args.AppendArgument(connect_remote_address);  m_server_process_info.SetArchitecture(arch_spec);  m_server_process_info.SetArguments(args, true);  Status status = Host::LaunchProcess(m_server_process_info);  if (status.Fail()) {    GTEST_LOG_(ERROR)        << formatv("Failure to launch lldb server: {0}.", status).str();    return false;  }  char connect_remote_uri[64];  snprintf(connect_remote_uri, sizeof(connect_remote_uri), "connect://%s",           connect_remote_address);  Socket *accept_socket;  listen_socket.Accept(accept_socket);  SetConnection(new ConnectionFileDescriptor(accept_socket));  SendAck(); // Send this as a handshake.  return true;}

TEST(sys_random, getrandom_EFAULT) {#if defined(HAVE_SYS_RANDOM)  errno = 0;  ASSERT_EQ(-1, getrandom(nullptr, 256, 0));  ASSERT_EQ(EFAULT, errno);#else  GTEST_LOG_(INFO) << "This test requires a C library with <sys/random.h>./n";#endif}

// libtest_dlopen_from_ctor_main.so depends on// libtest_dlopen_from_ctor.so which has a constructor// that calls dlopen(libc...). This is to test the situation// described in b/7941716.TEST(dlfcn, dlopen_dlopen_from_ctor) {#if defined(__BIONIC__)  void* handle = dlopen("libtest_dlopen_from_ctor_main.so", RTLD_NOW);  ASSERT_TRUE(handle != nullptr) << dlerror();  dlclose(handle);#else  GTEST_LOG_(INFO) << "This test is disabled for glibc (glibc segfaults if you try to call dlopen from a constructor)./n";#endif}

TEST(math_logf, logf_intel) {#if defined(__BIONIC__)  for (size_t i = 0; i < sizeof(g_logf_intel_data)/sizeof(logf_intel_data_t); i++) {    EXPECT_FLOAT_EQ(g_logf_intel_data[i].expected, logf(g_logf_intel_data[i].call_data)) << "Failed on element " << i;  }#else // __BIONIC__  GTEST_LOG_(INFO) << "This test does nothing.";#endif // __BIONIC__}