diff options
Diffstat (limited to 'chromium/testing/android')
-rw-r--r-- | chromium/testing/android/AndroidManifest.xml | 33 | ||||
-rw-r--r-- | chromium/testing/android/OWNERS | 2 | ||||
-rw-r--r-- | chromium/testing/android/README.chromium | 2 | ||||
-rw-r--r-- | chromium/testing/android/java/src/org/chromium/native_test/ChromeNativeTestActivity.java | 84 | ||||
-rw-r--r-- | chromium/testing/android/native_test.gyp | 64 | ||||
-rw-r--r-- | chromium/testing/android/native_test_launcher.cc | 202 | ||||
-rw-r--r-- | chromium/testing/android/native_test_util.cc | 54 | ||||
-rw-r--r-- | chromium/testing/android/native_test_util.h | 37 |
8 files changed, 478 insertions, 0 deletions
diff --git a/chromium/testing/android/AndroidManifest.xml b/chromium/testing/android/AndroidManifest.xml new file mode 100644 index 00000000000..73a0c148819 --- /dev/null +++ b/chromium/testing/android/AndroidManifest.xml @@ -0,0 +1,33 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- +Copyright (c) 2012 The Chromium Authors. All rights reserved. +Use of this source code is governed by a BSD-style license that can be +found in the LICENSE file. +--> + +<manifest xmlns:android="http://schemas.android.com/apk/res/android" + package="org.chromium.native_test" + android:versionCode="1" + android:versionName="1.0"> + + <uses-sdk android:minSdkVersion="14" android:targetSdkVersion="17" /> + + <application android:label="ChromeNativeTests"> + <activity android:name=".ChromeNativeTestActivity" + android:label="ChromeNativeTest" + android:configChanges="orientation|keyboardHidden"> + <intent-filter> + <action android:name="android.intent.action.MAIN" /> + <category android:name="android.intent.category.LAUNCHER" /> + </intent-filter> + </activity> + </application> + + <uses-permission android:name="android.permission.CAMERA" /> + <uses-permission android:name="android.permission.INTERNET"/> + <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS"/> + <uses-permission android:name="android.permission.RECORD_AUDIO"/> + <uses-permission android:name="android.permission.WAKE_LOCK"/> + <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/> + +</manifest> diff --git a/chromium/testing/android/OWNERS b/chromium/testing/android/OWNERS new file mode 100644 index 00000000000..87d5d224978 --- /dev/null +++ b/chromium/testing/android/OWNERS @@ -0,0 +1,2 @@ +bulach@chromium.org +yfriedman@chromium.org diff --git a/chromium/testing/android/README.chromium b/chromium/testing/android/README.chromium new file mode 100644 index 00000000000..c00255a43af --- /dev/null +++ b/chromium/testing/android/README.chromium @@ -0,0 +1,2 @@ +apk-based runner for Chromium unit test bundles. This is a simple wrapper APK +that should include a single gtest native library. diff --git a/chromium/testing/android/java/src/org/chromium/native_test/ChromeNativeTestActivity.java b/chromium/testing/android/java/src/org/chromium/native_test/ChromeNativeTestActivity.java new file mode 100644 index 00000000000..6486a14f3cb --- /dev/null +++ b/chromium/testing/android/java/src/org/chromium/native_test/ChromeNativeTestActivity.java @@ -0,0 +1,84 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +package org.chromium.native_test; + +import android.app.Activity; +import android.content.Context; +import android.os.Bundle; +import android.os.Environment; +import android.os.Handler; +import android.util.Log; + +import org.chromium.base.ChromiumActivity; +import org.chromium.base.PathUtils; +import org.chromium.base.PowerMonitor; + +// TODO(cjhopman): This should not refer to content. NativeLibraries should be moved to base. +import org.chromium.content.app.NativeLibraries; + +import java.io.File; + +// Android's NativeActivity is mostly useful for pure-native code. +// Our tests need to go up to our own java classes, which is not possible using +// the native activity class loader. +public class ChromeNativeTestActivity extends ChromiumActivity { + private static final String TAG = "ChromeNativeTestActivity"; + private static final String EXTRA_RUN_IN_SUB_THREAD = "RunInSubThread"; + // We post a delayed task to run tests so that we do not block onCreate(). + private static final long RUN_TESTS_DELAY_IN_MS = 300; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + // Needed by path_utils_unittest.cc + PathUtils.setPrivateDataDirectorySuffix("chrome"); + + // Needed by system_monitor_unittest.cc + PowerMonitor.createForTests(this); + + loadLibraries(); + Bundle extras = this.getIntent().getExtras(); + if (extras != null && extras.containsKey(EXTRA_RUN_IN_SUB_THREAD)) { + // Create a new thread and run tests on it. + new Thread() { + @Override + public void run() { + runTests(); + } + }.start(); + } else { + // Post a task to run the tests. This allows us to not block + // onCreate and still run tests on the main thread. + new Handler().postDelayed(new Runnable() { + @Override + public void run() { + runTests(); + } + }, RUN_TESTS_DELAY_IN_MS); + } + } + + private void runTests() { + // This directory is used by build/android/pylib/test_package_apk.py. + nativeRunTests(getFilesDir().getAbsolutePath(), getApplicationContext()); + } + + // Signal a failure of the native test loader to python scripts + // which run tests. For example, we look for + // RUNNER_FAILED build/android/test_package.py. + private void nativeTestFailed() { + Log.e(TAG, "[ RUNNER_FAILED ] could not load native library"); + } + + private void loadLibraries() { + for (String library: NativeLibraries.libraries) { + Log.i(TAG, "loading: " + library); + System.loadLibrary(library); + Log.i(TAG, "loaded: " + library); + } + } + + private native void nativeRunTests(String filesDir, Context appContext); +} diff --git a/chromium/testing/android/native_test.gyp b/chromium/testing/android/native_test.gyp new file mode 100644 index 00000000000..4a3cc4d8fab --- /dev/null +++ b/chromium/testing/android/native_test.gyp @@ -0,0 +1,64 @@ +# Copyright (c) 2012 The Chromium Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +{ + 'conditions': [ + ['OS=="android"', { + 'targets': [ + { + 'target_name': 'native_test_native_code', + 'message': 'building native pieces of native test package', + 'type': 'static_library', + 'sources': [ + 'native_test_launcher.cc', + ], + 'direct_dependent_settings': { + 'ldflags!': [ + # JNI_OnLoad is implemented in a .a and we need to + # re-export in the .so. + '-Wl,--exclude-libs=ALL', + ], + }, + 'dependencies': [ + '../../base/base.gyp:base', + '../../base/base.gyp:test_support_base', + '../../base/third_party/dynamic_annotations/dynamic_annotations.gyp:dynamic_annotations', + '../gtest.gyp:gtest', + 'native_test_jni_headers', + 'native_test_util', + ], + }, + { + 'target_name': 'native_test_jni_headers', + 'type': 'none', + 'sources': [ + 'java/src/org/chromium/native_test/ChromeNativeTestActivity.java' + ], + 'variables': { + 'jni_gen_package': 'testing', + }, + 'includes': [ '../../build/jni_generator.gypi' ], + # So generated jni headers can be found by targets that + # depend on this. + 'direct_dependent_settings': { + 'include_dirs': [ + '<(SHARED_INTERMEDIATE_DIR)', + ], + }, + }, + { + 'target_name': 'native_test_util', + 'type': 'static_library', + 'sources': [ + 'native_test_util.cc', + 'native_test_util.h', + ], + 'dependencies': [ + '../../base/base.gyp:base', + ], + }, + ], + }] + ], +} diff --git a/chromium/testing/android/native_test_launcher.cc b/chromium/testing/android/native_test_launcher.cc new file mode 100644 index 00000000000..e39eb2bdccb --- /dev/null +++ b/chromium/testing/android/native_test_launcher.cc @@ -0,0 +1,202 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// This class sets up the environment for running the native tests inside an +// android application. It outputs (to a fifo) markers identifying the +// START/PASSED/CRASH of the test suite, FAILURE/SUCCESS of individual tests, +// etc. +// These markers are read by the test runner script to generate test results. +// It installs signal handlers to detect crashes. + +#include <android/log.h> +#include <signal.h> + +#include "base/android/base_jni_registrar.h" +#include "base/android/fifo_utils.h" +#include "base/android/jni_android.h" +#include "base/android/jni_string.h" +#include "base/android/scoped_java_ref.h" +#include "base/at_exit.h" +#include "base/base_switches.h" +#include "base/command_line.h" +#include "base/file_util.h" +#include "base/files/file_path.h" +#include "base/logging.h" +#include "base/strings/stringprintf.h" +#include "gtest/gtest.h" +#include "testing/android/native_test_util.h" +#include "testing/jni/ChromeNativeTestActivity_jni.h" + +using testing::native_test_util::ArgsToArgv; +using testing::native_test_util::ParseArgsFromCommandLineFile; +using testing::native_test_util::ScopedMainEntryLogger; + +// The main function of the program to be wrapped as a test apk. +extern int main(int argc, char** argv); + +namespace { + +// These two command line flags are supported for DumpRenderTree, which needs +// three fifos rather than a combined one: one for stderr, stdin and stdout. +const char kSeparateStderrFifo[] = "separate-stderr-fifo"; +const char kCreateStdinFifo[] = "create-stdin-fifo"; + +// The test runner script writes the command line file in +// "/data/local/tmp". +static const char kCommandLineFilePath[] = + "/data/local/tmp/chrome-native-tests-command-line"; + +const char kLogTag[] = "chromium"; +const char kCrashedMarker[] = "[ CRASHED ]\n"; + +// The list of signals which are considered to be crashes. +const int kExceptionSignals[] = { + SIGSEGV, SIGABRT, SIGFPE, SIGILL, SIGBUS, -1 +}; + +struct sigaction g_old_sa[NSIG]; + +// This function runs in a compromised context. It should not allocate memory. +void SignalHandler(int sig, siginfo_t* info, void* reserved) { + // Output the crash marker. + write(STDOUT_FILENO, kCrashedMarker, sizeof(kCrashedMarker)); + g_old_sa[sig].sa_sigaction(sig, info, reserved); +} + +// TODO(nileshagrawal): now that we're using FIFO, test scripts can detect EOF. +// Remove the signal handlers. +void InstallHandlers() { + struct sigaction sa; + memset(&sa, 0, sizeof(sa)); + + sa.sa_sigaction = SignalHandler; + sa.sa_flags = SA_SIGINFO; + + for (unsigned int i = 0; kExceptionSignals[i] != -1; ++i) { + sigaction(kExceptionSignals[i], &sa, &g_old_sa[kExceptionSignals[i]]); + } +} + +// Writes printf() style string to Android's logger where |priority| is one of +// the levels defined in <android/log.h>. +void AndroidLog(int priority, const char* format, ...) { + va_list args; + va_start(args, format); + __android_log_vprint(priority, kLogTag, format, args); + va_end(args); +} + +// Ensures that the fifo at |path| is created by deleting whatever is at |path| +// prior to (re)creating the fifo, otherwise logs the error and terminates the +// program. +void EnsureCreateFIFO(const base::FilePath& path) { + unlink(path.value().c_str()); + if (base::android::CreateFIFO(path, 0666)) + return; + + AndroidLog(ANDROID_LOG_ERROR, "Failed to create fifo %s: %s\n", + path.value().c_str(), strerror(errno)); + exit(EXIT_FAILURE); +} + +// Ensures that |stream| is redirected to |path|, otherwise logs the error and +// terminates the program. +void EnsureRedirectStream(FILE* stream, + const base::FilePath& path, + const char* mode) { + if (base::android::RedirectStream(stream, path, mode)) + return; + + AndroidLog(ANDROID_LOG_ERROR, "Failed to redirect stream to file: %s: %s\n", + path.value().c_str(), strerror(errno)); + exit(EXIT_FAILURE); +} + +} // namespace + +// This method is called on a separate java thread so that we won't trigger +// an ANR. +static void RunTests(JNIEnv* env, + jobject obj, + jstring jfiles_dir, + jobject app_context) { + base::AtExitManager exit_manager; + + // Command line initialized basically, will be fully initialized later. + static const char* const kInitialArgv[] = { "ChromeTestActivity" }; + CommandLine::Init(arraysize(kInitialArgv), kInitialArgv); + + // Set the application context in base. + base::android::ScopedJavaLocalRef<jobject> scoped_context( + env, env->NewLocalRef(app_context)); + base::android::InitApplicationContext(scoped_context); + base::android::RegisterJni(env); + + std::vector<std::string> args; + ParseArgsFromCommandLineFile(kCommandLineFilePath, &args); + + std::vector<char*> argv; + int argc = ArgsToArgv(args, &argv); + + // Fully initialize command line with arguments. + CommandLine::ForCurrentProcess()->AppendArguments( + CommandLine(argc, &argv[0]), false); + const CommandLine& command_line = *CommandLine::ForCurrentProcess(); + + base::FilePath files_dir( + base::android::ConvertJavaStringToUTF8(env, jfiles_dir)); + + // A few options, such "--gtest_list_tests", will just use printf directly + // Always redirect stdout to a known file. + base::FilePath fifo_path(files_dir.Append(base::FilePath("test.fifo"))); + EnsureCreateFIFO(fifo_path); + + base::FilePath stderr_fifo_path, stdin_fifo_path; + + // DumpRenderTree needs a separate fifo for the stderr output. For all + // other tests, insert stderr content to the same fifo we use for stdout. + if (command_line.HasSwitch(kSeparateStderrFifo)) { + stderr_fifo_path = files_dir.Append(base::FilePath("stderr.fifo")); + EnsureCreateFIFO(stderr_fifo_path); + } + + // DumpRenderTree uses stdin to receive input about which test to run. + if (command_line.HasSwitch(kCreateStdinFifo)) { + stdin_fifo_path = files_dir.Append(base::FilePath("stdin.fifo")); + EnsureCreateFIFO(stdin_fifo_path); + } + + // Only redirect the streams after all fifos have been created. + EnsureRedirectStream(stdout, fifo_path, "w"); + if (!stdin_fifo_path.empty()) + EnsureRedirectStream(stdin, stdin_fifo_path, "r"); + if (!stderr_fifo_path.empty()) + EnsureRedirectStream(stderr, stderr_fifo_path, "w"); + else + dup2(STDOUT_FILENO, STDERR_FILENO); + + if (command_line.HasSwitch(switches::kWaitForDebugger)) { + AndroidLog(ANDROID_LOG_VERBOSE, + "Native test waiting for GDB because flag %s was supplied", + switches::kWaitForDebugger); + base::debug::WaitForDebugger(24 * 60 * 60, false); + } + + ScopedMainEntryLogger scoped_main_entry_logger; + main(argc, &argv[0]); +} + +// This is called by the VM when the shared library is first loaded. +JNI_EXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) { + // Install signal handlers to detect crashes. + InstallHandlers(); + + base::android::InitVM(vm); + JNIEnv* env = base::android::AttachCurrentThread(); + if (!RegisterNativesImpl(env)) { + return -1; + } + + return JNI_VERSION_1_4; +} diff --git a/chromium/testing/android/native_test_util.cc b/chromium/testing/android/native_test_util.cc new file mode 100644 index 00000000000..c0ea7b0fef8 --- /dev/null +++ b/chromium/testing/android/native_test_util.cc @@ -0,0 +1,54 @@ +// Copyright (c) 2013 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "testing/android/native_test_util.h" + +#include "base/file_util.h" +#include "base/files/file_path.h" +#include "base/strings/string_tokenizer.h" +#include "base/strings/string_util.h" + +namespace { + +void ParseArgsFromString(const std::string& command_line, + std::vector<std::string>* args) { + base::StringTokenizer tokenizer(command_line, kWhitespaceASCII); + tokenizer.set_quote_chars("\""); + while (tokenizer.GetNext()) { + std::string token; + RemoveChars(tokenizer.token(), "\"", &token); + args->push_back(token); + } +} + +} // namespace + +namespace testing { +namespace native_test_util { + +void ParseArgsFromCommandLineFile( + const char* path, std::vector<std::string>* args) { + base::FilePath command_line(path); + std::string command_line_string; + if (file_util::ReadFileToString(command_line, &command_line_string)) { + ParseArgsFromString(command_line_string, args); + } +} + +int ArgsToArgv(const std::vector<std::string>& args, + std::vector<char*>* argv) { + // We need to pass in a non-const char**. + int argc = args.size(); + + argv->resize(argc + 1); + for (int i = 0; i < argc; ++i) { + (*argv)[i] = const_cast<char*>(args[i].c_str()); + } + (*argv)[argc] = NULL; // argv must be NULL terminated. + + return argc; +} + +} // namespace native_test_util +} // namespace testing diff --git a/chromium/testing/android/native_test_util.h b/chromium/testing/android/native_test_util.h new file mode 100644 index 00000000000..a7567392b1e --- /dev/null +++ b/chromium/testing/android/native_test_util.h @@ -0,0 +1,37 @@ +// Copyright (c) 2013 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef TESTING_ANDROID_NATIVE_TEST_UTIL_ +#define TESTING_ANDROID_NATIVE_TEST_UTIL_ + +#include <stdio.h> +#include <string> +#include <vector> + +// Helper methods for setting up environment for running gtest tests +// inside an APK. +namespace testing { +namespace native_test_util { + +class ScopedMainEntryLogger { + public: + ScopedMainEntryLogger() { + printf(">>ScopedMainEntryLogger\n"); + } + + ~ScopedMainEntryLogger() { + printf("<<ScopedMainEntryLogger\n"); + fflush(stdout); + fflush(stderr); + } +}; + +void ParseArgsFromCommandLineFile( + const char* path, std::vector<std::string>* args); +int ArgsToArgv(const std::vector<std::string>& args, std::vector<char*>* argv); + +} // namespace native_test_util +} // namespace testing + +#endif // TESTING_ANDROID_NATIVE_TEST_UTIL_ |