From 20727babc7013b199a18abeb147e815fe10688fa Mon Sep 17 00:00:00 2001 From: Mark Salyzyn Date: Sat, 4 Jan 2014 00:41:16 +0000 Subject: [PATCH] Revert "liblog: Add liblog test suite" This reverts commit 46abc522964f797fafb0a3af2cbbabee05597f47. Change-Id: Iced83fdfa7de061c0495920ea28a9468023706d3 --- include/log/log.h | 49 ------ liblog/Android.mk | 2 - liblog/tests/Android.mk | 77 ---------- liblog/tests/benchmark.h | 147 ------------------ liblog/tests/benchmark_main.cpp | 245 ------------------------------ liblog/tests/liblog_benchmark.cpp | 202 ------------------------ liblog/tests/liblog_test.cpp | 164 -------------------- 7 files changed, 886 deletions(-) delete mode 100644 liblog/tests/Android.mk delete mode 100644 liblog/tests/benchmark.h delete mode 100644 liblog/tests/benchmark_main.cpp delete mode 100644 liblog/tests/liblog_benchmark.cpp delete mode 100644 liblog/tests/liblog_test.cpp diff --git a/include/log/log.h b/include/log/log.h index 1b79caa3c..3ae3086cd 100644 --- a/include/log/log.h +++ b/include/log/log.h @@ -552,55 +552,6 @@ typedef enum log_id { #define sizeof_log_id_t sizeof(typeof_log_id_t) #define typeof_log_id_t unsigned char -/* Currently helper to liblog unit tests, expect wider use. */ -#define NS_PER_SEC 1000000000ULL -#ifdef __cplusplus -typedef struct log_time : public timespec { -public: - log_time(void) - { - } - log_time(const char *T) - { - const uint8_t *c = (const uint8_t *) T; - tv_sec = c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24); - tv_nsec = c[4] | (c[5] << 8) | (c[6] << 16) | (c[7] << 24); - } - bool operator== (log_time &T) - { - return (tv_sec == T.tv_sec) && (tv_nsec == T.tv_nsec); - } - bool operator!= (log_time &T) - { - return !(*this == T); - } - bool operator< (log_time &T) - { - return (tv_sec < T.tv_sec) - || ((tv_sec == T.tv_sec) && (tv_nsec < T.tv_nsec)); - } - bool operator>= (log_time &T) - { - return !(*this < T); - } - bool operator> (log_time &T) - { - return (tv_sec > T.tv_sec) - || ((tv_sec == T.tv_sec) && (tv_nsec > T.tv_nsec)); - } - bool operator<= (log_time &T) - { - return !(*this > T); - } - uint64_t nsec(void) - { - return static_cast(tv_sec) * NS_PER_SEC + tv_nsec; - } -} log_time_t; -#else -typedef struct timespec log_time_t; -#endif - /* * Send a simple string to the log. */ diff --git a/liblog/Android.mk b/liblog/Android.mk index cc8df83b1..5dfbc06ef 100644 --- a/liblog/Android.mk +++ b/liblog/Android.mk @@ -80,5 +80,3 @@ include $(CLEAR_VARS) LOCAL_MODULE := liblog LOCAL_WHOLE_STATIC_LIBRARIES := liblog include $(BUILD_SHARED_LIBRARY) - -include $(call first-makefiles-under,$(LOCAL_PATH)) diff --git a/liblog/tests/Android.mk b/liblog/tests/Android.mk deleted file mode 100644 index a234a976d..000000000 --- a/liblog/tests/Android.mk +++ /dev/null @@ -1,77 +0,0 @@ -# -# Copyright (C) 2013 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. -# - -LOCAL_PATH := $(call my-dir) - -# ----------------------------------------------------------------------------- -# Benchmarks. -# ----------------------------------------------------------------------------- - -test_module_prefix := liblog- -test_tags := tests - -benchmark_c_flags := \ - -Ibionic/tests \ - -Wall -Wextra \ - -Werror \ - -fno-builtin \ - -std=gnu++11 - -benchmark_src_files := \ - benchmark_main.cpp \ - liblog_benchmark.cpp \ - -# Build benchmarks for the device. Run with: -# adb shell liblog-benchmarks -include $(CLEAR_VARS) -LOCAL_MODULE := $(test_module_prefix)benchmarks -LOCAL_MODULE_TAGS := $(test_tags) -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk -LOCAL_CFLAGS += $(benchmark_c_flags) -LOCAL_SHARED_LIBRARIES += liblog libm -LOCAL_SRC_FILES := $(benchmark_src_files) -ifndef LOCAL_SDK_VERSION -LOCAL_C_INCLUDES += bionic bionic/libstdc++/include external/stlport/stlport -LOCAL_SHARED_LIBRARIES += libstlport -endif -LOCAL_MODULE_PATH := $(TARGET_OUT_DATA_NATIVE_TESTS)/$(LOCAL_MODULE) -include $(BUILD_EXECUTABLE) - -# ----------------------------------------------------------------------------- -# Unit tests. -# ----------------------------------------------------------------------------- - -test_c_flags := \ - -fstack-protector-all \ - -g \ - -Wall -Wextra \ - -Werror \ - -fno-builtin \ - -test_src_files := \ - liblog_test.cpp \ - -# Build tests for the device (with .so). Run with: -# adb shell /data/nativetest/liblog-unit-tests/liblog-unit-tests -include $(CLEAR_VARS) -LOCAL_MODULE := $(test_module_prefix)unit-tests -LOCAL_MODULE_TAGS := $(test_tags) -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk -LOCAL_CFLAGS += $(test_c_flags) -LOCAL_LDLIBS := -lpthread -LOCAL_SHARED_LIBRARIES := liblog -LOCAL_SRC_FILES := $(test_src_files) -include $(BUILD_NATIVE_TEST) diff --git a/liblog/tests/benchmark.h b/liblog/tests/benchmark.h deleted file mode 100644 index ec72b806d..000000000 --- a/liblog/tests/benchmark.h +++ /dev/null @@ -1,147 +0,0 @@ -/* - * Copyright (C) 2012-2013 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 -#include -#include -#include - -#include - -#ifndef BIONIC_BENCHMARK_H_ -#define BIONIC_BENCHMARK_H_ - -namespace testing { - -class Benchmark; -template class BenchmarkWantsArg; -template class BenchmarkWithArg; - -void BenchmarkRegister(Benchmark* bm); -int PrettyPrintInt(char* str, int len, unsigned int arg); - -class Benchmark { - public: - Benchmark(const char* name, void (*fn)(int)) : name_(strdup(name)), fn_(fn) { - BenchmarkRegister(this); - } - Benchmark(const char* name) : name_(strdup(name)), fn_(NULL) {} - - virtual ~Benchmark() { - free(name_); - } - - const char* Name() { return name_; } - virtual const char* ArgName() { return NULL; } - virtual void RunFn(int iterations) { fn_(iterations); } - - protected: - char* name_; - - private: - void (*fn_)(int); -}; - -template -class BenchmarkWantsArgBase : public Benchmark { - public: - BenchmarkWantsArgBase(const char* name, void (*fn)(int, T)) : Benchmark(name) { - fn_arg_ = fn; - } - - BenchmarkWantsArgBase* Arg(const char* arg_name, T arg) { - BenchmarkRegister(new BenchmarkWithArg(name_, fn_arg_, arg_name, arg)); - return this; - } - - protected: - virtual void RunFn(int) { printf("can't run arg benchmark %s without arg\n", Name()); } - void (*fn_arg_)(int, T); -}; - -template -class BenchmarkWithArg : public BenchmarkWantsArg { - public: - BenchmarkWithArg(const char* name, void (*fn)(int, T), const char* arg_name, T arg) : - BenchmarkWantsArg(name, fn), arg_(arg) { - arg_name_ = strdup(arg_name); - } - - virtual ~BenchmarkWithArg() { - free(arg_name_); - } - - virtual const char* ArgName() { return arg_name_; } - - protected: - virtual void RunFn(int iterations) { BenchmarkWantsArg::fn_arg_(iterations, arg_); } - - private: - T arg_; - char* arg_name_; -}; - -template -class BenchmarkWantsArg : public BenchmarkWantsArgBase { - public: - BenchmarkWantsArg(const char* name, void (*fn)(int, T)) : - BenchmarkWantsArgBase(name, fn) { } -}; - -template <> -class BenchmarkWantsArg : public BenchmarkWantsArgBase { - public: - BenchmarkWantsArg(const char* name, void (*fn)(int, int)) : - BenchmarkWantsArgBase(name, fn) { } - - BenchmarkWantsArg* Arg(int arg) { - char arg_name[100]; - PrettyPrintInt(arg_name, sizeof(arg_name), arg); - BenchmarkRegister(new BenchmarkWithArg(name_, fn_arg_, arg_name, arg)); - return this; - } -}; - -static inline Benchmark* BenchmarkFactory(const char* name, void (*fn)(int)) { - return new Benchmark(name, fn); -} - -template -static inline BenchmarkWantsArg* BenchmarkFactory(const char* name, void (*fn)(int, T)) { - return new BenchmarkWantsArg(name, fn); -} - -} // namespace testing - -template -static inline void BenchmarkAddArg(::testing::Benchmark* b, const char* name, T arg) { - ::testing::BenchmarkWantsArg* ba; - ba = static_cast< ::testing::BenchmarkWantsArg* >(b); - ba->Arg(name, arg); -} - -void SetBenchmarkBytesProcessed(uint64_t); -void ResetBenchmarkTiming(void); -void StopBenchmarkTiming(void); -void StartBenchmarkTiming(void); -void StartBenchmarkTiming(uint64_t); -void StopBenchmarkTiming(uint64_t); - -#define BENCHMARK(f) \ - static ::testing::Benchmark* _benchmark_##f __attribute__((unused)) = \ - (::testing::Benchmark*)::testing::BenchmarkFactory(#f, f) - -#endif // BIONIC_BENCHMARK_H_ diff --git a/liblog/tests/benchmark_main.cpp b/liblog/tests/benchmark_main.cpp deleted file mode 100644 index 942e12c99..000000000 --- a/liblog/tests/benchmark_main.cpp +++ /dev/null @@ -1,245 +0,0 @@ -/* - * Copyright (C) 2012-2013 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 - -#include -#include -#include - -#include -#include -#include - -static uint64_t gBytesProcessed; -static uint64_t gBenchmarkTotalTimeNs; -static uint64_t gBenchmarkTotalTimeNsSquared; -static uint64_t gBenchmarkNum; -static uint64_t gBenchmarkStartTimeNs; - -typedef std::vector< ::testing::Benchmark* > BenchmarkList; -static BenchmarkList* gBenchmarks; - -static int Round(int n) { - int base = 1; - while (base*10 < n) { - base *= 10; - } - if (n < 2*base) { - return 2*base; - } - if (n < 5*base) { - return 5*base; - } - return 10*base; -} - -static uint64_t NanoTime() { - struct timespec t; - t.tv_sec = t.tv_nsec = 0; - clock_gettime(CLOCK_MONOTONIC, &t); - return static_cast(t.tv_sec) * 1000000000ULL + t.tv_nsec; -} - -namespace testing { - -int PrettyPrintInt(char* str, int len, unsigned int arg) -{ - if (arg >= (1<<30) && arg % (1<<30) == 0) { - return snprintf(str, len, "%uGi", arg/(1<<30)); - } else if (arg >= (1<<20) && arg % (1<<20) == 0) { - return snprintf(str, len, "%uMi", arg/(1<<20)); - } else if (arg >= (1<<10) && arg % (1<<10) == 0) { - return snprintf(str, len, "%uKi", arg/(1<<10)); - } else if (arg >= 1000000000 && arg % 1000000000 == 0) { - return snprintf(str, len, "%uG", arg/1000000000); - } else if (arg >= 1000000 && arg % 1000000 == 0) { - return snprintf(str, len, "%uM", arg/1000000); - } else if (arg >= 1000 && arg % 1000 == 0) { - return snprintf(str, len, "%uK", arg/1000); - } else { - return snprintf(str, len, "%u", arg); - } -} - -bool ShouldRun(Benchmark* b, int argc, char* argv[]) { - if (argc == 1) { - return true; // With no arguments, we run all benchmarks. - } - // Otherwise, we interpret each argument as a regular expression and - // see if any of our benchmarks match. - for (int i = 1; i < argc; i++) { - regex_t re; - if (regcomp(&re, argv[i], 0) != 0) { - fprintf(stderr, "couldn't compile \"%s\" as a regular expression!\n", argv[i]); - exit(EXIT_FAILURE); - } - int match = regexec(&re, b->Name(), 0, NULL, 0); - regfree(&re); - if (match != REG_NOMATCH) { - return true; - } - } - return false; -} - -void BenchmarkRegister(Benchmark* b) { - if (gBenchmarks == NULL) { - gBenchmarks = new BenchmarkList; - } - gBenchmarks->push_back(b); -} - -void RunRepeatedly(Benchmark* b, int iterations) { - gBytesProcessed = 0; - ResetBenchmarkTiming(); - uint64_t StartTimeNs = NanoTime(); - b->RunFn(iterations); - // Catch us if we fail to log anything. - if ((gBenchmarkTotalTimeNs == 0) - && (StartTimeNs != 0) - && (gBenchmarkStartTimeNs == 0)) { - gBenchmarkTotalTimeNs = NanoTime() - StartTimeNs; - } -} - -void Run(Benchmark* b) { - // run once in case it's expensive - unsigned iterations = 1; - uint64_t s = NanoTime(); - RunRepeatedly(b, iterations); - s = NanoTime() - s; - while (s < 2e9 && gBenchmarkTotalTimeNs < 1e9 && iterations < 1e9) { - unsigned last = iterations; - if (gBenchmarkTotalTimeNs/iterations == 0) { - iterations = 1e9; - } else { - iterations = 1e9 / (gBenchmarkTotalTimeNs/iterations); - } - iterations = std::max(last + 1, std::min(iterations + iterations/2, 100*last)); - iterations = Round(iterations); - s = NanoTime(); - RunRepeatedly(b, iterations); - s = NanoTime() - s; - } - - char throughput[100]; - throughput[0] = '\0'; - if (gBenchmarkTotalTimeNs > 0 && gBytesProcessed > 0) { - double mib_processed = static_cast(gBytesProcessed)/1e6; - double seconds = static_cast(gBenchmarkTotalTimeNs)/1e9; - snprintf(throughput, sizeof(throughput), " %8.2f MiB/s", mib_processed/seconds); - } - - char full_name[100]; - snprintf(full_name, sizeof(full_name), "%s%s%s", b->Name(), - b->ArgName() ? "/" : "", - b->ArgName() ? b->ArgName() : ""); - - uint64_t mean = gBenchmarkTotalTimeNs / iterations; - uint64_t sdev = 0; - if (gBenchmarkNum == iterations) { - mean = gBenchmarkTotalTimeNs / gBenchmarkNum; - uint64_t nXvariance = gBenchmarkTotalTimeNsSquared * gBenchmarkNum - - (gBenchmarkTotalTimeNs * gBenchmarkTotalTimeNs); - sdev = (sqrt((double)nXvariance) / gBenchmarkNum / gBenchmarkNum) + 0.5; - } - if (mean > (10000 * sdev)) { - printf("%-25s %10llu %10llu%s\n", full_name, - static_cast(iterations), mean, throughput); - } else { - printf("%-25s %10llu %10llu(\317\203%llu)%s\n", full_name, - static_cast(iterations), mean, sdev, throughput); - } - fflush(stdout); -} - -} // namespace testing - -void SetBenchmarkBytesProcessed(uint64_t x) { - gBytesProcessed = x; -} - -void ResetBenchmarkTiming() { - gBenchmarkStartTimeNs = 0; - gBenchmarkTotalTimeNs = 0; - gBenchmarkTotalTimeNsSquared = 0; - gBenchmarkNum = 0; -} - -void StopBenchmarkTiming(void) { - if (gBenchmarkStartTimeNs != 0) { - int64_t diff = NanoTime() - gBenchmarkStartTimeNs; - gBenchmarkTotalTimeNs += diff; - gBenchmarkTotalTimeNsSquared += diff * diff; - ++gBenchmarkNum; - } - gBenchmarkStartTimeNs = 0; -} - -void StartBenchmarkTiming(void) { - if (gBenchmarkStartTimeNs == 0) { - gBenchmarkStartTimeNs = NanoTime(); - } -} - -void StopBenchmarkTiming(uint64_t NanoTime) { - if (gBenchmarkStartTimeNs != 0) { - int64_t diff = NanoTime - gBenchmarkStartTimeNs; - gBenchmarkTotalTimeNs += diff; - gBenchmarkTotalTimeNsSquared += diff * diff; - if (NanoTime != 0) { - ++gBenchmarkNum; - } - } - gBenchmarkStartTimeNs = 0; -} - -void StartBenchmarkTiming(uint64_t NanoTime) { - if (gBenchmarkStartTimeNs == 0) { - gBenchmarkStartTimeNs = NanoTime; - } -} - -int main(int argc, char* argv[]) { - if (gBenchmarks->empty()) { - fprintf(stderr, "No benchmarks registered!\n"); - exit(EXIT_FAILURE); - } - - bool need_header = true; - for (auto b : *gBenchmarks) { - if (ShouldRun(b, argc, argv)) { - if (need_header) { - printf("%-25s %10s %10s\n", "", "iterations", "ns/op"); - fflush(stdout); - need_header = false; - } - Run(b); - } - } - - if (need_header) { - fprintf(stderr, "No matching benchmarks!\n"); - fprintf(stderr, "Available benchmarks:\n"); - for (auto b : *gBenchmarks) { - fprintf(stderr, " %s\n", b->Name()); - } - exit(EXIT_FAILURE); - } - - return 0; -} diff --git a/liblog/tests/liblog_benchmark.cpp b/liblog/tests/liblog_benchmark.cpp deleted file mode 100644 index c06ef91b7..000000000 --- a/liblog/tests/liblog_benchmark.cpp +++ /dev/null @@ -1,202 +0,0 @@ -/* - * Copyright (C) 2013 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 "benchmark.h" - -#include -#include -#include -#include - -/* - * Measure the fastest rate we can reliabley stuff print messages into - * the log at high pressure. Expect this to be less than double the process - * wakeup time (2ms?) - */ -static void BM_log_maximum_retry(int iters) { - StartBenchmarkTiming(); - - for (int i = 0; i < iters; ++i) { - TEMP_FAILURE_RETRY( - __android_log_print(ANDROID_LOG_INFO, - "BM_log_maximum_retry", "%d", i)); - } - - StopBenchmarkTiming(); -} -BENCHMARK(BM_log_maximum_retry); - -/* - * Measure the fastest rate we can stuff print messages into the log - * at high pressure. Expect this to be less than double the process wakeup - * time (2ms?) - */ -static void BM_log_maximum(int iters) { - StartBenchmarkTiming(); - - for (int i = 0; i < iters; ++i) { - __android_log_print(ANDROID_LOG_INFO, "BM_log_maximum", "%d", i); - } - - StopBenchmarkTiming(); -} -BENCHMARK(BM_log_maximum); - -/* - * Measure the time it takes to submit the android logging call using - * discrete acquisition under light load. Expect this to be a pair of - * syscall periods (2us). - */ -static void BM_clock_overhead(int iters) { - for (int i = 0; i < iters; ++i) { - StartBenchmarkTiming(); - StopBenchmarkTiming(); - } -} -BENCHMARK(BM_clock_overhead); - -/* - * Measure the time it takes to submit the android logging call using - * discrete acquisition under light load. Expect this to be a dozen or so - * syscall periods (40us). - */ -static void BM_log_overhead(int iters) { - for (int i = 0; i < iters; ++i) { - StartBenchmarkTiming(); - __android_log_print(ANDROID_LOG_INFO, "BM_log_overhead", "%d", i); - StopBenchmarkTiming(); - usleep(1000); - } -} -BENCHMARK(BM_log_overhead); - -/* - * Measure the time it takes for the logd posting call to acquire the - * timestamp to place into the internal record. Expect this to be less than - * 4 syscalls (3us). - */ -static void BM_log_latency(int iters) { - pid_t pid = getpid(); - - struct logger_list * logger_list = android_logger_list_open(LOG_ID_EVENTS, - O_RDONLY, 0, pid); - - if (!logger_list) { - fprintf(stderr, "Unable to open events log: %s\n", strerror(errno)); - exit(EXIT_FAILURE); - } - - for (int j = 0, i = 0; i < iters && j < 10*iters; ++i, ++j) { - log_time_t ts; - TEMP_FAILURE_RETRY(( - clock_gettime(CLOCK_REALTIME, &ts), - android_btWriteLog(0, EVENT_TYPE_LONG, &ts, sizeof(ts)))); - - for (;;) { - log_msg log_msg; - int ret = android_logger_list_read(logger_list, &log_msg); - - if (ret <= 0) { - iters = i; - break; - } - if ((log_msg.entry.len != (4 + 1 + 8)) - || (log_msg.id() != LOG_ID_EVENTS)) { - continue; - } - - char* eventData = log_msg.msg(); - - if (eventData[4] != EVENT_TYPE_LONG) { - continue; - } - log_time_t tx(eventData + 4 + 1); - if (ts != tx) { - continue; - } - - uint64_t start = ts.nsec(); - uint64_t end = log_msg.nsec(); - if (end >= start) { - StartBenchmarkTiming(start); - StopBenchmarkTiming(end); - } else { - --i; - } - break; - } - } - - android_logger_list_free(logger_list); -} -BENCHMARK(BM_log_latency); - -/* - * Measure the time it takes for the logd posting call to make it into - * the logs. Expect this to be less than double the process wakeup time (2ms). - */ -static void BM_log_delay(int iters) { - pid_t pid = getpid(); - - struct logger_list * logger_list = android_logger_list_open(LOG_ID_EVENTS, - O_RDONLY, 0, pid); - - if (!logger_list) { - fprintf(stderr, "Unable to open events log: %s\n", strerror(errno)); - exit(EXIT_FAILURE); - } - - StartBenchmarkTiming(); - - for (int i = 0; i < iters; ++i) { - log_time_t ts; - - clock_gettime(CLOCK_REALTIME, &ts); - TEMP_FAILURE_RETRY( - android_btWriteLog(0, EVENT_TYPE_LONG, &ts, sizeof(ts))); - - for (;;) { - log_msg log_msg; - int ret = android_logger_list_read(logger_list, &log_msg); - - if (ret <= 0) { - iters = i; - break; - } - if ((log_msg.entry.len != (4 + 1 + 8)) - || (log_msg.id() != LOG_ID_EVENTS)) { - continue; - } - - char* eventData = log_msg.msg(); - - if (eventData[4] != EVENT_TYPE_LONG) { - continue; - } - log_time_t tx(eventData + 4 + 1); - if (ts != tx) { - continue; - } - - break; - } - } - - StopBenchmarkTiming(); - - android_logger_list_free(logger_list); -} -BENCHMARK(BM_log_delay); diff --git a/liblog/tests/liblog_test.cpp b/liblog/tests/liblog_test.cpp deleted file mode 100644 index dfc08f0a7..000000000 --- a/liblog/tests/liblog_test.cpp +++ /dev/null @@ -1,164 +0,0 @@ -/* - * Copyright (C) 2013 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 -#include -#include -#include - -TEST(liblog, __android_log_buf_print) { - ASSERT_LT(0, __android_log_buf_print(LOG_ID_RADIO, ANDROID_LOG_INFO, - "TEST__android_log_buf_print", - "radio")); - usleep(1000); - ASSERT_LT(0, __android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_INFO, - "TEST__android_log_buf_print", - "system")); - usleep(1000); - ASSERT_LT(0, __android_log_buf_print(LOG_ID_MAIN, ANDROID_LOG_INFO, - "TEST__android_log_buf_print", - "main")); - usleep(1000); -} - -TEST(liblog, __android_log_buf_write) { - ASSERT_LT(0, __android_log_buf_write(LOG_ID_RADIO, ANDROID_LOG_INFO, - "TEST__android_log_buf_write", - "radio")); - usleep(1000); - ASSERT_LT(0, __android_log_buf_write(LOG_ID_SYSTEM, ANDROID_LOG_INFO, - "TEST__android_log_buf_write", - "system")); - usleep(1000); - ASSERT_LT(0, __android_log_buf_write(LOG_ID_MAIN, ANDROID_LOG_INFO, - "TEST__android_log_buf_write", - "main")); - usleep(1000); -} - -TEST(liblog, __android_log_btwrite) { - int intBuf = 0xDEADBEEF; - ASSERT_LT(0, __android_log_btwrite(0, - EVENT_TYPE_INT, - &intBuf, sizeof(intBuf))); - long long longBuf = 0xDEADBEEFA55A5AA5; - ASSERT_LT(0, __android_log_btwrite(0, - EVENT_TYPE_LONG, - &longBuf, sizeof(longBuf))); - usleep(1000); - char Buf[] = "\20\0\0\0DeAdBeEfA55a5aA5"; - ASSERT_LT(0, __android_log_btwrite(0, - EVENT_TYPE_STRING, - Buf, sizeof(Buf) - 1)); - usleep(1000); -} - -static void* ConcurrentPrintFn(void *arg) { - int ret = __android_log_buf_print(LOG_ID_MAIN, ANDROID_LOG_INFO, - "TEST__android_log_print", "Concurrent %d", - reinterpret_cast(arg)); - return reinterpret_cast(ret); -} - -#define NUM_CONCURRENT 64 -#define _concurrent_name(a,n) a##__concurrent##n -#define concurrent_name(a,n) _concurrent_name(a,n) - -TEST(liblog, concurrent_name(__android_log_buf_print, NUM_CONCURRENT)) { - pthread_t t[NUM_CONCURRENT]; - int i; - for (i=0; i < NUM_CONCURRENT; i++) { - ASSERT_EQ(0, pthread_create(&t[i], NULL, - ConcurrentPrintFn, - reinterpret_cast(i))); - } - int ret = 0; - for (i=0; i < NUM_CONCURRENT; i++) { - void* result; - ASSERT_EQ(0, pthread_join(t[i], &result)); - if ((0 == ret) && (0 != reinterpret_cast(result))) { - ret = reinterpret_cast(result); - } - } - ASSERT_LT(0, ret); -} - -TEST(liblog, __android_log_btwrite__android_logger_list_read) { - pid_t pid; - struct logger_list *logger_list; - log_time_t ts; - - pid = getpid(); - - ASSERT_EQ(0, NULL == (logger_list = android_logger_list_open( - LOG_ID_EVENTS, O_RDONLY | O_NDELAY, 1000, pid))); - - clock_gettime(CLOCK_MONOTONIC, &ts); - - ASSERT_LT(0, __android_log_btwrite(0, EVENT_TYPE_LONG, &ts, sizeof(ts))); - usleep(1000000); - - int count = 0; - - for (;;) { - log_msg log_msg; - if (android_logger_list_read(logger_list, &log_msg) <= 0) { - break; - } - - ASSERT_EQ(log_msg.entry.pid, pid); - - if ((log_msg.entry.len != (4 + 1 + 8)) - || (log_msg.id() != LOG_ID_EVENTS)) { - continue; - } - - char *eventData = log_msg.msg(); - - if (eventData[4] != EVENT_TYPE_LONG) { - continue; - } - - log_time_t tx(eventData + 4 + 1); - if (ts == tx) { - ++count; - } - } - - ASSERT_EQ(1, count); - - android_logger_list_close(logger_list); -} - -TEST(liblog, android_logger_get_) { - struct logger_list * logger_list = android_logger_list_alloc(O_WRONLY, 0, 0); - - for(int i = LOG_ID_MIN; i < LOG_ID_MAX; ++i) { - log_id_t id = static_cast(i); - const char *name = android_log_id_to_name(id); - if (id != android_name_to_log_id(name)) { - continue; - } - struct logger * logger; - ASSERT_EQ(0, NULL == (logger = android_logger_open(logger_list, id))); - ASSERT_EQ(id, android_logger_get_id(logger)); - ASSERT_LT(0, android_logger_get_log_size(logger)); - ASSERT_LT(0, android_logger_get_log_readable_size(logger)); - ASSERT_LT(0, android_logger_get_log_version(logger)); - } - - android_logger_list_close(logger_list); -}